gnunet-hello.c File Reference

change HELLO files to never expire More...

#include "platform.h"
#include "gnunet_protocols.h"
#include "gnunet_hello_uri_lib.h"
#include "gnunet_transport_plugin.h"

Include dependency graph for gnunet-hello.c:

Go to the source code of this file.

Data Structures
struct	AddContext
	Closure for add_to_buf(). More...
struct	TransportPlugin
	Entry in doubly-linked list of all of our plugins. More...

Functions
static void	plugins_load (const struct GNUNET_CONFIGURATION_Handle *cfg)
static int	add_to_builder (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
static int	add_to_buf (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
	Add the given address with infinite expiration to the buffer. More...
static ssize_t	add_from_hello (void *cls, size_t max, void *buf)
	Add addresses from the address list to the HELLO. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run without the scheduler. More...
int	main (int argc, char *argv[])

Variables
static int	address_count
static struct GNUNET_CRYPTO_EddsaPrivateKey *	my_private_key
	Our private key. More...
struct GNUNET_PeerIdentity	my_full_id
	Local peer own ID. More...
static char *	hello_file
	The file with hello in old style which we like to replace with the new one. More...
static struct TransportPlugin *	plugins_head
	Head of DLL of all loaded plugins. More...
static struct TransportPlugin *	plugins_tail
	Head of DLL of all loaded plugins. More...

Detailed Description

change HELLO files to never expire

Author

Christian Grothoff

Definition in file gnunet-hello.c.

Function Documentation

plugins_load()

static void plugins_load ( const struct GNUNET_CONFIGURATION_Handle *  cfg )

static

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

{
  struct TransportPlugin *plug;
  struct TransportPlugin *next;
  char *libname;
  char *plugs;
  char *pos;
 
  if (NULL != plugins_head)
    return; /* already loaded */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg, "TRANSPORT", "PLUGINS",
                                             &plugs))
    return;
  fprintf (stdout,"Starting transport plugins `%s'\n",
              plugs);
  for (pos = strtok (plugs, " "); pos != NULL; pos = strtok (NULL, " "))
  {
    fprintf (stdout,"Loading `%s' transport plugin\n",
                pos);
    GNUNET_asprintf (&libname, "libgnunet_plugin_transport_%s", pos);
    plug = GNUNET_new (struct TransportPlugin);
    plug->short_name = GNUNET_strdup (pos);
    plug->lib_name = libname;
    plug->env.cfg = cfg;
    plug->env.cls = plug->short_name;
    GNUNET_CONTAINER_DLL_insert (plugins_head, plugins_tail, plug);
  }
  GNUNET_free (plugs);
  next = plugins_head;
  while (next != NULL)
  {
    plug = next;
    next = plug->next;
    plug->api = GNUNET_PLUGIN_load (plug->lib_name, &plug->env);
    if (plug->api == NULL)
    {
      fprintf (stdout,"Failed to load transport plugin for `%s'\n",
                  plug->lib_name);
      GNUNET_CONTAINER_DLL_remove (plugins_head, plugins_tail, plug);
      GNUNET_free (plug->short_name);
      GNUNET_free (plug->lib_name);
      GNUNET_free (plug);
    }
  }
}

References TransportPlugin::api, cfg, TransportPlugin::env, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_new, GNUNET_OK, GNUNET_PLUGIN_load(), GNUNET_strdup, TransportPlugin::lib_name, TransportPlugin::next, plugins_head, plugins_tail, and TransportPlugin::short_name.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

add_to_builder()

static int add_to_builder ( void *  cls, const struct GNUNET_HELLO_Address *  address, struct GNUNET_TIME_Absolute  expiration  )

static

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

{
  struct GNUNET_HELLO_Builder *builder= cls;
  struct TransportPlugin *pos = plugins_head;
  const char *addr;
  char *uri;
 
  while (NULL != pos)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "short_name: %s transport_name: %s\n",
                pos->short_name,
              address->transport_name);
    if (0 == strcmp (address->transport_name, pos->short_name))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "short_name: %s transport_name: %s are the same\n",
                  pos->short_name,
              address->transport_name);
      addr = strchr (strchr (pos->api->address_to_string (pos, address, address->address_length), '.')+1, '.') + 1;
    }
    pos = pos->next;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Hello address string: %s\n",
              addr);
  GNUNET_asprintf (&uri, "%s://%s", address->transport_name, addr);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Hello address uri string: %s\n",
              uri);
  GNUNET_HELLO_builder_add_address (builder,
                                    uri);
}

References address, TransportPlugin::api, builder, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_builder_add_address(), GNUNET_log, TransportPlugin::next, plugins_head, TransportPlugin::short_name, and uri.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

