diff options
Diffstat (limited to 'src/peerinfo-tool/gnunet-peerinfo.c')
| -rw-r--r-- | src/peerinfo-tool/gnunet-peerinfo.c | 801 |
1 files changed, 747 insertions, 54 deletions
diff --git a/src/peerinfo-tool/gnunet-peerinfo.c b/src/peerinfo-tool/gnunet-peerinfo.c index 21c9966..de27cd2 100644 --- a/src/peerinfo-tool/gnunet-peerinfo.c +++ b/src/peerinfo-tool/gnunet-peerinfo.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - (C) 2001, 2002, 2003, 2004, 2006, 2009, 2010 Christian Grothoff (and other contributing authors) + (C) 2001-2012 Christian Grothoff (and other contributing authors) GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -30,26 +30,252 @@ #include "gnunet_peerinfo_service.h" #include "gnunet_transport_service.h" #include "gnunet_program_lib.h" +#include "gnunet_transport_plugin.h" +#include "gnunet-peerinfo_plugins.h" +/** + * Prefix that every HELLO URI must start with. + */ +#define HELLO_URI_PREFIX "gnunet://hello/" + +/** + * How long until we time out during peerinfo iterations? + */ +#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) + +/** + * Structure we use to collect printable address information. + */ +struct PrintContext; + +/** + * Record we keep for each printable address. + */ +struct AddressRecord +{ + /** + * Current address-to-string context (if active, otherwise NULL). + */ + struct GNUNET_TRANSPORT_AddressToStringContext *atsc; + + /** + * Printable address. + */ + char *result; + + /** + * Print context this address record belongs to. + */ + struct PrintContext *pc; +}; + + +/** + * Structure we use to collect printable address information. + */ +struct PrintContext +{ + + /** + * Kept in DLL. + */ + struct PrintContext *next; + + /** + * Kept in DLL. + */ + struct PrintContext *prev; + + /** + * Identity of the peer. + */ + struct GNUNET_PeerIdentity peer; + + /** + * List of printable addresses. + */ + struct AddressRecord *address_list; + + /** + * Number of completed addresses in 'address_list'. + */ + unsigned int num_addresses; + + /** + * Number of addresses allocated in 'address_list'. + */ + unsigned int address_list_size; + + /** + * Current offset in 'address_list' (counted down). + */ + unsigned int off; + +}; + + +/** + * Context used for building our own URI. + */ +struct GetUriContext +{ + /** + * Final URI. + */ + char *uri; + +}; + + +/** + * Context for 'add_address_to_hello'. + */ +struct GNUNET_PEERINFO_HelloAddressParsingContext +{ + /** + * Position in the URI with the next address to parse. + */ + const char *pos; + + /** + * Set to GNUNET_SYSERR to indicate parse errors. + */ + int ret; + +}; + + +/** + * Option '-n' + */ static int no_resolve; +/** + * Option '-q' + */ static int be_quiet; +/** + * Option '-s' + */ static int get_self; +/** + * Option + */ +static int get_uri; + +/** + * Option '-i' + */ +static int get_info; + +/** + * Option + */ +static char *put_uri; + +/** + * Handle to peerinfo service. + */ static struct GNUNET_PEERINFO_Handle *peerinfo; +/** + * Configuration handle. + */ static const struct GNUNET_CONFIGURATION_Handle *cfg; -struct PrintContext +/** + * Main state machine task (if active). + */ +static GNUNET_SCHEDULER_TaskIdentifier tt; + +/** + * Current iterator context (if active, otherwise NULL). + */ +static struct GNUNET_PEERINFO_IteratorContext *pic; + +/** + * My peer identity. + */ +static struct GNUNET_PeerIdentity my_peer_identity; + +/** + * My public key. + */ +static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key; + +/** + * Head of list of print contexts. + */ +static struct PrintContext *pc_head; + +/** + * Tail of list of print contexts. + */ +static struct PrintContext *pc_tail; + +/** + * Handle to current 'GNUNET_PEERINFO_add_peer' operation. + */ +static struct GNUNET_PEERINFO_AddContext *ac; + + +/** + * Main state machine that goes over all options and + * runs the next requested function. + * + * @param cls unused + * @param tc unused + */ +static void +state_machine (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc); + + + +/** + * Replace all characters in the input 'in' according + * to the mapping. The mapping says to map each character + * in 'oldchars' to the corresponding character (by offset) + * in 'newchars'. + * + * @param in input string to remap + * @param oldchars characters to replace + * @param newchars replacement characters, must have same length as 'oldchars' + * @return copy of string with replacement applied. + */ +static char * +map_characters (const char *in, + const char *oldchars, + const char *newchars) { - struct GNUNET_PeerIdentity peer; - char **address_list; - unsigned int num_addresses; - uint32_t off; -}; + char *ret; + const char *off; + size_t i; + + GNUNET_assert (strlen (oldchars) == strlen (newchars)); + ret = GNUNET_strdup (in); + i = 0; + while (ret[i] != '\0') + { + off = strchr (oldchars, ret[i]); + if (NULL != off) + ret[i] = newchars[off - oldchars]; + i++; + } + return ret; +} + + +/* ********************* 'get_info' ******************* */ +/** + * Print the collected address information to the console and free 'pc'. + * + * @param pc printing context + */ static void dump_pc (struct PrintContext *pc) { @@ -57,18 +283,31 @@ dump_pc (struct PrintContext *pc) unsigned int i; GNUNET_CRYPTO_hash_to_enc (&pc->peer.hashPubKey, &enc); - printf (_("Peer `%s'\n"), (const char *) &enc); + printf (_("Peer `%s'\n"), + (const char *) &enc); for (i = 0; i < pc->num_addresses; i++) { - printf ("\t%s\n", pc->address_list[i]); - GNUNET_free (pc->address_list[i]); + if (NULL != pc->address_list[i].result) + { + printf ("\t%s\n", pc->address_list[i].result); + GNUNET_free (pc->address_list[i].result); + } } printf ("\n"); - GNUNET_array_grow (pc->address_list, pc->num_addresses, 0); + GNUNET_free_non_null (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); } +/* ************************* list all known addresses **************** */ + + /** * Function to call with a human-readable format of an address * @@ -78,24 +317,26 @@ dump_pc (struct PrintContext *pc) static void process_resolved_address (void *cls, const char *address) { - struct PrintContext *pc = cls; + struct AddressRecord * ar = cls; + struct PrintContext *pc = ar->pc; - if (address == NULL) + if (NULL != address) { - pc->off--; - if (pc->off == 0) - dump_pc (pc); + if (NULL == ar->result) + ar->result = GNUNET_strdup (address); return; } - GNUNET_array_append (pc->address_list, pc->num_addresses, - GNUNET_strdup (address)); + ar->atsc = NULL; + pc->num_addresses++; + if (pc->num_addresses == pc->address_list_size) + dump_pc (pc); } /** - * Iterator callback to go over all addresses. + * Iterator callback to go over all addresses and count them. * - * @param cls closure + * @param cls 'struct PrintContext' with 'off' to increment * @param address the address * @param expiration expiration time * @return GNUNET_OK to keep the address and continue @@ -124,19 +365,27 @@ print_address (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration) { struct PrintContext *pc = cls; + struct AddressRecord *ar; - GNUNET_TRANSPORT_address_to_string (cfg, address, no_resolve, - GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, 10), - &process_resolved_address, pc); + GNUNET_assert (0 < pc->off); + ar = &pc->address_list[--pc->off]; + ar->pc = pc; + ar->atsc = GNUNET_TRANSPORT_address_to_string (cfg, address, no_resolve, + GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 10), + &process_resolved_address, ar); return GNUNET_OK; } /** * Print information about the peer. - * Currently prints the GNUNET_PeerIdentity and the IP. - * Could of course do more (e.g. resolve via DNS). + * Currently prints the GNUNET_PeerIdentity and the transport address. + * + * @param cls the 'struct PrintContext' + * @param peer identity of the peer + * @param hello addresses of the peer + * @param err_msg error message */ static void print_peer_info (void *cls, const struct GNUNET_PeerIdentity *peer, @@ -147,26 +396,403 @@ print_peer_info (void *cls, const struct GNUNET_PeerIdentity *peer, if (peer == NULL) { + pic = NULL; /* end of iteration */ if (err_msg != NULL) - FPRINTF (stderr, "%s", _("Error in communication with PEERINFO service\n")); - GNUNET_PEERINFO_disconnect (peerinfo); + { + 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; } - if ((be_quiet) || (NULL == hello)) + if ((GNUNET_YES == be_quiet) || (NULL == hello)) { GNUNET_CRYPTO_hash_to_enc (&peer->hashPubKey, &enc); printf ("%s\n", (const char *) &enc); return; } pc = GNUNET_malloc (sizeof (struct PrintContext)); + GNUNET_CONTAINER_DLL_insert (pc_head, + pc_tail, + pc); pc->peer = *peer; - GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &count_address, pc); + GNUNET_HELLO_iterate_addresses (hello, + GNUNET_NO, + &count_address, + pc); if (0 == pc->off) { dump_pc (pc); return; } - GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &print_address, pc); + 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); +} + + +/* ************************* GET URI ************************** */ + + +/** + * Function that is called on each address of this peer. + * Expands the corresponding URI string. + * + * @param cls the 'GetUriContext' + * @param address address to add + * @param expiration expiration time for the address + * @return GNUNET_OK (continue iteration). + */ +static int +compose_uri (void *cls, const struct GNUNET_HELLO_Address *address, + struct GNUNET_TIME_Absolute expiration) +{ + struct GetUriContext *guc = cls; + struct GNUNET_TRANSPORT_PluginFunctions *papi; + const char *addr; + char *uri_addr; + char *ret; + char tbuf[16]; + struct tm *t; + time_t seconds; + + papi = GPI_plugins_find (address->transport_name); + if (papi == NULL) + { + /* Not an error - we might just not have the right plugin. */ + return GNUNET_OK; + } + if (NULL == papi->address_to_string) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "URI conversion not implemented for plugin `%s'\n", + address->transport_name); + return GNUNET_OK; + } + addr = papi->address_to_string (papi->cls, address->address, address->address_length); + if ( (addr == NULL) || (strlen(addr) == 0) ) + return GNUNET_OK; + /* For URIs we use '(' and ')' instead of '[' and ']' as brackets are reserved + characters in URIs */ + uri_addr = map_characters (addr, "[]", "()"); + seconds = expiration.abs_value / 1000; + t = gmtime (&seconds); + GNUNET_assert (0 != strftime (tbuf, sizeof (tbuf), + "%Y%m%d%H%M%S", + t)); + GNUNET_asprintf (&ret, + "%s!%s!%s!%s", + guc->uri, + tbuf, + address->transport_name, + uri_addr); + GNUNET_free (uri_addr); + GNUNET_free (guc->uri); + guc->uri = ret; + return GNUNET_OK; +} + + +/** + * Print URI of the peer. + * + * @param cls the 'struct GetUriContext' + * @param peer identity of the peer (unused) + * @param hello addresses of the peer + * @param err_msg error message + */ +static void +print_my_uri (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_HELLO_Message *hello, + const char *err_msg) +{ + struct GetUriContext *guc = cls; + + if (peer == NULL) + { + pic = NULL; + if (err_msg != NULL) + FPRINTF (stderr, + _("Error in communication with PEERINFO service: %s\n"), + err_msg); + GNUNET_free_non_null (guc->uri); + GNUNET_free (guc); + tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL); + return; + } + if (NULL != hello) + GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &compose_uri, guc); + printf ("%s\n", (const char *) guc->uri); +} + + +/* ************************* import HELLO by URI ********************* */ + + +/** + * We're building a HELLO. Parse the next address from the + * parsing context and append it. + * + * @param cls the 'struct GNUNET_PEERINFO_HelloAddressParsingContext' + * @param max number of bytes available for HELLO construction + * @param buffer where to copy the next address (in binary format) + * @return number of bytes added to buffer + */ +static size_t +add_address_to_hello (void *cls, size_t max, void *buffer) +{ + struct GNUNET_PEERINFO_HelloAddressParsingContext *ctx = cls; + const char *tname; + const char *address; + char *uri_address; + char *plugin_address; + const char *end; + char *plugin_name; + struct tm expiration_time; + time_t expiration_seconds; + struct GNUNET_TIME_Absolute expire; + struct GNUNET_TRANSPORT_PluginFunctions *papi; + void *addr; + size_t addr_len; + struct GNUNET_HELLO_Address haddr; + size_t ret; + + if (NULL == ctx->pos) + return 0; + if ('!' != ctx->pos[0]) + { + ctx->ret = GNUNET_SYSERR; + GNUNET_break (0); + return 0; + } + ctx->pos++; + memset (&expiration_time, 0, sizeof (expiration_time)); + tname = strptime (ctx->pos, + "%Y%m%d%H%M%S", + &expiration_time); + + if (NULL == tname) + { + ctx->ret = GNUNET_SYSERR; + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _("Failed to parse HELLO message: missing expiration time\n")); + GNUNET_break (0); + return 0; + } + expiration_seconds = mktime (&expiration_time); + if (expiration_seconds == (time_t) -1) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _("Failed to parse HELLO message: invalid expiration time\n")); + ctx->ret = GNUNET_SYSERR; + GNUNET_break (0); + return 0; + } + expire.abs_value = expiration_seconds * 1000; + if ('!' != tname[0]) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _("Failed to parse HELLO message: malformed\n")); + ctx->ret = GNUNET_SYSERR; + GNUNET_break (0); + return 0; + } + tname++; + address = strchr (tname, (int) '!'); + if (NULL == address) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _("Failed to parse HELLO message: missing transport plugin\n")); + ctx->ret = GNUNET_SYSERR; + GNUNET_break (0); + return 0; + } + address++; + end = strchr (address, (int) '!'); + ctx->pos = end; + plugin_name = GNUNET_strndup (tname, address - (tname+1)); + papi = GPI_plugins_find (plugin_name); + if (NULL == papi) + { + /* Not an error - we might just not have the right plugin. + * Skip this part, advance to the next one and recurse. + * But only if this is not the end of string. + */ + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _("Plugin `%s' not found\n"), + plugin_name); + GNUNET_free (plugin_name); + GNUNET_break (0); + return 0; + } + if (NULL == papi->string_to_address) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _("Plugin `%s' does not support URIs yet\n"), + plugin_name); + GNUNET_free (plugin_name); + GNUNET_break (0); + return 0; + } + uri_address = GNUNET_strndup (address, end - address); + /* For URIs we use '(' and ')' instead of '[' and ']' as brackets are reserved + characters in URIs; need to convert back to '[]' for the plugin */ + plugin_address = map_characters (uri_address, "()", "[]"); + GNUNET_free (uri_address); + if (GNUNET_OK != + papi->string_to_address (papi->cls, + plugin_address, + strlen (plugin_address) + 1, + &addr, + &addr_len)) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _("Failed to parse `%s' as an address for plugin `%s'\n"), + plugin_address, + plugin_name); + GNUNET_free (plugin_name); + GNUNET_free (plugin_address); + return 0; + } + GNUNET_free (plugin_address); + /* address.peer is unset - not used by add_address() */ + haddr.address_length = addr_len; + haddr.address = addr; + haddr.transport_name = plugin_name; + ret = GNUNET_HELLO_add_address (&haddr, expire, buffer, max); + GNUNET_free (addr); + GNUNET_free (plugin_name); + return ret; +} + + +/** + * Continuation called from 'GNUNET_PEERINFO_add_peer' + * + * @param cls closure, NULL + * @param emsg error message, NULL on success + */ +static void +add_continuation (void *cls, + const char *emsg) +{ + ac = NULL; + if (NULL != emsg) + fprintf (stderr, + _("Failure adding HELLO: %s\n"), + emsg); + tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL); +} + + +/** + * Parse the PUT URI given at the command line and add it to our peerinfo + * database. + * + * @param put_uri URI string to parse + * @return GNUNET_OK on success, GNUNET_SYSERR if the URI was invalid, GNUNET_NO on other errors + */ +static int +parse_hello_uri (const char *put_uri) +{ + const char *pks; + const char *exc; + struct GNUNET_HELLO_Message *hello; + struct GNUNET_PEERINFO_HelloAddressParsingContext ctx; + + if (0 != strncmp (put_uri, + HELLO_URI_PREFIX, + strlen (HELLO_URI_PREFIX))) + return GNUNET_SYSERR; + pks = &put_uri[strlen (HELLO_URI_PREFIX)]; + exc = strstr (pks, "!"); + + if (GNUNET_OK != GNUNET_STRINGS_string_to_data (pks, + (NULL == exc) ? strlen (pks) : (exc - pks), + (unsigned char *) &my_public_key, + sizeof (my_public_key))) + return GNUNET_SYSERR; + ctx.pos = exc; + ctx.ret = GNUNET_OK; + hello = GNUNET_HELLO_create (&my_public_key, &add_address_to_hello, &ctx); + + if (NULL != hello) + { + /* WARNING: this adds the address from URI WITHOUT verification! */ + if (GNUNET_OK == ctx.ret) + ac = GNUNET_PEERINFO_add_peer (peerinfo, hello, &add_continuation, NULL); + else + tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL); + GNUNET_free (hello); + } + + /* wait 1s to give peerinfo operation a chance to succeed */ + /* FIXME: current peerinfo API sucks to require this; not to mention + that we get no feedback to determine if the operation actually succeeded */ + return ctx.ret; +} + + +/* ************************ Main state machine ********************* */ + + +/** + * Main state machine that goes over all options and + * runs the next requested function. + * + * @param cls unused + * @param tc scheduler context + */ +static void +shutdown_task (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct PrintContext *pc; + struct AddressRecord *ar; + unsigned int i; + + if (NULL != ac) + { + GNUNET_PEERINFO_add_peer_cancel (ac); + ac = NULL; + } + if (GNUNET_SCHEDULER_NO_TASK != tt) + { + GNUNET_SCHEDULER_cancel (tt); + tt = GNUNET_SCHEDULER_NO_TASK; + } + if (NULL != pic) + { + GNUNET_PEERINFO_iterate_cancel (pic); + pic = 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_non_null (ar->result); + if (NULL != ar->atsc) + { + GNUNET_TRANSPORT_address_to_string_cancel (ar->atsc); + ar->atsc = NULL; + } + } + GNUNET_free_non_null (pc->address_list); + GNUNET_free (pc); + } + GPI_plugins_unload (); + if (NULL != peerinfo) + { + GNUNET_PEERINFO_disconnect (peerinfo); + peerinfo = NULL; + } } @@ -183,9 +809,6 @@ run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c) { struct GNUNET_CRYPTO_RsaPrivateKey *priv; - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub; - struct GNUNET_PeerIdentity pid; - struct GNUNET_CRYPTO_HashAsciiEncoded enc; char *fn; cfg = c; @@ -194,46 +817,107 @@ run (void *cls, char *const *args, const char *cfgfile, FPRINTF (stderr, _("Invalid command line argument `%s'\n"), args[0]); return; } - if (get_self != GNUNET_YES) + peerinfo = GNUNET_PEERINFO_connect (cfg); + if (peerinfo == NULL) { - peerinfo = GNUNET_PEERINFO_connect (cfg); - if (peerinfo == NULL) - { - FPRINTF (stderr, "%s", _("Could not access PEERINFO service. Exiting.\n")); - return; - } - GNUNET_PEERINFO_iterate (peerinfo, NULL, - GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, 5), &print_peer_info, - NULL); + FPRINTF (stderr, "%s", _("Could not access PEERINFO service. Exiting.\n")); + return; } - else + if ( (GNUNET_YES == get_self) || (GNUNET_YES == get_uri) ) { + /* load private key */ if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_filename (cfg, "GNUNETD", "HOSTKEY", - &fn)) + GNUNET_CONFIGURATION_get_value_filename (cfg, "GNUNETD", "HOSTKEY", + &fn)) { FPRINTF (stderr, _("Could not find option `%s:%s' in configuration.\n"), - "GNUNETD", "HOSTKEYFILE"); + "GNUNETD", "HOSTKEYFILE"); return; } - priv = GNUNET_CRYPTO_rsa_key_create_from_file (fn); - if (priv == NULL) + + if (NULL == (priv = GNUNET_CRYPTO_rsa_key_create_from_file (fn))) { FPRINTF (stderr, _("Loading hostkey from `%s' failed.\n"), fn); GNUNET_free (fn); return; } GNUNET_free (fn); - GNUNET_CRYPTO_rsa_key_get_public (priv, &pub); + GNUNET_CRYPTO_rsa_key_get_public (priv, &my_public_key); GNUNET_CRYPTO_rsa_key_free (priv); - GNUNET_CRYPTO_hash (&pub, sizeof (pub), &pid.hashPubKey); - GNUNET_CRYPTO_hash_to_enc (&pid.hashPubKey, &enc); + GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key), &my_peer_identity.hashPubKey); + } + + tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL); + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, + &shutdown_task, + NULL); +} + + +/** + * Main state machine that goes over all options and + * runs the next requested function. + * + * @param cls unused + * @param tc scheduler context + */ +static void +state_machine (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + tt = GNUNET_SCHEDULER_NO_TASK; + + 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_free (put_uri); + put_uri = NULL; + return; + } + if (GNUNET_YES == get_info) + { + get_info = GNUNET_NO; + GPI_plugins_load (cfg); + pic = GNUNET_PEERINFO_iterate (peerinfo, NULL, + TIMEOUT, + &print_peer_info, NULL); + return; + } + if (GNUNET_YES == get_self) + { + struct GNUNET_CRYPTO_HashAsciiEncoded enc; + + get_self = GNUNET_NO; + GNUNET_CRYPTO_hash_to_enc (&my_peer_identity.hashPubKey, &enc); if (be_quiet) printf ("%s\n", (char *) &enc); else printf (_("I am peer `%s'.\n"), (const char *) &enc); } + if (GNUNET_YES == get_uri) + { + struct GetUriContext *guc; + char *pkey; + + guc = GNUNET_malloc (sizeof (struct GetUriContext)); + pkey = GNUNET_CRYPTO_rsa_public_key_to_string (&my_public_key); + GNUNET_asprintf (&guc->uri, + "%s%s", + HELLO_URI_PREFIX, + pkey); + GNUNET_free (pkey); + GPI_plugins_load (cfg); + pic = GNUNET_PEERINFO_iterate (peerinfo, &my_peer_identity, + TIMEOUT, + &print_my_uri, guc); + get_uri = GNUNET_NO; + return; + } + GNUNET_SCHEDULER_shutdown (); } @@ -257,6 +941,15 @@ main (int argc, char *const *argv) {'s', "self", NULL, gettext_noop ("output our own identity only"), 0, &GNUNET_GETOPT_set_one, &get_self}, + {'i', "info", NULL, + gettext_noop ("list all known peers"), + 0, &GNUNET_GETOPT_set_one, &get_info}, + {'g', "get-hello", NULL, + gettext_noop ("also output HELLO uri(s)"), + 0, &GNUNET_GETOPT_set_one, &get_uri}, + {'p', "put-hello", "HELLO", + gettext_noop ("add given HELLO uri to the database"), + 1, &GNUNET_GETOPT_set_string, &put_uri}, GNUNET_GETOPT_OPTION_END }; return (GNUNET_OK == |