#include "gnunet_crypto_lib.h"
#include "gnunet_configuration_lib.h"
#include "gnunet_getopt_lib.h"
-#include "gnunet_peerinfo_service.h"
-#include "gnunet_transport_service.h"
#include "gnunet_program_lib.h"
-#include "gnunet_transport_plugin.h"
+#include "gnunet_hello_lib.h"
+#include "gnunet_transport_service.h"
+#include "gnunet_peerinfo_service.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?
*/
*/
struct GNUNET_TRANSPORT_AddressToStringContext *atsc;
+ /**
+ * Address expiration time
+ */
+ struct GNUNET_TIME_Absolute expiration;
+
/**
* Printable address.
*/
char *result;
-
+
/**
* Print context this address record belongs to.
*/
* Identity of the peer.
*/
struct GNUNET_PeerIdentity peer;
-
+
/**
* List of printable addresses.
*/
*/
unsigned int off;
-};
-
-
-/**
- * Context used for building our own URI.
- */
-struct GetUriContext
-{
/**
- * Final URI.
+ * Hello was friend only, GNUNET_YES or GNUNET_NO
*/
- 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;
+ int friend_only;
};
*/
static int be_quiet;
+/**
+ * Option '-f'
+ */
+static int include_friend_only;
+
/**
* Option '-s'
*/
static int get_self;
/**
- * Option
+ * Option
*/
static int get_uri;
+/**
+ * Option
+ */
+static int default_operation;
+
/**
* Option '-i'
*/
static int get_info;
/**
- * Option
+ * Option
*/
static char *put_uri;
+/**
+ * Option -d
+ */
+static char *dump_hello;
+
/**
* Handle to peerinfo service.
*/
*/
static struct GNUNET_PeerIdentity my_peer_identity;
-/**
- * My public key.
- */
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key;
-
/**
* Head of list of print contexts.
*/
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)
-{
- 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' ******************* */
/**
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++)
{
if (NULL != pc->address_list[i].result)
{
- printf ("\t%s\n", 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);
}
}
GNUNET_free (pc);
if ( (NULL == pc_head) &&
(NULL == pic) )
- tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
+ tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
}
{
struct PrintContext *pc = cls;
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,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 10),
* Currently prints the GNUNET_PeerIdentity and the transport address.
*
* @param cls the 'struct PrintContext'
- * @param peer identity of the peer
+ * @param peer identity of the peer
* @param hello addresses of the peer
* @param err_msg error message
*/
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)
{
pic = NULL; /* end of iteration */
- if (err_msg != NULL)
+ if (NULL != err_msg)
{
- FPRINTF (stderr,
+ FPRINTF (stderr,
_("Error in communication with PEERINFO service: %s\n"),
err_msg);
}
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))
{
- 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_tail,
pc);
pc->peer = *peer;
- GNUNET_HELLO_iterate_addresses (hello,
- GNUNET_NO,
- &count_address,
+ pc->friend_only = friend_only;
+ GNUNET_HELLO_iterate_addresses (hello,
+ GNUNET_NO,
+ &count_address,
pc);
if (0 == pc->off)
{
}
pc->address_list_size = pc->off;
pc->address_list = GNUNET_malloc (sizeof (struct AddressRecord) * pc->off);
- GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO,
+ GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO,
&print_address, pc);
}
+/* ************************* DUMP Hello ************************** */
-/* ************************* 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)
+static int count_addr(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;
+ int *c = cls;
+ (*c) ++;
return GNUNET_OK;
}
-
/**
- * Print URI of the peer.
+ * Write Hello of my peer to a file.
*
* @param cls the 'struct GetUriContext'
* @param peer identity of the peer (unused)
* @param err_msg error message
*/
static void
-print_my_uri (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Message *hello,
+dump_my_hello (void *cls, const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Message *hello,
const char *err_msg)
{
- struct GetUriContext *guc = cls;
-
+ unsigned int size;
+ unsigned int c_addr;
if (peer == NULL)
{
pic = NULL;
if (err_msg != NULL)
FPRINTF (stderr,
- _("Error in communication with PEERINFO service: %s\n"),
+ _("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)
+ if (NULL == hello)
{
- 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;
+ FPRINTF (stderr,
+ _("Failure: Did not receive %s\n"), "HELLO");
+ return;
}
- expire.abs_value = expiration_seconds * 1000;
- if ('!' != tname[0])
+
+ size = GNUNET_HELLO_size (hello);
+ if (0 == size)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Failed to parse HELLO message: malformed\n"));
- ctx->ret = GNUNET_SYSERR;
- GNUNET_break (0);
- return 0;
+ FPRINTF (stderr,
+ _("Failure: Received invalid %s\n"), "HELLO");
+ return;
}
- tname++;
- address = strchr (tname, (int) '!');
- if (NULL == address)
+ 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))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Failed to parse HELLO message: missing transport plugin\n"));
- ctx->ret = GNUNET_SYSERR;
- GNUNET_break (0);
- return 0;
+ 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);
+
}
- 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)
+ c_addr = 0;
+ GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, count_addr, &c_addr);
+
+ if (!be_quiet)
{
- /* 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;
+ 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);
}
- if (NULL == papi->string_to_address)
+
+ GNUNET_free (dump_hello);
+ dump_hello = NULL;
+
+}
+
+
+/* ************************* 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 (peer == NULL)
{
- 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;
+ pic = NULL;
+ if (err_msg != NULL)
+ FPRINTF (stderr,
+ _("Error in communication with PEERINFO service: %s\n"),
+ err_msg);
+ tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
+ return;
}
- 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;
+
+ if (NULL == hello)
+ return;
+ char *uri = GNUNET_HELLO_compose_uri(hello, &GPI_plugins_find);
+ if (NULL != uri) {
+ printf ("%s\n", (const char *) uri);
+ GNUNET_free (uri);
}
- 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;
}
+/* ************************* import HELLO by URI ********************* */
+
+
/**
* Continuation called from 'GNUNET_PEERINFO_add_peer'
*
add_continuation (void *cls,
const char *emsg)
{
- ai = NULL;
+ ac = NULL;
if (NULL != emsg)
fprintf (stderr,
_("Failure adding HELLO: %s\n"),
/**
- * Parse the PUT URI given at the command line and add it to our peerinfo
+ * Parse the PUT URI given at the command line and add it to our peerinfo
* database.
*
* @param put_uri URI string to parse
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);
+ struct GNUNET_HELLO_Message *hello = NULL;
- if (NULL != hello)
- {
+ 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 == ctx.ret)
- ac = GNUNET_PEERINFO_add_peer (peerinfo, hello, NULL, NULL);
+ 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);
/* 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;
+ return ret;
}
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
- struct GNUNET_CRYPTO_RsaPrivateKey *priv;
+ struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
char *fn;
cfg = c;
- if (args[0] != NULL)
+ 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]);
+ FPRINTF (stderr,
+ _("Invalid command line argument `%s'\n"),
+ args[0]);
return;
}
- peerinfo = GNUNET_PEERINFO_connect (cfg);
- if (peerinfo == NULL)
+ 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) )
+ if ( (GNUNET_YES == get_self) || (GNUNET_YES == get_uri) || (NULL != dump_hello) )
{
/* load private key */
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (cfg, "GNUNETD", "HOSTKEY",
- &fn))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "PEER",
+ "PRIVATE_KEY",
+ &fn))
{
- FPRINTF (stderr, _("Could not find option `%s:%s' in configuration.\n"),
- "GNUNETD", "HOSTKEYFILE");
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "PEER", "PRIVATE_KEY");
return;
}
-
- if (NULL == (priv = GNUNET_CRYPTO_rsa_key_create_from_file (fn)))
+ 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_rsa_key_get_public (priv, &my_public_key);
- GNUNET_CRYPTO_rsa_key_free (priv);
- GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key), &my_peer_identity.hashPubKey);
+ GNUNET_CRYPTO_eddsa_key_get_public (priv,
+ &my_peer_identity.public_key);
+ GNUNET_free (priv);
}
tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
{
GPI_plugins_load (cfg);
if (GNUNET_SYSERR == parse_hello_uri (put_uri))
+ {
fprintf (stderr,
_("Invalid URI `%s'\n"),
- put_uri);
+ put_uri);
+ GNUNET_SCHEDULER_shutdown ();
+ }
GNUNET_free (put_uri);
put_uri = NULL;
- return;
}
- if (GNUNET_YES == get_info)
+ else if (GNUNET_YES == get_info)
{
get_info = GNUNET_NO;
GPI_plugins_load (cfg);
- pic = GNUNET_PEERINFO_iterate (peerinfo, NULL,
+ pic = GNUNET_PEERINFO_iterate (peerinfo, include_friend_only, NULL,
TIMEOUT,
&print_peer_info, NULL);
- return;
}
- if (GNUNET_YES == get_self)
+ else 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);
+ printf ("%s\n",
+ GNUNET_i2s_full (&my_peer_identity));
else
- printf (_("I am peer `%s'.\n"), (const char *) &enc);
+ printf (_("I am peer `%s'.\n"),
+ GNUNET_i2s_full (&my_peer_identity));
+ tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
}
- if (GNUNET_YES == get_uri)
+ else 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);
+ pic = GNUNET_PEERINFO_iterate (peerinfo, include_friend_only, &my_peer_identity,
+ TIMEOUT, &print_my_uri, NULL);
get_uri = GNUNET_NO;
- return;
}
- GNUNET_SCHEDULER_shutdown ();
+ 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
+ {
+ GNUNET_SCHEDULER_shutdown ();
+ }
+ default_operation = GNUNET_NO;
}
int
main (int argc, char *const *argv)
{
+ default_operation = GNUNET_YES;
static const struct GNUNET_GETOPT_CommandLineOption options[] = {
{'n', "numeric", NULL,
gettext_noop ("don't resolve host names"),
{'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;
+
+ 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 */
projects / oweals / gnunet.git / blobdiff