gnunet-hello.c File Reference

Export/import/print HELLOs. More...

#include "gnunet_common.h"
#include "platform.h"
#include "gnunet_time_lib.h"
#include "gnunet_util_lib.h"
#include "gnunet_hello_uri_lib.h"
#include "gnunet_peerstore_service.h"

Include dependency graph for gnunet-hello.c:

Go to the source code of this file.

Functions
static void	shutdown_task (void *cls)
	Task run in monitor mode when the user presses CTRL-C to abort. More...
static void	print_hello_addrs (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
	Callback function used to extract URIs from a builder. More...
static void	hello_iter (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
static void	hello_store_success (void *cls, int success)
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)
	The main function to obtain peer information from CORE. More...

Variables
static int	ret
	Return code. More...
static struct GNUNET_PEERSTORE_Handle *	peerstore_handle
static struct GNUNET_PEERSTORE_IterateContext *	iter_ctx
	PEERSTORE iteration context. More...
static struct GNUNET_PEERSTORE_StoreHelloContext *	shc
	HELLO store context handle. More...
static struct GNUNET_CRYPTO_EddsaPrivateKey	my_private_key
	Peer private key. More...
static struct GNUNET_PeerIdentity	my_full_id
	Peer identity. More...
static int	export_own_hello
	HELLO export option -H. More...
static char *	expirationstring
	Optional expiration string -E. More...
static struct GNUNET_TIME_Relative	hello_validity
	Expiration time for exported hello. More...
static enum GNUNET_GenericReturnValue	binary_output
	HELLO export/import format option. More...
static int	print_hellos
	Hello list option -D. More...
static enum GNUNET_GenericReturnValue	import_hello
	HELLO import option -I. More...

Detailed Description

Export/import/print HELLOs.

Author

Nathan Evans

Definition in file gnunet-hello.c.

Function Documentation

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run in monitor mode when the user presses CTRL-C to abort.

Stops monitoring activity.

Parameters

cls

NULL

Definition at line 101 of file gnunet-hello.c.

{
  (void) cls;
  if (NULL != shc)
  {
    GNUNET_PEERSTORE_hello_add_cancel (shc);
    shc = NULL;
  }
  if (NULL != iter_ctx)
  {
    GNUNET_PEERSTORE_iteration_stop (iter_ctx);
  }
  if (NULL != peerstore_handle)
  {
    GNUNET_PEERSTORE_disconnect (peerstore_handle);
    peerstore_handle = NULL;
  }
}

References GNUNET_PEERSTORE_disconnect(), GNUNET_PEERSTORE_hello_add_cancel(), GNUNET_PEERSTORE_iteration_stop(), iter_ctx, peerstore_handle, and shc.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

print_hello_addrs()

static void print_hello_addrs ( void *  cls, const struct GNUNET_PeerIdentity *  pid, const char *  uri  )

static

Callback function used to extract URIs from a builder.

Called when we should consider connecting to a peer.

Parameters

cls	closure pointing to a struct GNUNET_PeerIdentity *
uri	one of the URIs

Definition at line 129 of file gnunet-hello.c.

{
  (void) cls;
 
 
  printf ("|- %s\n", uri);
}

References uri.

Referenced by hello_iter().

Here is the caller graph for this function:

hello_iter()

static void hello_iter ( void *  cls, const struct GNUNET_PEERSTORE_Record *  record, const char *  emsg  )

static

If we ever get here, we are newer than the existing record or the only/first record.

Definition at line 141 of file gnunet-hello.c.

{
  struct GNUNET_HELLO_Parser *hp;
  struct GNUNET_TIME_Absolute hello_exp;
  const struct GNUNET_PeerIdentity *pid;
 
  if ((NULL == record) && (NULL == emsg))
  {
    iter_ctx = NULL;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n", emsg);
    GNUNET_PEERSTORE_iteration_next (iter_ctx, 1);
    return;
  }
  hp = GNUNET_HELLO_parser_from_msg (record->value);
  hello_exp = GNUNET_HELLO_get_expiration_time_from_msg (record->value);
  pid = GNUNET_HELLO_parser_get_id (hp);
  if (export_own_hello)
  {
    if (0 == GNUNET_memcmp (&my_full_id,
                            pid))
    {
      struct GNUNET_HELLO_Builder *hb;
 
      hb = GNUNET_HELLO_builder_from_parser (hp);
      if (GNUNET_NO == binary_output)
      {
        char *url;
        if (NULL != expirationstring)
        {
          url = GNUNET_HELLO_builder_to_url2 (hb,
                                              &my_private_key,
                                              hello_validity);
        }
        else
        {
          url = GNUNET_HELLO_builder_to_url (hb, &my_private_key);
        }
        printf ("%s\n", url);
        GNUNET_free (url);
        GNUNET_PEERSTORE_iteration_stop (iter_ctx);
        iter_ctx = NULL;
        GNUNET_HELLO_parser_free (hp);
        GNUNET_HELLO_builder_free (hb);
        GNUNET_SCHEDULER_shutdown ();
      }
      else
      {
        struct GNUNET_MQ_Envelope *env;
        struct GNUNET_TIME_Relative validity_tmp;
        const struct GNUNET_MessageHeader *msg;
 
        if (NULL != expirationstring)
        {
          env = GNUNET_HELLO_builder_to_env (hb,
                                             &my_private_key,
                                             hello_validity);
        }
        else
        {
          validity_tmp = GNUNET_TIME_absolute_get_duration (hello_exp);
          env = GNUNET_HELLO_builder_to_env (hb,
                                             &my_private_key,
                                             validity_tmp);
        }
        msg = GNUNET_MQ_env_get_msg (env);
        fwrite (msg, 1, ntohs (msg->size), stdout);
        GNUNET_free (env);
        GNUNET_PEERSTORE_iteration_stop (iter_ctx);
        iter_ctx = NULL;
        GNUNET_HELLO_parser_free (hp);
        GNUNET_HELLO_builder_free (hb);
        GNUNET_SCHEDULER_shutdown ();
      }
      return;
    }
  }
  else if (print_hellos)
  {
    printf ("`%s' (expires: %s):\n", GNUNET_i2s (pid),
            GNUNET_STRINGS_absolute_time_to_string (hello_exp));
    GNUNET_HELLO_parser_iterate (hp, &print_hello_addrs, NULL);
  }
  GNUNET_HELLO_parser_free (hp);
  GNUNET_PEERSTORE_iteration_next (iter_ctx, 1);
}

References binary_output, env, expirationstring, export_own_hello, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_HELLO_builder_free(), GNUNET_HELLO_builder_from_parser(), GNUNET_HELLO_builder_to_env(), GNUNET_HELLO_builder_to_url(), GNUNET_HELLO_builder_to_url2(), GNUNET_HELLO_get_expiration_time_from_msg(), GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_get_id(), GNUNET_HELLO_parser_iterate(), GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_MQ_env_get_msg(), GNUNET_NO, GNUNET_PEERSTORE_iteration_next(), GNUNET_PEERSTORE_iteration_stop(), GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get_duration(), hello_validity, iter_ctx, msg, my_full_id, my_private_key, pid, print_hello_addrs(), print_hellos, record(), and GNUNET_MessageHeader::size.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

hello_store_success()

static void hello_store_success ( void *  cls, int  success  )

static

Definition at line 238 of file gnunet-hello.c.

{
  shc = NULL;
  if (GNUNET_OK != success)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Storing hello uri failed\n");
  }
  printf ("HELLO imported.");
  GNUNET_SCHEDULER_shutdown ();
}

References GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), and shc.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Main function that will be run by the scheduler.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
cfg	configuration

Definition at line 260 of file gnunet-hello.c.

{
  struct GNUNET_HELLO_Parser *hp;
  struct GNUNET_MQ_Envelope *env;
  char *keyfile;
  (void) cls;
  (void) cfgfile;
 
  if (NULL != args[0])
  {
    fprintf (stderr, _ ("Invalid command line argument `%s'\n"), args[0]);
    return;
  }
  if (! print_hellos &&
      (GNUNET_NO == export_own_hello) &&
      (GNUNET_NO == import_hello))
  {
    fprintf (stderr, "%s", _ ("No argument given.\n"));
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               "PEER",
                                               "PRIVATE_KEY",
                                               &keyfile))
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_ERROR,
      _ ("Core service is lacking HOSTKEY configuration setting.  Exiting.\n"));
    GNUNET_SCHEDULER_shutdown ();
    ret =  1;
    return;
  }
  if (GNUNET_SYSERR ==
      GNUNET_CRYPTO_eddsa_key_from_file (keyfile,
                                         GNUNET_YES,
                                         &my_private_key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read peer's private key!\n");
    GNUNET_SCHEDULER_shutdown ();
    ret = 1;
    GNUNET_free (keyfile);
    return;
  }
  GNUNET_free (keyfile);
  GNUNET_CRYPTO_eddsa_key_get_public (&my_private_key, &my_full_id.public_key);
  peerstore_handle = GNUNET_PEERSTORE_connect (cfg);
  GNUNET_assert (NULL != peerstore_handle);
  hello_validity = GNUNET_TIME_UNIT_DAYS;
  if (NULL != expirationstring)
  {
    if (GNUNET_OK != GNUNET_STRINGS_fancy_time_to_relative (expirationstring,
                                                            &hello_validity))
    {
      fprintf (stderr, "Invalid expiration time `%s'", expirationstring);
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
  }
  if (GNUNET_YES == import_hello)
  {
    char buffer[GNUNET_MAX_MESSAGE_SIZE - 1];
    char *write_ptr;
    ssize_t nread;
    size_t read_total = 0;
 
    write_ptr = buffer;
    while (0 < (nread = fread (write_ptr, 1,
                               sizeof buffer - read_total, stdin)))
    {
      read_total += nread;
      write_ptr += nread;
    }
    buffer[read_total] = '\0';
    if (strlen ("gnunet://hello/") > read_total)
    {
      fprintf (stderr, "HELLO malformed\n");
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    if (0 == strncasecmp ("gnunet://hello/",
                          buffer, strlen ("gnunet://hello/")))
    {
      // Remove newline
      buffer[read_total - 1] = '\0';
      hp = GNUNET_HELLO_parser_from_url (buffer);
      if (NULL == hp)
      {
        fprintf (stderr, "Unable to parse URI `%s'\n", buffer);
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      env = GNUNET_HELLO_parser_to_env (hp);
      shc = GNUNET_PEERSTORE_hello_add (peerstore_handle,
                                        GNUNET_MQ_env_get_msg (env),
                                        &hello_store_success, NULL);
      GNUNET_free (env);
      GNUNET_HELLO_parser_free (hp);
    }
    else if (read_total > sizeof (struct GNUNET_MessageHeader))
    {
      shc = GNUNET_PEERSTORE_hello_add (peerstore_handle,
                                        (const struct GNUNET_MessageHeader*)
                                        buffer,
                                        &hello_store_success, NULL);
    }
    else
    {
      fprintf (stderr, "HELLO malformed\n");
      GNUNET_SCHEDULER_shutdown ();
    }
    return;
  }
 
  iter_ctx = GNUNET_PEERSTORE_iteration_start (peerstore_handle,
                                               "peerstore",
                                               NULL,
                                               GNUNET_PEERSTORE_HELLO_KEY,
                                               &hello_iter,
                                               NULL);
 
}

References _, consensus-simulation::args, cfg, env, expirationstring, export_own_hello, GNUNET_assert, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CRYPTO_eddsa_key_from_file(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_url(), GNUNET_HELLO_parser_to_env(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_MQ_env_get_msg(), GNUNET_NO, GNUNET_OK, GNUNET_PEERSTORE_connect(), GNUNET_PEERSTORE_hello_add(), GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_iteration_start(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_fancy_time_to_relative(), GNUNET_SYSERR, GNUNET_TIME_UNIT_DAYS, GNUNET_YES, hello_iter(), hello_store_success(), hello_validity, import_hello, iter_ctx, my_full_id, my_private_key, peerstore_handle, print_hellos, GNUNET_PeerIdentity::public_key, ret, shc, and shutdown_task().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

The main function to obtain peer information from CORE.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 399 of file gnunet-hello.c.

{
  int res;
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_flag ('e',
                               "export-hello",
                               gettext_noop (
                                 "Print a HELLO for our peer identity"),
                               &export_own_hello),
    GNUNET_GETOPT_option_flag ('b',
                               "binary",
                               gettext_noop (
                                 "Output HELLO in binary format. Use with `--export'."),
                               &binary_output),
    GNUNET_GETOPT_option_flag ('i',
                               "import-hello",
                               gettext_noop ("Import a HELLO"),
                               &import_hello),
    GNUNET_GETOPT_option_string ('E',
                                 "expiration",
                                 "TIME",
                                 gettext_noop (
                                   "Expiration time to set for exported hello. (Default: 1 day)"),
                                 &expirationstring),
    GNUNET_GETOPT_option_flag ('D',
                               "dump-hellos",
                               gettext_noop (
                                 "List all known HELLOs in peerstore"),
                               &print_hellos),
    GNUNET_GETOPT_OPTION_END
  };
 
  res = GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                            argc,
                            argv,
                            "gnunet-hello",
                            gettext_noop (
                              "Import/export/print HELLOs."),
                            options,
                            &run,
                            NULL);
 
  if (GNUNET_OK == res)
    return ret;
  return 1;
}

References binary_output, expirationstring, export_own_hello, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), import_hello, options, print_hellos, res, ret, and run().

Here is the call graph for this function:

Variable Documentation

ret

int ret

static

Return code.

Definition at line 37 of file gnunet-hello.c.

Referenced by main(), and run().

peerstore_handle

struct GNUNET_PEERSTORE_Handle* peerstore_handle

static

Definition at line 42 of file gnunet-hello.c.

Referenced by run(), and shutdown_task().

iter_ctx

struct GNUNET_PEERSTORE_IterateContext* iter_ctx

static

PEERSTORE iteration context.

Definition at line 47 of file gnunet-hello.c.

Referenced by hello_iter(), run(), and shutdown_task().

shc

struct GNUNET_PEERSTORE_StoreHelloContext* shc

static

HELLO store context handle.

Definition at line 52 of file gnunet-hello.c.

Referenced by GNUNET_sh2s(), hello_store_success(), run(), and shutdown_task().

my_private_key

struct GNUNET_CRYPTO_EddsaPrivateKey my_private_key

static

Peer private key.

Definition at line 57 of file gnunet-hello.c.

Referenced by hello_iter(), and run().

my_full_id

struct GNUNET_PeerIdentity my_full_id

static

Peer identity.

Definition at line 62 of file gnunet-hello.c.

Referenced by hello_iter(), and run().

export_own_hello

int export_own_hello

static

HELLO export option -H.

Definition at line 67 of file gnunet-hello.c.

Referenced by hello_iter(), main(), and run().

expirationstring

char* expirationstring

static

Optional expiration string -E.

Definition at line 72 of file gnunet-hello.c.

Referenced by hello_iter(), main(), parse_expiration(), and run().

hello_validity

struct GNUNET_TIME_Relative hello_validity

static

Expiration time for exported hello.

Definition at line 77 of file gnunet-hello.c.

Referenced by hello_iter(), and run().

binary_output

enum GNUNET_GenericReturnValue binary_output

static

HELLO export/import format option.

Definition at line 82 of file gnunet-hello.c.

Referenced by hello_iter(), and main().

print_hellos

int print_hellos

static

Hello list option -D.

Definition at line 87 of file gnunet-hello.c.

Referenced by hello_iter(), main(), and run().

import_hello

enum GNUNET_GenericReturnValue import_hello

static

HELLO import option -I.

Definition at line 92 of file gnunet-hello.c.

Referenced by main(), and run().