gnunet-peerinfo.c File Reference

Print information about other known peers. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_hello_lib.h"
#include "gnunet_transport_service.h"
#include "gnunet_transport_hello_service.h"
#include "gnunet_peerinfo_service.h"
#include "gnunet-peerinfo_plugins.h"

Include dependency graph for gnunet-peerinfo.c:

Go to the source code of this file.

Data Structures
struct	AddressRecord
	Record we keep for each printable address. More...
struct	PrintContext
	Structure we use to collect printable address information. More...

Macros
#define	TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
	How long until we time out during address lookup? More...

Functions
static void	state_machine (void *cls)
	Main state machine that goes over all options and runs the next requested function. More...
static void	dump_pc (struct PrintContext *pc)
	Print the collected address information to the console and free pc. More...
static void	process_resolved_address (void *cls, const char *address, int res)
	Function to call with a human-readable format of an address. More...
static int	count_address (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
	Iterator callback to go over all addresses and count them. More...
static int	print_address (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
	Iterator callback to go over all addresses. More...
static void	print_peer_info (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Message *hello, const char *err_msg)
	Print information about the peer. More...
static int	count_addr (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
	Count the number of addresses in the HELLO. More...
static void	dump_my_hello ()
	Write HELLO of my peer to a file. More...
static void	print_my_uri (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Message *hello, const char *err_msg)
	Print URI of the peer. More...
static void	add_continuation (void *cls)
	Continuation called from GNUNET_PEERINFO_add_peer() More...
static int	parse_hello_uri (const char *put_uri)
	Parse the PUT URI given at the command line and add it to our peerinfo database. More...
static void	shutdown_task (void *cls)
	Main state machine that goes over all options and runs the next requested function. More...
static void	hello_callback (void *cls, const struct GNUNET_MessageHeader *hello)
	Function called with our peer's HELLO message. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)
	The main function to obtain peer information. More...

Variables
static int	no_resolve
	Option '-n'. More...
static int	be_quiet
	Option '-q'. More...
static int	include_friend_only
	Option '-f'. More...
static int	get_self
	Option '-s'. More...
static int	get_uri
	Option. More...
static int	default_operation
	Option. More...
static int	get_info
	Option '-i'. More...
static char *	put_uri
	Option. More...
static char *	dump_hello
	Option -d. More...
static struct GNUNET_PEERINFO_Handle *	peerinfo
	Handle to peerinfo service. More...
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Configuration handle. More...
static struct GNUNET_SCHEDULER_Task *	tt
	Main state machine task (if active). More...
static struct GNUNET_TRANSPORT_HelloGetHandle *	gh
	Pending GNUNET_TRANSPORT_hello_get() operation. More...
static struct GNUNET_PEERINFO_IteratorContext *	pic
	Current iterator context (if active, otherwise NULL). More...
static struct GNUNET_PeerIdentity	my_peer_identity
	My peer identity. More...
static struct PrintContext *	pc_head
	Head of list of print contexts. More...
static struct PrintContext *	pc_tail
	Tail of list of print contexts. More...
static struct GNUNET_MQ_Envelope *	ac
	Handle to current GNUNET_PEERINFO_add_peer() operation. More...
static struct GNUNET_HELLO_Message *	my_hello
	Hello of this peer (if initialized). More...

Detailed Description

Print information about other known peers.

Author

Christian Grothoff

Matthias Wachs

Definition in file gnunet-peerinfo.c.

Macro Definition Documentation

TIMEOUT

#define TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

How long until we time out during address lookup?

Definition at line 38 of file gnunet-peerinfo.c.

Function Documentation

state_machine()

static void state_machine ( void *  cls )

static

Main state machine that goes over all options and runs the next requested function.

Parameters

cls

unused

Definition at line 728 of file gnunet-peerinfo.c.

{
  tt = NULL;
 
  if (NULL != put_uri)
  {
    GPI_plugins_load (cfg);
    if (GNUNET_SYSERR == parse_hello_uri (put_uri))
    {
      fprintf (stderr, _ ("Invalid URI `%s'\n"), put_uri);
      GNUNET_SCHEDULER_shutdown ();
    }
    GNUNET_free (put_uri);
    put_uri = NULL;
  }
  else if (GNUNET_YES == get_info)
  {
    get_info = GNUNET_NO;
    GPI_plugins_load (cfg);
    pic = GNUNET_PEERINFO_iterate (peerinfo,
                                   include_friend_only,
                                   NULL,
                                   &print_peer_info,
                                   NULL);
  }
  else if (GNUNET_YES == get_self)
  {
    get_self = GNUNET_NO;
    if (be_quiet)
      printf ("%s\n", GNUNET_i2s_full (&my_peer_identity));
    else
      printf (_ ("I am peer `%s'.\n"), GNUNET_i2s_full (&my_peer_identity));
    tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
  }
  else if (GNUNET_YES == get_uri)
  {
    GPI_plugins_load (cfg);
    pic = GNUNET_PEERINFO_iterate (peerinfo,
                                   include_friend_only,
                                   &my_peer_identity,
                                   &print_my_uri,
                                   NULL);
    get_uri = GNUNET_NO;
  }
  else if (GNUNET_YES == default_operation)
  {
    /* default operation list all */
    default_operation = GNUNET_NO;
    get_info = GNUNET_YES;
    tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
  }
  else
  {
    GNUNET_SCHEDULER_shutdown ();
  }
  default_operation = GNUNET_NO;
}

References _, be_quiet, cfg, default_operation, get_info, get_self, get_uri, GNUNET_free, GNUNET_i2s_full(), GNUNET_NO, GNUNET_PEERINFO_iterate(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_YES, GPI_plugins_load(), include_friend_only, my_peer_identity, parse_hello_uri(), peerinfo, pic, print_my_uri(), print_peer_info(), put_uri, and tt.

Referenced by add_continuation(), dump_pc(), hello_callback(), parse_hello_uri(), print_my_uri(), print_peer_info(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_pc()

static void dump_pc ( struct PrintContext *  pc )

static

Print the collected address information to the console and free pc.

Parameters

pc	printing context

Definition at line 233 of file gnunet-peerinfo.c.

{
  unsigned int i;
 
  printf (_ ("%sPeer `%s'\n"),
          (GNUNET_YES == pc->friend_only) ? "F2F: " : "",
          GNUNET_i2s_full (&pc->peer));
  for (i = 0; i < pc->num_addresses; i++)
  {
    if (NULL != pc->address_list[i].result)
    {
      printf (_ ("\tExpires: %s \t %s\n"),
              GNUNET_STRINGS_absolute_time_to_string (
                pc->address_list[i].expiration),
              pc->address_list[i].result);
      GNUNET_free (pc->address_list[i].result);
    }
  }
  printf ("\n");
  GNUNET_free (pc->address_list);
  GNUNET_CONTAINER_DLL_remove (pc_head, pc_tail, pc);
  GNUNET_free (pc);
  if ((NULL == pc_head) && (NULL == pic))
    tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
}

References _, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_i2s_full(), GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_YES, pc, pc_head, pc_tail, pic, state_machine(), and tt.

Referenced by print_peer_info(), and process_resolved_address().

Here is the call graph for this function:

Here is the caller graph for this function:

process_resolved_address()

static void process_resolved_address ( void *  cls, const char *  address, int  res  )

static

Function to call with a human-readable format of an address.

Parameters

cls	closure
address	NULL on error, otherwise 0-terminated printable UTF-8 string
res	result of the address to string conversion: if GNUNET_OK: address was valid (conversion to string might still have failed) if GNUNET_SYSERR: address is invalid

Definition at line 274 of file gnunet-peerinfo.c.

{
  struct AddressRecord *ar = cls;
  struct PrintContext *pc = ar->pc;
 
  if (NULL != address)
  {
    if (0 != strlen (address))
    {
      if (NULL != ar->result)
        GNUNET_free (ar->result);
      ar->result = GNUNET_strdup (address);
    }
    return;
  }
  ar->atsc = NULL;
  if (GNUNET_SYSERR == res)
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Failure: Cannot convert address to string for peer `%s'\n"),
                GNUNET_i2s (&ar->pc->peer));
  pc->num_addresses++;
  if (pc->num_addresses == pc->address_list_size)
    dump_pc (pc);
}

References _, address, AddressRecord::atsc, dump_pc(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_strdup, GNUNET_SYSERR, pc, AddressRecord::pc, PrintContext::peer, res, and AddressRecord::result.

Referenced by print_address().

Here is the call graph for this function:

Here is the caller graph for this function:

count_address()

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

static

Iterator callback to go over all addresses and count them.

Parameters

cls	struct PrintContext * with off to increment
address	the address
expiration	expiration time

Returns

GNUNET_OK to keep the address and continue

Definition at line 309 of file gnunet-peerinfo.c.

{
  struct PrintContext *pc = cls;
 
  pc->off++;
  return GNUNET_OK;
}

References GNUNET_OK, and pc.

Referenced by print_peer_info().

Here is the caller graph for this function:

print_address()

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

static

Iterator callback to go over all addresses.

Parameters

cls	closure
address	the address
expiration	expiration time

Returns

GNUNET_OK to keep the address and continue

Definition at line 329 of file gnunet-peerinfo.c.

{
  struct PrintContext *pc = cls;
  struct AddressRecord *ar;
 
  GNUNET_assert (0 < pc->off);
  ar = &pc->address_list[--pc->off];
  ar->pc = pc;
  ar->expiration = expiration;
  GNUNET_asprintf (&ar->result,
                   "%s:%lu:%u",
                   address->transport_name,
                   (unsigned long) address->address_length,
                   address->local_info);
  ar->atsc = GNUNET_TRANSPORT_address_to_string (cfg,
                                                 address,
                                                 no_resolve,
                                                 TIMEOUT,
                                                 &process_resolved_address,
                                                 ar);
  return GNUNET_OK;
}

References address, AddressRecord::atsc, cfg, expiration, AddressRecord::expiration, GNUNET_asprintf(), GNUNET_assert, GNUNET_OK, GNUNET_TRANSPORT_address_to_string(), no_resolve, pc, AddressRecord::pc, process_resolved_address(), AddressRecord::result, and TIMEOUT.

Referenced by print_peer_info().

Here is the call graph for this function:

Here is the caller graph for this function:

print_peer_info()

static void print_peer_info ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_HELLO_Message *  hello, const char *  err_msg  )

static

Print information about the peer.

Currently prints the struct GNUNET_PeerIdentity and the transport address.

Parameters

cls	the struct PrintContext *
peer	identity of the peer
hello	addresses of the peer
err_msg	error message

Definition at line 365 of file gnunet-peerinfo.c.

{
  struct PrintContext *pc;
  int friend_only;
 
  if (NULL == peer)
  {
    pic = NULL;   /* end of iteration */
    if (NULL != err_msg)
    {
      fprintf (stderr,
               _ ("Error in communication with PEERINFO service: %s\n"),
               err_msg);
    }
    if (NULL == pc_head)
      tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
    return;
  }
  friend_only = GNUNET_NO;
  if (NULL != hello)
    friend_only = GNUNET_HELLO_is_friend_only (hello);
  if ((GNUNET_YES == be_quiet) || (NULL == hello))
  {
    printf ("%s%s\n",
            (GNUNET_YES == friend_only) ? "F2F: " : "",
            GNUNET_i2s_full (peer));
    return;
  }
  pc = GNUNET_new (struct PrintContext);
  GNUNET_CONTAINER_DLL_insert (pc_head, pc_tail, pc);
  pc->peer = *peer;
  pc->friend_only = friend_only;
  GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &count_address, pc);
  if (0 == pc->off)
  {
    dump_pc (pc);
    return;
  }
  pc->address_list_size = pc->off;
  pc->address_list = GNUNET_malloc (sizeof(struct AddressRecord) * pc->off);
  GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &print_address, pc);
}

References _, be_quiet, count_address(), dump_pc(), PrintContext::friend_only, GNUNET_CONTAINER_DLL_insert, GNUNET_HELLO_is_friend_only(), GNUNET_HELLO_iterate_addresses(), GNUNET_i2s_full(), GNUNET_malloc, GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_YES, pc, pc_head, pc_tail, peer, pic, print_address(), state_machine(), and tt.

Referenced by state_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

count_addr()

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

static

Count the number of addresses in the HELLO.

Parameters

cls	pointer to an int * used for the counter
address	an address to count
expiration	(unused)

Returns

GNUNET_OK

Definition at line 423 of file gnunet-peerinfo.c.

{
  int *c = cls;
 
  (*c)++;
  return GNUNET_OK;
}

References GNUNET_OK.

Referenced by dump_my_hello().

Here is the caller graph for this function:

dump_my_hello()

static void dump_my_hello ( )

static

Write HELLO of my peer to a file.

Parameters

cls	the struct GetUriContext *
peer	identity of the peer (unused)
hello	addresses of the peer
err_msg	error message

Definition at line 443 of file gnunet-peerinfo.c.

{
  unsigned int size;
  unsigned int c_addr;
 
  size = GNUNET_HELLO_size (my_hello);
  if (0 == size)
  {
    fprintf (stderr, _ ("Failure: Received invalid %s\n"), "HELLO");
    return;
  }
  if (GNUNET_SYSERR ==
      GNUNET_DISK_fn_write (dump_hello,
                            my_hello,
                            size,
                            GNUNET_DISK_PERM_USER_READ
                            | GNUNET_DISK_PERM_USER_WRITE
                            | GNUNET_DISK_PERM_GROUP_READ
                            | GNUNET_DISK_PERM_OTHER_READ))
  {
    fprintf (stderr,
             _ ("Failed to write HELLO with %u bytes to file `%s'\n"),
             size,
             dump_hello);
    if (0 != unlink (dump_hello))
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING
                                | GNUNET_ERROR_TYPE_BULK,
                                "unlink",
                                dump_hello);
  }
  c_addr = 0;
  GNUNET_HELLO_iterate_addresses (my_hello, GNUNET_NO, count_addr, &c_addr);
 
  if (! be_quiet)
  {
    fprintf (
      stderr,
      _ ("Wrote %s HELLO containing %u addresses with %u bytes to file `%s'\n"),
      (GNUNET_YES == GNUNET_HELLO_is_friend_only (my_hello)) ? "friend-only"
      : "public",
      c_addr,
      size,
      dump_hello);
  }
  GNUNET_free (dump_hello);
  dump_hello = NULL;
}

References _, be_quiet, count_addr(), dump_hello, GNUNET_DISK_fn_write(), GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_OTHER_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_is_friend_only(), GNUNET_HELLO_iterate_addresses(), GNUNET_HELLO_size(), GNUNET_log_strerror_file, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, my_hello, and size.

Referenced by hello_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

print_my_uri()

static void print_my_uri ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_HELLO_Message *  hello, const char *  err_msg  )

static

Print URI of the peer.

Parameters

cls	the struct GetUriContext *
peer	identity of the peer (unused)
hello	addresses of the peer
err_msg	error message

Definition at line 504 of file gnunet-peerinfo.c.

{
  char *uri;
 
  if (NULL == peer)
  {
    pic = NULL;
    if (NULL != err_msg)
      fprintf (stderr,
               _ ("Error in communication with PEERINFO service: %s\n"),
               err_msg);
    tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
    return;
  }
 
  if (NULL == hello)
    return;
  uri = GNUNET_HELLO_compose_uri (hello, &GPI_plugins_find);
  if (NULL != uri)
  {
    printf ("%s\n", (const char *) uri);
    GNUNET_free (uri);
  }
}

References _, GNUNET_free, GNUNET_HELLO_compose_uri(), GNUNET_SCHEDULER_add_now(), GPI_plugins_find(), peer, pic, state_machine(), tt, and uri.

Referenced by state_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

add_continuation()

static void add_continuation ( void *  cls )

static

Continuation called from GNUNET_PEERINFO_add_peer()

Parameters

cls	closure, NULL

Definition at line 542 of file gnunet-peerinfo.c.

{
  ac = NULL;
  tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
}

References ac, GNUNET_SCHEDULER_add_now(), state_machine(), and tt.

Referenced by parse_hello_uri().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_hello_uri()

static int parse_hello_uri ( const char *  put_uri )

static

Parse the PUT URI given at the command line and add it to our peerinfo database.

Parameters

put_uri

URI string to parse

Returns

GNUNET_OK on success, GNUNET_SYSERR if the URI was invalid, GNUNET_NO on other errors

Definition at line 559 of file gnunet-peerinfo.c.

{
  struct GNUNET_HELLO_Message *hello = NULL;
 
  int ret = GNUNET_HELLO_parse_uri (put_uri,
                                    &my_peer_identity.public_key,
                                    &hello,
                                    &GPI_plugins_find);
 
  if (NULL != hello)
  {
    /* WARNING: this adds the address from URI WITHOUT verification! */
    if (GNUNET_OK == ret)
      ac = GNUNET_PEERINFO_add_peer (peerinfo, hello, &add_continuation, NULL);
    else
      tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
    GNUNET_free (hello);
  }
  return ret;
}

References ac, add_continuation(), GNUNET_free, GNUNET_HELLO_parse_uri(), GNUNET_OK, GNUNET_PEERINFO_add_peer(), GNUNET_SCHEDULER_add_now(), GPI_plugins_find(), my_peer_identity, peerinfo, GNUNET_PeerIdentity::public_key, put_uri, ret, state_machine(), and tt.

Referenced by state_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Main state machine that goes over all options and runs the next requested function.

Parameters

cls

unused

Definition at line 591 of file gnunet-peerinfo.c.

{
  struct PrintContext *pc;
  struct AddressRecord *ar;
  unsigned int i;
 
  if (NULL != ac)
  {
    GNUNET_MQ_send_cancel (ac);
    ac = NULL;
  }
  if (NULL != tt)
  {
    GNUNET_SCHEDULER_cancel (tt);
    tt = NULL;
  }
  if (NULL != pic)
  {
    GNUNET_PEERINFO_iterate_cancel (pic);
    pic = NULL;
  }
  if (NULL != gh)
  {
    GNUNET_TRANSPORT_hello_get_cancel (gh);
    gh = NULL;
  }
  while (NULL != (pc = pc_head))
  {
    GNUNET_CONTAINER_DLL_remove (pc_head, pc_tail, pc);
    for (i = 0; i < pc->address_list_size; i++)
    {
      ar = &pc->address_list[i];
      GNUNET_free (ar->result);
      if (NULL != ar->atsc)
      {
        GNUNET_TRANSPORT_address_to_string_cancel (ar->atsc);
        ar->atsc = NULL;
      }
    }
    GNUNET_free (pc->address_list);
    GNUNET_free (pc);
  }
  GPI_plugins_unload ();
  if (NULL != peerinfo)
  {
    GNUNET_PEERINFO_disconnect (peerinfo);
    peerinfo = NULL;
  }
  if (NULL != my_hello)
  {
    GNUNET_free (my_hello);
    my_hello = NULL;
  }
}

References ac, AddressRecord::atsc, gh, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_send_cancel(), GNUNET_PEERINFO_disconnect(), GNUNET_PEERINFO_iterate_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_address_to_string_cancel(), GNUNET_TRANSPORT_hello_get_cancel(), GPI_plugins_unload(), my_hello, pc, pc_head, pc_tail, peerinfo, pic, AddressRecord::result, and tt.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

hello_callback()

static void hello_callback ( void *  cls, const struct GNUNET_MessageHeader *  hello  )

static

Function called with our peer's HELLO message.

Used to obtain our peer's public key.

Parameters

cls	NULL
hello	the HELLO message

Definition at line 655 of file gnunet-peerinfo.c.

{
  if (NULL == hello)
  {
    fprintf (stderr, "Failed to get my own HELLO from this peer!\n");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  my_hello = (struct GNUNET_HELLO_Message *) GNUNET_copy_message (hello);
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_HELLO_get_id (my_hello, &my_peer_identity));
  GNUNET_TRANSPORT_hello_get_cancel (gh);
  gh = NULL;
  if (NULL != dump_hello)
    dump_my_hello ();
  tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
}

References dump_hello, dump_my_hello(), gh, GNUNET_assert, GNUNET_copy_message(), GNUNET_HELLO_get_id(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_TRANSPORT_hello_get_cancel(), my_hello, my_peer_identity, state_machine(), and tt.

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 *  c  )

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!)
c	configuration

