From: Christian Grothoff Date: Thu, 6 Feb 2014 08:52:04 +0000 (+0000) Subject: -doxygen, indentation, code cleanup X-Git-Tag: initial-import-from-subversion-38251~4766 X-Git-Url: https://git.librecmc.org/?a=commitdiff_plain;h=44bb5a6082b7f240458abf8b39154cf0d4f06c45;p=oweals%2Fgnunet.git -doxygen, indentation, code cleanup --- diff --git a/src/transport/plugin_transport_udp.c b/src/transport/plugin_transport_udp.c index a50aaa436..12e551fef 100644 --- a/src/transport/plugin_transport_udp.c +++ b/src/transport/plugin_transport_udp.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet - (C) 2010-2013 Christian Grothoff (and other contributing authors) + (C) 2010-2014 Christian Grothoff (and other contributing authors) GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -73,6 +73,7 @@ static struct PrettyPrinterContext *ppc_dll_head; */ static struct PrettyPrinterContext *ppc_dll_tail; + /** * Closure for 'append_port'. */ @@ -125,15 +126,6 @@ struct PrettyPrinterContext uint32_t options; }; -enum UDP_MessageType -{ - UNDEFINED = 0, - MSG_FRAGMENTED = 1, - MSG_FRAGMENTED_COMPLETE = 2, - MSG_UNFRAGMENTED = 3, - MSG_ACK = 4, - MSG_BEACON = 5 -}; struct Session { @@ -351,6 +343,40 @@ struct UDP_FragmentationContext }; + +/** + * Message types included in a `struct UDP_MessageWrapper` + */ +enum UDP_MessageType +{ + /** + * Uninitialized (error) + */ + UMT_UNDEFINED = 0, + + /** + * Fragment of a message. + */ + UMT_MSG_FRAGMENTED = 1, + + /** + * + */ + UMT_MSG_FRAGMENTED_COMPLETE = 2, + + /** + * Unfragmented message. + */ + UMT_MSG_UNFRAGMENTED = 3, + + /** + * Receipt confirmation. + */ + UMT_MSG_ACK = 4 + +}; + + struct UDP_MessageWrapper { /** @@ -372,9 +398,8 @@ struct UDP_MessageWrapper /** * Message type - * According to UDP_MessageType */ - int msg_type; + enum UDP_MessageType msg_type; /** * Message with size msg_size including UDP specific overhead @@ -402,7 +427,7 @@ struct UDP_MessageWrapper GNUNET_TRANSPORT_TransmitContinuation cont; /** - * Closure for 'cont'. + * Closure for @e cont. */ void *cont_cls; @@ -414,6 +439,7 @@ struct UDP_MessageWrapper struct UDP_FragmentationContext *frag_ctx; }; + /** * UDP ACK Message-Packet header (after defragmentation). */ @@ -446,6 +472,7 @@ static uint32_t myoptions; */ struct Plugin * plugin; + /** * We have been notified that our readset has something to read. We don't * know which socket needs to be read, so we have to check each one @@ -521,6 +548,7 @@ schedule_select (struct Plugin *plugin) } } + /** * Function called for a quick conversion of the binary address to * a numeric address. Note that the caller must not free the @@ -533,7 +561,9 @@ schedule_select (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]; @@ -566,7 +596,7 @@ udp_address_to_string (void *cls, const void *addr, size_t addrlen) } else { - return NULL ; + return NULL; } inet_ntop (af, sb, buf, INET6_ADDRSTRLEN); @@ -576,6 +606,7 @@ udp_address_to_string (void *cls, const void *addr, size_t addrlen) return rbuf; } + /** * Function called to convert a string address to * a binary address. @@ -585,12 +616,15 @@ udp_address_to_string (void *cls, const void *addr, size_t addrlen) * @param addrlen length of the address * @param buf location to store the buffer * @param added location to store the number of bytes in the buffer. - * If the function returns GNUNET_SYSERR, its contents are undefined. - * @return GNUNET_OK on success, GNUNET_SYSERR on failure + * If the function returns #GNUNET_SYSERR, its contents are undefined. + * @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; @@ -639,9 +673,9 @@ udp_string_to_address (void *cls, const char *addr, uint16_t addrlen, address[0] = '\0'; address++; - if (GNUNET_OK - != GNUNET_STRINGS_to_address_ip (address, strlen (address), - &socket_address)) + if (GNUNET_OK != + GNUNET_STRINGS_to_address_ip (address, strlen (address), + &socket_address)) { GNUNET_break(0); GNUNET_free(plugin); @@ -682,8 +716,10 @@ udp_string_to_address (void *cls, const char *addr, uint16_t addrlen, } } + static void -ppc_cancel_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +ppc_cancel_task (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { struct PrettyPrinterContext *ppc = cls; @@ -697,6 +733,7 @@ ppc_cancel_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) GNUNET_free(ppc); } + /** * Append our port and forward the result. * @@ -741,6 +778,7 @@ append_port (void *cls, const char *hostname) GNUNET_free(ret); } + /** * Convert the transports address to a nice, human-readable * format. @@ -756,10 +794,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 PrettyPrinterContext *ppc; const void *sb; @@ -824,15 +866,17 @@ udp_plugin_address_pretty_printer (void *cls, const char *type, timeout, &append_port, ppc); } + static void -call_continuation (struct UDP_MessageWrapper *udpw, int result) +call_continuation (struct UDP_MessageWrapper *udpw, + int result) { size_t overhead; - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Calling continuation for %u byte message to `%s' with result %s\n", - udpw->payload_size, GNUNET_i2s (&udpw->session->target), - (GNUNET_OK == result) ? "OK" : "SYSERR"); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Calling continuation for %u byte message to `%s' with result %s\n", + udpw->payload_size, GNUNET_i2s (&udpw->session->target), + (GNUNET_OK == result) ? "OK" : "SYSERR"); if (udpw->msg_size >= udpw->payload_size) overhead = udpw->msg_size - udpw->payload_size; @@ -844,7 +888,7 @@ call_continuation (struct UDP_MessageWrapper *udpw, int result) case GNUNET_OK: switch (udpw->msg_type) { - case MSG_UNFRAGMENTED: + case UMT_MSG_UNFRAGMENTED: if (NULL != udpw->cont) { /* Transport continuation */ @@ -864,7 +908,7 @@ call_continuation (struct UDP_MessageWrapper *udpw, int result) GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, total, bytes payload, sent", udpw->payload_size, GNUNET_NO); break; - case MSG_FRAGMENTED_COMPLETE: + case UMT_MSG_FRAGMENTED_COMPLETE: GNUNET_assert(NULL != udpw->frag_ctx); if (udpw->frag_ctx->cont != NULL ) udpw->frag_ctx->cont (udpw->frag_ctx->cont_cls, &udpw->session->target, @@ -885,7 +929,7 @@ call_continuation (struct UDP_MessageWrapper *udpw, int result) GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, fragmented msgs, messages, pending", -1, GNUNET_NO); break; - case MSG_FRAGMENTED: + case UMT_MSG_FRAGMENTED: /* Fragmented message: enqueue next fragment */ if (NULL != udpw->cont) udpw->cont (udpw->cont_cls, &udpw->session->target, result, @@ -896,7 +940,7 @@ call_continuation (struct UDP_MessageWrapper *udpw, int result) "# UDP, fragmented msgs, fragments bytes, sent, success", udpw->msg_size, GNUNET_NO); break; - case MSG_ACK: + case UMT_MSG_ACK: /* No continuation */ GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, ACK msgs, messages, sent, success", 1, GNUNET_NO); @@ -906,11 +950,7 @@ call_continuation (struct UDP_MessageWrapper *udpw, int result) GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, total, bytes overhead, sent", overhead, GNUNET_NO); break; - case MSG_BEACON: - GNUNET_break(0); - break; default: - LOG(GNUNET_ERROR_TYPE_ERROR, "ERROR: %u\n", udpw->msg_type); GNUNET_break(0); break; } @@ -918,7 +958,7 @@ call_continuation (struct UDP_MessageWrapper *udpw, int result) case GNUNET_SYSERR: switch (udpw->msg_type) { - case MSG_UNFRAGMENTED: + case UMT_MSG_UNFRAGMENTED: /* Unfragmented message: failed to send */ if (NULL != udpw->cont) udpw->cont (udpw->cont_cls, &udpw->session->target, result, @@ -932,7 +972,7 @@ call_continuation (struct UDP_MessageWrapper *udpw, int result) "# UDP, unfragmented msgs, bytes overhead, sent, failure", overhead, GNUNET_NO); break; - case MSG_FRAGMENTED_COMPLETE: + case UMT_MSG_FRAGMENTED_COMPLETE: GNUNET_assert(NULL != udpw->frag_ctx); if (udpw->frag_ctx->cont != NULL ) udpw->frag_ctx->cont (udpw->frag_ctx->cont_cls, &udpw->session->target, @@ -952,7 +992,7 @@ call_continuation (struct UDP_MessageWrapper *udpw, int result) GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, fragmented msgs, messages, pending", -1, GNUNET_NO); break; - case MSG_FRAGMENTED: + case UMT_MSG_FRAGMENTED: GNUNET_assert(NULL != udpw->frag_ctx); /* Fragmented message: failed to send */ GNUNET_STATISTICS_update (plugin->env->stats, @@ -961,15 +1001,11 @@ call_continuation (struct UDP_MessageWrapper *udpw, int result) "# UDP, fragmented msgs, fragments bytes, sent, failure", udpw->msg_size, GNUNET_NO); break; - case MSG_ACK: + case UMT_MSG_ACK: /* ACK message: failed to send */ GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, ACK msgs, messages, sent, failure", 1, GNUNET_NO); break; - case MSG_BEACON: - /* Beacon message: failed to send */ - GNUNET_break(0); - break; default: GNUNET_break(0); break; @@ -981,6 +1017,7 @@ call_continuation (struct UDP_MessageWrapper *udpw, int result) } } + /** * Check if the given port is plausible (must be either our listen * port or our advertised port). If it is neither, we return @@ -998,6 +1035,7 @@ check_port (struct Plugin *plugin, uint16_t in_port) return GNUNET_SYSERR; } + /** * Function that will be called to check if a binary address for this * plugin is well-formed and corresponds to an address for THIS peer @@ -1055,6 +1093,7 @@ udp_plugin_check_address (void *cls, const void *addr, size_t addrlen) return GNUNET_OK; } + /** * Function to free last resources associated with a session. * @@ -1072,8 +1111,10 @@ free_session (struct Session *s) GNUNET_free(s); } + static void -dequeue (struct Plugin *plugin, struct UDP_MessageWrapper * udpw) +dequeue (struct Plugin *plugin, + struct UDP_MessageWrapper * udpw) { if (plugin->bytes_in_buffer < udpw->msg_size) GNUNET_break(0); @@ -1096,8 +1137,10 @@ dequeue (struct Plugin *plugin, struct UDP_MessageWrapper * udpw) GNUNET_break (0); } + static void -fragmented_message_done (struct UDP_FragmentationContext *fc, int result) +fragmented_message_done (struct UDP_FragmentationContext *fc, + int result) { struct UDP_MessageWrapper *udpw; struct UDP_MessageWrapper *tmp; @@ -1110,7 +1153,7 @@ fragmented_message_done (struct UDP_FragmentationContext *fc, int result) /* Call continuation for fragmented message */ memset (&dummy, 0, sizeof(dummy)); - dummy.msg_type = MSG_FRAGMENTED_COMPLETE; + dummy.msg_type = UMT_MSG_FRAGMENTED_COMPLETE; dummy.msg_size = s->frag_ctx->on_wire_size; dummy.payload_size = s->frag_ctx->payload_size; dummy.frag_ctx = s->frag_ctx; @@ -1158,6 +1201,7 @@ fragmented_message_done (struct UDP_FragmentationContext *fc, int result) GNUNET_free(fc); } + /** * Functions with this signature are called whenever we need * to close a session due to a disconnect or failure to @@ -1240,9 +1284,10 @@ udp_disconnect_session (void *cls, struct Session *s) return GNUNET_OK; } + /** * Function that is called to get the keepalive factor. - * GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to + * #GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to * calculate the interval between keepalive packets. * * @param cls closure with the `struct Plugin` @@ -1254,6 +1299,7 @@ udp_query_keepalive_factor (void *cls) return 15; } + /** * Destroy a session, plugin is being unloaded. * @@ -1263,8 +1309,9 @@ udp_query_keepalive_factor (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; @@ -1272,6 +1319,7 @@ disconnect_and_free_it (void *cls, const struct GNUNET_PeerIdentity *key, return GNUNET_OK; } + /** * Disconnect from a remote node. Clean up session if we have one for * this peer. @@ -1281,17 +1329,20 @@ disconnect_and_free_it (void *cls, const struct GNUNET_PeerIdentity *key, * @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)); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Disconnecting from peer `%s'\n", + GNUNET_i2s (target)); /* Clean up sessions */ GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessions, target, - &disconnect_and_free_it, plugin); + &disconnect_and_free_it, plugin); } + /** * Session was idle, so disconnect it * @@ -1299,18 +1350,22 @@ udp_disconnect (void *cls, const struct GNUNET_PeerIdentity *target) * @param tc scheduler context */ static void -session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +session_timeout (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { struct Session *s = cls; s->timeout_task = GNUNET_SCHEDULER_NO_TASK; - GNUNET_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)); + GNUNET_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); } + /** * Increment session timeout due to activity * @@ -1328,9 +1383,10 @@ reschedule_session_timeout (struct Session *s) GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Timeout restarted for session %p\n", s); } + static struct Session * create_session (struct Plugin *plugin, - const struct GNUNET_HELLO_Address *address) + const struct GNUNET_HELLO_Address *address) { struct Session *s; @@ -1343,20 +1399,24 @@ create_session (struct Plugin *plugin, s->flow_delay_from_other_peer = GNUNET_TIME_UNIT_ZERO_ABS; s->flow_delay_for_other_peer = GNUNET_TIME_UNIT_ZERO; s->timeout_task = GNUNET_SCHEDULER_add_delayed (UDP_SESSION_TIME_OUT, - &session_timeout, s); + &session_timeout, s); return s; } + 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 SessionCompareContext * cctx = cls; + struct SessionCompareContext *cctx = cls; const struct GNUNET_HELLO_Address *address = cctx->address; struct Session *s = value; - LOG(GNUNET_ERROR_TYPE_DEBUG, "Comparing address %s <-> %s\n", - udp_address_to_string (NULL, (void *) address->address, address->address_length), - udp_address_to_string (NULL, s->address->address, s->address->address_length)); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Comparing address %s <-> %s\n", + udp_address_to_string (NULL, address->address, address->address_length), + udp_address_to_string (NULL, s->address->address, s->address->address_length)); if (0 == GNUNET_HELLO_address_cmp(s->address, cctx->address)) { @@ -1366,6 +1426,7 @@ session_cmp_it (void *cls, const struct GNUNET_PeerIdentity * key, void *value) return GNUNET_YES; } + /** * Function obtain the network type for a session * @@ -1374,11 +1435,13 @@ session_cmp_it (void *cls, const struct GNUNET_PeerIdentity * key, void *value) * @return the network type */ static enum GNUNET_ATS_Network_Type -udp_get_network (void *cls, struct Session *session) +udp_get_network (void *cls, + struct Session *session) { return ntohl (session->ats.value); } + /** * Creates a new outbound session the transport service will use to * send data to the peer @@ -1389,7 +1452,7 @@ udp_get_network (void *cls, struct Session *session) */ static struct Session * udp_plugin_lookup_session (void *cls, - const struct GNUNET_HELLO_Address *address) + const struct GNUNET_HELLO_Address *address) { struct Plugin * plugin = cls; struct IPv6UdpAddress * udp_a6; @@ -1398,33 +1461,34 @@ udp_plugin_lookup_session (void *cls, GNUNET_assert(plugin != NULL); GNUNET_assert(address != NULL); - if ((address->address == NULL )|| - ((address->address_length != sizeof (struct IPv4UdpAddress)) && - (address->address_length != sizeof (struct IPv6UdpAddress)))){ - LOG (GNUNET_ERROR_TYPE_WARNING, - _("Trying to create session for address of unexpected length %u (should be %u or %u)\n"), - address->address_length, - sizeof (struct IPv4UdpAddress), - sizeof (struct IPv6UdpAddress)); - return NULL; -} + if ( (address->address == NULL )|| + ((address->address_length != sizeof (struct IPv4UdpAddress)) && + (address->address_length != sizeof (struct IPv6UdpAddress)))) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + _("Trying to create session for address of unexpected length %u (should be %u or %u)\n"), + address->address_length, + sizeof (struct IPv4UdpAddress), + sizeof (struct IPv6UdpAddress)); + return NULL; + } if (address->address_length == sizeof(struct IPv4UdpAddress)) { - if (plugin->sockv4 == NULL ) - return NULL ; + if (plugin->sockv4 == NULL) + return NULL; udp_a4 = (struct IPv4UdpAddress *) address->address; if (udp_a4->u4_port == 0) - return NULL ; + return NULL; } if (address->address_length == sizeof(struct IPv6UdpAddress)) { - if (plugin->sockv6 == NULL ) - return NULL ; + if (plugin->sockv6 == NULL) + return NULL; udp_a6 = (struct IPv6UdpAddress *) address->address; if (udp_a6->u6_port == 0) - return NULL ; + return NULL; } /* check if session already exists */ @@ -1439,16 +1503,18 @@ udp_plugin_lookup_session (void *cls, session_cmp_it, &cctx); if (cctx.res != 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; } - return NULL ; + return NULL; } static struct Session * udp_plugin_create_session (void *cls, - const struct GNUNET_HELLO_Address *address) + const struct GNUNET_HELLO_Address *address) { struct Session *s; struct IPv4UdpAddress *udp_v4; @@ -1485,7 +1551,7 @@ udp_plugin_create_session (void *cls, } if (NULL == s) - return NULL ; /* protocol not supported or address invalid */ + return NULL; /* protocol not supported or address invalid */ LOG(GNUNET_ERROR_TYPE_DEBUG, "Creating new %s session %p for peer `%s' address `%s'\n", GNUNET_HELLO_address_check_option (address, GNUNET_HELLO_ADDRESS_INFO_INBOUND) ? "inbound" : "outbound", @@ -1498,13 +1564,15 @@ udp_plugin_create_session (void *cls, return s; } + static void udp_plugin_update_session_timeout (void *cls, - const struct GNUNET_PeerIdentity *peer, struct Session *session) + const struct GNUNET_PeerIdentity *peer, + struct Session *session) { - if (GNUNET_YES - != GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessions, peer, - session)) + if (GNUNET_YES != + GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessions, peer, + session)) { GNUNET_break(0); return; @@ -1514,6 +1582,7 @@ udp_plugin_update_session_timeout (void *cls, reschedule_session_timeout (session); } + /** * Creates a new outbound session the transport service will use to send data to the * peer @@ -1523,18 +1592,19 @@ udp_plugin_update_session_timeout (void *cls, * @return the session or NULL of max connections exceeded */ static struct 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 Session *s; if (NULL == address) { GNUNET_break(0); - return NULL ; + return NULL; } - if ((address->address_length != sizeof(struct IPv4UdpAddress)) - && (address->address_length != sizeof(struct IPv6UdpAddress))) - return NULL ; + if ( (address->address_length != sizeof(struct IPv4UdpAddress)) && + (address->address_length != sizeof(struct IPv6UdpAddress)) ) + return NULL; /* otherwise create new */ if (NULL != (s = udp_plugin_lookup_session (cls, address))) @@ -1542,8 +1612,10 @@ udp_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address) return udp_plugin_create_session (cls, address); } + static void -enqueue (struct Plugin *plugin, struct UDP_MessageWrapper * udpw) +enqueue (struct Plugin *plugin, + struct UDP_MessageWrapper *udpw) { if (plugin->bytes_in_buffer + udpw->msg_size > INT64_MAX) GNUNET_break(0); @@ -1565,6 +1637,7 @@ enqueue (struct Plugin *plugin, struct UDP_MessageWrapper * udpw) GNUNET_break (0); } + /** * Fragment message was transmitted via UDP, let fragmentation know * to send the next fragment now. @@ -1576,14 +1649,18 @@ enqueue (struct Plugin *plugin, struct UDP_MessageWrapper * udpw) * @param physical bytes physical sent */ static void -send_next_fragment (void *cls, const struct GNUNET_PeerIdentity *target, - int result, size_t payload, size_t physical) +send_next_fragment (void *cls, + const struct GNUNET_PeerIdentity *target, + int result, + size_t payload, + size_t physical) { struct UDP_MessageWrapper *udpw = cls; GNUNET_FRAGMENT_context_transmission_done (udpw->frag_ctx->frag); } + /** * Function that is called with messages created by the fragmentation * module. In the case of the 'proc' callback of the @@ -1612,12 +1689,13 @@ enqueue_fragment (void *cls, const struct GNUNET_MessageHeader *msg) udpw->cont_cls = udpw; udpw->timeout = frag_ctx->timeout; udpw->frag_ctx = frag_ctx; - udpw->msg_type = MSG_FRAGMENTED; + udpw->msg_type = UMT_MSG_FRAGMENTED; memcpy (udpw->msg_buf, msg, msg_len); enqueue (plugin, udpw); schedule_select (plugin); } + /** * Function that can be used by the transport service to transmit * a message using the plugin. Note that in the case of a @@ -1646,9 +1724,13 @@ enqueue_fragment (void *cls, const struct GNUNET_MessageHeader *msg) * and does NOT mean that the message was not transmitted (DV) */ static ssize_t -udp_plugin_send (void *cls, struct 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 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); @@ -1659,14 +1741,12 @@ udp_plugin_send (void *cls, struct Session *s, const char *msgbuf, GNUNET_assert(plugin != NULL); GNUNET_assert(s != NULL); - if ((s->address->address_length == sizeof(struct IPv6UdpAddress)) && (plugin->sockv6 == NULL )) - { + if ( (s->address->address_length == sizeof(struct IPv6UdpAddress)) && + (plugin->sockv6 == NULL) ) return GNUNET_SYSERR; - } - if ((s->address->address_length == sizeof(struct IPv4UdpAddress)) && (plugin->sockv4 == NULL )) - { + if ( (s->address->address_length == sizeof(struct IPv4UdpAddress)) && + (plugin->sockv4 == NULL) ) return GNUNET_SYSERR; - } if (udpmlen >= GNUNET_SERVER_MAX_MESSAGE_SIZE) { GNUNET_break(0); @@ -1679,9 +1759,11 @@ udp_plugin_send (void *cls, struct Session *s, const char *msgbuf, 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 (NULL, s->address->address, s->address->address_length)); + 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 (NULL, s->address->address, + s->address->address_length)); /* Message */ udp = (struct UDPMessage *) mbuf; @@ -1709,7 +1791,7 @@ udp_plugin_send (void *cls, struct Session *s, const char *msgbuf, udpw->cont = cont; udpw->cont_cls = cont_cls; udpw->frag_ctx = NULL; - udpw->msg_type = MSG_UNFRAGMENTED; + udpw->msg_type = UMT_MSG_UNFRAGMENTED; memcpy (udpw->msg_buf, udp, sizeof(struct UDPMessage)); memcpy (&udpw->msg_buf[sizeof(struct UDPMessage)], msgbuf, msgbuf_size); enqueue (plugin, udpw); @@ -1723,7 +1805,7 @@ udp_plugin_send (void *cls, struct Session *s, const char *msgbuf, else { /* fragmented message */ - if (s->frag_ctx != NULL ) + if (s->frag_ctx != NULL) return GNUNET_SYSERR; memcpy (&udp[1], msgbuf, msgbuf_size); frag_ctx = GNUNET_new (struct UDP_FragmentationContext); @@ -1751,18 +1833,20 @@ udp_plugin_send (void *cls, struct Session *s, const char *msgbuf, return udpmlen; } + /** * Our external IP address/port mapping has changed. * - * @param cls closure, the 'struct LocalAddrList' - * @param add_remove GNUNET_YES to mean the new public IP address, GNUNET_NO to mean + * @param cls closure, the `struct LocalAddrList` + * @param add_remove #GNUNET_YES to mean the new public IP address, #GNUNET_NO to mean * the previous (now invalid) one * @param addr either the previous or the new public IP address * @param addrlen actual lenght of the address */ static void udp_nat_port_map_callback (void *cls, int add_remove, - const struct sockaddr *addr, socklen_t addrlen) + const struct sockaddr *addr, + socklen_t addrlen) { struct Plugin *plugin = cls; struct GNUNET_HELLO_Address *address; @@ -1812,6 +1896,7 @@ udp_nat_port_map_callback (void *cls, int add_remove, GNUNET_HELLO_address_free (address); } + /** * Message tokenizer has broken up an incomming message. Pass it on * to the service. @@ -1843,6 +1928,7 @@ process_inbound_tokenized_messages (void *cls, void *client, return GNUNET_OK; } + /** * We've received a UDP Message. Process it (pass contents to main service). * @@ -1852,8 +1938,10 @@ process_inbound_tokenized_messages (void *cls, void *client, * @param sender_addr_len number of bytes in sender_addr */ static void -process_udp_message (struct Plugin *plugin, const struct UDPMessage *msg, - const struct sockaddr *sender_addr, socklen_t sender_addr_len) +process_udp_message (struct Plugin *plugin, + const struct UDPMessage *msg, + const struct sockaddr *sender_addr, + socklen_t sender_addr_len) { struct SourceInformation si; struct Session * s; @@ -1928,6 +2016,7 @@ process_udp_message (struct Plugin *plugin, const struct UDPMessage *msg, free_session (s); } + /** * Scan the heap for a receive context with the given address. * @@ -1954,6 +2043,7 @@ find_receive_context (void *cls, struct GNUNET_CONTAINER_HeapNode *node, return GNUNET_YES; } + /** * Process a defragmented message. * @@ -2006,9 +2096,11 @@ struct LookupContext int must_have_frag_ctx; }; + static int -lookup_session_by_sockaddr_it (void *cls, const struct GNUNET_PeerIdentity *key, - void *value) +lookup_session_by_sockaddr_it (void *cls, + const struct GNUNET_PeerIdentity *key, + void *value) { struct LookupContext *l_ctx = cls; struct Session * s = value; @@ -2057,6 +2149,7 @@ lookup_session_by_sockaddr_it (void *cls, const struct GNUNET_PeerIdentity *key, return GNUNET_YES; } + /** * Transmit an acknowledgement. * @@ -2099,7 +2192,7 @@ ack_proc (void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg) udpw->session = s; udpw->timeout = GNUNET_TIME_UNIT_FOREVER_ABS; udpw->msg_buf = (char *) &udpw[1]; - udpw->msg_type = MSG_ACK; + udpw->msg_type = UMT_MSG_ACK; 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); @@ -2110,9 +2203,12 @@ ack_proc (void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg) schedule_select (rc->plugin); } + static void -read_process_msg (struct Plugin *plugin, const struct GNUNET_MessageHeader *msg, - const struct sockaddr *addr, socklen_t fromlen) +read_process_msg (struct Plugin *plugin, + const struct GNUNET_MessageHeader *msg, + const struct sockaddr *addr, + socklen_t fromlen) { if (ntohs (msg->size) < sizeof(struct UDPMessage)) { @@ -2122,9 +2218,12 @@ read_process_msg (struct Plugin *plugin, const struct GNUNET_MessageHeader *msg, process_udp_message (plugin, (const struct UDPMessage *) msg, addr, fromlen); } + static void -read_process_ack (struct Plugin *plugin, const struct GNUNET_MessageHeader *msg, - const struct sockaddr *addr, socklen_t fromlen) +read_process_ack (struct Plugin *plugin, + const struct GNUNET_MessageHeader *msg, + const struct sockaddr *addr, + socklen_t fromlen) { const struct GNUNET_MessageHeader *ack; const struct UDP_ACK_Message *udp_ack; @@ -2187,10 +2286,12 @@ read_process_ack (struct Plugin *plugin, const struct GNUNET_MessageHeader *msg, fragmented_message_done (s->frag_ctx, GNUNET_OK); } + static void read_process_fragment (struct Plugin *plugin, - const struct GNUNET_MessageHeader *msg, const struct sockaddr *addr, - socklen_t fromlen) + const struct GNUNET_MessageHeader *msg, + const struct sockaddr *addr, + socklen_t fromlen) { struct DefragContext *d_ctx; struct GNUNET_TIME_Absolute now; @@ -2249,6 +2350,7 @@ read_process_fragment (struct Plugin *plugin, } } + /** * Read and process a message from the given socket. * @@ -2256,7 +2358,8 @@ 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; @@ -2341,9 +2444,10 @@ udp_select_read (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock) } } + static struct UDP_MessageWrapper * remove_timeout_messages_and_select (struct UDP_MessageWrapper *head, - struct GNUNET_NETWORK_Handle *sock) + struct GNUNET_NETWORK_Handle *sock) { struct UDP_MessageWrapper *udpw = NULL; struct GNUNET_TIME_Relative remaining; @@ -2358,7 +2462,7 @@ remove_timeout_messages_and_select (struct UDP_MessageWrapper *head, /* Message timed out */ switch (udpw->msg_type) { - case MSG_UNFRAGMENTED: + case UMT_MSG_UNFRAGMENTED: GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, total, bytes, sent, timeout", udpw->msg_size, GNUNET_NO); GNUNET_STATISTICS_update (plugin->env->stats, @@ -2377,7 +2481,7 @@ remove_timeout_messages_and_select (struct UDP_MessageWrapper *head, dequeue (plugin, udpw); GNUNET_free(udpw); break; - case MSG_FRAGMENTED: + case UMT_MSG_FRAGMENTED: /* Fragmented message */ GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, total, bytes, sent, timeout", udpw->frag_ctx->on_wire_size, @@ -2397,7 +2501,7 @@ remove_timeout_messages_and_select (struct UDP_MessageWrapper *head, /* Remove fragmented message due to timeout */ fragmented_message_done (udpw->frag_ctx, GNUNET_SYSERR); break; - case MSG_ACK: + case UMT_MSG_ACK: GNUNET_STATISTICS_update (plugin->env->stats, "# UDP, total, bytes, sent, timeout", udpw->msg_size, GNUNET_NO); GNUNET_STATISTICS_update (plugin->env->stats, @@ -2451,9 +2555,11 @@ remove_timeout_messages_and_select (struct UDP_MessageWrapper *head, return udpw; } + 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) { static int network_down_error; struct GNUNET_ATS_Information type; @@ -2462,43 +2568,45 @@ analyze_send_error (struct Plugin *plugin, const struct sockaddr * sa, if (((GNUNET_ATS_NET_LAN == ntohl (type.value)) || (GNUNET_ATS_NET_WAN == ntohl (type.value))) && ((ENETUNREACH == errno)|| (ENETDOWN == errno))) - { - if ((network_down_error == GNUNET_NO) && (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 ((network_down_error == GNUNET_NO) && (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)); - } + { + if ((network_down_error == GNUNET_NO) && (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 ((network_down_error == GNUNET_NO) && (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)); + } +} + static size_t -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; @@ -2507,14 +2615,13 @@ udp_select_send (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock) struct sockaddr_in a4; const struct IPv6UdpAddress *u6; struct sockaddr_in6 a6; - - - struct UDP_MessageWrapper *udpw = NULL; + struct UDP_MessageWrapper *udpw; /* Find message to send */ - udpw = remove_timeout_messages_and_select ( - (sock == plugin->sockv4) ? - plugin->ipv4_queue_head : plugin->ipv6_queue_head, sock); + udpw = remove_timeout_messages_and_select ((sock == plugin->sockv4) + ? plugin->ipv4_queue_head + : plugin->ipv6_queue_head, + sock); if (NULL == udpw) return 0; /* No message to send */ @@ -2584,6 +2691,7 @@ udp_select_send (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock) return sent; } + /** * We have been notified that our readset has something to read. We don't * know which socket needs to be read, so we have to check each one @@ -2593,7 +2701,8 @@ udp_select_send (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock) * @param tc the scheduling context (for rescheduling this function again) */ static void -udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +udp_plugin_select (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { struct Plugin *plugin = cls; @@ -2611,6 +2720,7 @@ udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) schedule_select (plugin); } + /** * We have been notified that our readset has something to read. We don't * know which socket needs to be read, so we have to check each one @@ -2620,7 +2730,8 @@ udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) * @param tc the scheduling context (for rescheduling this function again) */ static void -udp_plugin_select_v6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +udp_plugin_select_v6 (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { struct Plugin *plugin = cls; @@ -2637,13 +2748,19 @@ udp_plugin_select_v6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) schedule_select (plugin); } + /** + * Setup the UDP sockets (for IPv4 and IPv6) for the plugin. * + * @param plugin the plugin to initialize + * @param bind_v6 IPv6 address to bind to (can be NULL, for 'any') + * @param bind_v4 IPv4 address to bind to (can be NULL, for 'any') * @return number of sockets that were successfully bound */ static 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; int sockets_created = 0; @@ -2657,7 +2774,7 @@ setup_sockets (struct Plugin *plugin, const struct sockaddr_in6 *bind_v6, /* Create IPv6 socket */ eno = EINVAL; - if (plugin->enable_ipv6 == GNUNET_YES) + if (GNUNET_YES == plugin->enable_ipv6) { plugin->sockv6 = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 0); if (NULL == plugin->sockv6) @@ -2756,9 +2873,9 @@ setup_sockets (struct Plugin *plugin, const struct sockaddr_in6 *bind_v6, if (0 == plugin->port) /* autodetect */ - server_addrv4.sin_port = htons ( - GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) - + 32000); + server_addrv4.sin_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, + 33537) + + 32000); else server_addrv4.sin_port = htons (plugin->port); @@ -2768,8 +2885,9 @@ setup_sockets (struct Plugin *plugin, const struct sockaddr_in6 *bind_v6, tries = 0; while (tries < 10) { - LOG(GNUNET_ERROR_TYPE_DEBUG, "Binding to IPv4 `%s'\n", - GNUNET_a2s (server_addr, addrlen)); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Binding to IPv4 `%s'\n", + GNUNET_a2s (server_addr, addrlen)); /* binding */ if (GNUNET_OK @@ -2796,7 +2914,7 @@ setup_sockets (struct Plugin *plugin, const struct sockaddr_in6 *bind_v6, plugin->sockv4 = NULL; } - if (plugin->sockv4 != NULL ) + if (NULL != plugin->sockv4) { LOG(GNUNET_ERROR_TYPE_DEBUG, "IPv4 socket created on port %s\n", GNUNET_a2s (server_addr, addrlen)); @@ -2846,18 +2964,20 @@ setup_sockets (struct Plugin *plugin, const struct sockaddr_in6 *bind_v6, schedule_select (plugin); plugin->nat = GNUNET_NAT_register (plugin->env->cfg, GNUNET_NO, plugin->port, - sockets_created, (const struct sockaddr **) addrs, addrlens, - &udp_nat_port_map_callback, NULL, plugin); + sockets_created, + (const struct sockaddr **) addrs, addrlens, + &udp_nat_port_map_callback, NULL, plugin); return sockets_created; } + /** * The exported method. Makes the core api available via a global and * returns the udp transport API. * - * @param cls our 'struct GNUNET_TRANSPORT_PluginEnvironment' - * @return our 'struct GNUNET_TRANSPORT_PluginFunctions' + * @param cls our `struct GNUNET_TRANSPORT_PluginEnvironment` + * @return our `struct GNUNET_TRANSPORT_PluginFunctions` */ void * libgnunet_plugin_transport_udp_init (void *cls) @@ -2871,9 +2991,9 @@ libgnunet_plugin_transport_udp_init (void *cls) unsigned long long enable_v6; unsigned long long enable_broadcasting; unsigned long long enable_broadcasting_recv; - char * bind4_address; - char * bind6_address; - char * fancy_interval; + char *bind4_address; + char *bind6_address; + char *fancy_interval; struct GNUNET_TIME_Relative interval; struct sockaddr_in server_addrv4; struct sockaddr_in6 server_addrv6; @@ -2893,29 +3013,28 @@ libgnunet_plugin_transport_udp_init (void *cls) return api; } - GNUNET_assert(NULL != env->stats); - /* 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 (GNUNET_OK - != GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp", - "ADVERTISED_PORT", &aport)) + if (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp", + "ADVERTISED_PORT", &aport)) aport = port; if (port > 65535) { - LOG(GNUNET_ERROR_TYPE_WARNING, - _("Given `%s' option is out of range: %llu > %u\n"), "PORT", port, - 65535); - return NULL ; + LOG (GNUNET_ERROR_TYPE_WARNING, + _("Given `%s' option is out of range: %llu > %u\n"), + "PORT", port, + 65535); + return NULL; } /* Protocols */ - if ((GNUNET_YES - == GNUNET_CONFIGURATION_get_value_yesno (env->cfg, "nat", "DISABLEV6"))) + if (GNUNET_YES == + GNUNET_CONFIGURATION_get_value_yesno (env->cfg, "nat", "DISABLEV6")) enable_v6 = GNUNET_NO; else enable_v6 = GNUNET_YES; @@ -2923,38 +3042,39 @@ libgnunet_plugin_transport_udp_init (void *cls) /* Addresses */ 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)) + 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); + 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_free(bind4_address); - return NULL ; + GNUNET_free (bind4_address); + return NULL; } 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)) + 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); + 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)) { - LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid IPv6 address: `%s'\n"), - bind6_address); - GNUNET_free(bind6_address); - return NULL ; + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Invalid IPv6 address: `%s'\n"), + bind6_address); + GNUNET_free (bind6_address); + return NULL; } have_bind6 = GNUNET_YES; } - GNUNET_free_non_null(bind6_address); + GNUNET_free_non_null (bind6_address); /* Initialize my flags */ myoptions = 0; @@ -2987,9 +3107,9 @@ libgnunet_plugin_transport_udp_init (void *cls) } /* Maximum datarate */ - if (GNUNET_OK - != GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp", - "MAX_BPS", &udp_max_bps)) + if (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp", + "MAX_BPS", &udp_max_bps)) { udp_max_bps = 1024 * 1024 * 50; /* 50 MB/s == infinity for practical purposes */ } @@ -3012,8 +3132,9 @@ libgnunet_plugin_transport_udp_init (void *cls) plugin = p; LOG(GNUNET_ERROR_TYPE_DEBUG, "Setting up sockets\n"); - res = setup_sockets (p, (GNUNET_YES == have_bind6) ? &server_addrv6 : NULL, - (GNUNET_YES == have_bind4) ? &server_addrv4 : NULL ); + res = setup_sockets (p, + (GNUNET_YES == have_bind6) ? &server_addrv6 : NULL, + (GNUNET_YES == have_bind4) ? &server_addrv4 : NULL); if ((res == 0) || ((p->sockv4 == NULL )&& (p->sockv6 == NULL))) { LOG (GNUNET_ERROR_TYPE_ERROR, @@ -3045,24 +3166,37 @@ libgnunet_plugin_transport_udp_init (void *cls) return api; } + +/** + * Function called on each entry in the defragmentation heap to + * clean it up. + * + * @param cls NULL + * @param node node in the heap (to be removed) + * @param element a `struct DefragContext` to be cleaned up + * @param cost unused + * @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; + struct DefragContext *d_ctx = element; GNUNET_CONTAINER_heap_remove_node (node); GNUNET_DEFRAGMENT_context_destroy (d_ctx->defrag); - GNUNET_free(d_ctx); - + GNUNET_free (d_ctx); return GNUNET_YES; } + /** * The exported method. Makes the core api available via a global and * returns the udp transport API. * - * @param cls our 'struct GNUNET_TRANSPORT_PluginEnvironment' + * @param cls our `struct GNUNET_TRANSPORT_PluginEnvironment` * @return NULL */ void * @@ -3072,13 +3206,13 @@ libgnunet_plugin_transport_udp_done (void *cls) struct Plugin *plugin = api->cls; struct PrettyPrinterContext *cur; struct PrettyPrinterContext *next; + struct UDP_MessageWrapper *udpw; if (NULL == plugin) { GNUNET_free(api); - return NULL ; + return NULL; } - stop_broadcast (plugin); if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK ) { @@ -3096,7 +3230,7 @@ libgnunet_plugin_transport_udp_done (void *cls) { if (NULL != plugin->sockv4) { - GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4)); + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4)); plugin->sockv4 = NULL; } GNUNET_NETWORK_fdset_destroy (plugin->rs_v4); @@ -3106,7 +3240,7 @@ libgnunet_plugin_transport_udp_done (void *cls) { if (NULL != plugin->sockv6) { - GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6)); + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6)); plugin->sockv6 = NULL; GNUNET_NETWORK_fdset_destroy (plugin->rs_v6); @@ -3120,44 +3254,42 @@ libgnunet_plugin_transport_udp_done (void *cls) } if (NULL != plugin->defrag_ctxs) { - GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs, heap_cleanup_iterator, - NULL ); + GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs, + &heap_cleanup_iterator, NULL); GNUNET_CONTAINER_heap_destroy (plugin->defrag_ctxs); plugin->defrag_ctxs = NULL; } - if (plugin->mst != NULL ) + if (NULL != plugin->mst) { GNUNET_SERVER_mst_destroy (plugin->mst); plugin->mst = NULL; } /* Clean up leftover messages */ - struct UDP_MessageWrapper * udpw; udpw = plugin->ipv4_queue_head; - while (udpw != NULL ) + while (NULL != udpw) { struct UDP_MessageWrapper *tmp = udpw->next; dequeue (plugin, udpw); call_continuation (udpw, GNUNET_SYSERR); GNUNET_free(udpw); - udpw = tmp; } udpw = plugin->ipv6_queue_head; - while (udpw != NULL ) + while (NULL != udpw) { struct UDP_MessageWrapper *tmp = udpw->next; dequeue (plugin, udpw); call_continuation (udpw, GNUNET_SYSERR); GNUNET_free(udpw); - udpw = tmp; } /* Clean up sessions */ - LOG(GNUNET_ERROR_TYPE_DEBUG, "Cleaning up sessions\n"); + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Cleaning up sessions\n"); GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions, - &disconnect_and_free_it, plugin); + &disconnect_and_free_it, plugin); GNUNET_CONTAINER_multipeermap_destroy (plugin->sessions); next = ppc_dll_head; @@ -3170,27 +3302,9 @@ libgnunet_plugin_transport_udp_done (void *cls) GNUNET_free(cur); GNUNET_break(0); } - - plugin->nat = NULL; - GNUNET_free(plugin); - GNUNET_free(api); -#if DEBUG_MALLOC - struct Allocation *allocation; - while (NULL != ahead) - { - allocation = ahead; - GNUNET_CONTAINER_DLL_remove (ahead, atail, allocation); - GNUNET_free (allocation); - } - struct Allocator *allocator; - while (NULL != aehead) - { - allocator = aehead; - GNUNET_CONTAINER_DLL_remove (aehead, aetail, allocator); - GNUNET_free (allocator); - } -#endif - return NULL ; + GNUNET_free (plugin); + GNUNET_free (api); + return NULL; } /* end of plugin_transport_udp.c */ diff --git a/src/transport/plugin_transport_udp_broadcasting.c b/src/transport/plugin_transport_udp_broadcasting.c index 7dfe86944..cb7e4ddee 100644 --- a/src/transport/plugin_transport_udp_broadcasting.c +++ b/src/transport/plugin_transport_udp_broadcasting.c @@ -216,7 +216,7 @@ broadcast_ipv4_mst_cb (void *cls, void *client, void udp_broadcast_receive (struct Plugin *plugin, - const char * buf, + const char *buf, ssize_t size, const struct sockaddr *addr, size_t addrlen)