/*
This file is part of GNUnet.
- (C) 2001, 2002, 2003, 2004, 2006, 2009, 2010 Christian Grothoff (and other contributing authors)
+ (C) 2001-2014 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
* @file peerinfo-tool/gnunet-peerinfo.c
* @brief Print information about other known peers.
* @author Christian Grothoff
+ * @author Matthias Wachs
*/
#include "platform.h"
-#include "gnunet_crypto_lib.h"
-#include "gnunet_configuration_lib.h"
-#include "gnunet_getopt_lib.h"
-#include "gnunet_peerinfo_service.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_hello_lib.h"
#include "gnunet_transport_service.h"
-#include "gnunet_program_lib.h"
-#include "gnunet_transport_plugin.h"
-#include "../transport/gnunet-service-transport_plugins.h"
+#include "gnunet_peerinfo_service.h"
+#include "gnunet-peerinfo_plugins.h"
+
+/**
+ * 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;
+
+ /**
+ * Address expiration time
+ */
+ struct GNUNET_TIME_Absolute expiration;
+
+ /**
+ * 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 @e address_list.
+ */
+ unsigned int num_addresses;
+
+ /**
+ * Number of addresses allocated in @e address_list.
+ */
+ unsigned int address_list_size;
+
+ /**
+ * Current offset in @e address_list (counted down).
+ */
+ unsigned int off;
+
+ /**
+ * Hello was friend only, #GNUNET_YES or #GNUNET_NO
+ */
+ int friend_only;
+
+};
+
+
+/**
+ * Option '-n'
+ */
static int no_resolve;
+/**
+ * Option '-q'
+ */
static int be_quiet;
+/**
+ * Option '-f'
+ */
+static int include_friend_only;
+
+/**
+ * Option '-s'
+ */
static int get_self;
+/**
+ * Option
+ */
static int get_uri;
+/**
+ * Option
+ */
+static int default_operation;
+
+/**
+ * Option '-i'
+ */
+static int get_info;
+
+/**
+ * Option
+ */
static char *put_uri;
+/**
+ * Option -d
+ */
+static char *dump_hello;
+
+/**
+ * Handle to peerinfo service.
+ */
static struct GNUNET_PEERINFO_Handle *peerinfo;
/**
* Configuration handle.
*/
-const struct GNUNET_CONFIGURATION_Handle *GST_cfg;
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
/**
- * Statistics handle.
+ * Main state machine task (if active).
*/
-struct GNUNET_STATISTICS_Handle *GST_stats;
+static GNUNET_SCHEDULER_TaskIdentifier tt;
/**
- * Configuration handle.
+ * Current iterator context (if active, otherwise NULL).
*/
-struct GNUNET_PeerIdentity GST_my_identity;
+static struct GNUNET_PEERINFO_IteratorContext *pic;
-struct GNUNET_MessageHeader *our_hello = NULL;
+/**
+ * My peer identity.
+ */
+static struct GNUNET_PeerIdentity my_peer_identity;
-static const struct GNUNET_CONFIGURATION_Handle *cfg;
+/**
+ * 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;
-struct PrintContext
-{
- struct GNUNET_PeerIdentity peer;
- char **address_list;
- unsigned int num_addresses;
- uint32_t off;
- char *uri;
- size_t uri_len;
-};
/**
- * Obtain this peers HELLO message.
+ * Main state machine that goes over all options and
+ * runs the next requested function.
*
- * @return our HELLO message
+ * @param cls unused
+ * @param tc unused
*/
-const struct GNUNET_MessageHeader *
-GST_hello_get ()
-{
- return (struct GNUNET_MessageHeader *) our_hello;
-}
+static void
+state_machine (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc);
+
+
+/* ********************* 'get_info' ******************* */
+/**
+ * Print the collected address information to the console and free @a pc.
+ *
+ * @param pc printing context
+ */
static void
dump_pc (struct PrintContext *pc)
{
- struct GNUNET_CRYPTO_HashAsciiEncoded enc;
unsigned int i;
- GNUNET_CRYPTO_hash_to_enc (&pc->peer.hashPubKey, &enc);
- printf (_("Peer `%s'\n"), (const char *) &enc);
+ printf (_("%sPeer `%s'\n"),
+ (GNUNET_YES == pc->friend_only) ? "F2F: " : "",
+ GNUNET_i2s_full (&pc->peer));
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 (_("\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_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
*
* @param cls closure
* @param address NULL on error, otherwise 0-terminated printable UTF-8 string
+ * @param 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
*/
static void
-process_resolved_address (void *cls, const char *address)
+process_resolved_address (void *cls,
+ const char *address,
+ int res)
{
- 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;
+ 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);
}
/**
- * 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
+ * @return #GNUNET_OK to keep the address and continue
*/
static int
-count_address (void *cls, const struct GNUNET_HELLO_Address *address,
+count_address (void *cls,
+ const struct GNUNET_HELLO_Address *address,
struct GNUNET_TIME_Absolute expiration)
{
struct PrintContext *pc = cls;
* @param cls closure
* @param address the address
* @param expiration expiration time
- * @return GNUNET_OK to keep the address and continue
+ * @return #GNUNET_OK to keep the address and continue
*/
static int
-print_address (void *cls, const struct GNUNET_HELLO_Address *address,
+print_address (void *cls,
+ const struct GNUNET_HELLO_Address *address,
struct GNUNET_TIME_Absolute expiration)
{
struct PrintContext *pc = cls;
-
- GNUNET_TRANSPORT_address_to_string (cfg, address, no_resolve,
- GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 10),
- &process_resolved_address, pc);
+ struct AddressRecord *ar;
+
+ GNUNET_assert (0 < pc->off);
+ ar = &pc->address_list[--pc->off];
+ ar->pc = pc;
+ ar->expiration = expiration;
+ ar->atsc = GNUNET_TRANSPORT_address_to_string (cfg,
+ address,
+ no_resolve,
+ TIMEOUT,
+ &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).
+ * Print information about the peer. Currently prints the `struct
+ * 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,
- const struct GNUNET_HELLO_Message *hello, const char *err_msg)
+print_peer_info (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Message *hello,
+ const char *err_msg)
{
- struct GNUNET_CRYPTO_HashAsciiEncoded enc;
struct PrintContext *pc;
+ int friend_only;
- if (peer == NULL)
+ if (NULL == peer)
{
- if (err_msg != NULL)
- FPRINTF (stderr, "%s", _("Error in communication with PEERINFO service\n"));
- GNUNET_PEERINFO_disconnect (peerinfo);
- GST_plugins_unload ();
- GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
+ 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;
}
- if ((be_quiet) || (NULL == hello))
+ friend_only = GNUNET_NO;
+ if (NULL != hello)
+ friend_only = GNUNET_HELLO_is_friend_only (hello);
+ if ( (GNUNET_YES == be_quiet) ||
+ (NULL == hello) )
{
- GNUNET_CRYPTO_hash_to_enc (&peer->hashPubKey, &enc);
- printf ("%s\n", (const char *) &enc);
+ printf ("%s%s\n",
+ (GNUNET_YES == friend_only) ? "F2F: " : "",
+ GNUNET_i2s_full (peer));
return;
}
- pc = GNUNET_malloc (sizeof (struct PrintContext));
+ pc = GNUNET_new (struct PrintContext);
+ GNUNET_CONTAINER_DLL_insert (pc_head,
+ pc_tail,
+ pc);
pc->peer = *peer;
- GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &count_address, pc);
+ pc->friend_only = friend_only;
+ 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);
}
+/* ************************* DUMP Hello ************************** */
+
+/**
+ * Count the number of addresses in the HELLO.
+ *
+ * @param cls pointer to an `int *` used for the counter
+ * @param address an address to count
+ * @param expiration (unused)
+ * @return #GNUNET_OK
+ */
static int
-compose_uri (void *cls, const struct GNUNET_HELLO_Address *address,
- struct GNUNET_TIME_Absolute expiration)
+count_addr (void *cls,
+ const struct GNUNET_HELLO_Address *address,
+ struct GNUNET_TIME_Absolute expiration)
{
- struct PrintContext *pc = cls;
- struct GNUNET_TRANSPORT_PluginFunctions *papi;
- static const char *addr;
+ int *c = cls;
- papi = GST_plugins_find (address->transport_name);
- if (papi == NULL)
- {
- /* Not an error - we might just not have the right plugin. */
- return GNUNET_OK;
- }
-
- addr = papi->address_to_string (papi->cls, address->address, address->address_length);
- if (addr != NULL)
- {
- ssize_t l = strlen (addr);
- if (l > 0)
- {
- struct tm *t;
- time_t seconds;
- int s;
- seconds = expiration.abs_value / 1000;
- t = gmtime(&seconds);
- pc->uri = GNUNET_realloc (pc->uri, pc->uri_len + 1 + 14 + 1 + strlen (address->transport_name) + 1 + l + 1 /* 0 */);
- s = sprintf (&pc->uri[pc->uri_len], "!%04u%02u%02u%02u%02u%02u!%s!%s",
- t->tm_year, t->tm_mon, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec,
- address->transport_name, addr);
- if (s > 0)
- pc->uri_len += s;
- }
- }
+ (*c) ++;
return GNUNET_OK;
}
+
/**
- * Print information about the peer.
+ * Write HELLO of my peer to a file.
+ *
+ * @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)
+dump_my_hello (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Message *hello,
+ const char *err_msg)
{
- struct GNUNET_CRYPTO_HashAsciiEncoded enc;
- struct PrintContext *pc = cls;
- char *pkey;
+ unsigned int size;
+ unsigned int c_addr;
- if (peer == NULL)
+ if (NULL == peer)
{
- if (err_msg != NULL)
- FPRINTF (stderr, "%s", _("Error in communication with PEERINFO service\n"));
- GNUNET_PEERINFO_disconnect (peerinfo);
- GST_plugins_unload ();
- GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
+ 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)
+ {
+ FPRINTF (stderr,
+ _("Failure: Did not receive %s\n"),
+ "HELLO");
return;
}
- if ((be_quiet) || (NULL == hello))
+
+ size = GNUNET_HELLO_size (hello);
+ if (0 == size)
{
- GNUNET_CRYPTO_hash_to_enc (&peer->hashPubKey, &enc);
- printf ("%s\n", (const char *) &enc);
- if (be_quiet && get_uri != GNUNET_YES)
+ FPRINTF (stderr,
+ _("Failure: Received invalid %s\n"),
+ "HELLO");
return;
}
- pc->peer = *peer;
- GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &count_address, pc);
- GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &compose_uri, pc);
- printf ("%s\n", pc->uri);
- GNUNET_free (pc->uri);
- GNUNET_free (pc);
-}
+ if (GNUNET_SYSERR ==
+ GNUNET_DISK_fn_write (dump_hello, 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);
-struct GNUNET_PEERINFO_HelloAddressParsingContext
-{
- char *tmp;
- char *pos;
- size_t tmp_len;
-};
+ }
+ c_addr = 0;
+ GNUNET_HELLO_iterate_addresses (hello,
+ GNUNET_NO,
+ count_addr,
+ &c_addr);
-static size_t
-add_addr_to_hello (void *cls, size_t max, void *buffer)
-{
- struct tm expiration_time;
- char buf[5];
- long l;
- time_t expiration_seconds;
- struct GNUNET_TIME_Absolute expire;
-
- struct GNUNET_PEERINFO_HelloAddressParsingContext *ctx = cls;
- char *exp1, *exp2;
- struct GNUNET_TRANSPORT_PluginFunctions *papi;
- void *addr;
- size_t addr_len;
-
- /* End of string */
- if (ctx->pos - ctx->tmp == ctx->tmp_len)
- return 0;
-
- /* Parsed past the end of string, OR wrong format */
- if ((ctx->pos - ctx->tmp > ctx->tmp_len) || ctx->pos[0] != '!')
+ if (! be_quiet)
{
- GNUNET_break (0);
- return 0;
+ FPRINTF (stderr,
+ _("Wrote %s HELLO containing %u addresses with %u bytes to file `%s'\n"),
+ (GNUNET_YES == GNUNET_HELLO_is_friend_only(hello)) ? "friend-only": "public",
+ c_addr,
+ size,
+ dump_hello);
}
+ GNUNET_free (dump_hello);
+ dump_hello = NULL;
+}
- /* Not enough bytes (3 for three '!', 14 for expiration date, and
- * at least 1 for type and 1 for address (1-byte long address is a joke,
- * but it is not completely unrealistic. Zero-length address is.
- */
- if (ctx->tmp_len - (ctx->pos - ctx->tmp) < 1 /*!*/ * 3 + 14 + /* at least */ 2)
+
+/* ************************* GET URI ************************** */
+
+
+/**
+ * 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)
+{
+ if (NULL == peer)
{
- GNUNET_break (0);
- return 0;
+ 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;
}
- /* Go past the first '!', now we're on expiration date */
- ctx->pos += 1;
- /* Its length is known, so check for the next '!' right away */
- if (ctx->pos[14] != '!')
+
+ if (NULL == hello)
+ return;
+ char *uri = GNUNET_HELLO_compose_uri (hello,
+ &GPI_plugins_find);
+ if (NULL != uri)
{
- GNUNET_break (0);
- return 0;
+ printf ("%s\n",
+ (const char *) uri);
+ GNUNET_free (uri);
}
+}
- memset (&expiration_time, 0, sizeof (struct tm));
- /* This is FAR more strict than strptime(ctx->pos, "%Y%m%d%H%M%S", ...); */
- /* FIXME: make it a separate function, since expiration is specified to every address */
-#define GETNDIGITS(n,cond) \
- strncpy (buf, &ctx->pos[0], n); \
- buf[n] = '\0'; \
- errno = 0; \
- l = strtol (buf, NULL, 10); \
- if (errno != 0 || cond) \
- { \
- GNUNET_break (0); \
- return 0; \
- } \
- ctx->pos += n;
+/* ************************* import HELLO by URI ********************* */
- GETNDIGITS (4, l < 1900)
- expiration_time.tm_year = l - 1900;
- GETNDIGITS (2, l < 1 || l > 12)
- expiration_time.tm_mon = l;
+/**
+ * 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);
+}
- GETNDIGITS (2, l < 1 || l > 31)
- expiration_time.tm_mday = l;
- GETNDIGITS (2, l < 0 || l > 23)
- expiration_time.tm_hour = l;
+/**
+ * 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)
+{
+ struct GNUNET_HELLO_Message *hello = NULL;
- GETNDIGITS (2, l < 0 || l > 59)
- expiration_time.tm_min = l;
+ int ret = GNUNET_HELLO_parse_uri (put_uri,
+ &my_peer_identity.public_key,
+ &hello,
+ &GPI_plugins_find);
- /* 60 - with a leap second */
- GETNDIGITS (2, l < 0 || l > 60)
- expiration_time.tm_sec = l;
+ 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;
+}
- expiration_time.tm_isdst = -1;
-#undef GETNDIGITS
+/* ************************ Main state machine ********************* */
- expiration_seconds = mktime (&expiration_time);
- if (expiration_seconds == (time_t) -1)
- {
- GNUNET_break (0);
- return 0;
- }
- expire.abs_value = expiration_seconds * 1000;
- /* Now we're at '!', advance to the transport type */
- ctx->pos += 1;
+/**
+ * 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;
- /* Find the next '!' that separates transport type from
- * the address
- */
- exp1 = strstr (ctx->pos, "!");
- if (exp1 == NULL)
+ if (NULL != ac)
{
- GNUNET_break (0);
- return 0;
+ GNUNET_PEERINFO_add_peer_cancel (ac);
+ ac = NULL;
}
- /* We need it 0-terminated */
- exp1[0] = '\0';
- /* Find the '!' that separates address from the next record.
- * It might not be there, if this is the last record.
- */
- exp2 = strstr (&exp1[1], "!");
- if (exp2 == NULL)
- exp2 = &ctx->tmp[ctx->tmp_len];
-
- papi = GST_plugins_find (ctx->pos);
- if (papi == NULL)
+ if (GNUNET_SCHEDULER_NO_TASK != tt)
{
- /* 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.
- */
- ctx->pos = exp2 + 1;
- if (ctx->pos - ctx->tmp >= ctx->tmp_len)
- return 0;
- return add_addr_to_hello (cls, max, buffer);
+ GNUNET_SCHEDULER_cancel (tt);
+ tt = GNUNET_SCHEDULER_NO_TASK;
}
-
- if (GNUNET_OK == papi->string_to_address (papi->cls, &exp1[1], exp2 - &exp1[1], &addr, &addr_len))
+ if (NULL != pic)
{
- struct GNUNET_HELLO_Address address;
- int ret;
-
- /* address.peer is unset - not used by add_address() */
- address.address_length = addr_len;
- address.address = addr;
- address.transport_name = ctx->pos;
- ret = GNUNET_HELLO_add_address (&address, expire, buffer, max);
- GNUNET_free (addr);
- ctx->pos = exp2;
- return ret;
+ GNUNET_PEERINFO_iterate_cancel (pic);
+ pic = NULL;
}
- return 0;
-}
-
-void
-parse_hello (const struct GNUNET_CONFIGURATION_Handle *c,
- const char *put_uri)
-{
- int r;
- char *scheme_part = NULL;
- char *path_part = NULL;
- char *exc;
- struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
- int std_result;
- struct GNUNET_HELLO_Message *hello;
- struct GNUNET_PEERINFO_HelloAddressParsingContext ctx;
-
- r = GNUNET_STRINGS_parse_uri (put_uri, &scheme_part, (const char **) &path_part);
- if (r == GNUNET_NO)
- return;
- if (scheme_part == NULL || strcmp (scheme_part, "gnunet://") != 0)
+ while (NULL != (pc = pc_head))
{
- GNUNET_free_non_null (scheme_part);
- return;
+ 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);
}
- GNUNET_free (scheme_part);
-
- if (strncmp (path_part, "hello/", 6) != 0)
- return;
-
- path_part = &path_part[6];
- ctx.tmp = GNUNET_strdup (path_part);
- ctx.tmp_len = strlen (path_part);
- exc = strstr (ctx.tmp, "!");
- if (exc == NULL)
- exc = ctx.pos + ctx.tmp_len;
- ctx.pos = exc;
-
- std_result = GNUNET_STRINGS_string_to_data (ctx.tmp, exc - ctx.tmp,
- (unsigned char *) &pub, sizeof (pub));
- if (std_result != GNUNET_OK)
+ GPI_plugins_unload ();
+ if (NULL != peerinfo)
{
- GNUNET_free (ctx.tmp);
- return;
+ GNUNET_PEERINFO_disconnect (peerinfo);
+ peerinfo = NULL;
}
-
- hello = GNUNET_HELLO_create (&pub, add_addr_to_hello, &ctx);
- GNUNET_free (ctx.tmp);
-
- /* WARNING: this adds the address from URI WITHOUT verification! */
- GNUNET_PEERINFO_add_peer (peerinfo, hello);
}
-static struct GNUNET_TIME_Relative
-receive_stub (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_ATS_Information *ats, uint32_t ats_count,
- struct Session *session, const char *sender_address,
- uint16_t sender_address_len)
-{
- struct GNUNET_TIME_Relative t;
- t.rel_value = 0;
- return t;
-}
+/**
+ * Function called with the result of the check if the PEERINFO
+ * service is running.
+ *
+ * @param cls closure with our configuration
+ * @param result #GNUNET_YES if PEERINFO is running
+ */
static void
-address_notification_stub (void *cls, int add_remove,
- const void *addr, size_t addrlen)
+testservice_task (void *cls,
+ int result)
{
-}
+ struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
+ char *fn;
-static void
-session_end_stub (void *cls, const struct GNUNET_PeerIdentity *peer,
- struct Session * session)
-{
-}
+ if (GNUNET_YES != result)
+ {
+ FPRINTF (stderr,
+ _("Service `%s' is not running, please start GNUnet\n"),
+ "peerinfo");
+ return;
+ }
-static const struct GNUNET_ATS_Information
-address_to_type_stub (void *cls, const struct sockaddr *addr,
- size_t addrlen)
-{
- struct GNUNET_ATS_Information t;
- t.type = 0;
- t.value = 0;
- return t;
+ 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) )
+ {
+ /* load private key */
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_filename (cfg,
+ "PEER",
+ "PRIVATE_KEY",
+ &fn))
+ {
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+ "PEER",
+ "PRIVATE_KEY");
+ return;
+ }
+ if (NULL == (priv = GNUNET_CRYPTO_eddsa_key_create_from_file (fn)))
+ {
+ FPRINTF (stderr,
+ _("Loading hostkey from `%s' failed.\n"),
+ fn);
+ GNUNET_free (fn);
+ return;
+ }
+ GNUNET_free (fn);
+ GNUNET_CRYPTO_eddsa_key_get_public (priv,
+ &my_peer_identity.public_key);
+ GNUNET_free (priv);
+ }
+
+ tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
+ &shutdown_task,
+ NULL);
}
* @param c configuration
*/
static void
-run (void *cls, char *const *args, const char *cfgfile,
+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;
- if (args[0] != NULL)
+ if ( (NULL != args[0]) &&
+ (NULL == put_uri) &&
+ (args[0] == strcasestr (args[0], "gnunet://hello/")) )
{
- FPRINTF (stderr, _("Invalid command line argument `%s'\n"), args[0]);
- return;
+ put_uri = GNUNET_strdup (args[0]);
+ args++;
}
- if (put_uri != NULL && get_uri == GNUNET_YES)
+ if (NULL != args[0])
{
- FPRINTF (stderr, "%s", _("--put-uri and --get-uri are mutually exclusive\n"));
+ FPRINTF (stderr,
+ _("Invalid command line argument `%s'\n"),
+ args[0]);
return;
}
- if (put_uri != NULL || get_uri == GNUNET_YES)
+
+ GNUNET_CLIENT_service_test ("peerinfo",
+ cfg,
+ GNUNET_TIME_UNIT_SECONDS,
+ &testservice_task, (void *) cfg);
+}
+
+
+/**
+ * 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)
{
- peerinfo = GNUNET_PEERINFO_connect (cfg);
- if (peerinfo == NULL)
+ GPI_plugins_load (cfg);
+ if (GNUNET_SYSERR == parse_hello_uri (put_uri))
{
- FPRINTF (stderr, "%s", _("Could not access PEERINFO service. Exiting.\n"));
- return;
+ fprintf (stderr,
+ _("Invalid URI `%s'\n"),
+ put_uri);
+ GNUNET_SCHEDULER_shutdown ();
}
- GST_cfg = c;
- GST_stats = GNUNET_STATISTICS_create ("transport", c);
- /* FIXME: shouldn't we free GST_stats somewhere? */
- GST_plugins_load (receive_stub, address_notification_stub,
- session_end_stub, address_to_type_stub);
- }
- if (put_uri != NULL)
- {
- parse_hello (c, put_uri);
- GST_plugins_unload ();
- GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
- return;
+ GNUNET_free (put_uri);
+ put_uri = NULL;
}
- if (get_self != GNUNET_YES)
+ else if (GNUNET_YES == get_info)
{
- GNUNET_PEERINFO_iterate (peerinfo, NULL,
- GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 5), &print_peer_info,
- NULL);
+ get_info = GNUNET_NO;
+ GPI_plugins_load (cfg);
+ pic = GNUNET_PEERINFO_iterate (peerinfo,
+ include_friend_only,
+ NULL,
+ TIMEOUT,
+ &print_peer_info, NULL);
}
- else
+ else if (GNUNET_YES == get_self)
{
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (cfg, "GNUNETD", "HOSTKEY",
- &fn))
- {
- FPRINTF (stderr, _("Could not find option `%s:%s' in configuration.\n"),
- "GNUNETD", "HOSTKEYFILE");
- return;
- }
- priv = GNUNET_CRYPTO_rsa_key_create_from_file (fn);
- if (priv == NULL)
- {
- 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_free (priv);
- GNUNET_CRYPTO_hash (&pub, sizeof (pub), &pid.hashPubKey);
- GNUNET_CRYPTO_hash_to_enc (&pid.hashPubKey, &enc);
+ get_self = GNUNET_NO;
if (be_quiet)
- printf ("%s\n", (char *) &enc);
+ printf ("%s\n",
+ GNUNET_i2s_full (&my_peer_identity));
else
- printf (_("I am peer `%s'.\n"), (const char *) &enc);
- if (get_uri == GNUNET_YES)
+ 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,
+ TIMEOUT,
+ &print_my_uri, NULL);
+ get_uri = GNUNET_NO;
+ }
+ else if (NULL != dump_hello)
+ {
+ pic = GNUNET_PEERINFO_iterate (peerinfo,
+ include_friend_only,
+ &my_peer_identity,
+ TIMEOUT,
+ &dump_my_hello, NULL);
+ }
+ 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
{
- struct PrintContext *pc;
- char *pkey;
- ssize_t l, pl;
- pc = GNUNET_malloc (sizeof (struct PrintContext));
- pkey = GNUNET_CRYPTO_rsa_public_key_to_string (&pub);
- pl = strlen ("gnunet://hello/");
- l = strlen (pkey) + pl;
- pc->uri = GNUNET_malloc (l + 1);
- strcpy (pc->uri, "gnunet://hello/");
- strcpy (&pc->uri[pl], pkey);
- pc->uri_len = l;
- GNUNET_PEERINFO_iterate (peerinfo, &pid,
- GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
- print_my_uri, pc);
- }
+ GNUNET_SCHEDULER_shutdown ();
}
+ default_operation = GNUNET_NO;
}
{'q', "quiet", NULL,
gettext_noop ("output only the identity strings"),
0, &GNUNET_GETOPT_set_one, &be_quiet},
+ {'f', "friends", NULL,
+ gettext_noop ("include friend-only information"),
+ 0, &GNUNET_GETOPT_set_one, &include_friend_only},
{'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},
+ {'d', "dump-hello", NULL,
+ gettext_noop ("dump hello to file"),
+ 1, &GNUNET_GETOPT_set_string, &dump_hello},
{'g', "get-hello", NULL,
gettext_noop ("also output HELLO uri(s)"),
0, &GNUNET_GETOPT_set_one, &get_uri},
1, &GNUNET_GETOPT_set_string, &put_uri},
GNUNET_GETOPT_OPTION_END
};
- return (GNUNET_OK ==
- GNUNET_PROGRAM_run (argc, argv, "gnunet-peerinfo",
- gettext_noop ("Print information about peers."),
- options, &run, NULL)) ? 0 : 1;
+ 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 ((void*) argv);
+ return ret;
}
/* end of gnunet-peerinfo.c */