Definition at line 683 of file gnunet-peerinfo.c.

{
  cfg = c;
  if ((NULL != args[0]) && (NULL == put_uri) &&
      (args[0] == strcasestr (args[0], "gnunet://hello/")))
  {
    put_uri = GNUNET_strdup (args[0]);
    args++;
  }
  if (NULL != args[0])
  {
    fprintf (stderr, _ ("Invalid command line argument `%s'\n"), args[0]);
    return;
  }
  if (NULL == (peerinfo = GNUNET_PEERINFO_connect (cfg)))
  {
    fprintf (stderr, "%s", "Could not access PEERINFO service.  Exiting.\n");
    return;
  }
  if ((GNUNET_YES == get_self) || (GNUNET_YES == get_uri) ||
      (NULL != dump_hello))
  {
    gh = GNUNET_TRANSPORT_hello_get (cfg,
                                     GNUNET_TRANSPORT_AC_ANY,
                                     &hello_callback,
                                     NULL);
  }
  else
  {
    tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
  }
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}

References _, consensus-simulation::args, cfg, dump_hello, get_self, get_uri, gh, GNUNET_PEERINFO_connect(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_strdup, GNUNET_TRANSPORT_AC_ANY, GNUNET_TRANSPORT_hello_get(), GNUNET_YES, hello_callback(), peerinfo, put_uri, shutdown_task(), state_machine(), and tt.

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.

Parameters

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

Returns

0 ok, 1 on error

Definition at line 795 of file gnunet-peerinfo.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_flag ('n',
                               "numeric",
                               gettext_noop ("don't resolve host names"),
                               &no_resolve),
 
    GNUNET_GETOPT_option_flag ('q',
                               "quiet",
                               gettext_noop (
                                 "output only the identity strings"),
                               &be_quiet),
    GNUNET_GETOPT_option_flag ('f',
                               "friends",
                               gettext_noop (
                                 "include friend-only information"),
                               &include_friend_only),
 
    GNUNET_GETOPT_option_flag ('s',
                               "self",
                               gettext_noop ("output our own identity only"),
                               &get_self),
 
    GNUNET_GETOPT_option_flag ('i',
                               "info",
                               gettext_noop ("list all known peers"),
                               &get_info),
 
    GNUNET_GETOPT_option_string ('d',
                                 "dump-hello",
                                 NULL,
                                 gettext_noop ("dump hello to file"),
                                 &dump_hello),
 
    GNUNET_GETOPT_option_flag ('g',
                               "get-hello",
                               gettext_noop ("also output HELLO uri(s)"),
                               &get_uri),
 
    GNUNET_GETOPT_option_string ('p',
                                 "put-hello",
                                 "HELLO",
                                 gettext_noop (
                                   "add given HELLO uri to the database"),
                                 &put_uri),
 
    GNUNET_GETOPT_OPTION_END };
  int ret;
 
  default_operation = GNUNET_YES;
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
 
  ret = (GNUNET_OK ==
         GNUNET_PROGRAM_run (argc,
                             argv,
                             "gnunet-peerinfo",
                             gettext_noop ("Print information about peers."),
                             options,
                             &run,
                             NULL))
        ? 0
        : 1;
  GNUNET_free_nz ((void *) argv);
  return ret;
}