add_to_buf()

static int add_to_buf ( void *  cls, const struct GNUNET_HELLO_Address *  address, struct GNUNET_TIME_Absolute  expiration  )

static

Add the given address with infinite expiration to the buffer.

Parameters

cls	closure
address	address to add
expiration	old expiration

Returns

GNUNET_OK keep iterating

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

{
  struct AddContext *ac = cls;
  size_t ret;
 
  ret = GNUNET_HELLO_add_address (address,
                                  GNUNET_TIME_UNIT_FOREVER_ABS,
                                  ac->buf,
                                  ac->max);
 
  ac->buf += ret;
  ac->max -= ret;
  ac->ret += ret;
  address_count++;
  return GNUNET_OK;
}

References address, address_count, AddContext::buf, GNUNET_OK, GNUNET_TIME_UNIT_FOREVER_ABS, AddContext::max, ret, and AddContext::ret.

Referenced by add_from_hello().

Here is the caller graph for this function:

add_from_hello()

static ssize_t add_from_hello ( void *  cls, size_t  max, void *  buf  )

static

Add addresses from the address list to the HELLO.

Parameters

cls	the HELLO with the addresses to add
max	maximum space available
buf	where to add the addresses

Returns

number of bytes added, 0 to terminate

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

{
  struct GNUNET_HELLO_Message **orig = cls;
  struct AddContext ac;
 
  if (NULL == *orig)
    return GNUNET_SYSERR; /* already done */
  ac.buf = buf;
  ac.max = max;
  ac.ret = 0;
  GNUNET_assert (
    NULL ==
    GNUNET_HELLO_iterate_addresses (*orig, GNUNET_NO, &add_to_buf, &ac));
  *orig = NULL;
  return ac.ret;
}

References add_to_buf(), AddContext::buf, GNUNET_assert, GNUNET_NO, GNUNET_SYSERR, AddContext::max, max, and AddContext::ret.

Here is the call graph for this function:

run()

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

static

Main function that will be run without the scheduler.

Parameters

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

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

{
  struct GNUNET_DISK_FileHandle *fh;
  struct GNUNET_HELLO_Message *orig;
  struct GNUNET_HELLO_Message *result;
  struct GNUNET_PeerIdentity pid;
  uint64_t fsize;
  ssize_t size_written;
  struct GNUNET_HELLO_Builder *builder;
  char *url;
  const struct GNUNET_MessageHeader *msg;
  struct GNUNET_MQ_Envelope *env;
 
  plugins_load (c);
  address_count = 0;
 
  my_private_key =
    GNUNET_CRYPTO_eddsa_key_create_from_configuration (c);
  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
                                      &my_full_id.public_key);
  fprintf (stdout,"We are peer %s\n", GNUNET_i2s (&my_full_id));
 
  GNUNET_log_setup ("gnunet-hello", "DEBUG", NULL);
 
  if (GNUNET_OK !=
      GNUNET_DISK_file_size (hello_file, &fsize, GNUNET_YES, GNUNET_YES))
  {
    fprintf (stderr,
             _ ("Error accessing file `%s': %s\n"),
             hello_file,
             strerror (errno));
    return;
  }
  if (fsize > 65536)
  {
    fprintf (stderr, _ ("File `%s' is too big to be a HELLO\n"), hello_file);
    return;
  }
  if (fsize < sizeof(struct GNUNET_MessageHeader))
  {
    fprintf (stderr, _ ("File `%s' is too small to be a HELLO\n"), hello_file);
    return;
  }
  fh = GNUNET_DISK_file_open (hello_file,
                              GNUNET_DISK_OPEN_READ,
                              GNUNET_DISK_PERM_USER_READ);
  if (NULL == fh)
  {
    fprintf (stderr,
             _ ("Error opening file `%s': %s\n"),
             hello_file,
             strerror (errno));
    return;
  }
  {
    char buf[fsize] GNUNET_ALIGN;
 
    GNUNET_assert (fsize == GNUNET_DISK_file_read (fh, buf, fsize));
    GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
    orig = (struct GNUNET_HELLO_Message *) buf;
    if ((fsize < GNUNET_HELLO_size (orig)) ||
        (GNUNET_OK != GNUNET_HELLO_get_id (orig, &pid)))
    {
      fprintf (stderr,
               _ ("Did not find well-formed HELLO in file `%s'\n"),
               hello_file);
      return;
    }
    {
      char *pids;
 
      pids = GNUNET_CRYPTO_eddsa_public_key_to_string (&my_full_id.public_key);
      fprintf (stdout, "Processing HELLO for peer `%s'\n", pids);
      GNUNET_free (pids);
    }
    /* result = GNUNET_HELLO_create (&pid.public_key, */
    /*                               &add_from_hello, */
    /*                               &orig, */
    /*                               GNUNET_HELLO_is_friend_only (orig)); */
 
    builder = GNUNET_HELLO_builder_new (&my_full_id);
    GNUNET_assert (
    NULL ==
    GNUNET_HELLO_iterate_addresses ((const struct GNUNET_HELLO_Message *) orig, GNUNET_NO, &add_to_builder, builder));
    url = GNUNET_HELLO_builder_to_url (builder, my_private_key);
    fprintf (stdout,"url: %s\n", url);
    env = GNUNET_HELLO_builder_to_env (builder,
                                 my_private_key,
                                 GNUNET_TIME_UNIT_FOREVER_REL);
    msg = GNUNET_MQ_env_get_msg (env);
    //GNUNET_assert (NULL != result);
    GNUNET_assert (NULL != msg);
    fh =
      GNUNET_DISK_file_open (hello_file,
                             GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE,
                             GNUNET_DISK_PERM_USER_READ
                             | GNUNET_DISK_PERM_USER_WRITE);
    if (NULL == fh)
    {
      fprintf (stderr,
               _ ("Error opening file `%s': %s\n"),
               hello_file,
               strerror (errno));
      GNUNET_free (result);
      return;
    }
    //fsize = GNUNET_HELLO_size (result);
    size_written = GNUNET_DISK_file_write (fh, msg, ntohs (msg->size));
    if (ntohs (msg->size) != size_written)
    {
      fprintf (stderr,
               _ ("Error writing HELLO to file `%s': %s expected size %u size written %u\n"),
               hello_file,
               strerror (errno));
      (void) GNUNET_DISK_file_close (fh);
      return;
    }
    GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
  }
  fprintf (stderr,
           _ ("Modified %u addresses, wrote %u bytes\n"),
           address_count,
           (unsigned int) ntohs (msg->size));
  GNUNET_HELLO_builder_free (builder);
}

