Export/import/print HELLOs. More...

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

Include dependency graph for gnunet-hello.c:

Functions
static void	shutdown_task (void *cls)
	Task run in monitor mode when the user presses CTRL-C to abort.

static void	print_hello_addrs (void cls, const struct GNUNET_PeerIdentity pid, const char *uri)
	Callback function used to extract URIs from a builder.

static void	url_resign_cb (void cls, const struct GNUNET_PeerIdentity pid, const struct GNUNET_CRYPTO_EddsaSignature *sig)

static void	output_env (const struct GNUNET_MQ_Envelope *env)

static void	output_parser (const struct GNUNET_HELLO_Parser *parser)

static void	env_resign_cb (void cls, const struct GNUNET_PeerIdentity pid, const struct GNUNET_CRYPTO_EddsaSignature *sig)

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	pid_changed_cb (void cls, const struct GNUNET_HELLO_Parser parser, const struct GNUNET_HashCode *addr_hash)

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.

int	main (int argc, char const argv)
	The main function to obtain peer information from CORE.

Variables
static int	ret
	Return code.

static struct GNUNET_PEERSTORE_Handle *	peerstore_handle

static struct GNUNET_PILS_Handle *	pils_handle

static struct GNUNET_PEERSTORE_IterateContext *	iter_ctx
	PEERSTORE iteration context.

static struct GNUNET_PEERSTORE_StoreHelloContext *	shc
	HELLO store context handle.

static int	export_own_hello
	HELLO export option -H.

static char *	expirationstring
	Optional expiration string -E.

static struct GNUNET_TIME_Absolute	hello_validity
	Expiration time for exported hello.

static enum GNUNET_GenericReturnValue	binary_output
	HELLO export/import format option.

static int	print_hellos
	Hello list option -D.

static enum GNUNET_GenericReturnValue	import_hello
	HELLO import option -I.

struct GNUNET_PILS_Operation *	op
	PILS op.

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 103 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;
  }
  if (NULL != op)
    GNUNET_PILS_cancel (op);
  if (NULL != pils_handle)
  {
    GNUNET_PILS_disconnect (pils_handle);
    peerstore_handle = NULL;
  }
}

References GNUNET_PEERSTORE_disconnect(), GNUNET_PEERSTORE_hello_add_cancel(), GNUNET_PEERSTORE_iteration_stop(), GNUNET_PILS_cancel(), GNUNET_PILS_disconnect(), iter_ctx, op, peerstore_handle, pils_handle, and shc.

Here is the call 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 138 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:

◆ url_resign_cb()

static void url_resign_cb	(	void *	cls,
		const struct GNUNET_PeerIdentity *	pid,
		const struct GNUNET_CRYPTO_EddsaSignature *	sig
	)

static

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

{
  struct GNUNET_HELLO_Builder *builder = cls;
  char *url;
 
  op = NULL;
  GNUNET_HELLO_builder_to_url2 (builder,
                                pid,
                                sig,
                                hello_validity,
                                &url);
 
  printf ("%s\n", url);
  GNUNET_free (url); // TODO is this right?
  GNUNET_HELLO_builder_free (builder);
  GNUNET_SCHEDULER_shutdown ();
}

References builder, GNUNET_free, GNUNET_HELLO_builder_free(), GNUNET_HELLO_builder_to_url2(), GNUNET_SCHEDULER_shutdown(), hello_validity, and op.

Referenced by pid_changed_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ output_env()

static void output_env ( const struct GNUNET_MQ_Envelope * env )

static

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

{
  const struct GNUNET_MessageHeader *msg;
 
  msg = GNUNET_MQ_env_get_msg (env);
  fwrite (msg, 1, ntohs (msg->size), stdout);
}

References env, GNUNET_MQ_env_get_msg(), msg, and GNUNET_MessageHeader::size.

Referenced by env_resign_cb(), and output_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ output_parser()

static void output_parser ( const struct GNUNET_HELLO_Parser * parser )

static

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

