From c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sat, 5 Oct 2019 15:09:28 +0200 Subject: global reindent, now with uncrustify hook enabled --- src/transport/plugin_transport_udp.c | 3821 +++++++++++++++++----------------- 1 file changed, 1915 insertions(+), 1906 deletions(-) (limited to 'src/transport/plugin_transport_udp.c') diff --git a/src/transport/plugin_transport_udp.c b/src/transport/plugin_transport_udp.c index c056bb79c..8d0bbea47 100644 --- a/src/transport/plugin_transport_udp.c +++ b/src/transport/plugin_transport_udp.c @@ -40,13 +40,13 @@ #include "gnunet_transport_plugin.h" #include "transport.h" -#define LOG(kind, ...) GNUNET_log_from(kind, "transport-udp", __VA_ARGS__) +#define LOG(kind, ...) GNUNET_log_from (kind, "transport-udp", __VA_ARGS__) /** * After how much inactivity should a UDP session time out? */ #define UDP_SESSION_TIME_OUT \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60) /** * Number of messages we can defragment in parallel. We only really @@ -71,7 +71,8 @@ /** * UDP Message-Packet header (after defragmentation). */ -struct UDPMessage { +struct UDPMessage +{ /** * Message header. */ @@ -92,7 +93,8 @@ struct UDPMessage { /** * Closure for #append_port(). */ -struct PrettyPrinterContext { +struct PrettyPrinterContext +{ /** * DLL */ @@ -148,7 +150,8 @@ struct PrettyPrinterContext { /** * Session with another peer. */ -struct GNUNET_ATS_Session { +struct GNUNET_ATS_Session +{ /** * Which peer is this session for? */ @@ -248,7 +251,8 @@ struct GNUNET_ATS_Session { * Data structure to track defragmentation contexts based * on the source of the UDP traffic. */ -struct DefragContext { +struct DefragContext +{ /** * Defragmentation context. */ @@ -297,7 +301,8 @@ struct DefragContext { /** * Context to send fragmented messages */ -struct UDP_FragmentationContext { +struct UDP_FragmentationContext +{ /** * Next in linked list */ @@ -387,7 +392,8 @@ typedef void (*QueueContinuation) (void *cls, /** * Information we track for each message in the queue. */ -struct UDP_MessageWrapper { +struct UDP_MessageWrapper +{ /** * Session this message belongs to */ @@ -471,7 +477,8 @@ GNUNET_NETWORK_STRUCT_BEGIN /** * UDP ACK Message-Packet header. */ -struct UDP_ACK_Message { +struct UDP_ACK_Message +{ /** * Message header. */ @@ -505,9 +512,9 @@ GNUNET_NETWORK_STRUCT_END * @param state new state of the session */ static void -notify_session_monitor(struct Plugin *plugin, - struct GNUNET_ATS_Session *session, - enum GNUNET_TRANSPORT_SessionState state) +notify_session_monitor (struct Plugin *plugin, + struct GNUNET_ATS_Session *session, + enum GNUNET_TRANSPORT_SessionState state) { struct GNUNET_TRANSPORT_SessionInfo info; @@ -515,7 +522,7 @@ notify_session_monitor(struct Plugin *plugin, return; if (GNUNET_YES == session->in_destroy) return; /* already destroyed, just RC>0 left-over actions */ - memset(&info, 0, sizeof(info)); + memset (&info, 0, sizeof(info)); info.state = state; info.is_inbound = GNUNET_SYSERR; /* hard to say */ info.num_msg_pending = session->msgs_in_queue; @@ -525,7 +532,7 @@ notify_session_monitor(struct Plugin *plugin, to receive from others) */ info.session_timeout = session->timeout; info.address = session->address; - plugin->sic(plugin->sic_cls, session, &info); + plugin->sic (plugin->sic_cls, session, &info); } @@ -538,15 +545,15 @@ notify_session_monitor(struct Plugin *plugin, * @return #GNUNET_OK (continue to iterate) */ static int -send_session_info_iter(void *cls, - const struct GNUNET_PeerIdentity *peer, - void *value) +send_session_info_iter (void *cls, + const struct GNUNET_PeerIdentity *peer, + void *value) { struct Plugin *plugin = cls; struct GNUNET_ATS_Session *session = value; - notify_session_monitor(plugin, session, GNUNET_TRANSPORT_SS_INIT); - notify_session_monitor(plugin, session, GNUNET_TRANSPORT_SS_UP); + notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_INIT); + notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UP); return GNUNET_OK; } @@ -564,22 +571,22 @@ send_session_info_iter(void *cls, * @param sic_cls closure for @a sic */ static void -udp_plugin_setup_monitor(void *cls, - GNUNET_TRANSPORT_SessionInfoCallback sic, - void *sic_cls) +udp_plugin_setup_monitor (void *cls, + GNUNET_TRANSPORT_SessionInfoCallback sic, + void *sic_cls) { struct Plugin *plugin = cls; plugin->sic = sic; plugin->sic_cls = sic_cls; if (NULL != sic) - { - GNUNET_CONTAINER_multipeermap_iterate(plugin->sessions, - &send_session_info_iter, - plugin); - /* signal end of first iteration */ - sic(sic_cls, NULL, NULL); - } + { + GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions, + &send_session_info_iter, + plugin); + /* signal end of first iteration */ + sic (sic_cls, NULL, NULL); + } } @@ -592,25 +599,25 @@ udp_plugin_setup_monitor(void *cls, * @param s session to free */ static void -free_session(struct GNUNET_ATS_Session *s) +free_session (struct GNUNET_ATS_Session *s) { if (NULL != s->address) - { - GNUNET_HELLO_address_free(s->address); - s->address = NULL; - } + { + GNUNET_HELLO_address_free (s->address); + s->address = NULL; + } if (NULL != s->frag_ctx) - { - GNUNET_FRAGMENT_context_destroy(s->frag_ctx->frag, NULL, NULL); - GNUNET_free(s->frag_ctx); - s->frag_ctx = NULL; - } + { + GNUNET_FRAGMENT_context_destroy (s->frag_ctx->frag, NULL, NULL); + GNUNET_free (s->frag_ctx); + s->frag_ctx = NULL; + } if (NULL != s->mst) - { - GNUNET_MST_destroy(s->mst); - s->mst = NULL; - } - GNUNET_free(s); + { + GNUNET_MST_destroy (s->mst); + s->mst = NULL; + } + GNUNET_free (s); } @@ -623,7 +630,7 @@ free_session(struct GNUNET_ATS_Session *s) * @return keepalive factor */ static unsigned int -udp_query_keepalive_factor(void *cls) +udp_query_keepalive_factor (void *cls) { return 15; } @@ -637,7 +644,7 @@ udp_query_keepalive_factor(void *cls) * @return the network type */ static enum GNUNET_NetworkType -udp_plugin_get_network(void *cls, struct GNUNET_ATS_Session *session) +udp_plugin_get_network (void *cls, struct GNUNET_ATS_Session *session) { return session->scope; } @@ -651,8 +658,8 @@ udp_plugin_get_network(void *cls, struct GNUNET_ATS_Session *session) * @return the network type */ static enum GNUNET_NetworkType -udp_plugin_get_network_for_address(void *cls, - const struct GNUNET_HELLO_Address *address) +udp_plugin_get_network_for_address (void *cls, + const struct GNUNET_HELLO_Address *address) { struct Plugin *plugin = cls; size_t addrlen; @@ -665,39 +672,39 @@ udp_plugin_get_network_for_address(void *cls, addrlen = address->address_length; if (addrlen == sizeof(struct IPv6UdpAddress)) - { - GNUNET_assert(NULL != address->address); /* make static analysis happy */ - u6 = address->address; - memset(&a6, 0, sizeof(a6)); + { + GNUNET_assert (NULL != address->address); /* make static analysis happy */ + u6 = address->address; + memset (&a6, 0, sizeof(a6)); #if HAVE_SOCKADDR_IN_SIN_LEN - a6.sin6_len = sizeof(a6); + a6.sin6_len = sizeof(a6); #endif - a6.sin6_family = AF_INET6; - a6.sin6_port = u6->u6_port; - GNUNET_memcpy(&a6.sin6_addr, &u6->ipv6_addr, sizeof(struct in6_addr)); - sb = &a6; - sbs = sizeof(a6); - } + a6.sin6_family = AF_INET6; + a6.sin6_port = u6->u6_port; + GNUNET_memcpy (&a6.sin6_addr, &u6->ipv6_addr, sizeof(struct in6_addr)); + sb = &a6; + sbs = sizeof(a6); + } else if (addrlen == sizeof(struct IPv4UdpAddress)) - { - GNUNET_assert(NULL != address->address); /* make static analysis happy */ - u4 = address->address; - memset(&a4, 0, sizeof(a4)); + { + GNUNET_assert (NULL != address->address); /* make static analysis happy */ + u4 = address->address; + memset (&a4, 0, sizeof(a4)); #if HAVE_SOCKADDR_IN_SIN_LEN - a4.sin_len = sizeof(a4); + a4.sin_len = sizeof(a4); #endif - a4.sin_family = AF_INET; - a4.sin_port = u4->u4_port; - a4.sin_addr.s_addr = u4->ipv4_addr; - sb = &a4; - sbs = sizeof(a4); - } + a4.sin_family = AF_INET; + a4.sin_port = u4->u4_port; + a4.sin_addr.s_addr = u4->ipv4_addr; + sb = &a4; + sbs = sizeof(a4); + } else - { - GNUNET_break(0); - return GNUNET_NT_UNSPECIFIED; - } - return plugin->env->get_address_type(plugin->env->cls, sb, sbs); + { + GNUNET_break (0); + return GNUNET_NT_UNSPECIFIED; + } + return plugin->env->get_address_type (plugin->env->cls, sb, sbs); } @@ -711,7 +718,7 @@ udp_plugin_get_network_for_address(void *cls, * @param cls the plugin handle */ static void -udp_plugin_select_v4(void *cls); +udp_plugin_select_v4 (void *cls); /** @@ -722,7 +729,7 @@ udp_plugin_select_v4(void *cls); * @param cls the plugin handle */ static void -udp_plugin_select_v6(void *cls); +udp_plugin_select_v6 (void *cls); /** @@ -731,7 +738,7 @@ udp_plugin_select_v6(void *cls); * @param plugin plugin to reschedule */ static void -schedule_select_v4(struct Plugin *plugin) +schedule_select_v4 (struct Plugin *plugin) { struct GNUNET_TIME_Relative min_delay; struct GNUNET_TIME_Relative delay; @@ -739,47 +746,47 @@ schedule_select_v4(struct Plugin *plugin) struct UDP_MessageWrapper *min_udpw; if ((GNUNET_YES == plugin->enable_ipv4) && (NULL != plugin->sockv4)) - { - /* Find a message ready to send: - * Flow delay from other peer is expired or not set (0) */ - min_delay = GNUNET_TIME_UNIT_FOREVER_REL; - min_udpw = NULL; - for (udpw = plugin->ipv4_queue_head; NULL != udpw; udpw = udpw->next) - { - delay = GNUNET_TIME_absolute_get_remaining(udpw->transmission_time); - if (delay.rel_value_us < min_delay.rel_value_us) - { - min_delay = delay; - min_udpw = udpw; - } - } - if (NULL != plugin->select_task_v4) - GNUNET_SCHEDULER_cancel(plugin->select_task_v4); - if (NULL != min_udpw) - { - if (min_delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "Calculated flow delay for UDPv4 at %s for %s\n", - GNUNET_STRINGS_relative_time_to_string(min_delay, - GNUNET_YES), - GNUNET_i2s(&min_udpw->session->target)); - } - else - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Calculated flow delay for UDPv4 at %s for %s\n", - GNUNET_STRINGS_relative_time_to_string(min_delay, - GNUNET_YES), - GNUNET_i2s(&min_udpw->session->target)); - } - } - plugin->select_task_v4 = - GNUNET_SCHEDULER_add_read_net(min_delay, - plugin->sockv4, - &udp_plugin_select_v4, - plugin); - } + { + /* Find a message ready to send: + * Flow delay from other peer is expired or not set (0) */ + min_delay = GNUNET_TIME_UNIT_FOREVER_REL; + min_udpw = NULL; + for (udpw = plugin->ipv4_queue_head; NULL != udpw; udpw = udpw->next) + { + delay = GNUNET_TIME_absolute_get_remaining (udpw->transmission_time); + if (delay.rel_value_us < min_delay.rel_value_us) + { + min_delay = delay; + min_udpw = udpw; + } + } + if (NULL != plugin->select_task_v4) + GNUNET_SCHEDULER_cancel (plugin->select_task_v4); + if (NULL != min_udpw) + { + if (min_delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Calculated flow delay for UDPv4 at %s for %s\n", + GNUNET_STRINGS_relative_time_to_string (min_delay, + GNUNET_YES), + GNUNET_i2s (&min_udpw->session->target)); + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Calculated flow delay for UDPv4 at %s for %s\n", + GNUNET_STRINGS_relative_time_to_string (min_delay, + GNUNET_YES), + GNUNET_i2s (&min_udpw->session->target)); + } + } + plugin->select_task_v4 = + GNUNET_SCHEDULER_add_read_net (min_delay, + plugin->sockv4, + &udp_plugin_select_v4, + plugin); + } } @@ -789,7 +796,7 @@ schedule_select_v4(struct Plugin *plugin) * @param plugin plugin to reschedule */ static void -schedule_select_v6(struct Plugin *plugin) +schedule_select_v6 (struct Plugin *plugin) { struct GNUNET_TIME_Relative min_delay; struct GNUNET_TIME_Relative delay; @@ -797,45 +804,45 @@ schedule_select_v6(struct Plugin *plugin) struct UDP_MessageWrapper *min_udpw; if ((GNUNET_YES == plugin->enable_ipv6) && (NULL != plugin->sockv6)) - { - min_delay = GNUNET_TIME_UNIT_FOREVER_REL; - min_udpw = NULL; - for (udpw = plugin->ipv6_queue_head; NULL != udpw; udpw = udpw->next) - { - delay = GNUNET_TIME_absolute_get_remaining(udpw->transmission_time); - if (delay.rel_value_us < min_delay.rel_value_us) - { - min_delay = delay; - min_udpw = udpw; - } - } - if (NULL != plugin->select_task_v6) - GNUNET_SCHEDULER_cancel(plugin->select_task_v6); - if (NULL != min_udpw) - { - if (min_delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "Calculated flow delay for UDPv6 at %s for %s\n", - GNUNET_STRINGS_relative_time_to_string(min_delay, - GNUNET_YES), - GNUNET_i2s(&min_udpw->session->target)); - } - else - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Calculated flow delay for UDPv6 at %s for %s\n", - GNUNET_STRINGS_relative_time_to_string(min_delay, - GNUNET_YES), - GNUNET_i2s(&min_udpw->session->target)); - } - } - plugin->select_task_v6 = - GNUNET_SCHEDULER_add_read_net(min_delay, - plugin->sockv6, - &udp_plugin_select_v6, - plugin); - } + { + min_delay = GNUNET_TIME_UNIT_FOREVER_REL; + min_udpw = NULL; + for (udpw = plugin->ipv6_queue_head; NULL != udpw; udpw = udpw->next) + { + delay = GNUNET_TIME_absolute_get_remaining (udpw->transmission_time); + if (delay.rel_value_us < min_delay.rel_value_us) + { + min_delay = delay; + min_udpw = udpw; + } + } + if (NULL != plugin->select_task_v6) + GNUNET_SCHEDULER_cancel (plugin->select_task_v6); + if (NULL != min_udpw) + { + if (min_delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Calculated flow delay for UDPv6 at %s for %s\n", + GNUNET_STRINGS_relative_time_to_string (min_delay, + GNUNET_YES), + GNUNET_i2s (&min_udpw->session->target)); + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Calculated flow delay for UDPv6 at %s for %s\n", + GNUNET_STRINGS_relative_time_to_string (min_delay, + GNUNET_YES), + GNUNET_i2s (&min_udpw->session->target)); + } + } + plugin->select_task_v6 = + GNUNET_SCHEDULER_add_read_net (min_delay, + plugin->sockv6, + &udp_plugin_select_v6, + plugin); + } } @@ -854,7 +861,7 @@ schedule_select_v6(struct Plugin *plugin) * @return string representing the same address */ const char * -udp_address_to_string(void *cls, const void *addr, size_t addrlen) +udp_address_to_string (void *cls, const void *addr, size_t addrlen) { static char rbuf[INET6_ADDRSTRLEN + 10]; char buf[INET6_ADDRSTRLEN]; @@ -868,42 +875,42 @@ udp_address_to_string(void *cls, const void *addr, size_t addrlen) uint32_t options; if (NULL == addr) - { - GNUNET_break_op(0); - return NULL; - } + { + GNUNET_break_op (0); + return NULL; + } if (addrlen == sizeof(struct IPv6UdpAddress)) - { - t6 = addr; - af = AF_INET6; - options = ntohl(t6->options); - port = ntohs(t6->u6_port); - a6 = t6->ipv6_addr; - sb = &a6; - } + { + t6 = addr; + af = AF_INET6; + options = ntohl (t6->options); + port = ntohs (t6->u6_port); + a6 = t6->ipv6_addr; + sb = &a6; + } else if (addrlen == sizeof(struct IPv4UdpAddress)) - { - t4 = addr; - af = AF_INET; - options = ntohl(t4->options); - port = ntohs(t4->u4_port); - a4.s_addr = t4->ipv4_addr; - sb = &a4; - } + { + t4 = addr; + af = AF_INET; + options = ntohl (t4->options); + port = ntohs (t4->u4_port); + a4.s_addr = t4->ipv4_addr; + sb = &a4; + } else - { - GNUNET_break_op(0); - return NULL; - } - inet_ntop(af, sb, buf, INET6_ADDRSTRLEN); - GNUNET_snprintf(rbuf, - sizeof(rbuf), - (af == AF_INET6) ? "%s.%u.[%s]:%u" : "%s.%u.%s:%u", - PLUGIN_NAME, - options, - buf, - port); + { + GNUNET_break_op (0); + return NULL; + } + inet_ntop (af, sb, buf, INET6_ADDRSTRLEN); + GNUNET_snprintf (rbuf, + sizeof(rbuf), + (af == AF_INET6) ? "%s.%u.[%s]:%u" : "%s.%u.%s:%u", + PLUGIN_NAME, + options, + buf, + port); return rbuf; } @@ -920,11 +927,11 @@ udp_address_to_string(void *cls, const void *addr, size_t addrlen) * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure */ static int -udp_string_to_address(void *cls, - const char *addr, - uint16_t addrlen, - void **buf, - size_t *added) +udp_string_to_address (void *cls, + const char *addr, + uint16_t addrlen, + void **buf, + size_t *added) { struct sockaddr_storage socket_address; char *address; @@ -938,59 +945,59 @@ udp_string_to_address(void *cls, optionstr = NULL; if ((NULL == addr) || (0 == addrlen)) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } + { + GNUNET_break (0); + return GNUNET_SYSERR; + } if ('\0' != addr[addrlen - 1]) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } - if (strlen(addr) != addrlen - 1) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } - plugin = GNUNET_strdup(addr); - optionstr = strchr(plugin, '.'); + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + if (strlen (addr) != addrlen - 1) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + plugin = GNUNET_strdup (addr); + optionstr = strchr (plugin, '.'); if (NULL == optionstr) - { - GNUNET_break(0); - GNUNET_free(plugin); - return GNUNET_SYSERR; - } + { + GNUNET_break (0); + GNUNET_free (plugin); + return GNUNET_SYSERR; + } optionstr[0] = '\0'; optionstr++; - options = atol(optionstr); - address = strchr(optionstr, '.'); + options = atol (optionstr); + address = strchr (optionstr, '.'); if (NULL == address) - { - GNUNET_break(0); - GNUNET_free(plugin); - return GNUNET_SYSERR; - } + { + GNUNET_break (0); + GNUNET_free (plugin); + return GNUNET_SYSERR; + } address[0] = '\0'; address++; if (GNUNET_OK != - GNUNET_STRINGS_to_address_ip(address, strlen(address), &socket_address)) - { - GNUNET_break(0); - GNUNET_free(plugin); - return GNUNET_SYSERR; - } - GNUNET_free(plugin); + GNUNET_STRINGS_to_address_ip (address, strlen (address), &socket_address)) + { + GNUNET_break (0); + GNUNET_free (plugin); + return GNUNET_SYSERR; + } + GNUNET_free (plugin); switch (socket_address.ss_family) - { - case AF_INET: { + { + case AF_INET: { struct IPv4UdpAddress *u4; const struct sockaddr_in *in4 = - (const struct sockaddr_in *)&socket_address; + (const struct sockaddr_in *) &socket_address; - u4 = GNUNET_new(struct IPv4UdpAddress); - u4->options = htonl(options); + u4 = GNUNET_new (struct IPv4UdpAddress); + u4->options = htonl (options); u4->ipv4_addr = in4->sin_addr.s_addr; u4->u4_port = in4->sin_port; *buf = u4; @@ -998,13 +1005,13 @@ udp_string_to_address(void *cls, return GNUNET_OK; } - case AF_INET6: { + case AF_INET6: { struct IPv6UdpAddress *u6; const struct sockaddr_in6 *in6 = - (const struct sockaddr_in6 *)&socket_address; + (const struct sockaddr_in6 *) &socket_address; - u6 = GNUNET_new(struct IPv6UdpAddress); - u6->options = htonl(options); + u6 = GNUNET_new (struct IPv6UdpAddress); + u6->options = htonl (options); u6->ipv6_addr = in6->sin6_addr; u6->u6_port = in6->sin6_port; *buf = u6; @@ -1012,10 +1019,10 @@ udp_string_to_address(void *cls, return GNUNET_OK; } - default: - GNUNET_break(0); - return GNUNET_SYSERR; - } + default: + GNUNET_break (0); + return GNUNET_SYSERR; + } } @@ -1026,39 +1033,39 @@ udp_string_to_address(void *cls, * @param hostname result from DNS resolver */ static void -append_port(void *cls, const char *hostname) +append_port (void *cls, const char *hostname) { struct PrettyPrinterContext *ppc = cls; struct Plugin *plugin = ppc->plugin; char *ret; if (NULL == hostname) - { - /* Final call, done */ - GNUNET_CONTAINER_DLL_remove(plugin->ppc_dll_head, - plugin->ppc_dll_tail, - ppc); - ppc->resolver_handle = NULL; - ppc->asc(ppc->asc_cls, NULL, GNUNET_OK); - GNUNET_free(ppc); - return; - } + { + /* Final call, done */ + GNUNET_CONTAINER_DLL_remove (plugin->ppc_dll_head, + plugin->ppc_dll_tail, + ppc); + ppc->resolver_handle = NULL; + ppc->asc (ppc->asc_cls, NULL, GNUNET_OK); + GNUNET_free (ppc); + return; + } if (GNUNET_YES == ppc->ipv6) - GNUNET_asprintf(&ret, - "%s.%u.[%s]:%d", - PLUGIN_NAME, - ppc->options, - hostname, - ppc->port); + GNUNET_asprintf (&ret, + "%s.%u.[%s]:%d", + PLUGIN_NAME, + ppc->options, + hostname, + ppc->port); else - GNUNET_asprintf(&ret, - "%s.%u.%s:%d", - PLUGIN_NAME, - ppc->options, - hostname, - ppc->port); - ppc->asc(ppc->asc_cls, ret, GNUNET_OK); - GNUNET_free(ret); + GNUNET_asprintf (&ret, + "%s.%u.%s:%d", + PLUGIN_NAME, + ppc->options, + hostname, + ppc->port); + ppc->asc (ppc->asc_cls, ret, GNUNET_OK); + GNUNET_free (ret); } @@ -1077,14 +1084,14 @@ append_port(void *cls, const char *hostname) * @param asc_cls closure for @a asc */ static void -udp_plugin_address_pretty_printer(void *cls, - const char *type, - const void *addr, - size_t addrlen, - int numeric, - struct GNUNET_TIME_Relative timeout, - GNUNET_TRANSPORT_AddressStringCallback asc, - void *asc_cls) +udp_plugin_address_pretty_printer (void *cls, + const char *type, + const void *addr, + size_t addrlen, + int numeric, + struct GNUNET_TIME_Relative timeout, + GNUNET_TRANSPORT_AddressStringCallback asc, + void *asc_cls) { struct Plugin *plugin = cls; struct PrettyPrinterContext *ppc; @@ -1098,44 +1105,44 @@ udp_plugin_address_pretty_printer(void *cls, uint32_t options; if (addrlen == sizeof(struct IPv6UdpAddress)) - { - u6 = addr; - memset(&a6, 0, sizeof(a6)); - a6.sin6_family = AF_INET6; + { + u6 = addr; + memset (&a6, 0, sizeof(a6)); + a6.sin6_family = AF_INET6; #if HAVE_SOCKADDR_IN_SIN_LEN - a6.sin6_len = sizeof(a6); + a6.sin6_len = sizeof(a6); #endif - a6.sin6_port = u6->u6_port; - a6.sin6_addr = u6->ipv6_addr; - port = ntohs(u6->u6_port); - options = ntohl(u6->options); - sb = (const struct sockaddr *)&a6; - sbs = sizeof(a6); - } + a6.sin6_port = u6->u6_port; + a6.sin6_addr = u6->ipv6_addr; + port = ntohs (u6->u6_port); + options = ntohl (u6->options); + sb = (const struct sockaddr *) &a6; + sbs = sizeof(a6); + } else if (addrlen == sizeof(struct IPv4UdpAddress)) - { - u4 = addr; - memset(&a4, 0, sizeof(a4)); - a4.sin_family = AF_INET; + { + u4 = addr; + memset (&a4, 0, sizeof(a4)); + a4.sin_family = AF_INET; #if HAVE_SOCKADDR_IN_SIN_LEN - a4.sin_len = sizeof(a4); + a4.sin_len = sizeof(a4); #endif - a4.sin_port = u4->u4_port; - a4.sin_addr.s_addr = u4->ipv4_addr; - port = ntohs(u4->u4_port); - options = ntohl(u4->options); - sb = (const struct sockaddr *)&a4; - sbs = sizeof(a4); - } + a4.sin_port = u4->u4_port; + a4.sin_addr.s_addr = u4->ipv4_addr; + port = ntohs (u4->u4_port); + options = ntohl (u4->options); + sb = (const struct sockaddr *) &a4; + sbs = sizeof(a4); + } else - { - /* invalid address */ - GNUNET_break_op(0); - asc(asc_cls, NULL, GNUNET_SYSERR); - asc(asc_cls, NULL, GNUNET_OK); - return; - } - ppc = GNUNET_new(struct PrettyPrinterContext); + { + /* invalid address */ + GNUNET_break_op (0); + asc (asc_cls, NULL, GNUNET_SYSERR); + asc (asc_cls, NULL, GNUNET_OK); + return; + } + ppc = GNUNET_new (struct PrettyPrinterContext); ppc->plugin = plugin; ppc->asc = asc; ppc->asc_cls = asc_cls; @@ -1145,13 +1152,13 @@ udp_plugin_address_pretty_printer(void *cls, ppc->ipv6 = GNUNET_YES; else ppc->ipv6 = GNUNET_NO; - GNUNET_CONTAINER_DLL_insert(plugin->ppc_dll_head, plugin->ppc_dll_tail, ppc); - ppc->resolver_handle = GNUNET_RESOLVER_hostname_get(sb, - sbs, - !numeric, - timeout, - &append_port, - ppc); + GNUNET_CONTAINER_DLL_insert (plugin->ppc_dll_head, plugin->ppc_dll_tail, ppc); + ppc->resolver_handle = GNUNET_RESOLVER_hostname_get (sb, + sbs, + ! numeric, + timeout, + &append_port, + ppc); } @@ -1165,7 +1172,7 @@ udp_plugin_address_pretty_printer(void *cls, * @return #GNUNET_OK if port is either our open or advertised port */ static int -check_port(const struct Plugin *plugin, uint16_t in_port) +check_port (const struct Plugin *plugin, uint16_t in_port) { if ((plugin->port == in_port) || (plugin->aport == in_port)) return GNUNET_OK; @@ -1189,56 +1196,56 @@ check_port(const struct Plugin *plugin, uint16_t in_port) * and transport, #GNUNET_SYSERR if not */ static int -udp_plugin_check_address(void *cls, const void *addr, size_t addrlen) +udp_plugin_check_address (void *cls, const void *addr, size_t addrlen) { struct Plugin *plugin = cls; const struct IPv4UdpAddress *v4; const struct IPv6UdpAddress *v6; if (sizeof(struct IPv4UdpAddress) == addrlen) - { - struct sockaddr_in s4; + { + struct sockaddr_in s4; - v4 = (const struct IPv4UdpAddress *)addr; - if (GNUNET_OK != check_port(plugin, ntohs(v4->u4_port))) - return GNUNET_SYSERR; - memset(&s4, 0, sizeof(s4)); - s4.sin_family = AF_INET; + v4 = (const struct IPv4UdpAddress *) addr; + if (GNUNET_OK != check_port (plugin, ntohs (v4->u4_port))) + return GNUNET_SYSERR; + memset (&s4, 0, sizeof(s4)); + s4.sin_family = AF_INET; #if HAVE_SOCKADDR_IN_SIN_LEN - s4.sin_len = sizeof(s4); + s4.sin_len = sizeof(s4); #endif - s4.sin_port = v4->u4_port; - s4.sin_addr.s_addr = v4->ipv4_addr; + s4.sin_port = v4->u4_port; + s4.sin_addr.s_addr = v4->ipv4_addr; - if (GNUNET_OK != - GNUNET_NAT_test_address(plugin->nat, &s4, sizeof(struct sockaddr_in))) - return GNUNET_SYSERR; - } + if (GNUNET_OK != + GNUNET_NAT_test_address (plugin->nat, &s4, sizeof(struct sockaddr_in))) + return GNUNET_SYSERR; + } else if (sizeof(struct IPv6UdpAddress) == addrlen) - { - struct sockaddr_in6 s6; - - v6 = (const struct IPv6UdpAddress *)addr; - if (IN6_IS_ADDR_LINKLOCAL(&v6->ipv6_addr)) - return GNUNET_OK; /* plausible, if unlikely... */ - memset(&s6, 0, sizeof(s6)); - s6.sin6_family = AF_INET6; + { + struct sockaddr_in6 s6; + + v6 = (const struct IPv6UdpAddress *) addr; + if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr)) + return GNUNET_OK; /* plausible, if unlikely... */ + memset (&s6, 0, sizeof(s6)); + s6.sin6_family = AF_INET6; #if HAVE_SOCKADDR_IN_SIN_LEN - s6.sin6_len = sizeof(s6); + s6.sin6_len = sizeof(s6); #endif - s6.sin6_port = v6->u6_port; - s6.sin6_addr = v6->ipv6_addr; + s6.sin6_port = v6->u6_port; + s6.sin6_addr = v6->ipv6_addr; - if (GNUNET_OK != GNUNET_NAT_test_address(plugin->nat, - &s6, - sizeof(struct sockaddr_in6))) - return GNUNET_SYSERR; - } - else - { - GNUNET_break_op(0); + if (GNUNET_OK != GNUNET_NAT_test_address (plugin->nat, + &s6, + sizeof(struct sockaddr_in6))) return GNUNET_SYSERR; - } + } + else + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -1256,12 +1263,12 @@ udp_plugin_check_address(void *cls, const void *addr, size_t addrlen) * @param addrlen actual length of the @a addr */ static void -udp_nat_port_map_callback(void *cls, - void **app_ctx, - int add_remove, - enum GNUNET_NAT_AddressClass ac, - const struct sockaddr *addr, - socklen_t addrlen) +udp_nat_port_map_callback (void *cls, + void **app_ctx, + int add_remove, + enum GNUNET_NAT_AddressClass ac, + const struct sockaddr *addr, + socklen_t addrlen) { struct Plugin *plugin = cls; struct GNUNET_HELLO_Address *address; @@ -1270,23 +1277,23 @@ udp_nat_port_map_callback(void *cls, void *arg; size_t args; - (void)app_ctx; - LOG(GNUNET_ERROR_TYPE_DEBUG, - (GNUNET_YES == add_remove) ? "NAT notification to add address `%s'\n" - : "NAT notification to remove address `%s'\n", - GNUNET_a2s(addr, addrlen)); + (void) app_ctx; + LOG (GNUNET_ERROR_TYPE_DEBUG, + (GNUNET_YES == add_remove) ? "NAT notification to add address `%s'\n" + : "NAT notification to remove address `%s'\n", + GNUNET_a2s (addr, addrlen)); /* convert 'address' to our internal format */ switch (addr->sa_family) - { - case AF_INET: { + { + case AF_INET: { const struct sockaddr_in *i4; - GNUNET_assert(sizeof(struct sockaddr_in) == addrlen); - i4 = (const struct sockaddr_in *)addr; - if (0 == ntohs(i4->sin_port)) + GNUNET_assert (sizeof(struct sockaddr_in) == addrlen); + i4 = (const struct sockaddr_in *) addr; + if (0 == ntohs (i4->sin_port)) return; /* Port = 0 means unmapped, ignore these for UDP. */ - memset(&u4, 0, sizeof(u4)); - u4.options = htonl(plugin->myoptions); + memset (&u4, 0, sizeof(u4)); + u4.options = htonl (plugin->myoptions); u4.ipv4_addr = i4->sin_addr.s_addr; u4.u4_port = i4->sin_port; arg = &u4; @@ -1294,15 +1301,15 @@ udp_nat_port_map_callback(void *cls, break; } - case AF_INET6: { + case AF_INET6: { const struct sockaddr_in6 *i6; - GNUNET_assert(sizeof(struct sockaddr_in6) == addrlen); - i6 = (const struct sockaddr_in6 *)addr; - if (0 == ntohs(i6->sin6_port)) + GNUNET_assert (sizeof(struct sockaddr_in6) == addrlen); + i6 = (const struct sockaddr_in6 *) addr; + if (0 == ntohs (i6->sin6_port)) return; /* Port = 0 means unmapped, ignore these for UDP. */ - memset(&u6, 0, sizeof(u6)); - u6.options = htonl(plugin->myoptions); + memset (&u6, 0, sizeof(u6)); + u6.options = htonl (plugin->myoptions); u6.ipv6_addr = i6->sin6_addr; u6.u6_port = i6->sin6_port; arg = &u6; @@ -1310,19 +1317,19 @@ udp_nat_port_map_callback(void *cls, break; } - default: - GNUNET_break(0); - return; - } + default: + GNUNET_break (0); + return; + } /* modify our published address list */ /* TODO: use 'ac' here in the future... */ - address = GNUNET_HELLO_address_allocate(plugin->env->my_identity, - PLUGIN_NAME, - arg, - args, - GNUNET_HELLO_ADDRESS_INFO_NONE); - plugin->env->notify_address(plugin->env->cls, add_remove, address); - GNUNET_HELLO_address_free(address); + address = GNUNET_HELLO_address_allocate (plugin->env->my_identity, + PLUGIN_NAME, + arg, + args, + GNUNET_HELLO_ADDRESS_INFO_NONE); + plugin->env->notify_address (plugin->env->cls, add_remove, address); + GNUNET_HELLO_address_free (address); } @@ -1332,7 +1339,8 @@ udp_nat_port_map_callback(void *cls, /** * Closure for #session_cmp_it(). */ -struct GNUNET_ATS_SessionCompareContext { +struct GNUNET_ATS_SessionCompareContext +{ /** * Set to session matching the address. */ @@ -1354,17 +1362,17 @@ struct GNUNET_ATS_SessionCompareContext { * @return #GNUNET_NO if we found the session, #GNUNET_OK if not */ static int -session_cmp_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value) +session_cmp_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value) { struct GNUNET_ATS_SessionCompareContext *cctx = cls; struct GNUNET_ATS_Session *s = value; - if (0 == GNUNET_HELLO_address_cmp(s->address, cctx->address)) - { - GNUNET_assert(GNUNET_NO == s->in_destroy); - cctx->res = s; - return GNUNET_NO; - } + if (0 == GNUNET_HELLO_address_cmp (s->address, cctx->address)) + { + GNUNET_assert (GNUNET_NO == s->in_destroy); + cctx->res = s; + return GNUNET_NO; + } return GNUNET_OK; } @@ -1379,8 +1387,8 @@ session_cmp_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value) * @return the session if it exists, or NULL if it is not found */ static struct GNUNET_ATS_Session * -udp_plugin_lookup_session(void *cls, - const struct GNUNET_HELLO_Address *address) +udp_plugin_lookup_session (void *cls, + const struct GNUNET_HELLO_Address *address) { struct Plugin *plugin = cls; const struct IPv6UdpAddress *udp_a6; @@ -1388,54 +1396,54 @@ udp_plugin_lookup_session(void *cls, struct GNUNET_ATS_SessionCompareContext cctx; if (NULL == address->address) - { - GNUNET_break(0); - return NULL; - } + { + GNUNET_break (0); + return NULL; + } if (sizeof(struct IPv4UdpAddress) == address->address_length) + { + if (NULL == plugin->sockv4) + return NULL; + udp_a4 = (const struct IPv4UdpAddress *) address->address; + if (0 == udp_a4->u4_port) { - if (NULL == plugin->sockv4) - return NULL; - udp_a4 = (const struct IPv4UdpAddress *)address->address; - if (0 == udp_a4->u4_port) - { - GNUNET_break(0); - return NULL; - } + GNUNET_break (0); + return NULL; } + } else if (sizeof(struct IPv6UdpAddress) == address->address_length) + { + if (NULL == plugin->sockv6) + return NULL; + udp_a6 = (const struct IPv6UdpAddress *) address->address; + if (0 == udp_a6->u6_port) { - if (NULL == plugin->sockv6) - return NULL; - udp_a6 = (const struct IPv6UdpAddress *)address->address; - if (0 == udp_a6->u6_port) - { - GNUNET_break(0); - return NULL; - } - } - else - { - GNUNET_break(0); + GNUNET_break (0); return NULL; } + } + else + { + GNUNET_break (0); + return NULL; + } /* check if session already exists */ cctx.address = address; cctx.res = NULL; - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Looking for existing session for peer `%s' with address `%s'\n", - GNUNET_i2s(&address->peer), - udp_address_to_string(plugin, - address->address, - address->address_length)); - GNUNET_CONTAINER_multipeermap_get_multiple(plugin->sessions, - &address->peer, - &session_cmp_it, - &cctx); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Looking for existing session for peer `%s' with address `%s'\n", + GNUNET_i2s (&address->peer), + udp_address_to_string (plugin, + address->address, + address->address_length)); + GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessions, + &address->peer, + &session_cmp_it, + &cctx); if (NULL == cctx.res) return NULL; - LOG(GNUNET_ERROR_TYPE_DEBUG, "Found existing session %p\n", cctx.res); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Found existing session %p\n", cctx.res); return cctx.res; } @@ -1449,12 +1457,12 @@ udp_plugin_lookup_session(void *cls, * @param s session to reschedule timeout activity for */ static void -reschedule_session_timeout(struct GNUNET_ATS_Session *s) +reschedule_session_timeout (struct GNUNET_ATS_Session *s) { if (GNUNET_YES == s->in_destroy) return; - GNUNET_assert(NULL != s->timeout_task); - s->timeout = GNUNET_TIME_relative_to_absolute(UDP_SESSION_TIME_OUT); + GNUNET_assert (NULL != s->timeout_task); + s->timeout = GNUNET_TIME_relative_to_absolute (UDP_SESSION_TIME_OUT); } @@ -1468,22 +1476,22 @@ reschedule_session_timeout(struct GNUNET_ATS_Session *s) * @param session which session is being updated */ static void -udp_plugin_update_session_timeout(void *cls, - const struct GNUNET_PeerIdentity *peer, - struct GNUNET_ATS_Session *session) +udp_plugin_update_session_timeout (void *cls, + const struct GNUNET_PeerIdentity *peer, + struct GNUNET_ATS_Session *session) { struct Plugin *plugin = cls; if (GNUNET_YES != - GNUNET_CONTAINER_multipeermap_contains_value(plugin->sessions, - peer, - session)) - { - GNUNET_break(0); - return; - } + GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessions, + peer, + session)) + { + GNUNET_break (0); + return; + } /* Reschedule session timeout */ - reschedule_session_timeout(session); + reschedule_session_timeout (session); } @@ -1498,47 +1506,47 @@ udp_plugin_update_session_timeout(void *cls, * @param udpw message wrapper to dequeue */ static void -dequeue(struct Plugin *plugin, struct UDP_MessageWrapper *udpw) +dequeue (struct Plugin *plugin, struct UDP_MessageWrapper *udpw) { struct GNUNET_ATS_Session *session = udpw->session; if (plugin->bytes_in_buffer < udpw->msg_size) - { - GNUNET_break(0); - } + { + GNUNET_break (0); + } else - { - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total bytes in send buffers", - -(long long)udpw->msg_size, - GNUNET_NO); - plugin->bytes_in_buffer -= udpw->msg_size; - } - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total messages in send buffers", - -1, - GNUNET_NO); + { + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total bytes in send buffers", + -(long long) udpw->msg_size, + GNUNET_NO); + plugin->bytes_in_buffer -= udpw->msg_size; + } + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total messages in send buffers", + -1, + GNUNET_NO); if (sizeof(struct IPv4UdpAddress) == udpw->session->address->address_length) - { - GNUNET_CONTAINER_DLL_remove(plugin->ipv4_queue_head, - plugin->ipv4_queue_tail, - udpw); - } + { + GNUNET_CONTAINER_DLL_remove (plugin->ipv4_queue_head, + plugin->ipv4_queue_tail, + udpw); + } else if (sizeof(struct IPv6UdpAddress) == udpw->session->address->address_length) - { - GNUNET_CONTAINER_DLL_remove(plugin->ipv6_queue_head, - plugin->ipv6_queue_tail, - udpw); - } + { + GNUNET_CONTAINER_DLL_remove (plugin->ipv6_queue_head, + plugin->ipv6_queue_tail, + udpw); + } else - { - GNUNET_break(0); - return; - } - GNUNET_assert(session->msgs_in_queue > 0); + { + GNUNET_break (0); + return; + } + GNUNET_assert (session->msgs_in_queue > 0); session->msgs_in_queue--; - GNUNET_assert(session->bytes_in_queue >= udpw->msg_size); + GNUNET_assert (session->bytes_in_queue >= udpw->msg_size); session->bytes_in_queue -= udpw->msg_size; } @@ -1550,56 +1558,56 @@ dequeue(struct Plugin *plugin, struct UDP_MessageWrapper *udpw) * @param udpw message wrapper to queue */ static void -enqueue(struct Plugin *plugin, struct UDP_MessageWrapper *udpw) +enqueue (struct Plugin *plugin, struct UDP_MessageWrapper *udpw) { struct GNUNET_ATS_Session *session = udpw->session; if (GNUNET_YES == session->in_destroy) - { - GNUNET_break(0); - GNUNET_free(udpw); - return; - } + { + GNUNET_break (0); + GNUNET_free (udpw); + return; + } if (plugin->bytes_in_buffer > INT64_MAX - udpw->msg_size) - { - GNUNET_break(0); - } + { + GNUNET_break (0); + } else - { - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total bytes in send buffers", - udpw->msg_size, - GNUNET_NO); - plugin->bytes_in_buffer += udpw->msg_size; - } - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total messages in send buffers", - 1, - GNUNET_NO); + { + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total bytes in send buffers", + udpw->msg_size, + GNUNET_NO); + plugin->bytes_in_buffer += udpw->msg_size; + } + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total messages in send buffers", + 1, + GNUNET_NO); if (sizeof(struct IPv4UdpAddress) == udpw->session->address->address_length) - { - GNUNET_CONTAINER_DLL_insert(plugin->ipv4_queue_head, - plugin->ipv4_queue_tail, - udpw); - } + { + GNUNET_CONTAINER_DLL_insert (plugin->ipv4_queue_head, + plugin->ipv4_queue_tail, + udpw); + } else if (sizeof(struct IPv6UdpAddress) == udpw->session->address->address_length) - { - GNUNET_CONTAINER_DLL_insert(plugin->ipv6_queue_head, - plugin->ipv6_queue_tail, - udpw); - } + { + GNUNET_CONTAINER_DLL_insert (plugin->ipv6_queue_head, + plugin->ipv6_queue_tail, + udpw); + } else - { - GNUNET_break(0); - udpw->cont(udpw->cont_cls, - &session->target, - GNUNET_SYSERR, - udpw->msg_size, - 0); - GNUNET_free(udpw); - return; - } + { + GNUNET_break (0); + udpw->cont (udpw->cont_cls, + &session->target, + GNUNET_SYSERR, + udpw->msg_size, + 0); + GNUNET_free (udpw); + return; + } session->msgs_in_queue++; session->bytes_in_queue += udpw->msg_size; } @@ -1616,7 +1624,7 @@ enqueue(struct Plugin *plugin, struct UDP_MessageWrapper *udpw) * #GNUNET_SYSERR if the transmission failed */ static void -fragmented_message_done(struct UDP_FragmentationContext *frag_ctx, int result) +fragmented_message_done (struct UDP_FragmentationContext *frag_ctx, int result) { struct Plugin *plugin = frag_ctx->plugin; struct GNUNET_ATS_Session *s = frag_ctx->session; @@ -1625,122 +1633,122 @@ fragmented_message_done(struct UDP_FragmentationContext *frag_ctx, int result) size_t overhead; struct GNUNET_TIME_Relative delay; - LOG(GNUNET_ERROR_TYPE_DEBUG, - "%p: Fragmented message removed with result %s\n", - frag_ctx, - (result == GNUNET_SYSERR) ? "FAIL" : "SUCCESS"); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "%p: Fragmented message removed with result %s\n", + frag_ctx, + (result == GNUNET_SYSERR) ? "FAIL" : "SUCCESS"); /* Call continuation for fragmented message */ if (frag_ctx->on_wire_size >= frag_ctx->payload_size) overhead = frag_ctx->on_wire_size - frag_ctx->payload_size; else overhead = frag_ctx->on_wire_size; - delay = GNUNET_TIME_absolute_get_duration(frag_ctx->start_time); + delay = GNUNET_TIME_absolute_get_duration (frag_ctx->start_time); if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) - { - LOG(GNUNET_ERROR_TYPE_WARNING, - "Fragmented message acknowledged after %s (expected at %s)\n", - GNUNET_STRINGS_relative_time_to_string(delay, GNUNET_YES), - GNUNET_STRINGS_absolute_time_to_string(frag_ctx->next_frag_time)); - } + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "Fragmented message acknowledged after %s (expected at %s)\n", + GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES), + GNUNET_STRINGS_absolute_time_to_string (frag_ctx->next_frag_time)); + } else - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Fragmented message acknowledged after %s (expected at %s)\n", - GNUNET_STRINGS_relative_time_to_string(delay, GNUNET_YES), - GNUNET_STRINGS_absolute_time_to_string(frag_ctx->next_frag_time)); - } + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Fragmented message acknowledged after %s (expected at %s)\n", + GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES), + GNUNET_STRINGS_absolute_time_to_string (frag_ctx->next_frag_time)); + } if (NULL != frag_ctx->cont) - frag_ctx->cont(frag_ctx->cont_cls, - &s->target, - result, - s->frag_ctx->payload_size, - frag_ctx->on_wire_size); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented messages active", - -1, - GNUNET_NO); + frag_ctx->cont (frag_ctx->cont_cls, + &s->target, + result, + s->frag_ctx->payload_size, + frag_ctx->on_wire_size); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented messages active", + -1, + GNUNET_NO); if (GNUNET_OK == result) - { - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented msgs, messages, sent, success", - 1, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented msgs, bytes payload, sent, success", - s->frag_ctx->payload_size, - GNUNET_NO); - GNUNET_STATISTICS_update( - plugin->env->stats, - "# UDP, fragmented msgs, bytes overhead, sent, success", - overhead, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total, bytes overhead, sent", - overhead, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total, bytes payload, sent", - s->frag_ctx->payload_size, - GNUNET_NO); - } + { + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented msgs, messages, sent, success", + 1, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented msgs, bytes payload, sent, success", + s->frag_ctx->payload_size, + GNUNET_NO); + GNUNET_STATISTICS_update ( + plugin->env->stats, + "# UDP, fragmented msgs, bytes overhead, sent, success", + overhead, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total, bytes overhead, sent", + overhead, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total, bytes payload, sent", + s->frag_ctx->payload_size, + GNUNET_NO); + } else - { - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented msgs, messages, sent, failure", - 1, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented msgs, bytes payload, sent, failure", - s->frag_ctx->payload_size, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented msgs, bytes payload, sent, failure", - overhead, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented msgs, bytes payload, sent, failure", - overhead, - GNUNET_NO); - } + { + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented msgs, messages, sent, failure", + 1, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented msgs, bytes payload, sent, failure", + s->frag_ctx->payload_size, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented msgs, bytes payload, sent, failure", + overhead, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented msgs, bytes payload, sent, failure", + overhead, + GNUNET_NO); + } /* Remove remaining fragments from queue, no need to transmit those any longer. */ if (s->address->address_length == sizeof(struct IPv6UdpAddress)) - { - udpw = plugin->ipv6_queue_head; - while (NULL != udpw) - { - tmp = udpw->next; - if ((udpw->frag_ctx != NULL) && (udpw->frag_ctx == frag_ctx)) - { - dequeue(plugin, udpw); - GNUNET_free(udpw); - } - udpw = tmp; - } - } + { + udpw = plugin->ipv6_queue_head; + while (NULL != udpw) + { + tmp = udpw->next; + if ((udpw->frag_ctx != NULL) && (udpw->frag_ctx == frag_ctx)) + { + dequeue (plugin, udpw); + GNUNET_free (udpw); + } + udpw = tmp; + } + } if (s->address->address_length == sizeof(struct IPv4UdpAddress)) - { - udpw = plugin->ipv4_queue_head; - while (NULL != udpw) - { - tmp = udpw->next; - if ((NULL != udpw->frag_ctx) && (udpw->frag_ctx == frag_ctx)) - { - dequeue(plugin, udpw); - GNUNET_free(udpw); - } - udpw = tmp; - } - } - notify_session_monitor(s->plugin, s, GNUNET_TRANSPORT_SS_UPDATE); - GNUNET_FRAGMENT_context_destroy(frag_ctx->frag, - &s->last_expected_msg_delay, - &s->last_expected_ack_delay); + { + udpw = plugin->ipv4_queue_head; + while (NULL != udpw) + { + tmp = udpw->next; + if ((NULL != udpw->frag_ctx) && (udpw->frag_ctx == frag_ctx)) + { + dequeue (plugin, udpw); + GNUNET_free (udpw); + } + udpw = tmp; + } + } + notify_session_monitor (s->plugin, s, GNUNET_TRANSPORT_SS_UPDATE); + GNUNET_FRAGMENT_context_destroy (frag_ctx->frag, + &s->last_expected_msg_delay, + &s->last_expected_ack_delay); s->frag_ctx = NULL; - GNUNET_free(frag_ctx); + GNUNET_free (frag_ctx); } @@ -1753,45 +1761,45 @@ fragmented_message_done(struct UDP_FragmentationContext *frag_ctx, int result) * @param result #GNUNET_OK on success, #GNUNET_SYSERR on failure */ static void -qc_fragment_sent(void *cls, struct UDP_MessageWrapper *udpw, int result) +qc_fragment_sent (void *cls, struct UDP_MessageWrapper *udpw, int result) { struct Plugin *plugin = cls; - GNUNET_assert(NULL != udpw->frag_ctx); + GNUNET_assert (NULL != udpw->frag_ctx); if (GNUNET_OK == result) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Fragment of message with %u bytes transmitted to %s\n", - (unsigned int)udpw->payload_size, - GNUNET_i2s(&udpw->session->target)); - GNUNET_FRAGMENT_context_transmission_done(udpw->frag_ctx->frag); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented msgs, fragments, sent, success", - 1, - GNUNET_NO); - GNUNET_STATISTICS_update( - plugin->env->stats, - "# UDP, fragmented msgs, fragments bytes, sent, success", - udpw->msg_size, - GNUNET_NO); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Fragment of message with %u bytes transmitted to %s\n", + (unsigned int) udpw->payload_size, + GNUNET_i2s (&udpw->session->target)); + GNUNET_FRAGMENT_context_transmission_done (udpw->frag_ctx->frag); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented msgs, fragments, sent, success", + 1, + GNUNET_NO); + GNUNET_STATISTICS_update ( + plugin->env->stats, + "# UDP, fragmented msgs, fragments bytes, sent, success", + udpw->msg_size, + GNUNET_NO); + } else - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Failed to transmit fragment of message with %u bytes to %s\n", - (unsigned int)udpw->payload_size, - GNUNET_i2s(&udpw->session->target)); - fragmented_message_done(udpw->frag_ctx, GNUNET_SYSERR); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented msgs, fragments, sent, failure", - 1, - GNUNET_NO); - GNUNET_STATISTICS_update( - plugin->env->stats, - "# UDP, fragmented msgs, fragments bytes, sent, failure", - udpw->msg_size, - GNUNET_NO); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Failed to transmit fragment of message with %u bytes to %s\n", + (unsigned int) udpw->payload_size, + GNUNET_i2s (&udpw->session->target)); + fragmented_message_done (udpw->frag_ctx, GNUNET_SYSERR); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented msgs, fragments, sent, failure", + 1, + GNUNET_NO); + GNUNET_STATISTICS_update ( + plugin->env->stats, + "# UDP, fragmented msgs, fragments bytes, sent, failure", + udpw->msg_size, + GNUNET_NO); + } } @@ -1805,35 +1813,35 @@ qc_fragment_sent(void *cls, struct UDP_MessageWrapper *udpw, int result) * @param msg the message that was created */ static void -enqueue_fragment(void *cls, const struct GNUNET_MessageHeader *msg) +enqueue_fragment (void *cls, const struct GNUNET_MessageHeader *msg) { struct UDP_FragmentationContext *frag_ctx = cls; struct Plugin *plugin = frag_ctx->plugin; struct UDP_MessageWrapper *udpw; struct GNUNET_ATS_Session *session = frag_ctx->session; - size_t msg_len = ntohs(msg->size); + size_t msg_len = ntohs (msg->size); - LOG(GNUNET_ERROR_TYPE_DEBUG, "Enqueuing fragment with %u bytes\n", msg_len); - udpw = GNUNET_malloc(sizeof(struct UDP_MessageWrapper) + msg_len); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Enqueuing fragment with %u bytes\n", msg_len); + udpw = GNUNET_malloc (sizeof(struct UDP_MessageWrapper) + msg_len); udpw->session = session; - udpw->msg_buf = (char *)&udpw[1]; + udpw->msg_buf = (char *) &udpw[1]; udpw->msg_size = msg_len; udpw->payload_size = msg_len; /* FIXME: minus fragment overhead */ udpw->timeout = frag_ctx->timeout; udpw->start_time = frag_ctx->start_time; udpw->transmission_time = frag_ctx->next_frag_time; frag_ctx->next_frag_time = - GNUNET_TIME_absolute_add(frag_ctx->next_frag_time, - frag_ctx->flow_delay_from_other_peer); + GNUNET_TIME_absolute_add (frag_ctx->next_frag_time, + frag_ctx->flow_delay_from_other_peer); udpw->frag_ctx = frag_ctx; udpw->qc = &qc_fragment_sent; udpw->qc_cls = plugin; - GNUNET_memcpy(udpw->msg_buf, msg, msg_len); - enqueue(plugin, udpw); + GNUNET_memcpy (udpw->msg_buf, msg, msg_len); + enqueue (plugin, udpw); if (session->address->address_length == sizeof(struct IPv4UdpAddress)) - schedule_select_v4(plugin); + schedule_select_v4 (plugin); else - schedule_select_v6(plugin); + schedule_select_v6 (plugin); } @@ -1846,7 +1854,7 @@ enqueue_fragment(void *cls, const struct GNUNET_MessageHeader *msg) * @param result #GNUNET_OK on success, #GNUNET_SYSERR on failure */ static void -qc_message_sent(void *cls, struct UDP_MessageWrapper *udpw, int result) +qc_message_sent (void *cls, struct UDP_MessageWrapper *udpw, int result) { struct Plugin *plugin = cls; size_t overhead; @@ -1858,68 +1866,68 @@ qc_message_sent(void *cls, struct UDP_MessageWrapper *udpw, int result) overhead = udpw->msg_size; if (NULL != udpw->cont) - { - delay = GNUNET_TIME_absolute_get_duration(udpw->start_time); - if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) - { - LOG(GNUNET_ERROR_TYPE_WARNING, - "Message sent via UDP with delay of %s\n", - GNUNET_STRINGS_relative_time_to_string(delay, GNUNET_YES)); - } - else - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Message sent via UDP with delay of %s\n", - GNUNET_STRINGS_relative_time_to_string(delay, GNUNET_YES)); - } - udpw->cont(udpw->cont_cls, - &udpw->session->target, - result, - udpw->payload_size, - overhead); - } + { + delay = GNUNET_TIME_absolute_get_duration (udpw->start_time); + if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "Message sent via UDP with delay of %s\n", + GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); + } + else + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Message sent via UDP with delay of %s\n", + GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); + } + udpw->cont (udpw->cont_cls, + &udpw->session->target, + result, + udpw->payload_size, + overhead); + } if (GNUNET_OK == result) - { - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, unfragmented msgs, messages, sent, success", - 1, - GNUNET_NO); - GNUNET_STATISTICS_update( - plugin->env->stats, - "# UDP, unfragmented msgs, bytes payload, sent, success", - udpw->payload_size, - GNUNET_NO); - GNUNET_STATISTICS_update( - plugin->env->stats, - "# UDP, unfragmented msgs, bytes overhead, sent, success", - overhead, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total, bytes overhead, sent", - overhead, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total, bytes payload, sent", - udpw->payload_size, - GNUNET_NO); - } + { + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, unfragmented msgs, messages, sent, success", + 1, + GNUNET_NO); + GNUNET_STATISTICS_update ( + plugin->env->stats, + "# UDP, unfragmented msgs, bytes payload, sent, success", + udpw->payload_size, + GNUNET_NO); + GNUNET_STATISTICS_update ( + plugin->env->stats, + "# UDP, unfragmented msgs, bytes overhead, sent, success", + overhead, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total, bytes overhead, sent", + overhead, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total, bytes payload, sent", + udpw->payload_size, + GNUNET_NO); + } else - { - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, unfragmented msgs, messages, sent, failure", - 1, - GNUNET_NO); - GNUNET_STATISTICS_update( - plugin->env->stats, - "# UDP, unfragmented msgs, bytes payload, sent, failure", - udpw->payload_size, - GNUNET_NO); - GNUNET_STATISTICS_update( - plugin->env->stats, - "# UDP, unfragmented msgs, bytes overhead, sent, failure", - overhead, - GNUNET_NO); - } + { + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, unfragmented msgs, messages, sent, failure", + 1, + GNUNET_NO); + GNUNET_STATISTICS_update ( + plugin->env->stats, + "# UDP, unfragmented msgs, bytes payload, sent, failure", + udpw->payload_size, + GNUNET_NO); + GNUNET_STATISTICS_update ( + plugin->env->stats, + "# UDP, unfragmented msgs, bytes overhead, sent, failure", + overhead, + GNUNET_NO); + } } @@ -1951,14 +1959,14 @@ qc_message_sent(void *cls, struct UDP_MessageWrapper *udpw, int result) * and does NOT mean that the message was not transmitted (DV) */ static ssize_t -udp_plugin_send(void *cls, - struct GNUNET_ATS_Session *s, - const char *msgbuf, - size_t msgbuf_size, - unsigned int priority, - struct GNUNET_TIME_Relative to, - GNUNET_TRANSPORT_TransmitContinuation cont, - void *cont_cls) +udp_plugin_send (void *cls, + struct GNUNET_ATS_Session *s, + const char *msgbuf, + size_t msgbuf_size, + unsigned int priority, + struct GNUNET_TIME_Relative to, + GNUNET_TRANSPORT_TransmitContinuation cont, + void *cont_cls) { struct Plugin *plugin = cls; size_t udpmlen = msgbuf_size + sizeof(struct UDPMessage); @@ -1975,30 +1983,30 @@ udp_plugin_send(void *cls, (NULL == plugin->sockv4)) return GNUNET_SYSERR; if (udpmlen >= GNUNET_MAX_MESSAGE_SIZE) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } + { + GNUNET_break (0); + return GNUNET_SYSERR; + } if (GNUNET_YES != - GNUNET_CONTAINER_multipeermap_contains_value(plugin->sessions, - &s->target, - s)) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } - LOG(GNUNET_ERROR_TYPE_DEBUG, - "UDP transmits %u-byte message to `%s' using address `%s'\n", - udpmlen, - GNUNET_i2s(&s->target), - udp_address_to_string(plugin, - s->address->address, - s->address->address_length)); - - udp = (struct UDPMessage *)mbuf; - udp->header.size = htons(udpmlen); - udp->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE); - udp->reserved = htonl(0); + GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessions, + &s->target, + s)) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "UDP transmits %u-byte message to `%s' using address `%s'\n", + udpmlen, + GNUNET_i2s (&s->target), + udp_address_to_string (plugin, + s->address->address, + s->address->address_length)); + + udp = (struct UDPMessage *) mbuf; + udp->header.size = htons (udpmlen); + udp->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE); + udp->reserved = htonl (0); udp->sender = *plugin->env->my_identity; /* We do not update the session time out here! Otherwise this @@ -2010,100 +2018,100 @@ udp_plugin_send(void *cls, * responses! */ if (udpmlen <= UDP_MTU) - { - /* unfragmented message */ - udpw = GNUNET_malloc(sizeof(struct UDP_MessageWrapper) + udpmlen); - udpw->session = s; - udpw->msg_buf = (char *)&udpw[1]; - udpw->msg_size = udpmlen; /* message size with UDP overhead */ - udpw->payload_size = msgbuf_size; /* message size without UDP overhead */ - udpw->start_time = GNUNET_TIME_absolute_get(); - udpw->timeout = GNUNET_TIME_relative_to_absolute(to); - udpw->transmission_time = s->last_transmit_time; - s->last_transmit_time = - GNUNET_TIME_absolute_add(s->last_transmit_time, - s->flow_delay_from_other_peer); - udpw->cont = cont; - udpw->cont_cls = cont_cls; - udpw->frag_ctx = NULL; - udpw->qc = &qc_message_sent; - udpw->qc_cls = plugin; - GNUNET_memcpy(udpw->msg_buf, udp, sizeof(struct UDPMessage)); - GNUNET_memcpy(&udpw->msg_buf[sizeof(struct UDPMessage)], - msgbuf, - msgbuf_size); - enqueue(plugin, udpw); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, unfragmented messages queued total", - 1, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, unfragmented bytes payload queued total", - msgbuf_size, - GNUNET_NO); - if (s->address->address_length == sizeof(struct IPv4UdpAddress)) - schedule_select_v4(plugin); - else - schedule_select_v6(plugin); - } + { + /* unfragmented message */ + udpw = GNUNET_malloc (sizeof(struct UDP_MessageWrapper) + udpmlen); + udpw->session = s; + udpw->msg_buf = (char *) &udpw[1]; + udpw->msg_size = udpmlen; /* message size with UDP overhead */ + udpw->payload_size = msgbuf_size; /* message size without UDP overhead */ + udpw->start_time = GNUNET_TIME_absolute_get (); + udpw->timeout = GNUNET_TIME_relative_to_absolute (to); + udpw->transmission_time = s->last_transmit_time; + s->last_transmit_time = + GNUNET_TIME_absolute_add (s->last_transmit_time, + s->flow_delay_from_other_peer); + udpw->cont = cont; + udpw->cont_cls = cont_cls; + udpw->frag_ctx = NULL; + udpw->qc = &qc_message_sent; + udpw->qc_cls = plugin; + GNUNET_memcpy (udpw->msg_buf, udp, sizeof(struct UDPMessage)); + GNUNET_memcpy (&udpw->msg_buf[sizeof(struct UDPMessage)], + msgbuf, + msgbuf_size); + enqueue (plugin, udpw); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, unfragmented messages queued total", + 1, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, unfragmented bytes payload queued total", + msgbuf_size, + GNUNET_NO); + if (s->address->address_length == sizeof(struct IPv4UdpAddress)) + schedule_select_v4 (plugin); + else + schedule_select_v6 (plugin); + } else - { - /* fragmented message */ - if (NULL != s->frag_ctx) - return GNUNET_SYSERR; - GNUNET_memcpy(&udp[1], msgbuf, msgbuf_size); - frag_ctx = GNUNET_new(struct UDP_FragmentationContext); - frag_ctx->plugin = plugin; - frag_ctx->session = s; - frag_ctx->cont = cont; - frag_ctx->cont_cls = cont_cls; - frag_ctx->start_time = GNUNET_TIME_absolute_get(); - frag_ctx->next_frag_time = s->last_transmit_time; - frag_ctx->flow_delay_from_other_peer = - GNUNET_TIME_relative_divide(s->flow_delay_from_other_peer, - 1 + (msgbuf_size / UDP_MTU)); - frag_ctx->timeout = GNUNET_TIME_relative_to_absolute(to); - frag_ctx->payload_size = - msgbuf_size; /* unfragmented message size without UDP overhead */ - frag_ctx->on_wire_size = 0; /* bytes with UDP and fragmentation overhead */ - frag_ctx->frag = GNUNET_FRAGMENT_context_create(plugin->env->stats, - UDP_MTU, - &plugin->tracker, - s->last_expected_msg_delay, - s->last_expected_ack_delay, - &udp->header, - &enqueue_fragment, - frag_ctx); - s->frag_ctx = frag_ctx; - s->last_transmit_time = frag_ctx->next_frag_time; - latency = GNUNET_TIME_absolute_get_remaining(s->last_transmit_time); - if (latency.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) - LOG(GNUNET_ERROR_TYPE_WARNING, - "Enqueued fragments will take %s for transmission to %s (queue size: %u)\n", - GNUNET_STRINGS_relative_time_to_string(latency, GNUNET_YES), - GNUNET_i2s(&s->target), - (unsigned int)s->msgs_in_queue); - else - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Enqueued fragments will take %s for transmission to %s (queue size: %u)\n", - GNUNET_STRINGS_relative_time_to_string(latency, GNUNET_YES), - GNUNET_i2s(&s->target), - (unsigned int)s->msgs_in_queue); - - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented messages active", - 1, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented messages, total", - 1, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragmented bytes (payload)", - frag_ctx->payload_size, - GNUNET_NO); - } - notify_session_monitor(s->plugin, s, GNUNET_TRANSPORT_SS_UPDATE); + { + /* fragmented message */ + if (NULL != s->frag_ctx) + return GNUNET_SYSERR; + GNUNET_memcpy (&udp[1], msgbuf, msgbuf_size); + frag_ctx = GNUNET_new (struct UDP_FragmentationContext); + frag_ctx->plugin = plugin; + frag_ctx->session = s; + frag_ctx->cont = cont; + frag_ctx->cont_cls = cont_cls; + frag_ctx->start_time = GNUNET_TIME_absolute_get (); + frag_ctx->next_frag_time = s->last_transmit_time; + frag_ctx->flow_delay_from_other_peer = + GNUNET_TIME_relative_divide (s->flow_delay_from_other_peer, + 1 + (msgbuf_size / UDP_MTU)); + frag_ctx->timeout = GNUNET_TIME_relative_to_absolute (to); + frag_ctx->payload_size = + msgbuf_size; /* unfragmented message size without UDP overhead */ + frag_ctx->on_wire_size = 0; /* bytes with UDP and fragmentation overhead */ + frag_ctx->frag = GNUNET_FRAGMENT_context_create (plugin->env->stats, + UDP_MTU, + &plugin->tracker, + s->last_expected_msg_delay, + s->last_expected_ack_delay, + &udp->header, + &enqueue_fragment, + frag_ctx); + s->frag_ctx = frag_ctx; + s->last_transmit_time = frag_ctx->next_frag_time; + latency = GNUNET_TIME_absolute_get_remaining (s->last_transmit_time); + if (latency.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) + LOG (GNUNET_ERROR_TYPE_WARNING, + "Enqueued fragments will take %s for transmission to %s (queue size: %u)\n", + GNUNET_STRINGS_relative_time_to_string (latency, GNUNET_YES), + GNUNET_i2s (&s->target), + (unsigned int) s->msgs_in_queue); + else + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Enqueued fragments will take %s for transmission to %s (queue size: %u)\n", + GNUNET_STRINGS_relative_time_to_string (latency, GNUNET_YES), + GNUNET_i2s (&s->target), + (unsigned int) s->msgs_in_queue); + + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented messages active", + 1, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented messages, total", + 1, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragmented bytes (payload)", + frag_ctx->payload_size, + GNUNET_NO); + } + notify_session_monitor (s->plugin, s, GNUNET_TRANSPORT_SS_UPDATE); return udpmlen; } @@ -2114,7 +2122,8 @@ udp_plugin_send(void *cls, /** * Closure for #find_receive_context(). */ -struct FindReceiveContext { +struct FindReceiveContext +{ /** * Where to store the result. */ @@ -2148,20 +2157,20 @@ struct FindReceiveContext { * #GNUNET_NO if not. */ static int -find_receive_context(void *cls, - struct GNUNET_CONTAINER_HeapNode *node, - void *element, - GNUNET_CONTAINER_HeapCostType cost) +find_receive_context (void *cls, + struct GNUNET_CONTAINER_HeapNode *node, + void *element, + GNUNET_CONTAINER_HeapCostType cost) { struct FindReceiveContext *frc = cls; struct DefragContext *e = element; if ((frc->udp_addr_len == e->udp_addr_len) && - (0 == memcmp(frc->udp_addr, e->udp_addr, frc->udp_addr_len))) - { - frc->rc = e; - return GNUNET_NO; - } + (0 == memcmp (frc->udp_addr, e->udp_addr, frc->udp_addr_len))) + { + frc->rc = e; + return GNUNET_NO; + } return GNUNET_YES; } @@ -2175,96 +2184,96 @@ find_receive_context(void *cls, * @return #GNUNET_OK on success */ static int -udp_disconnect_session(void *cls, struct GNUNET_ATS_Session *s) +udp_disconnect_session (void *cls, struct GNUNET_ATS_Session *s) { struct Plugin *plugin = cls; struct UDP_MessageWrapper *udpw; struct UDP_MessageWrapper *next; struct FindReceiveContext frc; - GNUNET_assert(GNUNET_YES != s->in_destroy); - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Session %p to peer `%s' at address %s ended\n", - s, - GNUNET_i2s(&s->target), - udp_address_to_string(plugin, - s->address->address, - s->address->address_length)); + GNUNET_assert (GNUNET_YES != s->in_destroy); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Session %p to peer `%s' at address %s ended\n", + s, + GNUNET_i2s (&s->target), + udp_address_to_string (plugin, + s->address->address, + s->address->address_length)); if (NULL != s->timeout_task) - { - GNUNET_SCHEDULER_cancel(s->timeout_task); - s->timeout_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (s->timeout_task); + s->timeout_task = NULL; + } if (NULL != s->frag_ctx) - { - /* Remove fragmented message due to disconnect */ - fragmented_message_done(s->frag_ctx, GNUNET_SYSERR); - } - GNUNET_assert( + { + /* Remove fragmented message due to disconnect */ + fragmented_message_done (s->frag_ctx, GNUNET_SYSERR); + } + GNUNET_assert ( GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(plugin->sessions, &s->target, s)); + GNUNET_CONTAINER_multipeermap_remove (plugin->sessions, &s->target, s)); frc.rc = NULL; frc.udp_addr = s->address->address; frc.udp_addr_len = s->address->address_length; /* Lookup existing receive context for this address */ if (NULL != plugin->defrag_ctxs) + { + GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs, + &find_receive_context, + &frc); + if (NULL != frc.rc) { - GNUNET_CONTAINER_heap_iterate(plugin->defrag_ctxs, - &find_receive_context, - &frc); - if (NULL != frc.rc) - { - struct DefragContext *d_ctx = frc.rc; + struct DefragContext *d_ctx = frc.rc; - GNUNET_CONTAINER_heap_remove_node(d_ctx->hnode); - GNUNET_DEFRAGMENT_context_destroy(d_ctx->defrag); - GNUNET_free(d_ctx); - } + GNUNET_CONTAINER_heap_remove_node (d_ctx->hnode); + GNUNET_DEFRAGMENT_context_destroy (d_ctx->defrag); + GNUNET_free (d_ctx); } + } s->in_destroy = GNUNET_YES; next = plugin->ipv4_queue_head; while (NULL != (udpw = next)) + { + next = udpw->next; + if (udpw->session == s) { - next = udpw->next; - if (udpw->session == s) - { - dequeue(plugin, udpw); - udpw->qc(udpw->qc_cls, udpw, GNUNET_SYSERR); - GNUNET_free(udpw); - } + dequeue (plugin, udpw); + udpw->qc (udpw->qc_cls, udpw, GNUNET_SYSERR); + GNUNET_free (udpw); } + } next = plugin->ipv6_queue_head; while (NULL != (udpw = next)) + { + next = udpw->next; + if (udpw->session == s) { - next = udpw->next; - if (udpw->session == s) - { - dequeue(plugin, udpw); - udpw->qc(udpw->qc_cls, udpw, GNUNET_SYSERR); - GNUNET_free(udpw); - } + dequeue (plugin, udpw); + udpw->qc (udpw->qc_cls, udpw, GNUNET_SYSERR); + GNUNET_free (udpw); } + } if ((NULL != s->frag_ctx) && (NULL != s->frag_ctx->cont)) - { - /* The 'frag_ctx' itself will be freed in #free_session() a bit - later, as it might be in use right now */ - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Calling continuation for fragemented message to `%s' with result SYSERR\n", - GNUNET_i2s(&s->target)); - s->frag_ctx->cont(s->frag_ctx->cont_cls, - &s->target, - GNUNET_SYSERR, - s->frag_ctx->payload_size, - s->frag_ctx->on_wire_size); - } - notify_session_monitor(s->plugin, s, GNUNET_TRANSPORT_SS_DONE); - plugin->env->session_end(plugin->env->cls, s->address, s); - GNUNET_STATISTICS_set(plugin->env->stats, - "# UDP sessions active", - GNUNET_CONTAINER_multipeermap_size(plugin->sessions), - GNUNET_NO); + { + /* The 'frag_ctx' itself will be freed in #free_session() a bit + later, as it might be in use right now */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Calling continuation for fragemented message to `%s' with result SYSERR\n", + GNUNET_i2s (&s->target)); + s->frag_ctx->cont (s->frag_ctx->cont_cls, + &s->target, + GNUNET_SYSERR, + s->frag_ctx->payload_size, + s->frag_ctx->on_wire_size); + } + notify_session_monitor (s->plugin, s, GNUNET_TRANSPORT_SS_DONE); + plugin->env->session_end (plugin->env->cls, s->address, s); + GNUNET_STATISTICS_set (plugin->env->stats, + "# UDP sessions active", + GNUNET_CONTAINER_multipeermap_size (plugin->sessions), + GNUNET_NO); if (0 == s->rc) - free_session(s); + free_session (s); return GNUNET_OK; } @@ -2278,10 +2287,10 @@ udp_disconnect_session(void *cls, struct GNUNET_ATS_Session *s) * @param udp_addr_len number of bytes in @a udp_addr */ static void -read_process_ack(struct Plugin *plugin, - const struct GNUNET_MessageHeader *msg, - const union UdpAddress *udp_addr, - socklen_t udp_addr_len) +read_process_ack (struct Plugin *plugin, + const struct GNUNET_MessageHeader *msg, + const union UdpAddress *udp_addr, + socklen_t udp_addr_len) { const struct GNUNET_MessageHeader *ack; const struct UDP_ACK_Message *udp_ack; @@ -2290,93 +2299,93 @@ read_process_ack(struct Plugin *plugin, struct GNUNET_TIME_Relative flow_delay; /* check message format */ - if (ntohs(msg->size) < + if (ntohs (msg->size) < sizeof(struct UDP_ACK_Message) + sizeof(struct GNUNET_MessageHeader)) - { - GNUNET_break_op(0); - return; - } - udp_ack = (const struct UDP_ACK_Message *)msg; - ack = (const struct GNUNET_MessageHeader *)&udp_ack[1]; - if (ntohs(ack->size) != ntohs(msg->size) - sizeof(struct UDP_ACK_Message)) - { - GNUNET_break_op(0); - return; - } + { + GNUNET_break_op (0); + return; + } + udp_ack = (const struct UDP_ACK_Message *) msg; + ack = (const struct GNUNET_MessageHeader *) &udp_ack[1]; + if (ntohs (ack->size) != ntohs (msg->size) - sizeof(struct UDP_ACK_Message)) + { + GNUNET_break_op (0); + return; + } /* Locate session */ - address = GNUNET_HELLO_address_allocate(&udp_ack->sender, - PLUGIN_NAME, - udp_addr, - udp_addr_len, - GNUNET_HELLO_ADDRESS_INFO_NONE); - s = udp_plugin_lookup_session(plugin, address); + address = GNUNET_HELLO_address_allocate (&udp_ack->sender, + PLUGIN_NAME, + udp_addr, + udp_addr_len, + GNUNET_HELLO_ADDRESS_INFO_NONE); + s = udp_plugin_lookup_session (plugin, address); if (NULL == s) - { - LOG(GNUNET_ERROR_TYPE_WARNING, - "UDP session of address %s for ACK not found\n", - udp_address_to_string(plugin, + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "UDP session of address %s for ACK not found\n", + udp_address_to_string (plugin, address->address, address->address_length)); - GNUNET_HELLO_address_free(address); - return; - } + GNUNET_HELLO_address_free (address); + return; + } if (NULL == s->frag_ctx) - { - LOG(GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, - "Fragmentation context of address %s for ACK (%s) not found\n", - udp_address_to_string(plugin, + { + LOG (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + "Fragmentation context of address %s for ACK (%s) not found\n", + udp_address_to_string (plugin, address->address, address->address_length), - GNUNET_FRAGMENT_print_ack(ack)); - GNUNET_HELLO_address_free(address); - return; - } - GNUNET_HELLO_address_free(address); + GNUNET_FRAGMENT_print_ack (ack)); + GNUNET_HELLO_address_free (address); + return; + } + GNUNET_HELLO_address_free (address); /* evaluate flow delay: how long should we wait between messages? */ - if (UINT32_MAX == ntohl(udp_ack->delay)) - { - /* Other peer asked for us to terminate the session */ - LOG(GNUNET_ERROR_TYPE_INFO, - "Asked to disconnect UDP session of %s\n", - GNUNET_i2s(&udp_ack->sender)); - udp_disconnect_session(plugin, s); - return; - } - flow_delay.rel_value_us = (uint64_t)ntohl(udp_ack->delay); + if (UINT32_MAX == ntohl (udp_ack->delay)) + { + /* Other peer asked for us to terminate the session */ + LOG (GNUNET_ERROR_TYPE_INFO, + "Asked to disconnect UDP session of %s\n", + GNUNET_i2s (&udp_ack->sender)); + udp_disconnect_session (plugin, s); + return; + } + flow_delay.rel_value_us = (uint64_t) ntohl (udp_ack->delay); if (flow_delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) - LOG(GNUNET_ERROR_TYPE_WARNING, - "We received a sending delay of %s for %s\n", - GNUNET_STRINGS_relative_time_to_string(flow_delay, GNUNET_YES), - GNUNET_i2s(&udp_ack->sender)); + LOG (GNUNET_ERROR_TYPE_WARNING, + "We received a sending delay of %s for %s\n", + GNUNET_STRINGS_relative_time_to_string (flow_delay, GNUNET_YES), + GNUNET_i2s (&udp_ack->sender)); else - LOG(GNUNET_ERROR_TYPE_DEBUG, - "We received a sending delay of %s for %s\n", - GNUNET_STRINGS_relative_time_to_string(flow_delay, GNUNET_YES), - GNUNET_i2s(&udp_ack->sender)); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "We received a sending delay of %s for %s\n", + GNUNET_STRINGS_relative_time_to_string (flow_delay, GNUNET_YES), + GNUNET_i2s (&udp_ack->sender)); /* Flow delay is for the reassembled packet, however, our delay is per packet, so we need to adjust: */ s->flow_delay_from_other_peer = flow_delay; /* Handle ACK */ - if (GNUNET_OK != GNUNET_FRAGMENT_process_ack(s->frag_ctx->frag, ack)) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "UDP processes %u-byte acknowledgement from `%s' at `%s'\n", - (unsigned int)ntohs(msg->size), - GNUNET_i2s(&udp_ack->sender), - udp_address_to_string(plugin, udp_addr, udp_addr_len)); - /* Expect more ACKs to arrive */ - return; - } + if (GNUNET_OK != GNUNET_FRAGMENT_process_ack (s->frag_ctx->frag, ack)) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "UDP processes %u-byte acknowledgement from `%s' at `%s'\n", + (unsigned int) ntohs (msg->size), + GNUNET_i2s (&udp_ack->sender), + udp_address_to_string (plugin, udp_addr, udp_addr_len)); + /* Expect more ACKs to arrive */ + return; + } /* Remove fragmented message after successful sending */ - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Message from %s at %s full ACK'ed\n", - GNUNET_i2s(&udp_ack->sender), - udp_address_to_string(plugin, udp_addr, udp_addr_len)); - fragmented_message_done(s->frag_ctx, GNUNET_OK); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Message from %s at %s full ACK'ed\n", + GNUNET_i2s (&udp_ack->sender), + udp_address_to_string (plugin, udp_addr, udp_addr_len)); + fragmented_message_done (s->frag_ctx, GNUNET_OK); } @@ -2389,17 +2398,17 @@ read_process_ack(struct Plugin *plugin, * @return #GNUNET_OK (always) */ static int -process_inbound_tokenized_messages(void *cls, - const struct GNUNET_MessageHeader *hdr) +process_inbound_tokenized_messages (void *cls, + const struct GNUNET_MessageHeader *hdr) { struct GNUNET_ATS_Session *session = cls; struct Plugin *plugin = session->plugin; if (GNUNET_YES == session->in_destroy) return GNUNET_OK; - reschedule_session_timeout(session); + reschedule_session_timeout (session); session->flow_delay_for_other_peer = - plugin->env->receive(plugin->env->cls, session->address, session, hdr); + plugin->env->receive (plugin->env->cls, session->address, session, hdr); return GNUNET_OK; } @@ -2413,13 +2422,13 @@ process_inbound_tokenized_messages(void *cls, * @return #GNUNET_OK (continue to iterate) */ static int -disconnect_and_free_it(void *cls, - const struct GNUNET_PeerIdentity *key, - void *value) +disconnect_and_free_it (void *cls, + const struct GNUNET_PeerIdentity *key, + void *value) { struct Plugin *plugin = cls; - udp_disconnect_session(plugin, value); + udp_disconnect_session (plugin, value); return GNUNET_OK; } @@ -2433,17 +2442,17 @@ disconnect_and_free_it(void *cls, * @return #GNUNET_OK on success, #GNUNET_SYSERR if the operation failed */ static void -udp_disconnect(void *cls, const struct GNUNET_PeerIdentity *target) +udp_disconnect (void *cls, const struct GNUNET_PeerIdentity *target) { struct Plugin *plugin = cls; - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Disconnecting from peer `%s'\n", - GNUNET_i2s(target)); - GNUNET_CONTAINER_multipeermap_get_multiple(plugin->sessions, - target, - &disconnect_and_free_it, - plugin); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Disconnecting from peer `%s'\n", + GNUNET_i2s (target)); + GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessions, + target, + &disconnect_and_free_it, + plugin); } @@ -2453,29 +2462,29 @@ udp_disconnect(void *cls, const struct GNUNET_PeerIdentity *target) * @param cls the `struct GNUNET_ATS_Session` to time out */ static void -session_timeout(void *cls) +session_timeout (void *cls) { struct GNUNET_ATS_Session *s = cls; struct Plugin *plugin = s->plugin; struct GNUNET_TIME_Relative left; s->timeout_task = NULL; - left = GNUNET_TIME_absolute_get_remaining(s->timeout); + left = GNUNET_TIME_absolute_get_remaining (s->timeout); if (left.rel_value_us > 0) - { - /* not actually our turn yet, but let's at least update - the monitor, it may think we're about to die ... */ - notify_session_monitor(s->plugin, s, GNUNET_TRANSPORT_SS_UPDATE); - s->timeout_task = GNUNET_SCHEDULER_add_delayed(left, &session_timeout, s); - return; - } - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Session %p was idle for %s, disconnecting\n", - s, - GNUNET_STRINGS_relative_time_to_string(UDP_SESSION_TIME_OUT, - GNUNET_YES)); + { + /* not actually our turn yet, but let's at least update + the monitor, it may think we're about to die ... */ + notify_session_monitor (s->plugin, s, GNUNET_TRANSPORT_SS_UPDATE); + s->timeout_task = GNUNET_SCHEDULER_add_delayed (left, &session_timeout, s); + return; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Session %p was idle for %s, disconnecting\n", + s, + GNUNET_STRINGS_relative_time_to_string (UDP_SESSION_TIME_OUT, + GNUNET_YES)); /* call session destroy function */ - udp_disconnect_session(plugin, s); + udp_disconnect_session (plugin, s); } @@ -2491,46 +2500,46 @@ session_timeout(void *cls) * @return NULL on error, otherwise session handle */ static struct GNUNET_ATS_Session * -udp_plugin_create_session(void *cls, - const struct GNUNET_HELLO_Address *address, - enum GNUNET_NetworkType network_type) +udp_plugin_create_session (void *cls, + const struct GNUNET_HELLO_Address *address, + enum GNUNET_NetworkType network_type) { struct Plugin *plugin = cls; struct GNUNET_ATS_Session *s; - s = GNUNET_new(struct GNUNET_ATS_Session); - s->mst = GNUNET_MST_create(&process_inbound_tokenized_messages, s); + s = GNUNET_new (struct GNUNET_ATS_Session); + s->mst = GNUNET_MST_create (&process_inbound_tokenized_messages, s); s->plugin = plugin; - s->address = GNUNET_HELLO_address_copy(address); + s->address = GNUNET_HELLO_address_copy (address); s->target = address->peer; - s->last_transmit_time = GNUNET_TIME_absolute_get(); + s->last_transmit_time = GNUNET_TIME_absolute_get (); s->last_expected_ack_delay = - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 250); + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250); s->last_expected_msg_delay = GNUNET_TIME_UNIT_MILLISECONDS; s->flow_delay_from_other_peer = GNUNET_TIME_UNIT_ZERO; s->flow_delay_for_other_peer = GNUNET_TIME_UNIT_ZERO; - s->timeout = GNUNET_TIME_relative_to_absolute(UDP_SESSION_TIME_OUT); + s->timeout = GNUNET_TIME_relative_to_absolute (UDP_SESSION_TIME_OUT); s->timeout_task = - GNUNET_SCHEDULER_add_delayed(UDP_SESSION_TIME_OUT, &session_timeout, s); + GNUNET_SCHEDULER_add_delayed (UDP_SESSION_TIME_OUT, &session_timeout, s); s->scope = network_type; - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Creating new session %p for peer `%s' address `%s'\n", - s, - GNUNET_i2s(&address->peer), - udp_address_to_string(plugin, - address->address, - address->address_length)); - GNUNET_assert(GNUNET_OK == GNUNET_CONTAINER_multipeermap_put( - plugin->sessions, - &s->target, - s, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); - GNUNET_STATISTICS_set(plugin->env->stats, - "# UDP sessions active", - GNUNET_CONTAINER_multipeermap_size(plugin->sessions), - GNUNET_NO); - notify_session_monitor(plugin, s, GNUNET_TRANSPORT_SS_INIT); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Creating new session %p for peer `%s' address `%s'\n", + s, + GNUNET_i2s (&address->peer), + udp_address_to_string (plugin, + address->address, + address->address_length)); + GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_put ( + plugin->sessions, + &s->target, + s, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); + GNUNET_STATISTICS_set (plugin->env->stats, + "# UDP sessions active", + GNUNET_CONTAINER_multipeermap_size (plugin->sessions), + GNUNET_NO); + notify_session_monitor (plugin, s, GNUNET_TRANSPORT_SS_INIT); return s; } @@ -2544,7 +2553,7 @@ udp_plugin_create_session(void *cls, * @return the session or NULL of max connections exceeded */ static struct GNUNET_ATS_Session * -udp_plugin_get_session(void *cls, const struct GNUNET_HELLO_Address *address) +udp_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address) { struct Plugin *plugin = cls; struct GNUNET_ATS_Session *s; @@ -2553,54 +2562,54 @@ udp_plugin_get_session(void *cls, const struct GNUNET_HELLO_Address *address) const struct IPv6UdpAddress *udp_v6; if (NULL == address) - { - GNUNET_break(0); - return NULL; - } + { + GNUNET_break (0); + return NULL; + } if ((address->address_length != sizeof(struct IPv4UdpAddress)) && (address->address_length != sizeof(struct IPv6UdpAddress))) - { - GNUNET_break_op(0); - return NULL; - } - if (NULL != (s = udp_plugin_lookup_session(cls, address))) + { + GNUNET_break_op (0); + return NULL; + } + if (NULL != (s = udp_plugin_lookup_session (cls, address))) return s; /* need to create new session */ if (sizeof(struct IPv4UdpAddress) == address->address_length) - { - struct sockaddr_in v4; + { + struct sockaddr_in v4; - udp_v4 = (const struct IPv4UdpAddress *)address->address; - memset(&v4, '\0', sizeof(v4)); - v4.sin_family = AF_INET; + udp_v4 = (const struct IPv4UdpAddress *) address->address; + memset (&v4, '\0', sizeof(v4)); + v4.sin_family = AF_INET; #if HAVE_SOCKADDR_IN_SIN_LEN - v4.sin_len = sizeof(struct sockaddr_in); + v4.sin_len = sizeof(struct sockaddr_in); #endif - v4.sin_port = udp_v4->u4_port; - v4.sin_addr.s_addr = udp_v4->ipv4_addr; - network_type = plugin->env->get_address_type(plugin->env->cls, - (const struct sockaddr *)&v4, - sizeof(v4)); - } + v4.sin_port = udp_v4->u4_port; + v4.sin_addr.s_addr = udp_v4->ipv4_addr; + network_type = plugin->env->get_address_type (plugin->env->cls, + (const struct sockaddr *) &v4, + sizeof(v4)); + } if (sizeof(struct IPv6UdpAddress) == address->address_length) - { - struct sockaddr_in6 v6; + { + struct sockaddr_in6 v6; - udp_v6 = (const struct IPv6UdpAddress *)address->address; - memset(&v6, '\0', sizeof(v6)); - v6.sin6_family = AF_INET6; + udp_v6 = (const struct IPv6UdpAddress *) address->address; + memset (&v6, '\0', sizeof(v6)); + v6.sin6_family = AF_INET6; #if HAVE_SOCKADDR_IN_SIN_LEN - v6.sin6_len = sizeof(struct sockaddr_in6); + v6.sin6_len = sizeof(struct sockaddr_in6); #endif - v6.sin6_port = udp_v6->u6_port; - v6.sin6_addr = udp_v6->ipv6_addr; - network_type = plugin->env->get_address_type(plugin->env->cls, - (const struct sockaddr *)&v6, - sizeof(v6)); - } - GNUNET_break(GNUNET_NT_UNSPECIFIED != network_type); - return udp_plugin_create_session(cls, address, network_type); + v6.sin6_port = udp_v6->u6_port; + v6.sin6_addr = udp_v6->ipv6_addr; + network_type = plugin->env->get_address_type (plugin->env->cls, + (const struct sockaddr *) &v6, + sizeof(v6)); + } + GNUNET_break (GNUNET_NT_UNSPECIFIED != network_type); + return udp_plugin_create_session (cls, address, network_type); } @@ -2614,50 +2623,50 @@ udp_plugin_get_session(void *cls, const struct GNUNET_HELLO_Address *address) * @param network_type network type the address belongs to */ static void -process_udp_message(struct Plugin *plugin, - const struct UDPMessage *msg, - const union UdpAddress *udp_addr, - size_t udp_addr_len, - enum GNUNET_NetworkType network_type) +process_udp_message (struct Plugin *plugin, + const struct UDPMessage *msg, + const union UdpAddress *udp_addr, + size_t udp_addr_len, + enum GNUNET_NetworkType network_type) { struct GNUNET_ATS_Session *s; struct GNUNET_HELLO_Address *address; - GNUNET_break(GNUNET_NT_UNSPECIFIED != network_type); - if (0 != ntohl(msg->reserved)) - { - GNUNET_break_op(0); - return; - } - if (ntohs(msg->header.size) < + GNUNET_break (GNUNET_NT_UNSPECIFIED != network_type); + if (0 != ntohl (msg->reserved)) + { + GNUNET_break_op (0); + return; + } + if (ntohs (msg->header.size) < sizeof(struct GNUNET_MessageHeader) + sizeof(struct UDPMessage)) - { - GNUNET_break_op(0); - return; - } - - address = GNUNET_HELLO_address_allocate(&msg->sender, - PLUGIN_NAME, - udp_addr, - udp_addr_len, - GNUNET_HELLO_ADDRESS_INFO_NONE); - if (NULL == (s = udp_plugin_lookup_session(plugin, address))) - { - s = udp_plugin_create_session(plugin, address, network_type); - plugin->env->session_start(plugin->env->cls, address, s, s->scope); - notify_session_monitor(plugin, s, GNUNET_TRANSPORT_SS_UP); - } - GNUNET_free(address); + { + GNUNET_break_op (0); + return; + } + + address = GNUNET_HELLO_address_allocate (&msg->sender, + PLUGIN_NAME, + udp_addr, + udp_addr_len, + GNUNET_HELLO_ADDRESS_INFO_NONE); + if (NULL == (s = udp_plugin_lookup_session (plugin, address))) + { + s = udp_plugin_create_session (plugin, address, network_type); + plugin->env->session_start (plugin->env->cls, address, s, s->scope); + notify_session_monitor (plugin, s, GNUNET_TRANSPORT_SS_UP); + } + GNUNET_free (address); s->rc++; - GNUNET_MST_from_buffer(s->mst, - (const char *)&msg[1], - ntohs(msg->header.size) - sizeof(struct UDPMessage), - GNUNET_YES, - GNUNET_NO); + GNUNET_MST_from_buffer (s->mst, + (const char *) &msg[1], + ntohs (msg->header.size) - sizeof(struct UDPMessage), + GNUNET_YES, + GNUNET_NO); s->rc--; if ((0 == s->rc) && (GNUNET_YES == s->in_destroy)) - free_session(s); + free_session (s); } @@ -2668,29 +2677,29 @@ process_udp_message(struct Plugin *plugin, * @param msg the message */ static void -fragment_msg_proc(void *cls, const struct GNUNET_MessageHeader *msg) +fragment_msg_proc (void *cls, const struct GNUNET_MessageHeader *msg) { struct DefragContext *dc = cls; const struct UDPMessage *um; - if (ntohs(msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE) - { - GNUNET_break_op(0); - return; - } - if (ntohs(msg->size) < sizeof(struct UDPMessage)) - { - GNUNET_break_op(0); - return; - } - um = (const struct UDPMessage *)msg; + if (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE) + { + GNUNET_break_op (0); + return; + } + if (ntohs (msg->size) < sizeof(struct UDPMessage)) + { + GNUNET_break_op (0); + return; + } + um = (const struct UDPMessage *) msg; dc->sender = um->sender; dc->have_sender = GNUNET_YES; - process_udp_message(dc->plugin, - um, - dc->udp_addr, - dc->udp_addr_len, - dc->network_type); + process_udp_message (dc->plugin, + um, + dc->udp_addr, + dc->udp_addr_len, + dc->network_type); } @@ -2704,24 +2713,24 @@ fragment_msg_proc(void *cls, const struct GNUNET_MessageHeader *msg) * #GNUNET_SYSERR if we failed to send the ACK */ static void -ack_message_sent(void *cls, struct UDP_MessageWrapper *udpw, int result) +ack_message_sent (void *cls, struct UDP_MessageWrapper *udpw, int result) { struct Plugin *plugin = cls; if (GNUNET_OK == result) - { - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, ACK messages sent", - 1, - GNUNET_NO); - } + { + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, ACK messages sent", + 1, + GNUNET_NO); + } else - { - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, ACK transmissions failed", - 1, - GNUNET_NO); - } + { + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, ACK transmissions failed", + 1, + GNUNET_NO); + } } @@ -2733,11 +2742,11 @@ ack_message_sent(void *cls, struct UDP_MessageWrapper *udpw, int result) * @param msg ack to transmit */ static void -ack_proc(void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg) +ack_proc (void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg) { struct DefragContext *rc = cls; struct Plugin *plugin = rc->plugin; - size_t msize = sizeof(struct UDP_ACK_Message) + ntohs(msg->size); + size_t msize = sizeof(struct UDP_ACK_Message) + ntohs (msg->size); struct UDP_ACK_Message *udp_ack; uint32_t delay; struct UDP_MessageWrapper *udpw; @@ -2745,36 +2754,36 @@ ack_proc(void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg) struct GNUNET_HELLO_Address *address; if (GNUNET_NO == rc->have_sender) - { - /* tried to defragment but never succeeded, hence will not ACK */ - /* This can happen if we just lost msgs */ - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, fragments discarded without ACK", - 1, - GNUNET_NO); - return; - } - address = GNUNET_HELLO_address_allocate(&rc->sender, - PLUGIN_NAME, - rc->udp_addr, - rc->udp_addr_len, - GNUNET_HELLO_ADDRESS_INFO_NONE); - s = udp_plugin_lookup_session(plugin, address); - GNUNET_HELLO_address_free(address); + { + /* tried to defragment but never succeeded, hence will not ACK */ + /* This can happen if we just lost msgs */ + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, fragments discarded without ACK", + 1, + GNUNET_NO); + return; + } + address = GNUNET_HELLO_address_allocate (&rc->sender, + PLUGIN_NAME, + rc->udp_addr, + rc->udp_addr_len, + GNUNET_HELLO_ADDRESS_INFO_NONE); + s = udp_plugin_lookup_session (plugin, address); + GNUNET_HELLO_address_free (address); if (NULL == s) - { - LOG(GNUNET_ERROR_TYPE_ERROR, - "Trying to transmit ACK to peer `%s' but no session found!\n", - udp_address_to_string(plugin, rc->udp_addr, rc->udp_addr_len)); - GNUNET_CONTAINER_heap_remove_node(rc->hnode); - GNUNET_DEFRAGMENT_context_destroy(rc->defrag); - GNUNET_free(rc); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, ACK transmissions failed", - 1, - GNUNET_NO); - return; - } + { + LOG (GNUNET_ERROR_TYPE_ERROR, + "Trying to transmit ACK to peer `%s' but no session found!\n", + udp_address_to_string (plugin, rc->udp_addr, rc->udp_addr_len)); + GNUNET_CONTAINER_heap_remove_node (rc->hnode); + GNUNET_DEFRAGMENT_context_destroy (rc->defrag); + GNUNET_free (rc); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, ACK transmissions failed", + 1, + GNUNET_NO); + return; + } if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == s->flow_delay_for_other_peer.rel_value_us) delay = UINT32_MAX; @@ -2782,32 +2791,32 @@ ack_proc(void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg) delay = s->flow_delay_for_other_peer.rel_value_us; else delay = UINT32_MAX - 1; /* largest value we can communicate */ - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Sending ACK to `%s' including delay of %s\n", - udp_address_to_string(plugin, rc->udp_addr, rc->udp_addr_len), - GNUNET_STRINGS_relative_time_to_string(s->flow_delay_for_other_peer, - GNUNET_YES)); - udpw = GNUNET_malloc(sizeof(struct UDP_MessageWrapper) + msize); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Sending ACK to `%s' including delay of %s\n", + udp_address_to_string (plugin, rc->udp_addr, rc->udp_addr_len), + GNUNET_STRINGS_relative_time_to_string (s->flow_delay_for_other_peer, + GNUNET_YES)); + udpw = GNUNET_malloc (sizeof(struct UDP_MessageWrapper) + msize); udpw->msg_size = msize; udpw->payload_size = 0; udpw->session = s; - udpw->start_time = GNUNET_TIME_absolute_get(); + udpw->start_time = GNUNET_TIME_absolute_get (); udpw->timeout = GNUNET_TIME_UNIT_FOREVER_ABS; - udpw->msg_buf = (char *)&udpw[1]; + udpw->msg_buf = (char *) &udpw[1]; udpw->qc = &ack_message_sent; udpw->qc_cls = plugin; - udp_ack = (struct UDP_ACK_Message *)udpw->msg_buf; - udp_ack->header.size = htons((uint16_t)msize); - udp_ack->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK); - udp_ack->delay = htonl(delay); + udp_ack = (struct UDP_ACK_Message *) udpw->msg_buf; + udp_ack->header.size = htons ((uint16_t) msize); + udp_ack->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK); + udp_ack->delay = htonl (delay); udp_ack->sender = *plugin->env->my_identity; - GNUNET_memcpy(&udp_ack[1], msg, ntohs(msg->size)); - enqueue(plugin, udpw); - notify_session_monitor(plugin, s, GNUNET_TRANSPORT_SS_UPDATE); + GNUNET_memcpy (&udp_ack[1], msg, ntohs (msg->size)); + enqueue (plugin, udpw); + notify_session_monitor (plugin, s, GNUNET_TRANSPORT_SS_UPDATE); if (s->address->address_length == sizeof(struct IPv4UdpAddress)) - schedule_select_v4(plugin); + schedule_select_v4 (plugin); else - schedule_select_v6(plugin); + schedule_select_v6 (plugin); } @@ -2821,11 +2830,11 @@ ack_proc(void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg) * @param network_type network type the address belongs to */ static void -read_process_fragment(struct Plugin *plugin, - const struct GNUNET_MessageHeader *msg, - const union UdpAddress *udp_addr, - size_t udp_addr_len, - enum GNUNET_NetworkType network_type) +read_process_fragment (struct Plugin *plugin, + const struct GNUNET_MessageHeader *msg, + const union UdpAddress *udp_addr, + size_t udp_addr_len, + enum GNUNET_NetworkType network_type) { struct DefragContext *d_ctx; struct GNUNET_TIME_Absolute now; @@ -2836,65 +2845,65 @@ read_process_fragment(struct Plugin *plugin, frc.udp_addr_len = udp_addr_len; /* Lookup existing receive context for this address */ - GNUNET_CONTAINER_heap_iterate(plugin->defrag_ctxs, - &find_receive_context, - &frc); - now = GNUNET_TIME_absolute_get(); + GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs, + &find_receive_context, + &frc); + now = GNUNET_TIME_absolute_get (); d_ctx = frc.rc; if (NULL == d_ctx) - { - /* Create a new defragmentation context */ - d_ctx = GNUNET_malloc(sizeof(struct DefragContext) + udp_addr_len); - GNUNET_memcpy(&d_ctx[1], udp_addr, udp_addr_len); - d_ctx->udp_addr = (const union UdpAddress *)&d_ctx[1]; - d_ctx->udp_addr_len = udp_addr_len; - d_ctx->network_type = network_type; - d_ctx->plugin = plugin; - d_ctx->defrag = - GNUNET_DEFRAGMENT_context_create(plugin->env->stats, - UDP_MTU, - UDP_MAX_MESSAGES_IN_DEFRAG, - d_ctx, - &fragment_msg_proc, - &ack_proc); - d_ctx->hnode = GNUNET_CONTAINER_heap_insert(plugin->defrag_ctxs, - d_ctx, - (GNUNET_CONTAINER_HeapCostType) - now.abs_value_us); - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Created new defragmentation context for %u-byte fragment from `%s'\n", - (unsigned int)ntohs(msg->size), - udp_address_to_string(plugin, udp_addr, udp_addr_len)); - } + { + /* Create a new defragmentation context */ + d_ctx = GNUNET_malloc (sizeof(struct DefragContext) + udp_addr_len); + GNUNET_memcpy (&d_ctx[1], udp_addr, udp_addr_len); + d_ctx->udp_addr = (const union UdpAddress *) &d_ctx[1]; + d_ctx->udp_addr_len = udp_addr_len; + d_ctx->network_type = network_type; + d_ctx->plugin = plugin; + d_ctx->defrag = + GNUNET_DEFRAGMENT_context_create (plugin->env->stats, + UDP_MTU, + UDP_MAX_MESSAGES_IN_DEFRAG, + d_ctx, + &fragment_msg_proc, + &ack_proc); + d_ctx->hnode = GNUNET_CONTAINER_heap_insert (plugin->defrag_ctxs, + d_ctx, + (GNUNET_CONTAINER_HeapCostType) + now.abs_value_us); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Created new defragmentation context for %u-byte fragment from `%s'\n", + (unsigned int) ntohs (msg->size), + udp_address_to_string (plugin, udp_addr, udp_addr_len)); + } else - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Found existing defragmentation context for %u-byte fragment from `%s'\n", - (unsigned int)ntohs(msg->size), - udp_address_to_string(plugin, udp_addr, udp_addr_len)); - } - - if (GNUNET_OK == GNUNET_DEFRAGMENT_process_fragment(d_ctx->defrag, msg)) - { - /* keep this 'rc' from expiring */ - GNUNET_CONTAINER_heap_update_cost(d_ctx->hnode, - (GNUNET_CONTAINER_HeapCostType) - now.abs_value_us); - } - if (GNUNET_CONTAINER_heap_get_size(plugin->defrag_ctxs) > + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Found existing defragmentation context for %u-byte fragment from `%s'\n", + (unsigned int) ntohs (msg->size), + udp_address_to_string (plugin, udp_addr, udp_addr_len)); + } + + if (GNUNET_OK == GNUNET_DEFRAGMENT_process_fragment (d_ctx->defrag, msg)) + { + /* keep this 'rc' from expiring */ + GNUNET_CONTAINER_heap_update_cost (d_ctx->hnode, + (GNUNET_CONTAINER_HeapCostType) + now.abs_value_us); + } + if (GNUNET_CONTAINER_heap_get_size (plugin->defrag_ctxs) > UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG) - { - /* remove 'rc' that was inactive the longest */ - d_ctx = GNUNET_CONTAINER_heap_remove_root(plugin->defrag_ctxs); - GNUNET_assert(NULL != d_ctx); - GNUNET_DEFRAGMENT_context_destroy(d_ctx->defrag); - GNUNET_free(d_ctx); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, Defragmentations aborted", - 1, - GNUNET_NO); - } + { + /* remove 'rc' that was inactive the longest */ + d_ctx = GNUNET_CONTAINER_heap_remove_root (plugin->defrag_ctxs); + GNUNET_assert (NULL != d_ctx); + GNUNET_DEFRAGMENT_context_destroy (d_ctx->defrag); + GNUNET_free (d_ctx); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, Defragmentations aborted", + 1, + GNUNET_NO); + } } @@ -2905,7 +2914,7 @@ read_process_fragment(struct Plugin *plugin, * @param rsock socket to read from */ static void -udp_select_read(struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock) +udp_select_read (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock) { socklen_t fromlen; struct sockaddr_storage addr; @@ -2922,126 +2931,126 @@ udp_select_read(struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock) enum GNUNET_NetworkType network_type; fromlen = sizeof(addr); - memset(&addr, 0, sizeof(addr)); - size = GNUNET_NETWORK_socket_recvfrom(rsock, - buf, - sizeof(buf), - (struct sockaddr *)&addr, - &fromlen); - sa = (const struct sockaddr *)&addr; + memset (&addr, 0, sizeof(addr)); + size = GNUNET_NETWORK_socket_recvfrom (rsock, + buf, + sizeof(buf), + (struct sockaddr *) &addr, + &fromlen); + sa = (const struct sockaddr *) &addr; if (-1 == size) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "UDP failed to receive data: %s\n", - strerror(errno)); - /* Connection failure or something. Not a protocol violation. */ - return; - } + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "UDP failed to receive data: %s\n", + strerror (errno)); + /* Connection failure or something. Not a protocol violation. */ + return; + } /* Check if this is a STUN packet */ if (GNUNET_NO != - GNUNET_NAT_stun_handle_packet(plugin->nat, - (const struct sockaddr *)&addr, - fromlen, - buf, - size)) + GNUNET_NAT_stun_handle_packet (plugin->nat, + (const struct sockaddr *) &addr, + fromlen, + buf, + size)) return; /* was STUN, do not process further */ if (size < sizeof(struct GNUNET_MessageHeader)) - { - LOG(GNUNET_ERROR_TYPE_WARNING, - "UDP got %u bytes from %s, which is not enough for a GNUnet message header\n", - (unsigned int)size, - GNUNET_a2s(sa, fromlen)); - /* _MAY_ be a connection failure (got partial message) */ - /* But it _MAY_ also be that the other side uses non-GNUnet protocol. */ - GNUNET_break_op(0); - return; - } - - msg = (const struct GNUNET_MessageHeader *)buf; - LOG(GNUNET_ERROR_TYPE_DEBUG, - "UDP received %u-byte message from `%s' type %u\n", - (unsigned int)size, - GNUNET_a2s(sa, fromlen), - ntohs(msg->type)); - if (size != ntohs(msg->size)) - { - LOG(GNUNET_ERROR_TYPE_WARNING, - "UDP malformed message (size %u) header from %s\n", - (unsigned int)size, - GNUNET_a2s(sa, fromlen)); - GNUNET_break_op(0); - return; - } - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total bytes received", - size, - GNUNET_NO); - network_type = plugin->env->get_address_type(plugin->env->cls, sa, fromlen); + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "UDP got %u bytes from %s, which is not enough for a GNUnet message header\n", + (unsigned int) size, + GNUNET_a2s (sa, fromlen)); + /* _MAY_ be a connection failure (got partial message) */ + /* But it _MAY_ also be that the other side uses non-GNUnet protocol. */ + GNUNET_break_op (0); + return; + } + + msg = (const struct GNUNET_MessageHeader *) buf; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "UDP received %u-byte message from `%s' type %u\n", + (unsigned int) size, + GNUNET_a2s (sa, fromlen), + ntohs (msg->type)); + if (size != ntohs (msg->size)) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "UDP malformed message (size %u) header from %s\n", + (unsigned int) size, + GNUNET_a2s (sa, fromlen)); + GNUNET_break_op (0); + return; + } + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total bytes received", + size, + GNUNET_NO); + network_type = plugin->env->get_address_type (plugin->env->cls, sa, fromlen); switch (sa->sa_family) - { - case AF_INET: - sa4 = (const struct sockaddr_in *)&addr; - v4.options = 0; - v4.ipv4_addr = sa4->sin_addr.s_addr; - v4.u4_port = sa4->sin_port; - int_addr = (union UdpAddress *)&v4; - int_addr_len = sizeof(v4); - break; - - case AF_INET6: - sa6 = (const struct sockaddr_in6 *)&addr; - v6.options = 0; - v6.ipv6_addr = sa6->sin6_addr; - v6.u6_port = sa6->sin6_port; - int_addr = (union UdpAddress *)&v6; - int_addr_len = sizeof(v6); - break; - - default: - GNUNET_break(0); - return; - } + { + case AF_INET: + sa4 = (const struct sockaddr_in *) &addr; + v4.options = 0; + v4.ipv4_addr = sa4->sin_addr.s_addr; + v4.u4_port = sa4->sin_port; + int_addr = (union UdpAddress *) &v4; + int_addr_len = sizeof(v4); + break; + + case AF_INET6: + sa6 = (const struct sockaddr_in6 *) &addr; + v6.options = 0; + v6.ipv6_addr = sa6->sin6_addr; + v6.u6_port = sa6->sin6_port; + int_addr = (union UdpAddress *) &v6; + int_addr_len = sizeof(v6); + break; + + default: + GNUNET_break (0); + return; + } + + switch (ntohs (msg->type)) + { + case GNUNET_MESSAGE_TYPE_TRANSPORT_BROADCAST_BEACON: + if (GNUNET_YES == plugin->enable_broadcasting_receiving) + udp_broadcast_receive (plugin, + buf, + size, + int_addr, + int_addr_len, + network_type); + return; - switch (ntohs(msg->type)) + case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE: + if (ntohs (msg->size) < sizeof(struct UDPMessage)) { - case GNUNET_MESSAGE_TYPE_TRANSPORT_BROADCAST_BEACON: - if (GNUNET_YES == plugin->enable_broadcasting_receiving) - udp_broadcast_receive(plugin, - buf, - size, - int_addr, - int_addr_len, - network_type); - return; - - case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE: - if (ntohs(msg->size) < sizeof(struct UDPMessage)) - { - GNUNET_break_op(0); - return; - } - process_udp_message(plugin, - (const struct UDPMessage *)msg, - int_addr, - int_addr_len, - network_type); + GNUNET_break_op (0); return; + } + process_udp_message (plugin, + (const struct UDPMessage *) msg, + int_addr, + int_addr_len, + network_type); + return; - case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK: - read_process_ack(plugin, msg, int_addr, int_addr_len); - return; + case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK: + read_process_ack (plugin, msg, int_addr, int_addr_len); + return; - case GNUNET_MESSAGE_TYPE_FRAGMENT: - read_process_fragment(plugin, msg, int_addr, int_addr_len, network_type); - return; + case GNUNET_MESSAGE_TYPE_FRAGMENT: + read_process_fragment (plugin, msg, int_addr, int_addr_len, network_type); + return; - default: - GNUNET_break_op(0); - return; - } + default: + GNUNET_break_op (0); + return; + } } @@ -3055,8 +3064,8 @@ udp_select_read(struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock) * @return message selected for transmission, or NULL for none */ static struct UDP_MessageWrapper * -remove_timeout_messages_and_select(struct Plugin *plugin, - struct GNUNET_NETWORK_Handle *sock) +remove_timeout_messages_and_select (struct Plugin *plugin, + struct GNUNET_NETWORK_Handle *sock) { struct UDP_MessageWrapper *udpw; struct GNUNET_TIME_Relative remaining; @@ -3067,65 +3076,65 @@ remove_timeout_messages_and_select(struct Plugin *plugin, udpw = (sock == plugin->sockv4) ? plugin->ipv4_queue_head : plugin->ipv6_queue_head; while (NULL != udpw) - { - session = udpw->session; - /* Find messages with timeout */ - remaining = GNUNET_TIME_absolute_get_remaining(udpw->timeout); - if (GNUNET_TIME_UNIT_ZERO.rel_value_us == remaining.rel_value_us) - { - /* Message timed out */ - removed = GNUNET_YES; - dequeue(plugin, udpw); - udpw->qc(udpw->qc_cls, udpw, GNUNET_SYSERR); - GNUNET_free(udpw); - - if (sock == plugin->sockv4) - { - udpw = plugin->ipv4_queue_head; - } - else if (sock == plugin->sockv6) - { - udpw = plugin->ipv6_queue_head; - } - else - { - GNUNET_break(0); /* should never happen */ - udpw = NULL; - } - GNUNET_STATISTICS_update(plugin->env->stats, - "# messages discarded due to timeout", - 1, - GNUNET_NO); - } + { + session = udpw->session; + /* Find messages with timeout */ + remaining = GNUNET_TIME_absolute_get_remaining (udpw->timeout); + if (GNUNET_TIME_UNIT_ZERO.rel_value_us == remaining.rel_value_us) + { + /* Message timed out */ + removed = GNUNET_YES; + dequeue (plugin, udpw); + udpw->qc (udpw->qc_cls, udpw, GNUNET_SYSERR); + GNUNET_free (udpw); + + if (sock == plugin->sockv4) + { + udpw = plugin->ipv4_queue_head; + } + else if (sock == plugin->sockv6) + { + udpw = plugin->ipv6_queue_head; + } else - { - /* Message did not time out, check transmission time */ - remaining = GNUNET_TIME_absolute_get_remaining(udpw->transmission_time); - if (0 == remaining.rel_value_us) - { - /* this message is not delayed */ - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Message for peer `%s' (%u bytes) is not delayed \n", - GNUNET_i2s(&udpw->session->target), - udpw->payload_size); - break; /* Found message to send, break */ - } - else - { - /* Message is delayed, try next */ - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Message for peer `%s' (%u bytes) is delayed for %s\n", - GNUNET_i2s(&udpw->session->target), - udpw->payload_size, - GNUNET_STRINGS_relative_time_to_string(remaining, GNUNET_YES)); - udpw = udpw->next; - } - } - } + { + GNUNET_break (0); /* should never happen */ + udpw = NULL; + } + GNUNET_STATISTICS_update (plugin->env->stats, + "# messages discarded due to timeout", + 1, + GNUNET_NO); + } + else + { + /* Message did not time out, check transmission time */ + remaining = GNUNET_TIME_absolute_get_remaining (udpw->transmission_time); + if (0 == remaining.rel_value_us) + { + /* this message is not delayed */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Message for peer `%s' (%u bytes) is not delayed \n", + GNUNET_i2s (&udpw->session->target), + udpw->payload_size); + break; /* Found message to send, break */ + } + else + { + /* Message is delayed, try next */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Message for peer `%s' (%u bytes) is delayed for %s\n", + GNUNET_i2s (&udpw->session->target), + udpw->payload_size, + GNUNET_STRINGS_relative_time_to_string (remaining, GNUNET_YES)); + udpw = udpw->next; + } + } + } if (GNUNET_YES == removed) - notify_session_monitor(session->plugin, - session, - GNUNET_TRANSPORT_SS_UPDATE); + notify_session_monitor (session->plugin, + session, + GNUNET_TRANSPORT_SS_UPDATE); return udpw; } @@ -3140,50 +3149,50 @@ remove_timeout_messages_and_select(struct Plugin *plugin, * @param error the errno value returned from the sendto() call */ static void -analyze_send_error(struct Plugin *plugin, - const struct sockaddr *sa, - socklen_t slen, - int error) +analyze_send_error (struct Plugin *plugin, + const struct sockaddr *sa, + socklen_t slen, + int error) { enum GNUNET_NetworkType type; - type = plugin->env->get_address_type(plugin->env->cls, sa, slen); + type = plugin->env->get_address_type (plugin->env->cls, sa, slen); if (((GNUNET_NT_LAN == type) || (GNUNET_NT_WAN == type)) && ((ENETUNREACH == errno) || (ENETDOWN == errno))) - { - if (slen == sizeof(struct sockaddr_in)) - { - /* IPv4: "Network unreachable" or "Network down" - * - * This indicates we do not have connectivity - */ - LOG(GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK, - _("UDP could not transmit message to `%s': " - "Network seems down, please check your network configuration\n"), - GNUNET_a2s(sa, slen)); - } - if (slen == sizeof(struct sockaddr_in6)) - { - /* IPv6: "Network unreachable" or "Network down" - * - * This indicates that this system is IPv6 enabled, but does not - * have a valid global IPv6 address assigned or we do not have - * connectivity - */ - LOG(GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK, - _( - "UDP could not transmit IPv6 message! " - "Please check your network configuration and disable IPv6 if your " - "connection does not have a global IPv6 address\n")); - } - } + { + if (slen == sizeof(struct sockaddr_in)) + { + /* IPv4: "Network unreachable" or "Network down" + * + * This indicates we do not have connectivity + */ + LOG (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK, + _ ("UDP could not transmit message to `%s': " + "Network seems down, please check your network configuration\n"), + GNUNET_a2s (sa, slen)); + } + if (slen == sizeof(struct sockaddr_in6)) + { + /* IPv6: "Network unreachable" or "Network down" + * + * This indicates that this system is IPv6 enabled, but does not + * have a valid global IPv6 address assigned or we do not have + * connectivity + */ + LOG (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK, + _ ( + "UDP could not transmit IPv6 message! " + "Please check your network configuration and disable IPv6 if your " + "connection does not have a global IPv6 address\n")); + } + } else - { - LOG(GNUNET_ERROR_TYPE_WARNING, - "UDP could not transmit message to `%s': `%s'\n", - GNUNET_a2s(sa, slen), - strerror(error)); - } + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "UDP could not transmit message to `%s': `%s'\n", + GNUNET_a2s (sa, slen), + strerror (error)); + } } @@ -3195,7 +3204,7 @@ analyze_send_error(struct Plugin *plugin, * @param sock which socket (v4/v6) to send on */ static void -udp_select_send(struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock) +udp_select_send (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock) { ssize_t sent; socklen_t slen; @@ -3207,95 +3216,95 @@ udp_select_send(struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock) struct UDP_MessageWrapper *udpw; /* Find message(s) to send */ - while (NULL != (udpw = remove_timeout_messages_and_select(plugin, sock))) + while (NULL != (udpw = remove_timeout_messages_and_select (plugin, sock))) + { + if (sizeof(struct IPv4UdpAddress) == + udpw->session->address->address_length) { - if (sizeof(struct IPv4UdpAddress) == - udpw->session->address->address_length) - { - u4 = udpw->session->address->address; - memset(&a4, 0, sizeof(a4)); - a4.sin_family = AF_INET; + u4 = udpw->session->address->address; + memset (&a4, 0, sizeof(a4)); + a4.sin_family = AF_INET; #if HAVE_SOCKADDR_IN_SIN_LEN - a4.sin_len = sizeof(a4); + a4.sin_len = sizeof(a4); #endif - a4.sin_port = u4->u4_port; - a4.sin_addr.s_addr = u4->ipv4_addr; - a = (const struct sockaddr *)&a4; - slen = sizeof(a4); - } - else if (sizeof(struct IPv6UdpAddress) == - udpw->session->address->address_length) - { - u6 = udpw->session->address->address; - memset(&a6, 0, sizeof(a6)); - a6.sin6_family = AF_INET6; + a4.sin_port = u4->u4_port; + a4.sin_addr.s_addr = u4->ipv4_addr; + a = (const struct sockaddr *) &a4; + slen = sizeof(a4); + } + else if (sizeof(struct IPv6UdpAddress) == + udpw->session->address->address_length) + { + u6 = udpw->session->address->address; + memset (&a6, 0, sizeof(a6)); + a6.sin6_family = AF_INET6; #if HAVE_SOCKADDR_IN_SIN_LEN - a6.sin6_len = sizeof(a6); + a6.sin6_len = sizeof(a6); #endif - a6.sin6_port = u6->u6_port; - a6.sin6_addr = u6->ipv6_addr; - a = (const struct sockaddr *)&a6; - slen = sizeof(a6); - } - else - { - GNUNET_break(0); - dequeue(plugin, udpw); - udpw->qc(udpw->qc_cls, udpw, GNUNET_SYSERR); - notify_session_monitor(plugin, - udpw->session, - GNUNET_TRANSPORT_SS_UPDATE); - GNUNET_free(udpw); - continue; - } - sent = GNUNET_NETWORK_socket_sendto(sock, - udpw->msg_buf, - udpw->msg_size, - a, - slen); - udpw->session->last_transmit_time = - GNUNET_TIME_absolute_max(GNUNET_TIME_absolute_get(), - udpw->session->last_transmit_time); - dequeue(plugin, udpw); - if (GNUNET_SYSERR == sent) - { - /* Failure */ - analyze_send_error(plugin, a, slen, errno); - udpw->qc(udpw->qc_cls, udpw, GNUNET_SYSERR); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total, bytes, sent, failure", - sent, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total, messages, sent, failure", - 1, - GNUNET_NO); - } - else - { - /* Success */ - LOG(GNUNET_ERROR_TYPE_DEBUG, - "UDP transmitted %u-byte message to `%s' `%s' (%d: %s)\n", - (unsigned int)(udpw->msg_size), - GNUNET_i2s(&udpw->session->target), - GNUNET_a2s(a, slen), - (int)sent, - (sent < 0) ? strerror(errno) : "ok"); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total, bytes, sent, success", - sent, - GNUNET_NO); - GNUNET_STATISTICS_update(plugin->env->stats, - "# UDP, total, messages, sent, success", - 1, - GNUNET_NO); - if (NULL != udpw->frag_ctx) - udpw->frag_ctx->on_wire_size += udpw->msg_size; - udpw->qc(udpw->qc_cls, udpw, GNUNET_OK); - } - notify_session_monitor(plugin, udpw->session, GNUNET_TRANSPORT_SS_UPDATE); - GNUNET_free(udpw); - } + a6.sin6_port = u6->u6_port; + a6.sin6_addr = u6->ipv6_addr; + a = (const struct sockaddr *) &a6; + slen = sizeof(a6); + } + else + { + GNUNET_break (0); + dequeue (plugin, udpw); + udpw->qc (udpw->qc_cls, udpw, GNUNET_SYSERR); + notify_session_monitor (plugin, + udpw->session, + GNUNET_TRANSPORT_SS_UPDATE); + GNUNET_free (udpw); + continue; + } + sent = GNUNET_NETWORK_socket_sendto (sock, + udpw->msg_buf, + udpw->msg_size, + a, + slen); + udpw->session->last_transmit_time = + GNUNET_TIME_absolute_max (GNUNET_TIME_absolute_get (), + udpw->session->last_transmit_time); + dequeue (plugin, udpw); + if (GNUNET_SYSERR == sent) + { + /* Failure */ + analyze_send_error (plugin, a, slen, errno); + udpw->qc (udpw->qc_cls, udpw, GNUNET_SYSERR); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total, bytes, sent, failure", + sent, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total, messages, sent, failure", + 1, + GNUNET_NO); + } + else + { + /* Success */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "UDP transmitted %u-byte message to `%s' `%s' (%d: %s)\n", + (unsigned int) (udpw->msg_size), + GNUNET_i2s (&udpw->session->target), + GNUNET_a2s (a, slen), + (int) sent, + (sent < 0) ? strerror (errno) : "ok"); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total, bytes, sent, success", + sent, + GNUNET_NO); + GNUNET_STATISTICS_update (plugin->env->stats, + "# UDP, total, messages, sent, success", + 1, + GNUNET_NO); + if (NULL != udpw->frag_ctx) + udpw->frag_ctx->on_wire_size += udpw->msg_size; + udpw->qc (udpw->qc_cls, udpw, GNUNET_OK); + } + notify_session_monitor (plugin, udpw->session, GNUNET_TRANSPORT_SS_UPDATE); + GNUNET_free (udpw); + } } @@ -3310,7 +3319,7 @@ udp_select_send(struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock) * @param cls the plugin handle */ static void -udp_plugin_select_v4(void *cls) +udp_plugin_select_v4 (void *cls) { struct Plugin *plugin = cls; const struct GNUNET_SCHEDULER_TaskContext *tc; @@ -3318,12 +3327,12 @@ udp_plugin_select_v4(void *cls) plugin->select_task_v4 = NULL; if (NULL == plugin->sockv4) return; - tc = GNUNET_SCHEDULER_get_task_context(); + tc = GNUNET_SCHEDULER_get_task_context (); if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) && - (GNUNET_NETWORK_fdset_isset(tc->read_ready, plugin->sockv4))) - udp_select_read(plugin, plugin->sockv4); - udp_select_send(plugin, plugin->sockv4); - schedule_select_v4(plugin); + (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv4))) + udp_select_read (plugin, plugin->sockv4); + udp_select_send (plugin, plugin->sockv4); + schedule_select_v4 (plugin); } @@ -3335,7 +3344,7 @@ udp_plugin_select_v4(void *cls) * @param cls the plugin handle */ static void -udp_plugin_select_v6(void *cls) +udp_plugin_select_v6 (void *cls) { struct Plugin *plugin = cls; const struct GNUNET_SCHEDULER_TaskContext *tc; @@ -3343,13 +3352,13 @@ udp_plugin_select_v6(void *cls) plugin->select_task_v6 = NULL; if (NULL == plugin->sockv6) return; - tc = GNUNET_SCHEDULER_get_task_context(); + tc = GNUNET_SCHEDULER_get_task_context (); if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) && - (GNUNET_NETWORK_fdset_isset(tc->read_ready, plugin->sockv6))) - udp_select_read(plugin, plugin->sockv6); + (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv6))) + udp_select_read (plugin, plugin->sockv6); - udp_select_send(plugin, plugin->sockv6); - schedule_select_v6(plugin); + udp_select_send (plugin, plugin->sockv6); + schedule_select_v6 (plugin); } @@ -3365,9 +3374,9 @@ udp_plugin_select_v6(void *cls) * @return number of sockets that were successfully bound */ static unsigned int -setup_sockets(struct Plugin *plugin, - const struct sockaddr_in6 *bind_v6, - const struct sockaddr_in *bind_v4) +setup_sockets (struct Plugin *plugin, + const struct sockaddr_in6 *bind_v6, + const struct sockaddr_in *bind_v4) { int tries; unsigned int sockets_created = 0; @@ -3382,186 +3391,186 @@ setup_sockets(struct Plugin *plugin, /* Create IPv6 socket */ eno = EINVAL; if (GNUNET_YES == plugin->enable_ipv6) + { + plugin->sockv6 = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 0); + if (NULL == plugin->sockv6) { - plugin->sockv6 = GNUNET_NETWORK_socket_create(PF_INET6, SOCK_DGRAM, 0); - if (NULL == plugin->sockv6) - { - LOG(GNUNET_ERROR_TYPE_INFO, - _("Disabling IPv6 since it is not supported on this system!\n")); - plugin->enable_ipv6 = GNUNET_NO; - } - else - { - memset(&server_addrv6, 0, sizeof(struct sockaddr_in6)); -#if HAVE_SOCKADDR_IN_SIN_LEN - server_addrv6.sin6_len = sizeof(struct sockaddr_in6); -#endif - server_addrv6.sin6_family = AF_INET6; - if (NULL != bind_v6) - server_addrv6.sin6_addr = bind_v6->sin6_addr; - else - server_addrv6.sin6_addr = in6addr_any; - - if (0 == plugin->port) /* autodetect */ - server_addrv6.sin6_port = htons( - GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + - 32000); - else - server_addrv6.sin6_port = htons(plugin->port); - addrlen = sizeof(struct sockaddr_in6); - server_addr = (const struct sockaddr *)&server_addrv6; - - tries = 0; - while (tries < 10) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Binding to IPv6 `%s'\n", - GNUNET_a2s(server_addr, addrlen)); - /* binding */ - if (GNUNET_OK == - GNUNET_NETWORK_socket_bind(plugin->sockv6, server_addr, addrlen)) - break; - eno = errno; - if (0 != plugin->port) - { - tries = 10; /* fail immediately */ - break; /* bind failed on specific port */ - } - /* autodetect */ - server_addrv6.sin6_port = htons( - GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + - 32000); - tries++; - } - if (tries >= 10) - { - GNUNET_NETWORK_socket_close(plugin->sockv6); - plugin->enable_ipv6 = GNUNET_NO; - plugin->sockv6 = NULL; - } - else - { - plugin->port = ntohs(server_addrv6.sin6_port); - } - if (NULL != plugin->sockv6) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "IPv6 UDP socket created listinging at %s\n", - GNUNET_a2s(server_addr, addrlen)); - addrs[sockets_created] = server_addr; - addrlens[sockets_created] = addrlen; - sockets_created++; - } - else - { - LOG(GNUNET_ERROR_TYPE_WARNING, - _("Failed to bind UDP socket to %s: %s\n"), - GNUNET_a2s(server_addr, addrlen), - strerror(eno)); - } - } - } - - /* Create IPv4 socket */ - eno = EINVAL; - plugin->sockv4 = GNUNET_NETWORK_socket_create(PF_INET, SOCK_DGRAM, 0); - if (NULL == plugin->sockv4) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "socket"); - LOG(GNUNET_ERROR_TYPE_INFO, - _("Disabling IPv4 since it is not supported on this system!\n")); - plugin->enable_ipv4 = GNUNET_NO; + LOG (GNUNET_ERROR_TYPE_INFO, + _ ("Disabling IPv6 since it is not supported on this system!\n")); + plugin->enable_ipv6 = GNUNET_NO; } - else + else { - memset(&server_addrv4, 0, sizeof(struct sockaddr_in)); + memset (&server_addrv6, 0, sizeof(struct sockaddr_in6)); #if HAVE_SOCKADDR_IN_SIN_LEN - server_addrv4.sin_len = sizeof(struct sockaddr_in); + server_addrv6.sin6_len = sizeof(struct sockaddr_in6); #endif - server_addrv4.sin_family = AF_INET; - if (NULL != bind_v4) - server_addrv4.sin_addr = bind_v4->sin_addr; + server_addrv6.sin6_family = AF_INET6; + if (NULL != bind_v6) + server_addrv6.sin6_addr = bind_v6->sin6_addr; else - server_addrv4.sin_addr.s_addr = INADDR_ANY; + server_addrv6.sin6_addr = in6addr_any; - if (0 == plugin->port) - /* autodetect */ - server_addrv4.sin_port = htons( - GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); + if (0 == plugin->port) /* autodetect */ + server_addrv6.sin6_port = htons ( + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + + 32000); else - server_addrv4.sin_port = htons(plugin->port); - - addrlen = sizeof(struct sockaddr_in); - server_addr = (const struct sockaddr *)&server_addrv4; + server_addrv6.sin6_port = htons (plugin->port); + addrlen = sizeof(struct sockaddr_in6); + server_addr = (const struct sockaddr *) &server_addrv6; tries = 0; while (tries < 10) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Binding to IPv6 `%s'\n", + GNUNET_a2s (server_addr, addrlen)); + /* binding */ + if (GNUNET_OK == + GNUNET_NETWORK_socket_bind (plugin->sockv6, server_addr, addrlen)) + break; + eno = errno; + if (0 != plugin->port) { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Binding to IPv4 `%s'\n", - GNUNET_a2s(server_addr, addrlen)); - - /* binding */ - if (GNUNET_OK == - GNUNET_NETWORK_socket_bind(plugin->sockv4, server_addr, addrlen)) - break; - eno = errno; - if (0 != plugin->port) - { - tries = 10; /* fail */ - break; /* bind failed on specific port */ - } - - /* autodetect */ - server_addrv4.sin_port = htons( - GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); - tries++; + tries = 10; /* fail immediately */ + break; /* bind failed on specific port */ } + /* autodetect */ + server_addrv6.sin6_port = htons ( + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + + 32000); + tries++; + } if (tries >= 10) - { - GNUNET_NETWORK_socket_close(plugin->sockv4); - plugin->enable_ipv4 = GNUNET_NO; - plugin->sockv4 = NULL; - } + { + GNUNET_NETWORK_socket_close (plugin->sockv6); + plugin->enable_ipv6 = GNUNET_NO; + plugin->sockv6 = NULL; + } else - { - plugin->port = ntohs(server_addrv4.sin_port); - } - - if (NULL != plugin->sockv4) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "IPv4 socket created on port %s\n", - GNUNET_a2s(server_addr, addrlen)); - addrs[sockets_created] = server_addr; - addrlens[sockets_created] = addrlen; - sockets_created++; - } + { + plugin->port = ntohs (server_addrv6.sin6_port); + } + if (NULL != plugin->sockv6) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "IPv6 UDP socket created listinging at %s\n", + GNUNET_a2s (server_addr, addrlen)); + addrs[sockets_created] = server_addr; + addrlens[sockets_created] = addrlen; + sockets_created++; + } else - { - LOG(GNUNET_ERROR_TYPE_ERROR, - _("Failed to bind UDP socket to %s: %s\n"), - GNUNET_a2s(server_addr, addrlen), - strerror(eno)); - } + { + LOG (GNUNET_ERROR_TYPE_WARNING, + _ ("Failed to bind UDP socket to %s: %s\n"), + GNUNET_a2s (server_addr, addrlen), + strerror (eno)); + } } + } - if (0 == sockets_created) + /* Create IPv4 socket */ + eno = EINVAL; + plugin->sockv4 = GNUNET_NETWORK_socket_create (PF_INET, SOCK_DGRAM, 0); + if (NULL == plugin->sockv4) + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket"); + LOG (GNUNET_ERROR_TYPE_INFO, + _ ("Disabling IPv4 since it is not supported on this system!\n")); + plugin->enable_ipv4 = GNUNET_NO; + } + else + { + memset (&server_addrv4, 0, sizeof(struct sockaddr_in)); +#if HAVE_SOCKADDR_IN_SIN_LEN + server_addrv4.sin_len = sizeof(struct sockaddr_in); +#endif + server_addrv4.sin_family = AF_INET; + if (NULL != bind_v4) + server_addrv4.sin_addr = bind_v4->sin_addr; + else + server_addrv4.sin_addr.s_addr = INADDR_ANY; + + if (0 == plugin->port) + /* autodetect */ + server_addrv4.sin_port = htons ( + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); + else + server_addrv4.sin_port = htons (plugin->port); + + addrlen = sizeof(struct sockaddr_in); + server_addr = (const struct sockaddr *) &server_addrv4; + + tries = 0; + while (tries < 10) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Binding to IPv4 `%s'\n", + GNUNET_a2s (server_addr, addrlen)); + + /* binding */ + if (GNUNET_OK == + GNUNET_NETWORK_socket_bind (plugin->sockv4, server_addr, addrlen)) + break; + eno = errno; + if (0 != plugin->port) + { + tries = 10; /* fail */ + break; /* bind failed on specific port */ + } + + /* autodetect */ + server_addrv4.sin_port = htons ( + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); + tries++; + } + if (tries >= 10) + { + GNUNET_NETWORK_socket_close (plugin->sockv4); + plugin->enable_ipv4 = GNUNET_NO; + plugin->sockv4 = NULL; + } + else { - LOG(GNUNET_ERROR_TYPE_WARNING, _("Failed to open UDP sockets\n")); - return 0; /* No sockets created, return */ + plugin->port = ntohs (server_addrv4.sin_port); } - schedule_select_v4(plugin); - schedule_select_v6(plugin); - plugin->nat = GNUNET_NAT_register(plugin->env->cfg, - "transport-udp", - IPPROTO_UDP, - sockets_created, - addrs, - addrlens, - &udp_nat_port_map_callback, - NULL, - plugin); + + if (NULL != plugin->sockv4) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "IPv4 socket created on port %s\n", + GNUNET_a2s (server_addr, addrlen)); + addrs[sockets_created] = server_addr; + addrlens[sockets_created] = addrlen; + sockets_created++; + } + else + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _ ("Failed to bind UDP socket to %s: %s\n"), + GNUNET_a2s (server_addr, addrlen), + strerror (eno)); + } + } + + if (0 == sockets_created) + { + LOG (GNUNET_ERROR_TYPE_WARNING, _ ("Failed to open UDP sockets\n")); + return 0; /* No sockets created, return */ + } + schedule_select_v4 (plugin); + schedule_select_v6 (plugin); + plugin->nat = GNUNET_NAT_register (plugin->env->cfg, + "transport-udp", + IPPROTO_UDP, + sockets_created, + addrs, + addrlens, + &udp_nat_port_map_callback, + NULL, + plugin); return sockets_created; } @@ -3574,7 +3583,7 @@ setup_sockets(struct Plugin *plugin, * @return our `struct GNUNET_TRANSPORT_PluginFunctions` */ void * -libgnunet_plugin_transport_udp_init(void *cls) +libgnunet_plugin_transport_udp_init (void *cls) { struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; struct GNUNET_TRANSPORT_PluginFunctions *api; @@ -3595,128 +3604,128 @@ libgnunet_plugin_transport_udp_init(void *cls) int have_bind6; if (NULL == env->receive) - { - /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully - initialze the plugin or the API */ - api = GNUNET_new(struct GNUNET_TRANSPORT_PluginFunctions); - api->cls = NULL; - api->address_pretty_printer = &udp_plugin_address_pretty_printer; - api->address_to_string = &udp_address_to_string; - api->string_to_address = &udp_string_to_address; - return api; - } + { + /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully + initialze the plugin or the API */ + api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions); + api->cls = NULL; + api->address_pretty_printer = &udp_plugin_address_pretty_printer; + api->address_to_string = &udp_address_to_string; + api->string_to_address = &udp_string_to_address; + return api; + } /* Get port number: port == 0 : autodetect a port, * > 0 : use this port, not given : 2086 default */ - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(env->cfg, - "transport-udp", - "PORT", - &port)) + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (env->cfg, + "transport-udp", + "PORT", + &port)) port = 2086; if (port > 65535) - { - GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR, - "transport-udp", - "PORT", - _("must be in [0,65535]")); - return NULL; - } - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(env->cfg, - "transport-udp", - "ADVERTISED_PORT", - &aport)) + { + GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, + "transport-udp", + "PORT", + _ ("must be in [0,65535]")); + return NULL; + } + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (env->cfg, + "transport-udp", + "ADVERTISED_PORT", + &aport)) aport = port; if (aport > 65535) - { - GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR, - "transport-udp", - "ADVERTISED_PORT", - _("must be in [0,65535]")); - return NULL; - } + { + GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, + "transport-udp", + "ADVERTISED_PORT", + _ ("must be in [0,65535]")); + return NULL; + } if (GNUNET_YES == - GNUNET_CONFIGURATION_get_value_yesno(env->cfg, "nat", "DISABLEV6")) + GNUNET_CONFIGURATION_get_value_yesno (env->cfg, "nat", "DISABLEV6")) enable_v6 = GNUNET_NO; else enable_v6 = GNUNET_YES; have_bind4 = GNUNET_NO; - memset(&server_addrv4, 0, sizeof(server_addrv4)); - if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string(env->cfg, - "transport-udp", - "BINDTO", - &bind4_address)) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Binding UDP plugin to specific address: `%s'\n", - bind4_address); - if (1 != inet_pton(AF_INET, bind4_address, &server_addrv4.sin_addr)) - { - GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR, - "transport-udp", - "BINDTO", - _("must be valid IPv4 address")); - GNUNET_free(bind4_address); - return NULL; - } - have_bind4 = GNUNET_YES; + memset (&server_addrv4, 0, sizeof(server_addrv4)); + if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string (env->cfg, + "transport-udp", + "BINDTO", + &bind4_address)) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Binding UDP plugin to specific address: `%s'\n", + bind4_address); + if (1 != inet_pton (AF_INET, bind4_address, &server_addrv4.sin_addr)) + { + GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, + "transport-udp", + "BINDTO", + _ ("must be valid IPv4 address")); + GNUNET_free (bind4_address); + return NULL; } - GNUNET_free_non_null(bind4_address); + have_bind4 = GNUNET_YES; + } + GNUNET_free_non_null (bind4_address); have_bind6 = GNUNET_NO; - memset(&server_addrv6, 0, sizeof(server_addrv6)); - if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string(env->cfg, - "transport-udp", - "BINDTO6", - &bind6_address)) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Binding udp plugin to specific address: `%s'\n", - bind6_address); - if (1 != inet_pton(AF_INET6, bind6_address, &server_addrv6.sin6_addr)) - { - GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR, - "transport-udp", - "BINDTO6", - _("must be valid IPv6 address")); - GNUNET_free(bind6_address); - return NULL; - } - have_bind6 = GNUNET_YES; + memset (&server_addrv6, 0, sizeof(server_addrv6)); + if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string (env->cfg, + "transport-udp", + "BINDTO6", + &bind6_address)) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Binding udp plugin to specific address: `%s'\n", + bind6_address); + if (1 != inet_pton (AF_INET6, bind6_address, &server_addrv6.sin6_addr)) + { + GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, + "transport-udp", + "BINDTO6", + _ ("must be valid IPv6 address")); + GNUNET_free (bind6_address); + return NULL; } - GNUNET_free_non_null(bind6_address); + have_bind6 = GNUNET_YES; + } + GNUNET_free_non_null (bind6_address); - enable_broadcasting = GNUNET_CONFIGURATION_get_value_yesno(env->cfg, - "transport-udp", - "BROADCAST"); + enable_broadcasting = GNUNET_CONFIGURATION_get_value_yesno (env->cfg, + "transport-udp", + "BROADCAST"); if (enable_broadcasting == GNUNET_SYSERR) enable_broadcasting = GNUNET_NO; enable_broadcasting_recv = - GNUNET_CONFIGURATION_get_value_yesno(env->cfg, - "transport-udp", - "BROADCAST_RECEIVE"); + GNUNET_CONFIGURATION_get_value_yesno (env->cfg, + "transport-udp", + "BROADCAST_RECEIVE"); if (enable_broadcasting_recv == GNUNET_SYSERR) enable_broadcasting_recv = GNUNET_YES; if (GNUNET_SYSERR == - GNUNET_CONFIGURATION_get_value_time(env->cfg, - "transport-udp", - "BROADCAST_INTERVAL", - &interval)) - { - interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10); - } - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(env->cfg, - "transport-udp", - "MAX_BPS", - &udp_max_bps)) - { - /* 50 MB/s == infinity for practical purposes */ - udp_max_bps = 1024 * 1024 * 50; - } - - p = GNUNET_new(struct Plugin); + GNUNET_CONFIGURATION_get_value_time (env->cfg, + "transport-udp", + "BROADCAST_INTERVAL", + &interval)) + { + interval = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10); + } + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (env->cfg, + "transport-udp", + "MAX_BPS", + &udp_max_bps)) + { + /* 50 MB/s == infinity for practical purposes */ + udp_max_bps = 1024 * 1024 * 50; + } + + p = GNUNET_new (struct Plugin); p->port = port; p->aport = aport; p->broadcast_interval = interval; @@ -3725,33 +3734,33 @@ libgnunet_plugin_transport_udp_init(void *cls) p->enable_broadcasting = enable_broadcasting; p->enable_broadcasting_receiving = enable_broadcasting_recv; p->env = env; - p->sessions = GNUNET_CONTAINER_multipeermap_create(16, GNUNET_NO); + p->sessions = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_NO); p->defrag_ctxs = - GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); - GNUNET_BANDWIDTH_tracker_init(&p->tracker, - NULL, - NULL, - GNUNET_BANDWIDTH_value_init( - (uint32_t)udp_max_bps), - 30); - res = setup_sockets(p, - (GNUNET_YES == have_bind6) ? &server_addrv6 : NULL, - (GNUNET_YES == have_bind4) ? &server_addrv4 : NULL); + GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); + GNUNET_BANDWIDTH_tracker_init (&p->tracker, + NULL, + NULL, + GNUNET_BANDWIDTH_value_init ( + (uint32_t) udp_max_bps), + 30); + res = setup_sockets (p, + (GNUNET_YES == have_bind6) ? &server_addrv6 : NULL, + (GNUNET_YES == have_bind4) ? &server_addrv4 : NULL); if ((0 == res) || ((NULL == p->sockv4) && (NULL == p->sockv6))) - { - LOG(GNUNET_ERROR_TYPE_ERROR, _("Failed to create UDP network sockets\n")); - GNUNET_CONTAINER_multipeermap_destroy(p->sessions); - GNUNET_CONTAINER_heap_destroy(p->defrag_ctxs); - if (NULL != p->nat) - GNUNET_NAT_unregister(p->nat); - GNUNET_free(p); - return NULL; - } + { + LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Failed to create UDP network sockets\n")); + GNUNET_CONTAINER_multipeermap_destroy (p->sessions); + GNUNET_CONTAINER_heap_destroy (p->defrag_ctxs); + if (NULL != p->nat) + GNUNET_NAT_unregister (p->nat); + GNUNET_free (p); + return NULL; + } /* Setup broadcasting and receiving beacons */ - setup_broadcast(p, &server_addrv6, &server_addrv4); + setup_broadcast (p, &server_addrv6, &server_addrv4); - api = GNUNET_new(struct GNUNET_TRANSPORT_PluginFunctions); + api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions); api->cls = p; api->disconnect_session = &udp_disconnect_session; api->query_keepalive_factor = &udp_query_keepalive_factor; @@ -3781,16 +3790,16 @@ libgnunet_plugin_transport_udp_init(void *cls) * @return #GNUNET_YES */ static int -heap_cleanup_iterator(void *cls, - struct GNUNET_CONTAINER_HeapNode *node, - void *element, - GNUNET_CONTAINER_HeapCostType cost) +heap_cleanup_iterator (void *cls, + struct GNUNET_CONTAINER_HeapNode *node, + void *element, + GNUNET_CONTAINER_HeapCostType cost) { struct DefragContext *d_ctx = element; - GNUNET_CONTAINER_heap_remove_node(node); - GNUNET_DEFRAGMENT_context_destroy(d_ctx->defrag); - GNUNET_free(d_ctx); + GNUNET_CONTAINER_heap_remove_node (node); + GNUNET_DEFRAGMENT_context_destroy (d_ctx->defrag); + GNUNET_free (d_ctx); return GNUNET_YES; } @@ -3803,7 +3812,7 @@ heap_cleanup_iterator(void *cls, * @return NULL */ void * -libgnunet_plugin_transport_udp_done(void *cls) +libgnunet_plugin_transport_udp_done (void *cls) { struct GNUNET_TRANSPORT_PluginFunctions *api = cls; struct Plugin *plugin = api->cls; @@ -3811,77 +3820,77 @@ libgnunet_plugin_transport_udp_done(void *cls) struct UDP_MessageWrapper *udpw; if (NULL == plugin) - { - GNUNET_free(api); - return NULL; - } - stop_broadcast(plugin); + { + GNUNET_free (api); + return NULL; + } + stop_broadcast (plugin); if (NULL != plugin->select_task_v4) - { - GNUNET_SCHEDULER_cancel(plugin->select_task_v4); - plugin->select_task_v4 = NULL; - } + { + GNUNET_SCHEDULER_cancel (plugin->select_task_v4); + plugin->select_task_v4 = NULL; + } if (NULL != plugin->select_task_v6) - { - GNUNET_SCHEDULER_cancel(plugin->select_task_v6); - plugin->select_task_v6 = NULL; - } + { + GNUNET_SCHEDULER_cancel (plugin->select_task_v6); + plugin->select_task_v6 = NULL; + } if (NULL != plugin->sockv4) - { - GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(plugin->sockv4)); - plugin->sockv4 = NULL; - } + { + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4)); + plugin->sockv4 = NULL; + } if (NULL != plugin->sockv6) - { - GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(plugin->sockv6)); - plugin->sockv6 = NULL; - } + { + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6)); + plugin->sockv6 = NULL; + } if (NULL != plugin->nat) - { - GNUNET_NAT_unregister(plugin->nat); - plugin->nat = NULL; - } + { + GNUNET_NAT_unregister (plugin->nat); + plugin->nat = NULL; + } if (NULL != plugin->defrag_ctxs) - { - GNUNET_CONTAINER_heap_iterate(plugin->defrag_ctxs, - &heap_cleanup_iterator, - NULL); - GNUNET_CONTAINER_heap_destroy(plugin->defrag_ctxs); - plugin->defrag_ctxs = NULL; - } + { + GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs, + &heap_cleanup_iterator, + NULL); + GNUNET_CONTAINER_heap_destroy (plugin->defrag_ctxs); + plugin->defrag_ctxs = NULL; + } while (NULL != (udpw = plugin->ipv4_queue_head)) - { - dequeue(plugin, udpw); - udpw->qc(udpw->qc_cls, udpw, GNUNET_SYSERR); - GNUNET_free(udpw); - } + { + dequeue (plugin, udpw); + udpw->qc (udpw->qc_cls, udpw, GNUNET_SYSERR); + GNUNET_free (udpw); + } while (NULL != (udpw = plugin->ipv6_queue_head)) - { - dequeue(plugin, udpw); - udpw->qc(udpw->qc_cls, udpw, GNUNET_SYSERR); - GNUNET_free(udpw); - } - GNUNET_CONTAINER_multipeermap_iterate(plugin->sessions, - &disconnect_and_free_it, - plugin); - GNUNET_CONTAINER_multipeermap_destroy(plugin->sessions); + { + dequeue (plugin, udpw); + udpw->qc (udpw->qc_cls, udpw, GNUNET_SYSERR); + GNUNET_free (udpw); + } + GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions, + &disconnect_and_free_it, + plugin); + GNUNET_CONTAINER_multipeermap_destroy (plugin->sessions); while (NULL != (cur = plugin->ppc_dll_head)) - { - GNUNET_break(0); - GNUNET_CONTAINER_DLL_remove(plugin->ppc_dll_head, - plugin->ppc_dll_tail, - cur); - GNUNET_RESOLVER_request_cancel(cur->resolver_handle); - if (NULL != cur->timeout_task) - { - GNUNET_SCHEDULER_cancel(cur->timeout_task); - cur->timeout_task = NULL; - } - GNUNET_free(cur); - } - GNUNET_free(plugin); - GNUNET_free(api); + { + GNUNET_break (0); + GNUNET_CONTAINER_DLL_remove (plugin->ppc_dll_head, + plugin->ppc_dll_tail, + cur); + GNUNET_RESOLVER_request_cancel (cur->resolver_handle); + if (NULL != cur->timeout_task) + { + GNUNET_SCHEDULER_cancel (cur->timeout_task); + cur->timeout_task = NULL; + } + GNUNET_free (cur); + } + GNUNET_free (plugin); + GNUNET_free (api); return NULL; } -- cgit v1.2.3