References be_quiet, default_operation, dump_hello, get_info, get_self, get_uri, gettext_noop, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), GNUNET_YES, include_friend_only, no_resolve, options, put_uri, ret, and run().

Here is the call graph for this function:

Variable Documentation

no_resolve

int no_resolve

static

Option '-n'.

Definition at line 122 of file gnunet-peerinfo.c.

Referenced by main(), and print_address().

be_quiet

int be_quiet

static

Option '-q'.

Definition at line 127 of file gnunet-peerinfo.c.

Referenced by dump_my_hello(), main(), print_peer_info(), and state_machine().

include_friend_only

int include_friend_only

static

Option '-f'.

Definition at line 132 of file gnunet-peerinfo.c.

Referenced by GNUNET_PEERINFO_iterate(), GNUNET_PEERINFO_notify(), main(), make_info_message(), peerinfo_get(), and state_machine().

get_self

int get_self

static

Option '-s'.

Definition at line 137 of file gnunet-peerinfo.c.

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

get_uri

int get_uri

static

Option.

Definition at line 142 of file gnunet-peerinfo.c.

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

default_operation

int default_operation

static

Option.

Definition at line 147 of file gnunet-peerinfo.c.

Referenced by main(), and state_machine().

get_info

int get_info

static

Option '-i'.