{
  if (GNUNET_NO == binary_output)
  {
    char *url;
    url = GNUNET_HELLO_parser_to_url (parser);
    printf ("%s\n", url);
    GNUNET_free (url);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  else
  {
    struct GNUNET_MQ_Envelope *env;
    env = GNUNET_HELLO_parser_to_env (parser);
    output_env (env);
    GNUNET_free (env);
  }
}

References binary_output, env, GNUNET_free, GNUNET_HELLO_parser_to_env(), GNUNET_HELLO_parser_to_url(), GNUNET_NO, GNUNET_SCHEDULER_shutdown(), and output_env().

Referenced by pid_changed_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ env_resign_cb()

static void env_resign_cb	(	void *	cls,
		const struct GNUNET_PeerIdentity *	pid,
		const struct GNUNET_CRYPTO_EddsaSignature *	sig
	)

static

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

{
  struct GNUNET_HELLO_Builder *builder = cls;
  struct GNUNET_MQ_Envelope *env;
 
  op = NULL;
  env = GNUNET_HELLO_builder_to_env (builder,
                                     pid,
                                     sig,
                                     hello_validity);
  output_env (env);
  GNUNET_HELLO_builder_free (builder);
  GNUNET_free (env);
  GNUNET_SCHEDULER_shutdown ();
}

References builder, env, GNUNET_free, GNUNET_HELLO_builder_free(), GNUNET_HELLO_builder_to_env(), GNUNET_SCHEDULER_shutdown(), hello_validity, op, and output_env().

Referenced by pid_changed_cb().

Here is the call graph for this function:

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 224 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)
  {
    /* @a emsg comes with a NULL record, i.e. the iteration is over and the
       context is gone -- asking it for another record uses freed memory. */
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n", emsg);
    iter_ctx = NULL;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  hp = GNUNET_HELLO_parser_from_msg (record->value,
                                     &record->peer);
  if (NULL == hp)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "The HELLO is invalid. Skipping.\n");
    GNUNET_PEERSTORE_iteration_next (iter_ctx, 1);
    return;
  }
  hello_exp = GNUNET_HELLO_get_expiration_time_from_msg (record->value);
  pid = GNUNET_HELLO_parser_get_id (hp);
  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 GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, 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_PEERSTORE_iteration_next(), GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_absolute_time_to_string(), iter_ctx, print_hello_addrs(), print_hellos, and record().

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 272 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:

◆ pid_changed_cb()

static void pid_changed_cb	(	void *	cls,
		const struct GNUNET_HELLO_Parser *	parser,
		const struct GNUNET_HashCode *	addr_hash
	)

static

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

{
  struct GNUNET_HELLO_Builder *builder;
  if (! export_own_hello)
    return;
 
  if (NULL != expirationstring)
  {
    builder = GNUNET_HELLO_builder_from_parser (parser, NULL);
    op = GNUNET_PILS_sign_hello (
      pils_handle,
      builder,
      hello_validity,
      (GNUNET_NO == binary_output) ? &env_resign_cb : &url_resign_cb,
      builder);
    return;
  }
  output_parser (parser);
  GNUNET_SCHEDULER_shutdown ();
}

References binary_output, builder, env_resign_cb(), expirationstring, export_own_hello, GNUNET_HELLO_builder_from_parser(), GNUNET_NO, GNUNET_PILS_sign_hello(), GNUNET_SCHEDULER_shutdown(), hello_validity, op, output_parser(), pils_handle, and url_resign_cb().

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 319 of file gnunet-hello.c.

{
  struct GNUNET_HELLO_Parser *hp;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TIME_Relative hello_validity_rel;
  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;
  }
  peerstore_handle = GNUNET_PEERSTORE_connect (cfg);
  GNUNET_assert (NULL != peerstore_handle);
  pils_handle = GNUNET_PILS_connect (cfg, &pid_changed_cb, NULL);
  GNUNET_assert (NULL != pils_handle);
  hello_validity_rel = GNUNET_TIME_UNIT_DAYS;
  if (NULL != expirationstring)
  {
    if (GNUNET_OK != GNUNET_STRINGS_fancy_time_to_relative (expirationstring,
                                                            &hello_validity_rel)
        )
    {
      fprintf (stderr, "Invalid expiration time `%s'", expirationstring);
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
  }
  hello_validity = GNUNET_TIME_relative_to_absolute (hello_validity_rel);
  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;
  }
 
  if (print_hellos)
  {
    iter_ctx = GNUNET_PEERSTORE_iteration_start (peerstore_handle,
                                                 "peerstore",
                                                 NULL,
                                                 GNUNET_PEERSTORE_HELLO_KEY,
                                                 &hello_iter,
                                                 NULL);
  }
}

References _, cfg, env, expirationstring, export_own_hello, GNUNET_assert, GNUNET_CONFIGURATION_get_value_filename(), 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_PILS_connect(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_fancy_time_to_relative(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_DAYS, GNUNET_YES, hello_iter(), hello_store_success(), hello_validity, import_hello, iter_ctx, peerstore_handle, pid_changed_cb(), pils_handle, print_hellos, 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 451 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;
}