/**
* 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 ();
}
/**
* Main function that will be run by the scheduler.
*
* @param cls closure
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param cfg configuration
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_CRYPTO_RsaPrivateKey *pk;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
struct GNUNET_PeerIdentity pid;
if (NULL == args[0])
{
fprintf (stderr, _("No hostkey file specified on command line\n"));
return;
}
if (0 != weak_random)
GNUNET_CRYPTO_random_disable_entropy_gathering ();
if (make_keys > 0)
{
create_keys (args[0]);
return;
}
pk = GNUNET_CRYPTO_rsa_key_create_from_file (args[0]);
if (NULL == pk)
return;
if (print_public_key)
{
char *s;
GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
s = GNUNET_CRYPTO_rsa_public_key_to_string (&pub);
fprintf (stdout, "%s\n", s);
GNUNET_free (s);
}
if (print_peer_identity)
{
struct GNUNET_CRYPTO_HashAsciiEncoded enc;
GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
GNUNET_CRYPTO_hash (&pub, sizeof (pub), &pid.hashPubKey);
GNUNET_CRYPTO_hash_to_enc (&pid.hashPubKey, &enc);
fprintf (stdout, "%s\n", enc.encoding);
}
if (print_short_identity)
{
struct GNUNET_CRYPTO_ShortHashAsciiEncoded enc;
struct GNUNET_CRYPTO_ShortHashCode sh;
GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
GNUNET_CRYPTO_short_hash (&pub, sizeof (pub), &sh);
GNUNET_CRYPTO_short_hash_to_enc (&sh, &enc);
fprintf (stdout, "%s\n", enc.short_encoding);
}
GNUNET_CRYPTO_rsa_key_free (pk);
}
/**
* Compose a hello URI string from a hello message.
*
* @param hello Hello message
* @param plugins_find Function to find transport plugins by name
* @return Hello URI string
*/
char *
GNUNET_HELLO_compose_uri (const struct GNUNET_HELLO_Message *hello,
GNUNET_HELLO_TransportPluginsFind plugins_find)
{
struct GNUNET_HELLO_ComposeUriContext ctx;
ctx.plugins_find = plugins_find;
char *pkey = GNUNET_CRYPTO_rsa_public_key_to_string (&(hello->publicKey));
GNUNET_asprintf (&(ctx.uri),
"%s%s",
GNUNET_HELLO_URI_PREFIX,
pkey);
GNUNET_free (pkey);
GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &add_address_to_uri, &ctx);
return ctx.uri;
}
