/*
This file is part of GNUnet.
- (C) 2001-2014 Christian Grothoff (and other contributing authors)
+ Copyright (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
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
/**
* Main state machine task (if active).
*/
-static GNUNET_SCHEDULER_TaskIdentifier tt;
+static struct GNUNET_SCHEDULER_Task * tt;
+
+/**
+ * Pending #GNUNET_TRANSPORT_get_hello() operation.
+ */
+static struct GNUNET_TRANSPORT_GetHelloHandle *gh;
+
+/**
+ * Connection to transport service.
+ */
+static struct GNUNET_TRANSPORT_Handle *transport;
/**
* Current iterator context (if active, otherwise NULL).
*/
static struct GNUNET_PEERINFO_AddContext *ac;
+/**
+ * Hello of this peer (if initialized).
+ */
+static struct GNUNET_HELLO_Message *my_hello;
+
/**
* Main state machine that goes over all options and
*
* @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,
int res)
{
- struct AddressRecord * ar = cls;
+ struct AddressRecord *ar = cls;
struct PrintContext *pc = ar->pc;
if (NULL != address)
{
- if (NULL == ar->result)
+ 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)
- {
- FPRINTF (stderr,
- _("Failure: Cannot convert address to string for peer `%s'\n"),
- GNUNET_i2s (&ar->pc->peer));
- }
- else
- {
- pc->num_addresses++;
- }
+ 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);
}
{
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:%u:%u",
+ address->transport_name,
+ address->address_length,
+ address->local_info);
ar->atsc = GNUNET_TRANSPORT_address_to_string (cfg,
address,
no_resolve,
- GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 10),
+ TIMEOUT,
&process_resolved_address, ar);
return GNUNET_OK;
}
friend_only = GNUNET_NO;
if (NULL != hello)
friend_only = GNUNET_HELLO_is_friend_only (hello);
- if ((GNUNET_YES == be_quiet) || (NULL == hello))
+ if ( (GNUNET_YES == be_quiet) ||
+ (NULL == hello) )
{
printf ("%s%s\n",
(GNUNET_YES == friend_only) ? "F2F: " : "",
}
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);
+ GNUNET_HELLO_iterate_addresses (hello,
+ GNUNET_NO,
+ &print_address,
+ pc);
}
/* ************************* DUMP Hello ************************** */
/**
- * Write Hello of my peer to a file.
+ * 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
-dump_my_hello (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Message *hello,
- const char *err_msg)
+dump_my_hello ()
{
unsigned int size;
unsigned int c_addr;
- 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)
- {
- FPRINTF (stderr,
- _("Failure: Did not receive %s\n"),
- "HELLO");
- return;
- }
-
- size = GNUNET_HELLO_size (hello);
+ size = GNUNET_HELLO_size (my_hello);
if (0 == size)
{
FPRINTF (stderr,
_("Failure: Received invalid %s\n"),
"HELLO");
- return;
+ return;
}
if (GNUNET_SYSERR ==
- GNUNET_DISK_fn_write (dump_hello, hello, size,
+ GNUNET_DISK_fn_write (dump_hello,
+ my_hello,
+ size,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE |
GNUNET_DISK_PERM_GROUP_READ |
}
c_addr = 0;
- GNUNET_HELLO_iterate_addresses (hello,
+ GNUNET_HELLO_iterate_addresses (my_hello,
GNUNET_NO,
count_addr,
&c_addr);
{
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",
+ (GNUNET_YES == GNUNET_HELLO_is_friend_only (my_hello)) ? "friend-only": "public",
c_addr,
size,
dump_hello);
const struct GNUNET_HELLO_Message *hello,
const char *err_msg)
{
+ char *uri;
+
if (NULL == peer)
{
pic = NULL;
if (NULL == hello)
return;
- char *uri = GNUNET_HELLO_compose_uri (hello,
- &GPI_plugins_find);
+ uri = GNUNET_HELLO_compose_uri (hello,
+ &GPI_plugins_find);
if (NULL != uri)
{
printf ("%s\n",
{
struct GNUNET_HELLO_Message *hello = NULL;
- int ret = GNUNET_HELLO_parse_uri(put_uri,
- &my_peer_identity.public_key,
- &hello,
- &GPI_plugins_find);
+ int ret = GNUNET_HELLO_parse_uri (put_uri,
+ &my_peer_identity.public_key,
+ &hello,
+ &GPI_plugins_find);
if (NULL != hello)
{
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 ret;
}
GNUNET_PEERINFO_add_peer_cancel (ac);
ac = NULL;
}
- if (GNUNET_SCHEDULER_NO_TASK != tt)
+ if (NULL != tt)
{
GNUNET_SCHEDULER_cancel (tt);
- tt = GNUNET_SCHEDULER_NO_TASK;
+ tt = NULL;
}
if (NULL != pic)
{
GNUNET_PEERINFO_iterate_cancel (pic);
pic = NULL;
}
+ if (NULL != gh)
+ {
+ GNUNET_TRANSPORT_get_hello_cancel (gh);
+ gh = NULL;
+ }
+ if (NULL != transport)
+ {
+ GNUNET_TRANSPORT_disconnect (transport);
+ transport = NULL;
+ }
while (NULL != (pc = pc_head))
{
GNUNET_CONTAINER_DLL_remove (pc_head,
GNUNET_PEERINFO_disconnect (peerinfo);
peerinfo = NULL;
}
+ if (NULL != my_hello)
+ {
+ GNUNET_free (my_hello);
+ my_hello = NULL;
+ }
+}
+
+
+/**
+ * Function called with our peer's HELLO message.
+ * Used to obtain our peer's public key.
+ *
+ * @param cls NULL
+ * @param hello the HELLO message
+ */
+static void
+hello_callback (void *cls,
+ const struct GNUNET_MessageHeader *hello)
+{
+ 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_get_hello_cancel (gh);
+ gh = NULL;
+ GNUNET_TRANSPORT_disconnect (transport);
+ transport = NULL;
+ if (NULL != dump_hello)
+ dump_my_hello ();
+ tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
}
testservice_task (void *cls,
int result)
{
- struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
- char *fn;
-
if (GNUNET_YES != result)
{
FPRINTF (stderr,
(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);
+ transport = GNUNET_TRANSPORT_connect (cfg,
+ NULL,
+ NULL,
+ NULL, NULL, NULL);
+ gh = GNUNET_TRANSPORT_get_hello (transport,
+ &hello_callback,
+ NULL);
+ }
+ else
+ {
+ tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
}
-
- tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
state_machine (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- tt = GNUNET_SCHEDULER_NO_TASK;
+ tt = NULL;
if (NULL != put_uri)
{
&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 */
tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
}
else
- {
- GNUNET_SCHEDULER_shutdown ();
+ {
+ GNUNET_SCHEDULER_shutdown ();
}
default_operation = GNUNET_NO;
}
projects / oweals / gnunet.git / blobdiff