Definition at line 152 of file gnunet-peerinfo.c.

Referenced by main(), and state_machine().

put_uri

char* put_uri

static

Option.

Definition at line 157 of file gnunet-peerinfo.c.

Referenced by main(), parse_hello_uri(), run(), and state_machine().

dump_hello

char* dump_hello

static

Option -d.

Definition at line 162 of file gnunet-peerinfo.c.

Referenced by dump_my_hello(), hello_callback(), main(), and run().

peerinfo

struct GNUNET_PEERINFO_Handle* peerinfo

static

Handle to peerinfo service.

Definition at line 167 of file gnunet-peerinfo.c.

Referenced by parse_hello_uri(), run(), shutdown_task(), and state_machine().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Configuration handle.

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

Referenced by print_address(), run(), and state_machine().

tt

struct GNUNET_SCHEDULER_Task* tt

static

Main state machine task (if active).

Definition at line 177 of file gnunet-peerinfo.c.

Referenced by add_continuation(), dump_pc(), hello_callback(), parse_hello_uri(), print_my_uri(), print_peer_info(), run(), shutdown_task(), and state_machine().

gh

struct GNUNET_TRANSPORT_HelloGetHandle* gh

static

Pending GNUNET_TRANSPORT_hello_get() operation.

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

Referenced by add_get_request_to_pending(), clean_node(), connection_ready(), free_action_item(), GNUNET_DHT_get_start(), GNUNET_STATISTICS_get_cancel(), GST_connection_pool_get_handle(), GST_connection_pool_get_handle_done(), hello_callback(), main_task(), peer_connect_notify_cb(), reconnect_later(), run(), search_waiting(), send_get(), shutdown_task(), and try_connect().