References _, add_to_builder(), address_count, builder, env, fh, GNUNET_ALIGN, GNUNET_assert, GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_eddsa_public_key_to_string(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_file_size(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_free, GNUNET_HELLO_builder_free(), GNUNET_HELLO_builder_new(), GNUNET_HELLO_builder_to_env(), GNUNET_HELLO_builder_to_url(), GNUNET_i2s(), GNUNET_log_setup(), GNUNET_MQ_env_get_msg(), GNUNET_NO, GNUNET_OK, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, hello_file, msg, my_full_id, my_private_key, pid, plugins_load(), GNUNET_PeerIdentity::public_key, result, and GNUNET_MessageHeader::size.

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 *	argv[]
	)

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

{
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_string ('h',
                               "hello-file",
                               "HELLO_FILE",
                               gettext_noop ("Hello file to read"),
                               &hello_file),
    GNUNET_GETOPT_OPTION_END };
  int ret;
 
  ret = (GNUNET_OK ==
         GNUNET_PROGRAM_run2 (argc,
                             argv,
                             "gnunet-peerinfo",
                             gettext_noop ("Print information about peers."),
                             options,
                             &run,
                             NULL,
                             GNUNET_YES));
  return ret;
}

References gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_string(), GNUNET_OK, GNUNET_PROGRAM_run2(), GNUNET_YES, hello_file, options, ret, and run().

Here is the call graph for this function:

Variable Documentation

address_count

int address_count

static

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

Referenced by add_to_buf(), and run().

my_private_key

struct GNUNET_CRYPTO_EddsaPrivateKey* my_private_key

static

Our private key.

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

Referenced by GCH_get_mine(), GCT_handle_kx_auth(), got_hello(), run(), send_kx(), send_kx_auth(), set_monotime_sig(), and update_ax_by_kx().

my_full_id

struct GNUNET_PeerIdentity my_full_id

Local peer own ID.

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

Referenced by announce_id(), core_init_cb(), dir_ready_cb(), GCCH_bind(), GCCH_channel_local_new(), GCH_get_mine(), GCPP_try_path_from_dht(), GCT_alice_or_betty(), get_next_free_ctn(), got_hello(), handle_connection_create(), route_message(), run(), send_broken_without_mqm(), and send_create().

hello_file

char* hello_file

static

The file with hello in old style which we like to replace with the new one.

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

Referenced by main(), and run().

plugins_head

struct TransportPlugin* plugins_head

static

Head of DLL of all loaded plugins.

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

Referenced by add_to_builder(), and plugins_load().

plugins_tail

struct TransportPlugin* plugins_tail

static

Head of DLL of all loaded plugins.

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

Referenced by plugins_load().