X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Fgnunet-transport.c;h=4feb773986f7cd55c9b91dc7c08eb123c16fa97b;hb=f0a8d26b26cda04518e3555373172f6b4940e489;hp=354060ac8e8d21784bb3fb994d3b9efb4cbc530b;hpb=821e1221afc9f9fd127379865bd2e470232bd918;p=oweals%2Fgnunet.git diff --git a/src/transport/gnunet-transport.c b/src/transport/gnunet-transport.c index 354060ac8..4feb77398 100644 --- a/src/transport/gnunet-transport.c +++ b/src/transport/gnunet-transport.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - (C) 2011-2014 Christian Grothoff (and other contributing authors) + Copyright (C) 2011-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 @@ -14,8 +14,8 @@ 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. */ /** @@ -66,11 +66,6 @@ struct ValidationResolutionContext */ struct ValidationResolutionContext *prev; - /** - * Peer identity - */ - struct GNUNET_PeerIdentity id; - /** * Address to resolve */ @@ -148,11 +143,6 @@ struct PeerResolutionContext */ struct PeerResolutionContext *prev; - /** - * The peer id - */ - struct GNUNET_PeerIdentity id; - /** * address to resolve */ @@ -208,7 +198,7 @@ struct TestContext /** * Task identifier for the timeout. */ - GNUNET_SCHEDULER_TaskIdentifier tsk; + struct GNUNET_SCHEDULER_Task * tsk; /** * Name of plugin under test. @@ -281,10 +271,15 @@ static struct GNUNET_TRANSPORT_Handle *handle; static struct GNUNET_CONFIGURATION_Handle *cfg; /** - * Try_connect handle + * Try connect handle */ struct GNUNET_TRANSPORT_TryConnectHandle *tc_handle; +/** + * Try disconnect handle + */ +struct GNUNET_TRANSPORT_TryDisconnectHandle *td_handle; + /** * Option -s. */ @@ -335,6 +330,11 @@ static int monitor_connections; */ static int monitor_validation; +/** + * Option -P. + */ +static int monitor_plugins; + /** * Option -C. */ @@ -386,15 +386,25 @@ static struct GNUNET_TRANSPORT_TransmitHandle *th; static struct GNUNET_CONTAINER_MultiPeerMap *monitored_peers; /** - * + * Map storing information about monitored plugins's sessions. + */ +static struct GNUNET_CONTAINER_MultiPeerMap *monitored_plugins; + +/** + * Handle if we are monitoring peers at the transport level. */ static struct GNUNET_TRANSPORT_PeerMonitoringContext *pic; /** - * + * Handle if we are monitoring transport validation activity. */ static struct GNUNET_TRANSPORT_ValidationMonitoringContext *vic; +/** + * Handle if we are monitoring plugin session activity. + */ +static struct GNUNET_TRANSPORT_PluginMonitor *pm; + /** * Identity of the peer we transmit to / connect to. * (equivalent to 'cpid' string). @@ -404,12 +414,12 @@ static struct GNUNET_PeerIdentity pid; /** * Task scheduled for cleanup / termination of the process. */ -static GNUNET_SCHEDULER_TaskIdentifier end; +static struct GNUNET_SCHEDULER_Task * end; /** * Task for operation timeout */ -static GNUNET_SCHEDULER_TaskIdentifier op_timeout; +static struct GNUNET_SCHEDULER_Task * op_timeout; /** * Selected level of verbosity. @@ -462,6 +472,14 @@ static struct PeerResolutionContext *rc_head; static struct PeerResolutionContext *rc_tail; +/** + * Function called to release data stored in the #monitored_peers map. + * + * @param cls unused + * @param key the peer identity + * @param value a `struct MonitoredPeer` to release + * @return #GNUNET_OK (continue to iterate) + */ static int destroy_it (void *cls, const struct GNUNET_PeerIdentity *key, @@ -493,12 +511,13 @@ shutdown_task (void *cls, struct GNUNET_TIME_Relative duration; struct ValidationResolutionContext *cur; struct ValidationResolutionContext *next; + struct PeerResolutionContext *rc; - end = GNUNET_SCHEDULER_NO_TASK; - if (GNUNET_SCHEDULER_NO_TASK != op_timeout) + end = NULL; + if (NULL != op_timeout) { GNUNET_SCHEDULER_cancel (op_timeout); - op_timeout = GNUNET_SCHEDULER_NO_TASK; + op_timeout = NULL; } if (NULL != tc_handle) { @@ -515,6 +534,11 @@ shutdown_task (void *cls, GNUNET_TRANSPORT_monitor_validation_entries_cancel (vic); vic = NULL; } + if (NULL != pm) + { + GNUNET_TRANSPORT_monitor_plugins_cancel (pm); + pm = NULL; + } next = vc_head; for (cur = next; NULL != cur; cur = next) @@ -522,12 +546,23 @@ shutdown_task (void *cls, next = cur->next; GNUNET_TRANSPORT_address_to_string_cancel (cur->asc); - GNUNET_CONTAINER_DLL_remove (vc_head, vc_tail, cur); + GNUNET_CONTAINER_DLL_remove (vc_head, + vc_tail, + cur); GNUNET_free (cur->transport); GNUNET_HELLO_address_free (cur->addrcp); GNUNET_free (cur); } - + while (NULL != (rc = rc_head)) + { + GNUNET_CONTAINER_DLL_remove (rc_head, + rc_tail, + rc); + GNUNET_TRANSPORT_address_to_string_cancel (rc->asc); + GNUNET_free (rc->transport); + GNUNET_free (rc->addrcp); + GNUNET_free (rc); + } if (NULL != th) { GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); @@ -563,6 +598,13 @@ shutdown_task (void *cls, GNUNET_CONTAINER_multipeermap_destroy (monitored_peers); monitored_peers = NULL; } + if (NULL != monitored_plugins) + { + GNUNET_break (0 == + GNUNET_CONTAINER_multipeermap_size (monitored_plugins)); + GNUNET_CONTAINER_multipeermap_destroy (monitored_plugins); + monitored_plugins = NULL; + } } @@ -572,13 +614,13 @@ operation_timeout (void *cls, { struct PeerResolutionContext *cur; struct PeerResolutionContext *next; - op_timeout = GNUNET_SCHEDULER_NO_TASK; + op_timeout = NULL; if ((try_connect) || (benchmark_send) || (benchmark_receive)) { FPRINTF (stdout, _("Failed to connect to `%s'\n"), GNUNET_i2s_full (&pid)); - if (GNUNET_SCHEDULER_NO_TASK != end) + if (NULL != end) GNUNET_SCHEDULER_cancel (end); end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); ret = 1; @@ -604,7 +646,7 @@ operation_timeout (void *cls, FPRINTF (stdout, "%s", _("Failed to list connections, timeout occured\n")); - if (GNUNET_SCHEDULER_NO_TASK != end) + if (NULL != end) GNUNET_SCHEDULER_cancel (end); end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); ret = 1; @@ -614,7 +656,7 @@ operation_timeout (void *cls, static void -run_nat_test (); +run_nat_test (void); /** @@ -654,25 +696,15 @@ display_test_result (struct TestContext *tc, tc->name); break; default: + FPRINTF (stderr, + _("Configuration for plugin `%s' did not work!\n"), + tc->name); break; } - - if (GNUNET_YES != result) - { - FPRINTF (stderr, - _("Configuration for plugin `%s' did not work!\n"), - tc->name); - } - else - { - FPRINTF (stderr, - _("Configuration for plugin `%s' is working!\n"), - tc->name); - } - if (GNUNET_SCHEDULER_NO_TASK != tc->tsk) + if (NULL != tc->tsk) { GNUNET_SCHEDULER_cancel (tc->tsk); - tc->tsk = GNUNET_SCHEDULER_NO_TASK; + tc->tsk = NULL; } if (NULL != tc->tst) { @@ -695,6 +727,7 @@ display_test_result (struct TestContext *tc, run_nat_test (); } + /** * Function called by NAT to report the outcome of the nat-test. * Clean up and update GUI. @@ -708,14 +741,14 @@ result_callback (void *cls, { struct TestContext *tc = cls; - display_test_result (tc, result); + display_test_result (tc, + result); } /** * Resolve address we got a validation state for to a string. * - * @param id peer identity the address is for * @param address the address itself * @param numeric #GNUNET_YES to disable DNS, #GNUNET_NO to try reverse lookup * @param last_validation when was the address validated last @@ -724,8 +757,7 @@ result_callback (void *cls, * @param state where are we in the validation state machine */ static void -resolve_validation_address (const struct GNUNET_PeerIdentity *id, - const struct GNUNET_HELLO_Address *address, +resolve_validation_address (const struct GNUNET_HELLO_Address *address, int numeric, struct GNUNET_TIME_Absolute last_validation, struct GNUNET_TIME_Absolute valid_until, @@ -764,10 +796,10 @@ process_validation_string (void *cls, if (GNUNET_SYSERR == res) { FPRINTF (stderr, - "Failed to convert address for peer `%s' plugin `%s' length %lu to string \n", - GNUNET_i2s (&vc->id), + "Failed to convert address for peer `%s' plugin `%s' length %u to string \n", + GNUNET_i2s (&vc->addrcp->peer), vc->addrcp->transport_name, - vc->addrcp->address_length); + (unsigned int) vc->addrcp->address_length); } if (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us == vc->valid_until.abs_value_us) s_valid = GNUNET_strdup ("never"); @@ -786,7 +818,7 @@ process_validation_string (void *cls, FPRINTF (stdout, _("Peer `%s' %s %s\n\t%s%s\n\t%s%s\n\t%s%s\n"), - GNUNET_i2s (&vc->id), + GNUNET_i2s (&vc->addrcp->peer), (GNUNET_OK == res) ? address : "", (monitor_validation) ? GNUNET_TRANSPORT_vs2s (vc->state) : "", "Valid until : ", s_valid, @@ -810,8 +842,7 @@ process_validation_string (void *cls, (note: this should be unnecessary, as transport should fallback to numeric lookup internally if DNS takes too long anyway) */ - resolve_validation_address (&vc->id, - vc->addrcp, + resolve_validation_address (vc->addrcp, GNUNET_NO, vc->last_validation, vc->valid_until, @@ -822,7 +853,7 @@ process_validation_string (void *cls, { FPRINTF (stdout, _("Peer `%s' %s `%s' \n"), - GNUNET_i2s (&vc->id), + GNUNET_i2s (&vc->addrcp->peer), "", GNUNET_TRANSPORT_vs2s (vc->state)); } @@ -833,15 +864,15 @@ process_validation_string (void *cls, GNUNET_free (vc); if ((0 == address_resolutions) && (iterate_validation)) { - if (GNUNET_SCHEDULER_NO_TASK != end) + if (NULL != end) { GNUNET_SCHEDULER_cancel (end); - end = GNUNET_SCHEDULER_NO_TASK; + end = NULL; } - if (GNUNET_SCHEDULER_NO_TASK != op_timeout) + if (NULL != op_timeout) { GNUNET_SCHEDULER_cancel (op_timeout); - op_timeout = GNUNET_SCHEDULER_NO_TASK; + op_timeout = NULL; } ret = 0; end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); @@ -852,7 +883,6 @@ process_validation_string (void *cls, /** * Resolve address we got a validation state for to a string. * - * @param id peer identity the address is for * @param address the address itself * @param numeric #GNUNET_YES to disable DNS, #GNUNET_NO to try reverse lookup * @param last_validation when was the address validated last @@ -861,8 +891,7 @@ process_validation_string (void *cls, * @param state where are we in the validation state machine */ static void -resolve_validation_address (const struct GNUNET_PeerIdentity *id, - const struct GNUNET_HELLO_Address *address, +resolve_validation_address (const struct GNUNET_HELLO_Address *address, int numeric, struct GNUNET_TIME_Absolute last_validation, struct GNUNET_TIME_Absolute valid_until, @@ -876,7 +905,6 @@ resolve_validation_address (const struct GNUNET_PeerIdentity *id, GNUNET_CONTAINER_DLL_insert(vc_head, vc_tail, vc); address_resolutions++; - vc->id = (*id); vc->transport = GNUNET_strdup(address->transport_name); vc->addrcp = GNUNET_HELLO_address_copy (address); vc->printed = GNUNET_NO; @@ -898,7 +926,6 @@ resolve_validation_address (const struct GNUNET_PeerIdentity *id, * Resolve address we got a validation state for to a string. * * @param cls NULL - * @param peer peer identity the address is for * @param address the address itself * @param last_validation when was the address validated last * @param valid_until until when is the address valid @@ -907,14 +934,13 @@ resolve_validation_address (const struct GNUNET_PeerIdentity *id, */ static void process_validation_cb (void *cls, - const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute last_validation, struct GNUNET_TIME_Absolute valid_until, struct GNUNET_TIME_Absolute next_validation, enum GNUNET_TRANSPORT_ValidationState state) { - if ((NULL == peer) && (NULL == address)) + if (NULL == address) { if (monitor_validation) { @@ -923,25 +949,13 @@ process_validation_cb (void *cls, _("Monitor disconnected from transport service. Reconnecting.\n")); return; } - - /* done */ - vic = NULL; - if (GNUNET_SCHEDULER_NO_TASK != end) - GNUNET_SCHEDULER_cancel (end); - end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); - return; - } - if ((NULL == peer) || (NULL == address)) - { - /* invalid response */ vic = NULL; - if (GNUNET_SCHEDULER_NO_TASK != end) + if (NULL != end) GNUNET_SCHEDULER_cancel (end); end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); return; } - resolve_validation_address (peer, - address, + resolve_validation_address (address, numeric, last_validation, valid_until, @@ -960,11 +974,12 @@ run_nat_test () (uint16_t) head->adv_port); head->tst = GNUNET_NAT_test_start (cfg, - (0 == strcasecmp (head->name, "udp")) ? GNUNET_NO : GNUNET_YES, - (uint16_t) head->bnd_port, - (uint16_t) head->adv_port, - TIMEOUT, - &result_callback, head); + (0 == strcasecmp (head->name, "udp")) + ? GNUNET_NO : GNUNET_YES, + (uint16_t) head->bnd_port, + (uint16_t) head->adv_port, + TIMEOUT, + &result_callback, head); } @@ -1100,23 +1115,23 @@ notify_connect (void *cls, GNUNET_i2s_full (peer)); ret = 0; - if (GNUNET_SCHEDULER_NO_TASK != op_timeout) + if (NULL != op_timeout) { GNUNET_SCHEDULER_cancel (op_timeout); - op_timeout = GNUNET_SCHEDULER_NO_TASK; + op_timeout = NULL; } - if (GNUNET_SCHEDULER_NO_TASK != end) + if (NULL != end) GNUNET_SCHEDULER_cancel (end); end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); return; } if (benchmark_send) { - if (GNUNET_SCHEDULER_NO_TASK != op_timeout) + if (NULL != op_timeout) { GNUNET_SCHEDULER_cancel (op_timeout); - op_timeout = GNUNET_SCHEDULER_NO_TASK; + op_timeout = NULL; } if (verbosity > 0) FPRINTF (stdout, @@ -1157,13 +1172,13 @@ notify_disconnect (void *cls, GNUNET_i2s_full (peer)); ret = 0; - if (GNUNET_SCHEDULER_NO_TASK != op_timeout) + if (NULL != op_timeout) { GNUNET_SCHEDULER_cancel (op_timeout); - op_timeout = GNUNET_SCHEDULER_NO_TASK; + op_timeout = NULL; } - if (GNUNET_SCHEDULER_NO_TASK != end) + if (NULL != end) GNUNET_SCHEDULER_cancel (end); end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); return; @@ -1178,7 +1193,7 @@ notify_disconnect (void *cls, { FPRINTF (stdout, _("Disconnected from peer `%s' while benchmarking\n"), GNUNET_i2s (&pid)); - if (GNUNET_SCHEDULER_NO_TASK != end) + if (NULL != end) GNUNET_SCHEDULER_cancel (end); return; } @@ -1265,9 +1280,17 @@ notify_receive (void *cls, } +/** + * Convert address to a printable format. + * + * @param address the address + * @param numeric #GNUNET_YES to convert to numeric format, #GNUNET_NO + * to try to use reverse DNS + * @param state state the peer is in + * @param state_timeout when will the peer's state expire + */ static void -resolve_peer_address (const struct GNUNET_PeerIdentity *id, - const struct GNUNET_HELLO_Address *address, +resolve_peer_address (const struct GNUNET_HELLO_Address *address, int numeric, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout); @@ -1333,11 +1356,11 @@ process_peer_string (void *cls, if (GNUNET_SYSERR == res) { FPRINTF (stderr, - "Failed to convert address for peer `%s' plugin `%s' length %lu to string \n", - GNUNET_i2s (&rc->id), + "Failed to convert address for peer `%s' plugin `%s' length %u to string \n", + GNUNET_i2s (&rc->addrcp->peer), rc->addrcp->transport_name, - rc->addrcp->address_length); - print_info (&rc->id, + (unsigned int) rc->addrcp->address_length); + print_info (&rc->addrcp->peer, rc->transport, NULL, rc->state, @@ -1347,7 +1370,7 @@ process_peer_string (void *cls, } if (GNUNET_OK == res) { - print_info (&rc->id, + print_info (&rc->addrcp->peer, rc->transport, address, rc->state, @@ -1360,6 +1383,7 @@ process_peer_string (void *cls, } /* NULL == address, last call, we are done */ + rc->asc = NULL; GNUNET_assert (address_resolutions > 0); address_resolutions--; if (GNUNET_NO == rc->printed) @@ -1370,15 +1394,14 @@ process_peer_string (void *cls, (note: this should not be needed, as transport should fallback to numeric conversion if DNS takes too long) */ - resolve_peer_address (&rc->id, - rc->addrcp, + resolve_peer_address (rc->addrcp, GNUNET_YES, rc->state, rc->state_timeout); } else { - print_info (&rc->id, + print_info (&rc->addrcp->peer, rc->transport, NULL, rc->state, @@ -1391,25 +1414,35 @@ process_peer_string (void *cls, GNUNET_free (rc); if ((0 == address_resolutions) && (iterate_connections)) { - if (GNUNET_SCHEDULER_NO_TASK != end) + if (NULL != end) { GNUNET_SCHEDULER_cancel (end); - end = GNUNET_SCHEDULER_NO_TASK; + end = NULL; } - if (GNUNET_SCHEDULER_NO_TASK != op_timeout) + if (NULL != op_timeout) { GNUNET_SCHEDULER_cancel (op_timeout); - op_timeout = GNUNET_SCHEDULER_NO_TASK; + op_timeout = NULL; } ret = 0; - end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); + end = GNUNET_SCHEDULER_add_now (&shutdown_task, + NULL); } } +/** + * Convert address to a printable format and print it + * together with the given state data. + * + * @param address the address + * @param numeric #GNUNET_YES to convert to numeric format, #GNUNET_NO + * to try to use reverse DNS + * @param state state the peer is in + * @param state_timeout when will the peer's state expire + */ static void -resolve_peer_address (const struct GNUNET_PeerIdentity *id, - const struct GNUNET_HELLO_Address *address, +resolve_peer_address (const struct GNUNET_HELLO_Address *address, int numeric, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout) @@ -1417,12 +1450,11 @@ resolve_peer_address (const struct GNUNET_PeerIdentity *id, struct PeerResolutionContext *rc; rc = GNUNET_new (struct PeerResolutionContext); - GNUNET_assert(NULL != rc); - GNUNET_CONTAINER_DLL_insert(rc_head, rc_tail, rc); + GNUNET_CONTAINER_DLL_insert (rc_head, + rc_tail, + rc); address_resolutions++; - - rc->id = (*id); - rc->transport = GNUNET_strdup(address->transport_name); + rc->transport = GNUNET_strdup (address->transport_name); rc->addrcp = GNUNET_HELLO_address_copy (address); rc->printed = GNUNET_NO; rc->state = state; @@ -1458,7 +1490,7 @@ process_peer_iteration_cb (void *cls, /* done */ address_resolution_in_progress = GNUNET_NO; pic = NULL; - if (GNUNET_SCHEDULER_NO_TASK != end) + if (NULL != end) GNUNET_SCHEDULER_cancel (end); end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); return; @@ -1468,7 +1500,7 @@ process_peer_iteration_cb (void *cls, (GNUNET_NO == GNUNET_TRANSPORT_is_connected(state))) return; /* Display only connected peers */ - if (GNUNET_SCHEDULER_NO_TASK != op_timeout) + if (NULL != op_timeout) GNUNET_SCHEDULER_cancel (op_timeout); op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, @@ -1480,22 +1512,221 @@ process_peer_iteration_cb (void *cls, address->transport_name); if (NULL != address) - resolve_peer_address (peer, address, numeric, state, state_timeout); + resolve_peer_address (address, + numeric, + state, + state_timeout); else - print_info (peer, NULL, NULL, state, state_timeout); + print_info (peer, + NULL, + NULL, + state, + state_timeout); } /** - * Function called with information about a peers + * Context for address resolution by #plugin_monitoring_cb(). + */ +struct PluginMonitorAddress +{ + + /** + * Ongoing resolution request. + */ + struct GNUNET_TRANSPORT_AddressToStringContext *asc; + + /** + * Resolved address as string. + */ + char *str; + + /** + * Last event we got and did not yet print because + * @e str was NULL (address not yet resolved). + */ + struct GNUNET_TRANSPORT_SessionInfo si; +}; + + +/** + * Print information about a plugin monitoring event. + * + * @param addr out internal context + * @param info the monitoring information + */ +static void +print_plugin_event_info (struct PluginMonitorAddress *addr, + const struct GNUNET_TRANSPORT_SessionInfo *info) +{ + const char *state; + + switch (info->state) + { + case GNUNET_TRANSPORT_SS_INIT: + state = "INIT"; + break; + case GNUNET_TRANSPORT_SS_HANDSHAKE: + state = "HANDSHAKE"; + break; + case GNUNET_TRANSPORT_SS_UP: + state = "UP"; + break; + case GNUNET_TRANSPORT_SS_UPDATE: + state = "UPDATE"; + break; + case GNUNET_TRANSPORT_SS_DONE: + state = "DONE"; + break; + default: + state = "UNKNOWN"; + break; + } + fprintf (stdout, + "%s: state %s timeout in %s @ %s%s\n", + GNUNET_i2s (&info->address->peer), + state, + GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (info->session_timeout), + GNUNET_YES), + addr->str, + (info->is_inbound == GNUNET_YES) ? " (INBOUND)" : ""); + fprintf (stdout, + "%s: queue has %3u messages and %6u bytes\n", + GNUNET_i2s (&info->address->peer), + info->num_msg_pending, + info->num_bytes_pending); + if (0 != GNUNET_TIME_absolute_get_remaining (info->receive_delay).rel_value_us) + fprintf (stdout, + "%s: receiving blocked until %s\n", + GNUNET_i2s (&info->address->peer), + GNUNET_STRINGS_absolute_time_to_string (info->receive_delay)); +} + + +/** + * Function called with a textual representation of an address. This + * function will be called several times with different possible + * textual representations, and a last time with @a address being NULL + * to signal the end of the iteration. Note that @a address NULL + * always is the last call, regardless of the value in @a res. * * @param cls closure + * @param address NULL on end of iteration, + * otherwise 0-terminated printable UTF-8 string, + * in particular an empty string if @a res is #GNUNET_NO + * @param res result of the address to string conversion: + * if #GNUNET_OK: conversion successful + * if #GNUNET_NO: address was invalid (or not supported) + * if #GNUNET_SYSERR: communication error (IPC error) + */ +static void +address_cb (void *cls, + const char *address, + int res) +{ + struct PluginMonitorAddress *addr = cls; + + if (NULL == address) + { + addr->asc = NULL; + return; + } + if (NULL != addr->str) + return; + addr->str = GNUNET_strdup (address); + print_plugin_event_info (addr, + &addr->si); +} + + +/** + * Function called by the plugin with information about the + * current sessions managed by the plugin (for monitoring). + * + * @param cls closure (NULL) + * @param session session handle this information is about, + * NULL to indicate that we are "in sync" (initial + * iteration complete) + * @param session_ctx storage location where the application + * can store data; will point to NULL on #GNUNET_TRANSPORT_SS_INIT, + * and must be reset to NULL on #GNUNET_TRANSPORT_SS_DONE + * @param info information about the state of the session, + * NULL if @a session is also NULL and we are + * merely signalling that the initial iteration is over; + * NULL with @a session being non-NULL if the monitor + * was being cancelled while sessions were active + */ +static void +plugin_monitoring_cb (void *cls, + struct GNUNET_TRANSPORT_PluginSession *session, + void **session_ctx, + const struct GNUNET_TRANSPORT_SessionInfo *info) +{ + struct PluginMonitorAddress *addr; + + if ( (NULL == info) && + (NULL == session) ) + return; /* in sync with transport service */ + addr = *session_ctx; + if (NULL == info) + { + if (NULL != addr) + { + if (NULL != addr->asc) + { + GNUNET_TRANSPORT_address_to_string_cancel (addr->asc); + addr->asc = NULL; + } + GNUNET_free_non_null (addr->str); + GNUNET_free (addr); + *session_ctx = NULL; + } + return; /* shutdown */ + } + if ( (NULL != cpid) && + (0 != memcmp (&info->address->peer, + cpid, + sizeof (struct GNUNET_PeerIdentity))) ) + return; /* filtered */ + if (NULL == addr) + { + addr = GNUNET_new (struct PluginMonitorAddress); + addr->asc = GNUNET_TRANSPORT_address_to_string (cfg, + info->address, + numeric, + GNUNET_TIME_UNIT_FOREVER_REL, + &address_cb, + addr); + *session_ctx = addr; + } + if (NULL == addr->str) + addr->si = *info; + else + print_plugin_event_info (addr, + info); + if (GNUNET_TRANSPORT_SS_DONE == info->state) + { + if (NULL != addr->asc) + { + GNUNET_TRANSPORT_address_to_string_cancel (addr->asc); + addr->asc = NULL; + } + GNUNET_free_non_null (addr->str); + GNUNET_free (addr); + *session_ctx = NULL; + } +} + + +/** + * Function called with information about a peers + * + * @param cls closure, NULL * @param peer identity of the peer, NULL for final callback when operation done * @param address binary address used to communicate with this peer, * NULL on disconnect or when done * @param state current state this peer is in * @param state_timeout time out for the current state - * */ static void process_peer_monitoring_cb (void *cls, @@ -1514,28 +1745,34 @@ process_peer_monitoring_cb (void *cls, return; } - if (GNUNET_SCHEDULER_NO_TASK != op_timeout) + if (NULL != op_timeout) GNUNET_SCHEDULER_cancel (op_timeout); op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL); - if (NULL == (m = GNUNET_CONTAINER_multipeermap_get (monitored_peers, peer))) + if (NULL == (m = GNUNET_CONTAINER_multipeermap_get (monitored_peers, + peer))) { m = GNUNET_new (struct MonitoredPeer); - GNUNET_CONTAINER_multipeermap_put (monitored_peers, peer, - m, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST); + GNUNET_CONTAINER_multipeermap_put (monitored_peers, + peer, + m, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST); } else { if ( (m->state == state) && - (m->state_timeout.abs_value_us == state_timeout.abs_value_us) && - ((NULL == address) && (NULL == m->address))) + (m->state_timeout.abs_value_us == state_timeout.abs_value_us) && + (NULL == address) && + (NULL == m->address) ) { return; /* No real change */ } - if ( (m->state == state) && ((NULL != address) && (NULL != m->address)) && - (0 == GNUNET_HELLO_address_cmp(m->address, address))) + if ( (m->state == state) && + (NULL != address) && + (NULL != m->address) && + (0 == GNUNET_HELLO_address_cmp(m->address, address)) ) return; /* No real change */ } @@ -1550,8 +1787,7 @@ process_peer_monitoring_cb (void *cls, m->state_timeout = state_timeout; if (NULL != address) - resolve_peer_address (peer, - m->address, + resolve_peer_address (m->address, numeric, m->state, m->state_timeout); @@ -1564,59 +1800,74 @@ process_peer_monitoring_cb (void *cls, } +/** + * Function called with our result of trying to connect to a peer + * using the transport service. Will retry 10 times, and if we still + * fail to connect terminate with an error message. + * + * @param cls NULL + * @param result #GNUNET_OK if we connected to the service + */ static void try_connect_cb (void *cls, const int result) { static int retries = 0; + tc_handle = NULL; if (GNUNET_OK == result) - { - tc_handle = NULL; return; - } retries++; if (retries < 10) - tc_handle = GNUNET_TRANSPORT_try_connect (handle, &pid, try_connect_cb, - NULL); - else { - FPRINTF (stderr, - "%s", - _("Failed to send connect request to transport service\n")); - if (GNUNET_SCHEDULER_NO_TASK != end) - GNUNET_SCHEDULER_cancel (end); - ret = 1; - end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); + tc_handle = GNUNET_TRANSPORT_try_connect (handle, + &pid, + &try_connect_cb, + NULL); return; } + FPRINTF (stderr, + "%s", + _("Failed to send connect request to transport service\n")); + if (NULL != end) + GNUNET_SCHEDULER_cancel (end); + ret = 1; + end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); } +/** + * Function called with our result of trying to disconnect a peer + * using the transport service. Will retry 10 times, and if we still + * fail to disconnect, terminate with an error message. + * + * @param cls NULL + * @param result #GNUNET_OK if we connected to the service + */ static void try_disconnect_cb (void *cls, const int result) { static int retries = 0; + + td_handle = NULL; if (GNUNET_OK == result) - { - tc_handle = NULL; return; - } retries++; if (retries < 10) - tc_handle = GNUNET_TRANSPORT_try_disconnect (handle, &pid, try_disconnect_cb, - NULL); - else { - FPRINTF (stderr, "%s", - _("Failed to send connect request to transport service\n")); - if (GNUNET_SCHEDULER_NO_TASK != end) - GNUNET_SCHEDULER_cancel (end); - ret = 1; - end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); + td_handle = GNUNET_TRANSPORT_try_disconnect (handle, + &pid, + &try_disconnect_cb, + NULL); return; } + FPRINTF (stderr, "%s", + _("Failed to send disconnect request to transport service\n")); + if (NULL != end) + GNUNET_SCHEDULER_cancel (end); + ret = 1; + end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); } @@ -1628,7 +1879,8 @@ try_disconnect_cb (void *cls, * @param result #GNUNET_YES if transport is running */ static void -testservice_task (void *cls, int result) +testservice_task (void *cls, + int result) { int counter = 0; ret = 1; @@ -1650,22 +1902,22 @@ testservice_task (void *cls, int result) counter = benchmark_send + benchmark_receive + iterate_connections + monitor_connections + monitor_connects + try_connect + try_disconnect + - + iterate_validation + monitor_validation; + + iterate_validation + monitor_validation + monitor_plugins; if (1 < counter) { FPRINTF (stderr, - _("Multiple operations given. Please choose only one operation: %s, %s, %s, %s, %s, %s\n"), + _("Multiple operations given. Please choose only one operation: %s, %s, %s, %s, %s, %s %s\n"), "connect", "benchmark send", "benchmark receive", "information", - "monitor", "events"); + "monitor", "events", "plugins"); return; } if (0 == counter) { FPRINTF (stderr, - _("No operation given. Please choose one operation: %s, %s, %s, %s, %s, %s\n"), + _("No operation given. Please choose one operation: %s, %s, %s, %s, %s, %s, %s\n"), "connect", "benchmark send", "benchmark receive", "information", - "monitor", "events"); + "monitor", "events", "plugins"); return; } @@ -1716,9 +1968,10 @@ testservice_task (void *cls, int result) ret = 1; return; } - tc_handle = GNUNET_TRANSPORT_try_disconnect (handle, &pid, try_disconnect_cb, - NULL); - if (NULL == tc_handle) + td_handle = GNUNET_TRANSPORT_try_disconnect (handle, &pid, + &try_disconnect_cb, + NULL); + if (NULL == td_handle) { FPRINTF (stderr, "%s", _("Failed to send request to transport service\n")); @@ -1738,16 +1991,20 @@ testservice_task (void *cls, int result) ret = 1; return; } - handle = GNUNET_TRANSPORT_connect (cfg, NULL, NULL, ¬ify_receive, - ¬ify_connect, ¬ify_disconnect); + handle = GNUNET_TRANSPORT_connect (cfg, NULL, NULL, + ¬ify_receive, + ¬ify_connect, + ¬ify_disconnect); if (NULL == handle) { FPRINTF (stderr, "%s", _("Failed to connect to transport service\n")); ret = 1; return; } - tc_handle = GNUNET_TRANSPORT_try_connect (handle, &pid, try_connect_cb, - NULL); + tc_handle = GNUNET_TRANSPORT_try_connect (handle, + &pid, + &try_connect_cb, + NULL); if (NULL == tc_handle) { FPRINTF (stderr, "%s", @@ -1756,8 +2013,9 @@ testservice_task (void *cls, int result) return; } start_time = GNUNET_TIME_absolute_get (); - op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, - NULL); + op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, + &operation_timeout, + NULL); } else if (benchmark_receive) /* -b: Benchmark receiving */ { @@ -1784,11 +2042,21 @@ testservice_task (void *cls, int result) } else if (monitor_connections) /* -m: List information about peers continuously */ { - monitored_peers = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO); + monitored_peers = GNUNET_CONTAINER_multipeermap_create (10, + GNUNET_NO); address_resolution_in_progress = GNUNET_YES; - pic = GNUNET_TRANSPORT_monitor_peers (cfg, (NULL == cpid) ? NULL : &pid, - GNUNET_NO, TIMEOUT, - &process_peer_monitoring_cb, (void *) cfg); + pic = GNUNET_TRANSPORT_monitor_peers (cfg, + (NULL == cpid) ? NULL : &pid, + GNUNET_NO, + TIMEOUT, + &process_peer_monitoring_cb, NULL); + } + else if (monitor_plugins) /* -P: List information about plugins continuously */ + { + monitored_plugins = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO); + pm = GNUNET_TRANSPORT_monitor_plugins (cfg, + &plugin_monitoring_cb, + NULL); } else if (iterate_validation) /* -d: Print information about validations */ { @@ -1877,7 +2145,7 @@ main (int argc, char * const *argv) gettext_noop ("print information for all pending validations "), 0, &GNUNET_GETOPT_set_one, &iterate_validation }, { 'f', "monitorvalidation", NULL, - gettext_noop ("print information for all pending validations continously"), + gettext_noop ("print information for all pending validations continuously"), 0, &GNUNET_GETOPT_set_one, &monitor_validation }, { 'i', "information", NULL, gettext_noop ("provide information about all current connections (once)"), @@ -1894,6 +2162,9 @@ main (int argc, char * const *argv) { 'p', "peer", "PEER", gettext_noop ("peer identity"), 1, &GNUNET_GETOPT_set_string, &cpid }, + { 'P', "plugins", NULL, + gettext_noop ("monitor plugin sessions"), 0, &GNUNET_GETOPT_set_one, + &monitor_plugins }, { 's', "send", NULL, gettext_noop ("send data for benchmarking to the other peer (until CTRL-C)"), 0, &GNUNET_GETOPT_set_one, &benchmark_send },