pic

struct GNUNET_PEERINFO_IteratorContext* pic

static

Current iterator context (if active, otherwise NULL).

Definition at line 187 of file gnunet-peerinfo.c.

Referenced by dump_pc(), GNUNET_TRANSPORT_monitor_peers_cancel(), print_my_uri(), print_peer_info(), shutdown_task(), and state_machine().

my_peer_identity

struct GNUNET_PeerIdentity my_peer_identity

static

My peer identity.

Definition at line 187 of file gnunet-peerinfo.c.

Referenced by hello_callback(), parse_hello_uri(), and state_machine().

pc_head

struct PrintContext* pc_head

static

Head of list of print contexts.

Definition at line 197 of file gnunet-peerinfo.c.

Referenced by dump_pc(), print_peer_info(), and shutdown_task().

pc_tail

struct PrintContext* pc_tail

static

Tail of list of print contexts.

Definition at line 202 of file gnunet-peerinfo.c.

Referenced by dump_pc(), print_peer_info(), and shutdown_task().

ac

struct GNUNET_MQ_Envelope* ac

static

Handle to current GNUNET_PEERINFO_add_peer() operation.

Definition at line 207 of file gnunet-peerinfo.c.

Referenced by add_continuation(), add_from_hello(), add_to_buf(), address_cb(), age_values(), block_until_external_trigger_traits(), cancel_get(), check_autoconfig_finished(), conclude_autoconfig_request(), continue_with_gns2dns(), cummulative_ack(), delayed_get(), delayed_put(), destroy_ack_cummulator(), dht_connected(), dht_disconnect(), do_refresh(), do_shutdown(), free_ack_cummulator_cb(), get_iter(), GNS_resolver_lookup_cancel(), GNUNET_NAT_mini_map_start(), GNUNET_TESTING_async_fail(), GNUNET_TESTING_async_finish(), GNUNET_TRANSPORT_hello_get(), handle_address_change_notification(), handle_autoconfig_request(), handle_dht_response(), handle_gns2dns_ip(), handle_gns2dns_result(), handle_gns_redirect_result(), handle_gns_resolution_result(), handle_namecache_block_response(), handle_revocation_result(), ifc_proc(), notify_client(), occ_cache_get_handle_ats_occ_cb(), occ_cache_get_handle_ats_rocc_cb(), parse_hello_uri(), preference_aging(), put_cont(), recursive_dns_resolution(), recursive_gns2dns_resolution(), recursive_gns_resolution_namecache(), recursive_gns_resolution_revocation(), recursive_pkey_resolution(), shutdown_task(), start_profiling(), start_resolver_lookup(), terminate_ac_activities(), transmit_cummulative_ack_cb(), update_enable_upnpc_option(), and upnp_addr_change_cb().

my_hello

struct GNUNET_HELLO_Message* my_hello

static

Hello of this peer (if initialized).

Definition at line 212 of file gnunet-peerinfo.c.

Referenced by dump_my_hello(), hello_callback(), and shutdown_task().