From d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb Mon Sep 17 00:00:00 2001 From: ng0 Date: Sun, 8 Sep 2019 12:33:09 +0000 Subject: uncrustify as demanded. --- src/transport/plugin_transport_unix.c | 1603 ++++++++++++++++----------------- 1 file changed, 796 insertions(+), 807 deletions(-) (limited to 'src/transport/plugin_transport_unix.c') diff --git a/src/transport/plugin_transport_unix.c b/src/transport/plugin_transport_unix.c index 2c408ebf5..5f7b38479 100644 --- a/src/transport/plugin_transport_unix.c +++ b/src/transport/plugin_transport_unix.c @@ -11,12 +11,12 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . SPDX-License-Identifier: AGPL3.0-or-later -*/ + */ /** * @file transport/plugin_transport_unix.c @@ -51,8 +51,7 @@ /** * Options for UNIX Domain addresses. */ -enum UNIX_ADDRESS_OPTIONS -{ +enum UNIX_ADDRESS_OPTIONS { /** * No special options. */ @@ -69,9 +68,9 @@ enum UNIX_ADDRESS_OPTIONS * How long until we give up on transmitting the welcome message? */ #define HOSTNAME_RESOLVE_TIMEOUT \ - GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) + GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5) -#define LOG(kind, ...) GNUNET_log_from (kind, "transport-unix", __VA_ARGS__) +#define LOG(kind, ...) GNUNET_log_from(kind, "transport-unix", __VA_ARGS__) GNUNET_NETWORK_STRUCT_BEGIN @@ -79,8 +78,7 @@ GNUNET_NETWORK_STRUCT_BEGIN /** * Binary format for an UNIX Domain Socket address in GNUnet. */ -struct UnixAddress -{ +struct UnixAddress { /** * Options to use for the address, in NBO */ @@ -98,8 +96,7 @@ struct UnixAddress /** * UNIX Message-Packet header. */ -struct UNIXMessage -{ +struct UNIXMessage { /** * Message header. */ @@ -117,8 +114,7 @@ GNUNET_NETWORK_STRUCT_END /** * Information we track for a message awaiting transmission. */ -struct UNIXMessageWrapper -{ +struct UNIXMessageWrapper { /** * We keep messages in a doubly linked list. */ @@ -174,9 +170,7 @@ struct UNIXMessageWrapper /** * Handle for a session. */ -struct GNUNET_ATS_Session -{ - +struct GNUNET_ATS_Session { /** * Sessions with pending messages (!) are kept in a DLL. */ @@ -236,8 +230,7 @@ struct Plugin; /** * Information we keep for each of our listen sockets. */ -struct UNIX_Sock_Info -{ +struct UNIX_Sock_Info { /** * The network handle */ @@ -248,9 +241,7 @@ struct UNIX_Sock_Info /** * Encapsulation of all of the state of the plugin. */ -struct Plugin -{ - +struct Plugin { /** * ID of task used to update our addresses when one expires. */ @@ -332,15 +323,15 @@ struct Plugin * @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; if (NULL == plugin->sic) return; - 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; @@ -350,7 +341,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); } @@ -366,50 +357,50 @@ notify_session_monitor (struct Plugin *plugin, * @return string representing the same address */ static const char * -unix_plugin_address_to_string (void *cls, const void *addr, size_t addrlen) +unix_plugin_address_to_string(void *cls, const void *addr, size_t addrlen) { static char rbuf[1024]; - struct UnixAddress *ua = (struct UnixAddress *) addr; + struct UnixAddress *ua = (struct UnixAddress *)addr; char *addrstr; size_t addr_str_len; unsigned int off; - if ((NULL == addr) || (sizeof (struct UnixAddress) > addrlen)) - { - GNUNET_break (0); - return NULL; - } - addrstr = (char *) &ua[1]; - addr_str_len = ntohl (ua->addrlen); - - if (addr_str_len != addrlen - sizeof (struct UnixAddress)) - { - GNUNET_break (0); - return NULL; - } + if ((NULL == addr) || (sizeof(struct UnixAddress) > addrlen)) + { + GNUNET_break(0); + return NULL; + } + addrstr = (char *)&ua[1]; + addr_str_len = ntohl(ua->addrlen); + + if (addr_str_len != addrlen - sizeof(struct UnixAddress)) + { + GNUNET_break(0); + return NULL; + } if ('\0' != addrstr[addr_str_len - 1]) - { - GNUNET_break (0); - return NULL; - } - if (strlen (addrstr) + 1 != addr_str_len) - { - GNUNET_break (0); - return NULL; - } + { + GNUNET_break(0); + return NULL; + } + if (strlen(addrstr) + 1 != addr_str_len) + { + GNUNET_break(0); + return NULL; + } off = 0; if ('\0' == addrstr[0]) off++; - memset (rbuf, 0, sizeof (rbuf)); - GNUNET_snprintf (rbuf, - sizeof (rbuf) - 1, - "%s.%u.%s%.*s", - PLUGIN_NAME, - ntohl (ua->options), - (off == 1) ? "@" : "", - (int) (addr_str_len - off), - &addrstr[off]); + memset(rbuf, 0, sizeof(rbuf)); + GNUNET_snprintf(rbuf, + sizeof(rbuf) - 1, + "%s.%u.%s%.*s", + PLUGIN_NAME, + ntohl(ua->options), + (off == 1) ? "@" : "", + (int)(addr_str_len - off), + &addrstr[off]); return rbuf; } @@ -424,61 +415,61 @@ unix_plugin_address_to_string (void *cls, const void *addr, size_t addrlen) * @return #GNUNET_OK on success */ static int -unix_plugin_session_disconnect (void *cls, struct GNUNET_ATS_Session *session) +unix_plugin_session_disconnect(void *cls, struct GNUNET_ATS_Session *session) { struct Plugin *plugin = cls; struct UNIXMessageWrapper *msgw; struct UNIXMessageWrapper *next; - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Disconnecting session for peer `%s' `%s'\n", - GNUNET_i2s (&session->target), - unix_plugin_address_to_string (NULL, - session->address->address, - session->address->address_length)); - plugin->env->session_end (plugin->env->cls, session->address, session); + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Disconnecting session for peer `%s' `%s'\n", + GNUNET_i2s(&session->target), + unix_plugin_address_to_string(NULL, + session->address->address, + session->address->address_length)); + plugin->env->session_end(plugin->env->cls, session->address, session); next = plugin->msg_head; while (NULL != next) - { - msgw = next; - next = msgw->next; - if (msgw->session != session) - continue; - GNUNET_CONTAINER_DLL_remove (plugin->msg_head, plugin->msg_tail, msgw); - session->msgs_in_queue--; - GNUNET_assert (session->bytes_in_queue >= msgw->msgsize); - session->bytes_in_queue -= msgw->msgsize; - GNUNET_assert (plugin->bytes_in_queue >= msgw->msgsize); - plugin->bytes_in_queue -= msgw->msgsize; - if (NULL != msgw->cont) - msgw->cont (msgw->cont_cls, - &msgw->session->target, - GNUNET_SYSERR, - msgw->payload, - 0); - GNUNET_free (msgw->msg); - GNUNET_free (msgw); - } - GNUNET_assert (GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove (plugin->session_map, - &session->target, - session)); - GNUNET_STATISTICS_set (plugin->env->stats, - "# UNIX sessions active", - GNUNET_CONTAINER_multipeermap_size ( - plugin->session_map), - GNUNET_NO); + { + msgw = next; + next = msgw->next; + if (msgw->session != session) + continue; + GNUNET_CONTAINER_DLL_remove(plugin->msg_head, plugin->msg_tail, msgw); + session->msgs_in_queue--; + GNUNET_assert(session->bytes_in_queue >= msgw->msgsize); + session->bytes_in_queue -= msgw->msgsize; + GNUNET_assert(plugin->bytes_in_queue >= msgw->msgsize); + plugin->bytes_in_queue -= msgw->msgsize; + if (NULL != msgw->cont) + msgw->cont(msgw->cont_cls, + &msgw->session->target, + GNUNET_SYSERR, + msgw->payload, + 0); + GNUNET_free(msgw->msg); + GNUNET_free(msgw); + } + GNUNET_assert(GNUNET_YES == + GNUNET_CONTAINER_multipeermap_remove(plugin->session_map, + &session->target, + session)); + GNUNET_STATISTICS_set(plugin->env->stats, + "# UNIX sessions active", + GNUNET_CONTAINER_multipeermap_size( + plugin->session_map), + GNUNET_NO); if (NULL != session->timeout_task) - { - GNUNET_SCHEDULER_cancel (session->timeout_task); - session->timeout_task = NULL; - session->timeout = GNUNET_TIME_UNIT_ZERO_ABS; - } - notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_DONE); - GNUNET_HELLO_address_free (session->address); - GNUNET_break (0 == session->bytes_in_queue); - GNUNET_break (0 == session->msgs_in_queue); - GNUNET_free (session); + { + GNUNET_SCHEDULER_cancel(session->timeout_task); + session->timeout_task = NULL; + session->timeout = GNUNET_TIME_UNIT_ZERO_ABS; + } + notify_session_monitor(plugin, session, GNUNET_TRANSPORT_SS_DONE); + GNUNET_HELLO_address_free(session->address); + GNUNET_break(0 == session->bytes_in_queue); + GNUNET_break(0 == session->msgs_in_queue); + GNUNET_free(session); return GNUNET_OK; } @@ -489,31 +480,31 @@ unix_plugin_session_disconnect (void *cls, struct GNUNET_ATS_Session *session) * @param cls the `struct GNUNET_ATS_Session *` to disconnect */ static void -session_timeout (void *cls) +session_timeout(void *cls) { struct GNUNET_ATS_Session *session = cls; struct GNUNET_TIME_Relative left; session->timeout_task = NULL; - left = GNUNET_TIME_absolute_get_remaining (session->timeout); + left = GNUNET_TIME_absolute_get_remaining(session->timeout); if (0 != left.rel_value_us) - { - /* not actually our turn yet, but let's at least update - the monitor, it may think we're about to die ... */ - notify_session_monitor (session->plugin, - session, - GNUNET_TRANSPORT_SS_UPDATE); - session->timeout_task = - GNUNET_SCHEDULER_add_delayed (left, &session_timeout, session); - return; - } - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Session %p was idle for %s, disconnecting\n", - session, - GNUNET_STRINGS_relative_time_to_string ( - GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, - GNUNET_YES)); - unix_plugin_session_disconnect (session->plugin, session); + { + /* not actually our turn yet, but let's at least update + the monitor, it may think we're about to die ... */ + notify_session_monitor(session->plugin, + session, + GNUNET_TRANSPORT_SS_UPDATE); + session->timeout_task = + GNUNET_SCHEDULER_add_delayed(left, &session_timeout, session); + return; + } + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Session %p was idle for %s, disconnecting\n", + session, + GNUNET_STRINGS_relative_time_to_string( + GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, + GNUNET_YES)); + unix_plugin_session_disconnect(session->plugin, session); } @@ -525,11 +516,11 @@ session_timeout (void *cls) * @param session session for which the timeout should be rescheduled */ static void -reschedule_session_timeout (struct GNUNET_ATS_Session *session) +reschedule_session_timeout(struct GNUNET_ATS_Session *session) { - GNUNET_assert (NULL != session->timeout_task); + GNUNET_assert(NULL != session->timeout_task); session->timeout = - GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); } @@ -541,22 +532,22 @@ reschedule_session_timeout (struct GNUNET_ATS_Session *session) * @return converted unix path */ static struct sockaddr_un * -unix_address_to_sockaddr (const char *unixpath, socklen_t *sock_len) +unix_address_to_sockaddr(const char *unixpath, socklen_t *sock_len) { struct sockaddr_un *un; size_t slen; - GNUNET_assert (0 < strlen (unixpath)); /* sanity check */ - un = GNUNET_new (struct sockaddr_un); + GNUNET_assert(0 < strlen(unixpath)); /* sanity check */ + un = GNUNET_new(struct sockaddr_un); un->sun_family = AF_UNIX; - slen = strlen (unixpath); - if (slen >= sizeof (un->sun_path)) - slen = sizeof (un->sun_path) - 1; - GNUNET_memcpy (un->sun_path, unixpath, slen); + slen = strlen(unixpath); + if (slen >= sizeof(un->sun_path)) + slen = sizeof(un->sun_path) - 1; + GNUNET_memcpy(un->sun_path, unixpath, slen); un->sun_path[slen] = '\0'; - slen = sizeof (struct sockaddr_un); + slen = sizeof(struct sockaddr_un); #if HAVE_SOCKADDR_UN_SUN_LEN - un->sun_len = (u_char) slen; + un->sun_len = (u_char)slen; #endif (*sock_len) = slen; return un; @@ -566,8 +557,7 @@ unix_address_to_sockaddr (const char *unixpath, socklen_t *sock_len) /** * Closure to #lookup_session_it(). */ -struct LookupCtx -{ +struct LookupCtx { /** * Location to store the session, if found. */ @@ -589,18 +579,18 @@ struct LookupCtx * @return #GNUNET_YES if not found (continue looking), #GNUNET_NO on success */ static int -lookup_session_it (void *cls, - const struct GNUNET_PeerIdentity *key, - void *value) +lookup_session_it(void *cls, + const struct GNUNET_PeerIdentity *key, + void *value) { struct LookupCtx *lctx = cls; struct GNUNET_ATS_Session *session = value; - if (0 == GNUNET_HELLO_address_cmp (lctx->address, session->address)) - { - lctx->res = session; - return GNUNET_NO; - } + if (0 == GNUNET_HELLO_address_cmp(lctx->address, session->address)) + { + lctx->res = session; + return GNUNET_NO; + } return GNUNET_YES; } @@ -613,17 +603,17 @@ lookup_session_it (void *cls, * @return NULL if session was not found */ static struct GNUNET_ATS_Session * -lookup_session (struct Plugin *plugin, - const struct GNUNET_HELLO_Address *address) +lookup_session(struct Plugin *plugin, + const struct GNUNET_HELLO_Address *address) { struct LookupCtx lctx; lctx.address = address; lctx.res = NULL; - GNUNET_CONTAINER_multipeermap_get_multiple (plugin->session_map, - &address->peer, - &lookup_session_it, - &lctx); + GNUNET_CONTAINER_multipeermap_get_multiple(plugin->session_map, + &address->peer, + &lookup_session_it, + &lctx); return lctx.res; } @@ -637,7 +627,7 @@ lookup_session (struct Plugin *plugin, * @return keepalive factor */ static unsigned int -unix_plugin_query_keepalive_factor (void *cls) +unix_plugin_query_keepalive_factor(void *cls) { return 3; } @@ -665,18 +655,18 @@ unix_plugin_query_keepalive_factor (void *cls) * @return on success the number of bytes written, RETRY for retry, -1 on errors */ static ssize_t -unix_real_send (void *cls, - struct GNUNET_NETWORK_Handle *send_handle, - const struct GNUNET_PeerIdentity *target, - const char *msgbuf, - size_t msgbuf_size, - unsigned int priority, - struct GNUNET_TIME_Absolute timeout, - const struct UnixAddress *addr, - size_t addrlen, - size_t payload, - GNUNET_TRANSPORT_TransmitContinuation cont, - void *cont_cls) +unix_real_send(void *cls, + struct GNUNET_NETWORK_Handle *send_handle, + const struct GNUNET_PeerIdentity *target, + const char *msgbuf, + size_t msgbuf_size, + unsigned int priority, + struct GNUNET_TIME_Absolute timeout, + const struct UnixAddress *addr, + size_t addrlen, + size_t payload, + GNUNET_TRANSPORT_TransmitContinuation cont, + void *cont_cls) { struct Plugin *plugin = cls; ssize_t sent; @@ -685,96 +675,96 @@ unix_real_send (void *cls, const char *unixpath; if (NULL == send_handle) - { - GNUNET_break (0); /* We do not have a send handle */ - return GNUNET_SYSERR; - } + { + GNUNET_break(0); /* We do not have a send handle */ + return GNUNET_SYSERR; + } if ((NULL == addr) || (0 == addrlen)) - { - GNUNET_break (0); /* Can never send if we don't have an address */ - return GNUNET_SYSERR; - } + { + GNUNET_break(0); /* Can never send if we don't have an address */ + return GNUNET_SYSERR; + } /* Prepare address */ - unixpath = (const char *) &addr[1]; - if (NULL == (un = unix_address_to_sockaddr (unixpath, &un_len))) - { - GNUNET_break (0); - return -1; - } + unixpath = (const char *)&addr[1]; + if (NULL == (un = unix_address_to_sockaddr(unixpath, &un_len))) + { + GNUNET_break(0); + return -1; + } if ((GNUNET_YES == plugin->is_abstract) && - (0 != (UNIX_OPTIONS_USE_ABSTRACT_SOCKETS & ntohl (addr->options)))) - { - un->sun_path[0] = '\0'; - } + (0 != (UNIX_OPTIONS_USE_ABSTRACT_SOCKETS & ntohl(addr->options)))) + { + un->sun_path[0] = '\0'; + } resend: /* Send the data */ - sent = GNUNET_NETWORK_socket_sendto (send_handle, - msgbuf, - msgbuf_size, - (const struct sockaddr *) un, - un_len); + sent = GNUNET_NETWORK_socket_sendto(send_handle, + msgbuf, + msgbuf_size, + (const struct sockaddr *)un, + un_len); if (GNUNET_SYSERR == sent) - { - if ((EAGAIN == errno) || (ENOBUFS == errno)) { - GNUNET_free (un); - return RETRY; /* We have to retry later */ - } - if (EMSGSIZE == errno) - { - socklen_t size = 0; - socklen_t len = sizeof (size); - - GNUNET_NETWORK_socket_getsockopt ((struct GNUNET_NETWORK_Handle *) - send_handle, - SOL_SOCKET, - SO_SNDBUF, - &size, - &len); - if (size < msgbuf_size) - { - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Trying to increase socket buffer size from %u to %u for message size %u\n", - (unsigned int) size, - (unsigned int) ((msgbuf_size / 1000) + 2) * 1000, - (unsigned int) msgbuf_size); - size = ((msgbuf_size / 1000) + 2) * 1000; - if (GNUNET_OK == - GNUNET_NETWORK_socket_setsockopt ((struct GNUNET_NETWORK_Handle *) - send_handle, - SOL_SOCKET, - SO_SNDBUF, - &size, - sizeof (size))) - goto resend; /* Increased buffer size, retry sending */ - else + if ((EAGAIN == errno) || (ENOBUFS == errno)) { - /* Could not increase buffer size: error, no retry */ - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsockopt"); - GNUNET_free (un); - return GNUNET_SYSERR; + GNUNET_free(un); + return RETRY; /* We have to retry later */ + } + if (EMSGSIZE == errno) + { + socklen_t size = 0; + socklen_t len = sizeof(size); + + GNUNET_NETWORK_socket_getsockopt((struct GNUNET_NETWORK_Handle *) + send_handle, + SOL_SOCKET, + SO_SNDBUF, + &size, + &len); + if (size < msgbuf_size) + { + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Trying to increase socket buffer size from %u to %u for message size %u\n", + (unsigned int)size, + (unsigned int)((msgbuf_size / 1000) + 2) * 1000, + (unsigned int)msgbuf_size); + size = ((msgbuf_size / 1000) + 2) * 1000; + if (GNUNET_OK == + GNUNET_NETWORK_socket_setsockopt((struct GNUNET_NETWORK_Handle *) + send_handle, + SOL_SOCKET, + SO_SNDBUF, + &size, + sizeof(size))) + goto resend; /* Increased buffer size, retry sending */ + else + { + /* Could not increase buffer size: error, no retry */ + GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "setsockopt"); + GNUNET_free(un); + return GNUNET_SYSERR; + } + } + else + { + /* Buffer is bigger than message: error, no retry + * This should never happen!*/ + GNUNET_break(0); + GNUNET_free(un); + return GNUNET_SYSERR; + } } - } - else - { - /* Buffer is bigger than message: error, no retry - * This should never happen!*/ - GNUNET_break (0); - GNUNET_free (un); - return GNUNET_SYSERR; - } } - } - - LOG (GNUNET_ERROR_TYPE_DEBUG, - "UNIX transmitted %u-byte message to %s (%d: %s)\n", - (unsigned int) msgbuf_size, - GNUNET_a2s ((const struct sockaddr *) un, un_len), - (int) sent, - (sent < 0) ? strerror (errno) : "ok"); - GNUNET_free (un); + + LOG(GNUNET_ERROR_TYPE_DEBUG, + "UNIX transmitted %u-byte message to %s (%d: %s)\n", + (unsigned int)msgbuf_size, + GNUNET_a2s((const struct sockaddr *)un, un_len), + (int)sent, + (sent < 0) ? strerror(errno) : "ok"); + GNUNET_free(un); return sent; } @@ -787,9 +777,9 @@ resend: * @return the network type in HBO or #GNUNET_SYSERR */ static enum GNUNET_NetworkType -unix_plugin_get_network (void *cls, struct GNUNET_ATS_Session *session) +unix_plugin_get_network(void *cls, struct GNUNET_ATS_Session *session) { - GNUNET_assert (NULL != session); + GNUNET_assert(NULL != session); return GNUNET_NT_LOOPBACK; } @@ -802,9 +792,8 @@ unix_plugin_get_network (void *cls, struct GNUNET_ATS_Session *session) * @return the network type */ static enum GNUNET_NetworkType -unix_plugin_get_network_for_address (void *cls, - const struct GNUNET_HELLO_Address *address) - +unix_plugin_get_network_for_address(void *cls, + const struct GNUNET_HELLO_Address *address) { return GNUNET_NT_LOOPBACK; } @@ -819,7 +808,7 @@ unix_plugin_get_network_for_address (void *cls, * @return the session or NULL of max connections exceeded */ static struct GNUNET_ATS_Session * -unix_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address) +unix_plugin_get_session(void *cls, const struct GNUNET_HELLO_Address *address) { struct Plugin *plugin = cls; struct GNUNET_ATS_Session *session; @@ -828,80 +817,80 @@ unix_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address) uint32_t addr_str_len; uint32_t addr_option; - ua = (struct UnixAddress *) address->address; + ua = (struct UnixAddress *)address->address; if ((NULL == address->address) || (0 == address->address_length) || - (sizeof (struct UnixAddress) > address->address_length)) - { - GNUNET_break (0); - return NULL; - } - addrstr = (char *) &ua[1]; - addr_str_len = ntohl (ua->addrlen); - addr_option = ntohl (ua->options); + (sizeof(struct UnixAddress) > address->address_length)) + { + GNUNET_break(0); + return NULL; + } + addrstr = (char *)&ua[1]; + addr_str_len = ntohl(ua->addrlen); + addr_option = ntohl(ua->options); if ((0 != (UNIX_OPTIONS_USE_ABSTRACT_SOCKETS & addr_option)) && (GNUNET_NO == plugin->is_abstract)) - { - return NULL; - } + { + return NULL; + } - if (addr_str_len != address->address_length - sizeof (struct UnixAddress)) - { - return NULL; /* This can be a legacy address */ - } + if (addr_str_len != address->address_length - sizeof(struct UnixAddress)) + { + return NULL; /* This can be a legacy address */ + } if ('\0' != addrstr[addr_str_len - 1]) - { - GNUNET_break (0); - return NULL; - } - if (strlen (addrstr) + 1 != addr_str_len) - { - GNUNET_break (0); - return NULL; - } + { + GNUNET_break(0); + return NULL; + } + if (strlen(addrstr) + 1 != addr_str_len) + { + GNUNET_break(0); + return NULL; + } /* Check if a session for this address already exists */ - if (NULL != (session = lookup_session (plugin, address))) - { - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Found existing session %p for address `%s'\n", - session, - unix_plugin_address_to_string (NULL, + if (NULL != (session = lookup_session(plugin, address))) + { + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Found existing session %p for address `%s'\n", + session, + unix_plugin_address_to_string(NULL, address->address, address->address_length)); - return session; - } + return session; + } /* create a new session */ - session = GNUNET_new (struct GNUNET_ATS_Session); + session = GNUNET_new(struct GNUNET_ATS_Session); session->target = address->peer; - session->address = GNUNET_HELLO_address_copy (address); + session->address = GNUNET_HELLO_address_copy(address); session->plugin = plugin; session->timeout = - GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); session->timeout_task = - GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, - &session_timeout, - session); - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Creating a new session %p for address `%s'\n", - session, - unix_plugin_address_to_string (NULL, - address->address, - address->address_length)); - (void) GNUNET_CONTAINER_multipeermap_put ( + GNUNET_SCHEDULER_add_delayed(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, + &session_timeout, + session); + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Creating a new session %p for address `%s'\n", + session, + unix_plugin_address_to_string(NULL, + address->address, + address->address_length)); + (void)GNUNET_CONTAINER_multipeermap_put( plugin->session_map, &address->peer, session, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); - GNUNET_STATISTICS_set (plugin->env->stats, - "# UNIX sessions active", - GNUNET_CONTAINER_multipeermap_size ( - plugin->session_map), - GNUNET_NO); - notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_INIT); - notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UP); + GNUNET_STATISTICS_set(plugin->env->stats, + "# UNIX sessions active", + GNUNET_CONTAINER_multipeermap_size( + plugin->session_map), + GNUNET_NO); + notify_session_monitor(plugin, session, GNUNET_TRANSPORT_SS_INIT); + notify_session_monitor(plugin, session, GNUNET_TRANSPORT_SS_UP); return session; } @@ -916,21 +905,21 @@ unix_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address) * @param session which session is being updated */ static void -unix_plugin_update_session_timeout (void *cls, - const struct GNUNET_PeerIdentity *peer, - struct GNUNET_ATS_Session *session) +unix_plugin_update_session_timeout(void *cls, + const struct GNUNET_PeerIdentity *peer, + struct GNUNET_ATS_Session *session) { struct Plugin *plugin = cls; if (GNUNET_OK != - GNUNET_CONTAINER_multipeermap_contains_value (plugin->session_map, - &session->target, - session)) - { - GNUNET_break (0); - return; - } - reschedule_session_timeout (session); + GNUNET_CONTAINER_multipeermap_contains_value(plugin->session_map, + &session->target, + session)) + { + GNUNET_break(0); + return; + } + reschedule_session_timeout(session); } @@ -944,47 +933,47 @@ unix_plugin_update_session_timeout (void *cls, * @param ua_len length of the address @a ua */ static void -unix_demultiplexer (struct Plugin *plugin, - struct GNUNET_PeerIdentity *sender, - const struct GNUNET_MessageHeader *currhdr, - const struct UnixAddress *ua, - size_t ua_len) +unix_demultiplexer(struct Plugin *plugin, + struct GNUNET_PeerIdentity *sender, + const struct GNUNET_MessageHeader *currhdr, + const struct UnixAddress *ua, + size_t ua_len) { struct GNUNET_ATS_Session *session; struct GNUNET_HELLO_Address *address; - GNUNET_assert (ua_len >= sizeof (struct UnixAddress)); - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Received message from %s\n", - unix_plugin_address_to_string (NULL, ua, ua_len)); - GNUNET_STATISTICS_update (plugin->env->stats, - "# bytes received via UNIX", - ntohs (currhdr->size), - GNUNET_NO); + GNUNET_assert(ua_len >= sizeof(struct UnixAddress)); + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Received message from %s\n", + unix_plugin_address_to_string(NULL, ua, ua_len)); + GNUNET_STATISTICS_update(plugin->env->stats, + "# bytes received via UNIX", + ntohs(currhdr->size), + GNUNET_NO); /* Look for existing session */ - address = GNUNET_HELLO_address_allocate ( + address = GNUNET_HELLO_address_allocate( sender, PLUGIN_NAME, ua, ua_len, GNUNET_HELLO_ADDRESS_INFO_NONE); /* UNIX does not have "inbound" sessions */ - session = lookup_session (plugin, address); + session = lookup_session(plugin, address); if (NULL == session) - { - session = unix_plugin_get_session (plugin, address); - /* Notify transport and ATS about new inbound session */ - plugin->env->session_start (NULL, - session->address, - session, - GNUNET_NT_LOOPBACK); - } + { + session = unix_plugin_get_session(plugin, address); + /* Notify transport and ATS about new inbound session */ + plugin->env->session_start(NULL, + session->address, + session, + GNUNET_NT_LOOPBACK); + } else - { - reschedule_session_timeout (session); - } - GNUNET_HELLO_address_free (address); - plugin->env->receive (plugin->env->cls, session->address, session, currhdr); + { + reschedule_session_timeout(session); + } + GNUNET_HELLO_address_free(address); + plugin->env->receive(plugin->env->cls, session->address, session, currhdr); } @@ -994,7 +983,7 @@ unix_demultiplexer (struct Plugin *plugin, * @param plugin the plugin */ static void -unix_plugin_do_read (struct Plugin *plugin) +unix_plugin_do_read(struct Plugin *plugin) { char buf[65536] GNUNET_ALIGN; struct UnixAddress *ua; @@ -1011,71 +1000,71 @@ unix_plugin_do_read (struct Plugin *plugin) uint16_t csize; size_t ua_len; - addrlen = sizeof (un); - memset (&un, 0, sizeof (un)); - ret = GNUNET_NETWORK_socket_recvfrom (plugin->unix_sock.desc, - buf, - sizeof (buf), - (struct sockaddr *) &un, - &addrlen); + addrlen = sizeof(un); + memset(&un, 0, sizeof(un)); + ret = GNUNET_NETWORK_socket_recvfrom(plugin->unix_sock.desc, + buf, + sizeof(buf), + (struct sockaddr *)&un, + &addrlen); if ((GNUNET_SYSERR == ret) && ((errno == EAGAIN) || (errno == ENOBUFS))) return; if (GNUNET_SYSERR == ret) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "recvfrom"); - return; - } + { + GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "recvfrom"); + return; + } else - { - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Read %d bytes from socket %s\n", - (int) ret, - un.sun_path); - } - - GNUNET_assert (AF_UNIX == (un.sun_family)); + { + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Read %d bytes from socket %s\n", + (int)ret, + un.sun_path); + } + + GNUNET_assert(AF_UNIX == (un.sun_family)); is_abstract = GNUNET_NO; if ('\0' == un.sun_path[0]) - { - un.sun_path[0] = '@'; - is_abstract = GNUNET_YES; - } - - ua_len = sizeof (struct UnixAddress) + strlen (un.sun_path) + 1; - ua = GNUNET_malloc (ua_len); - ua->addrlen = htonl (strlen (&un.sun_path[0]) + 1); - GNUNET_memcpy (&ua[1], &un.sun_path[0], strlen (un.sun_path) + 1); + { + un.sun_path[0] = '@'; + is_abstract = GNUNET_YES; + } + + ua_len = sizeof(struct UnixAddress) + strlen(un.sun_path) + 1; + ua = GNUNET_malloc(ua_len); + ua->addrlen = htonl(strlen(&un.sun_path[0]) + 1); + GNUNET_memcpy(&ua[1], &un.sun_path[0], strlen(un.sun_path) + 1); if (is_abstract) - ua->options = htonl (UNIX_OPTIONS_USE_ABSTRACT_SOCKETS); + ua->options = htonl(UNIX_OPTIONS_USE_ABSTRACT_SOCKETS); else - ua->options = htonl (UNIX_OPTIONS_NONE); - - msg = (struct UNIXMessage *) buf; - csize = ntohs (msg->header.size); - if ((csize < sizeof (struct UNIXMessage)) || (csize > ret)) - { - GNUNET_break_op (0); - GNUNET_free (ua); - return; - } - msgbuf = (char *) &msg[1]; - GNUNET_memcpy (&sender, &msg->sender, sizeof (struct GNUNET_PeerIdentity)); + ua->options = htonl(UNIX_OPTIONS_NONE); + + msg = (struct UNIXMessage *)buf; + csize = ntohs(msg->header.size); + if ((csize < sizeof(struct UNIXMessage)) || (csize > ret)) + { + GNUNET_break_op(0); + GNUNET_free(ua); + return; + } + msgbuf = (char *)&msg[1]; + GNUNET_memcpy(&sender, &msg->sender, sizeof(struct GNUNET_PeerIdentity)); offset = 0; - tsize = csize - sizeof (struct UNIXMessage); - while (offset + sizeof (struct GNUNET_MessageHeader) <= tsize) - { - currhdr = (struct GNUNET_MessageHeader *) &msgbuf[offset]; - csize = ntohs (currhdr->size); - if ((csize < sizeof (struct GNUNET_MessageHeader)) || - (csize > tsize - offset)) + tsize = csize - sizeof(struct UNIXMessage); + while (offset + sizeof(struct GNUNET_MessageHeader) <= tsize) { - GNUNET_break_op (0); - break; + currhdr = (struct GNUNET_MessageHeader *)&msgbuf[offset]; + csize = ntohs(currhdr->size); + if ((csize < sizeof(struct GNUNET_MessageHeader)) || + (csize > tsize - offset)) + { + GNUNET_break_op(0); + break; + } + unix_demultiplexer(plugin, &sender, currhdr, ua, ua_len); + offset += csize; } - unix_demultiplexer (plugin, &sender, currhdr, ua, ua_len); - offset += csize; - } - GNUNET_free (ua); + GNUNET_free(ua); } @@ -1085,7 +1074,7 @@ unix_plugin_do_read (struct Plugin *plugin) * @param plugin handle to the plugin */ static void -unix_plugin_do_write (struct Plugin *plugin) +unix_plugin_do_write(struct Plugin *plugin) { ssize_t sent = 0; struct UNIXMessageWrapper *msgw; @@ -1095,108 +1084,108 @@ unix_plugin_do_write (struct Plugin *plugin) session = NULL; did_delete = GNUNET_NO; while (NULL != (msgw = plugin->msg_head)) - { - if (GNUNET_TIME_absolute_get_remaining (msgw->timeout).rel_value_us > 0) - break; /* Message is ready for sending */ - /* Message has a timeout */ - did_delete = GNUNET_YES; - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Timeout for message with %u bytes \n", - (unsigned int) msgw->msgsize); - GNUNET_CONTAINER_DLL_remove (plugin->msg_head, plugin->msg_tail, msgw); - session = msgw->session; - session->msgs_in_queue--; - GNUNET_assert (session->bytes_in_queue >= msgw->msgsize); - session->bytes_in_queue -= msgw->msgsize; - GNUNET_assert (plugin->bytes_in_queue >= msgw->msgsize); - plugin->bytes_in_queue -= msgw->msgsize; - GNUNET_STATISTICS_set (plugin->env->stats, - "# bytes currently in UNIX buffers", - plugin->bytes_in_queue, - GNUNET_NO); - GNUNET_STATISTICS_update (plugin->env->stats, - "# UNIX bytes discarded", - msgw->msgsize, - GNUNET_NO); - if (NULL != msgw->cont) - msgw->cont (msgw->cont_cls, - &msgw->session->target, - GNUNET_SYSERR, - msgw->payload, - 0); - GNUNET_free (msgw->msg); - GNUNET_free (msgw); - } + { + if (GNUNET_TIME_absolute_get_remaining(msgw->timeout).rel_value_us > 0) + break; /* Message is ready for sending */ + /* Message has a timeout */ + did_delete = GNUNET_YES; + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Timeout for message with %u bytes \n", + (unsigned int)msgw->msgsize); + GNUNET_CONTAINER_DLL_remove(plugin->msg_head, plugin->msg_tail, msgw); + session = msgw->session; + session->msgs_in_queue--; + GNUNET_assert(session->bytes_in_queue >= msgw->msgsize); + session->bytes_in_queue -= msgw->msgsize; + GNUNET_assert(plugin->bytes_in_queue >= msgw->msgsize); + plugin->bytes_in_queue -= msgw->msgsize; + GNUNET_STATISTICS_set(plugin->env->stats, + "# bytes currently in UNIX buffers", + plugin->bytes_in_queue, + GNUNET_NO); + GNUNET_STATISTICS_update(plugin->env->stats, + "# UNIX bytes discarded", + msgw->msgsize, + GNUNET_NO); + if (NULL != msgw->cont) + msgw->cont(msgw->cont_cls, + &msgw->session->target, + GNUNET_SYSERR, + msgw->payload, + 0); + GNUNET_free(msgw->msg); + GNUNET_free(msgw); + } if (NULL == msgw) - { - if (GNUNET_YES == did_delete) - notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UPDATE); - return; /* Nothing to send at the moment */ - } + { + if (GNUNET_YES == did_delete) + notify_session_monitor(plugin, session, GNUNET_TRANSPORT_SS_UPDATE); + return; /* Nothing to send at the moment */ + } session = msgw->session; - sent = unix_real_send (plugin, - plugin->unix_sock.desc, - &session->target, - (const char *) msgw->msg, - msgw->msgsize, - msgw->priority, - msgw->timeout, - msgw->session->address->address, - msgw->session->address->address_length, - msgw->payload, - msgw->cont, - msgw->cont_cls); + sent = unix_real_send(plugin, + plugin->unix_sock.desc, + &session->target, + (const char *)msgw->msg, + msgw->msgsize, + msgw->priority, + msgw->timeout, + msgw->session->address->address, + msgw->session->address->address_length, + msgw->payload, + msgw->cont, + msgw->cont_cls); if (RETRY == sent) - { - GNUNET_STATISTICS_update (plugin->env->stats, - "# UNIX retry attempts", - 1, - GNUNET_NO); - notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UPDATE); - return; - } - GNUNET_CONTAINER_DLL_remove (plugin->msg_head, plugin->msg_tail, msgw); + { + GNUNET_STATISTICS_update(plugin->env->stats, + "# UNIX retry attempts", + 1, + GNUNET_NO); + notify_session_monitor(plugin, session, GNUNET_TRANSPORT_SS_UPDATE); + return; + } + GNUNET_CONTAINER_DLL_remove(plugin->msg_head, plugin->msg_tail, msgw); session->msgs_in_queue--; - GNUNET_assert (session->bytes_in_queue >= msgw->msgsize); + GNUNET_assert(session->bytes_in_queue >= msgw->msgsize); session->bytes_in_queue -= msgw->msgsize; - GNUNET_assert (plugin->bytes_in_queue >= msgw->msgsize); + GNUNET_assert(plugin->bytes_in_queue >= msgw->msgsize); plugin->bytes_in_queue -= msgw->msgsize; - GNUNET_STATISTICS_set (plugin->env->stats, - "# bytes currently in UNIX buffers", - plugin->bytes_in_queue, - GNUNET_NO); - notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UPDATE); + GNUNET_STATISTICS_set(plugin->env->stats, + "# bytes currently in UNIX buffers", + plugin->bytes_in_queue, + GNUNET_NO); + notify_session_monitor(plugin, session, GNUNET_TRANSPORT_SS_UPDATE); if (GNUNET_SYSERR == sent) - { - /* failed and no retry */ - if (NULL != msgw->cont) - msgw->cont (msgw->cont_cls, - &msgw->session->target, - GNUNET_SYSERR, - msgw->payload, - 0); - GNUNET_STATISTICS_update (plugin->env->stats, - "# UNIX bytes discarded", - msgw->msgsize, - GNUNET_NO); - GNUNET_free (msgw->msg); - GNUNET_free (msgw); - return; - } + { + /* failed and no retry */ + if (NULL != msgw->cont) + msgw->cont(msgw->cont_cls, + &msgw->session->target, + GNUNET_SYSERR, + msgw->payload, + 0); + GNUNET_STATISTICS_update(plugin->env->stats, + "# UNIX bytes discarded", + msgw->msgsize, + GNUNET_NO); + GNUNET_free(msgw->msg); + GNUNET_free(msgw); + return; + } /* successfully sent bytes */ - GNUNET_break (sent > 0); - GNUNET_STATISTICS_update (plugin->env->stats, - "# bytes transmitted via UNIX", - msgw->msgsize, - GNUNET_NO); + GNUNET_break(sent > 0); + GNUNET_STATISTICS_update(plugin->env->stats, + "# bytes transmitted via UNIX", + msgw->msgsize, + GNUNET_NO); if (NULL != msgw->cont) - msgw->cont (msgw->cont_cls, - &msgw->session->target, - GNUNET_OK, - msgw->payload, - msgw->msgsize); - GNUNET_free (msgw->msg); - GNUNET_free (msgw); + msgw->cont(msgw->cont_cls, + &msgw->session->target, + GNUNET_OK, + msgw->payload, + msgw->msgsize); + GNUNET_free(msgw->msg); + GNUNET_free(msgw); } @@ -1207,20 +1196,20 @@ unix_plugin_do_write (struct Plugin *plugin) * @param cls the plugin handle */ static void -unix_plugin_select_read (void *cls) +unix_plugin_select_read(void *cls) { struct Plugin *plugin = cls; const struct GNUNET_SCHEDULER_TaskContext *tc; plugin->read_task = NULL; - tc = GNUNET_SCHEDULER_get_task_context (); + tc = GNUNET_SCHEDULER_get_task_context(); if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) - unix_plugin_do_read (plugin); + unix_plugin_do_read(plugin); plugin->read_task = - GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, - plugin->unix_sock.desc, - &unix_plugin_select_read, - plugin); + GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, + plugin->unix_sock.desc, + &unix_plugin_select_read, + plugin); } @@ -1231,22 +1220,22 @@ unix_plugin_select_read (void *cls) * @param cls the plugin handle */ static void -unix_plugin_select_write (void *cls) +unix_plugin_select_write(void *cls) { struct Plugin *plugin = cls; const struct GNUNET_SCHEDULER_TaskContext *tc; plugin->write_task = NULL; - tc = GNUNET_SCHEDULER_get_task_context (); + tc = GNUNET_SCHEDULER_get_task_context(); if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) - unix_plugin_do_write (plugin); + unix_plugin_do_write(plugin); if (NULL == plugin->msg_head) return; /* write queue empty */ plugin->write_task = - GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, - plugin->unix_sock.desc, - &unix_plugin_select_write, - plugin); + GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, + plugin->unix_sock.desc, + &unix_plugin_select_write, + plugin); } @@ -1278,14 +1267,14 @@ unix_plugin_select_write (void *cls) * and does NOT mean that the message was not transmitted (DV) */ static ssize_t -unix_plugin_send (void *cls, - struct GNUNET_ATS_Session *session, - const char *msgbuf, - size_t msgbuf_size, - unsigned int priority, - struct GNUNET_TIME_Relative to, - GNUNET_TRANSPORT_TransmitContinuation cont, - void *cont_cls) +unix_plugin_send(void *cls, + struct GNUNET_ATS_Session *session, + 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; struct UNIXMessageWrapper *wrapper; @@ -1293,60 +1282,60 @@ unix_plugin_send (void *cls, int ssize; if (GNUNET_OK != - GNUNET_CONTAINER_multipeermap_contains_value (plugin->session_map, - &session->target, - session)) - { - LOG (GNUNET_ERROR_TYPE_ERROR, - "Invalid session for peer `%s' `%s'\n", - GNUNET_i2s (&session->target), - unix_plugin_address_to_string (NULL, + GNUNET_CONTAINER_multipeermap_contains_value(plugin->session_map, + &session->target, + session)) + { + LOG(GNUNET_ERROR_TYPE_ERROR, + "Invalid session for peer `%s' `%s'\n", + GNUNET_i2s(&session->target), + unix_plugin_address_to_string(NULL, session->address->address, session->address->address_length)); - GNUNET_break (0); - return GNUNET_SYSERR; - } - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Sending %u bytes with session for peer `%s' `%s'\n", - msgbuf_size, - GNUNET_i2s (&session->target), - unix_plugin_address_to_string (NULL, - session->address->address, - session->address->address_length)); - ssize = sizeof (struct UNIXMessage) + msgbuf_size; - message = GNUNET_malloc (sizeof (struct UNIXMessage) + msgbuf_size); - message->header.size = htons (ssize); - message->header.type = htons (0); - GNUNET_memcpy (&message->sender, - plugin->env->my_identity, - sizeof (struct GNUNET_PeerIdentity)); - GNUNET_memcpy (&message[1], msgbuf, msgbuf_size); - wrapper = GNUNET_new (struct UNIXMessageWrapper); + GNUNET_break(0); + return GNUNET_SYSERR; + } + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Sending %u bytes with session for peer `%s' `%s'\n", + msgbuf_size, + GNUNET_i2s(&session->target), + unix_plugin_address_to_string(NULL, + session->address->address, + session->address->address_length)); + ssize = sizeof(struct UNIXMessage) + msgbuf_size; + message = GNUNET_malloc(sizeof(struct UNIXMessage) + msgbuf_size); + message->header.size = htons(ssize); + message->header.type = htons(0); + GNUNET_memcpy(&message->sender, + plugin->env->my_identity, + sizeof(struct GNUNET_PeerIdentity)); + GNUNET_memcpy(&message[1], msgbuf, msgbuf_size); + wrapper = GNUNET_new(struct UNIXMessageWrapper); wrapper->msg = message; wrapper->msgsize = ssize; wrapper->payload = msgbuf_size; wrapper->priority = priority; - wrapper->timeout = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), to); + wrapper->timeout = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), to); wrapper->cont = cont; wrapper->cont_cls = cont_cls; wrapper->session = session; - GNUNET_CONTAINER_DLL_insert_tail (plugin->msg_head, - plugin->msg_tail, - wrapper); + GNUNET_CONTAINER_DLL_insert_tail(plugin->msg_head, + plugin->msg_tail, + wrapper); plugin->bytes_in_queue += ssize; session->bytes_in_queue += ssize; session->msgs_in_queue++; - GNUNET_STATISTICS_set (plugin->env->stats, - "# bytes currently in UNIX buffers", - plugin->bytes_in_queue, - GNUNET_NO); - notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UPDATE); + GNUNET_STATISTICS_set(plugin->env->stats, + "# bytes currently in UNIX buffers", + plugin->bytes_in_queue, + GNUNET_NO); + notify_session_monitor(plugin, session, GNUNET_TRANSPORT_SS_UPDATE); if (NULL == plugin->write_task) plugin->write_task = - GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, - plugin->unix_sock.desc, - &unix_plugin_select_write, - plugin); + GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, + plugin->unix_sock.desc, + &unix_plugin_select_write, + plugin); return ssize; } @@ -1358,57 +1347,57 @@ unix_plugin_send (void *cls, * @return number of sockets created or #GNUNET_SYSERR on error */ static int -unix_transport_server_start (void *cls) +unix_transport_server_start(void *cls) { struct Plugin *plugin = cls; struct sockaddr_un *un; socklen_t un_len; - un = unix_address_to_sockaddr (plugin->unix_socket_path, &un_len); + un = unix_address_to_sockaddr(plugin->unix_socket_path, &un_len); if (GNUNET_YES == plugin->is_abstract) - { - plugin->unix_socket_path[0] = '@'; - un->sun_path[0] = '\0'; - } + { + plugin->unix_socket_path[0] = '@'; + un->sun_path[0] = '\0'; + } plugin->unix_sock.desc = - GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_DGRAM, 0); + GNUNET_NETWORK_socket_create(AF_UNIX, SOCK_DGRAM, 0); if (NULL == plugin->unix_sock.desc) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket"); - GNUNET_free (un); - return GNUNET_SYSERR; - } + { + GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "socket"); + GNUNET_free(un); + return GNUNET_SYSERR; + } if ('\0' != un->sun_path[0]) - { - if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (un->sun_path)) { - LOG (GNUNET_ERROR_TYPE_ERROR, - _ ("Cannot create path to `%s'\n"), - un->sun_path); - GNUNET_NETWORK_socket_close (plugin->unix_sock.desc); + if (GNUNET_OK != GNUNET_DISK_directory_create_for_file(un->sun_path)) + { + LOG(GNUNET_ERROR_TYPE_ERROR, + _("Cannot create path to `%s'\n"), + un->sun_path); + GNUNET_NETWORK_socket_close(plugin->unix_sock.desc); + plugin->unix_sock.desc = NULL; + GNUNET_free(un); + return GNUNET_SYSERR; + } + } + if (GNUNET_OK != GNUNET_NETWORK_socket_bind(plugin->unix_sock.desc, + (const struct sockaddr *)un, + un_len)) + { + GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind"); + LOG(GNUNET_ERROR_TYPE_ERROR, _("Cannot bind to `%s'\n"), un->sun_path); + GNUNET_NETWORK_socket_close(plugin->unix_sock.desc); plugin->unix_sock.desc = NULL; - GNUNET_free (un); + GNUNET_free(un); return GNUNET_SYSERR; } - } - if (GNUNET_OK != GNUNET_NETWORK_socket_bind (plugin->unix_sock.desc, - (const struct sockaddr *) un, - un_len)) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind"); - LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Cannot bind to `%s'\n"), un->sun_path); - GNUNET_NETWORK_socket_close (plugin->unix_sock.desc); - plugin->unix_sock.desc = NULL; - GNUNET_free (un); - return GNUNET_SYSERR; - } - LOG (GNUNET_ERROR_TYPE_DEBUG, "Bound to `%s'\n", plugin->unix_socket_path); + LOG(GNUNET_ERROR_TYPE_DEBUG, "Bound to `%s'\n", plugin->unix_socket_path); plugin->read_task = - GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, - plugin->unix_sock.desc, - &unix_plugin_select_read, - plugin); - GNUNET_free (un); + GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, + plugin->unix_sock.desc, + &unix_plugin_select_read, + plugin); + GNUNET_free(un); return 1; } @@ -1430,7 +1419,7 @@ unix_transport_server_start (void *cls) * */ static int -unix_plugin_check_address (void *cls, const void *addr, size_t addrlen) +unix_plugin_check_address(void *cls, const void *addr, size_t addrlen) { struct Plugin *plugin = cls; const struct UnixAddress *ua = addr; @@ -1438,25 +1427,25 @@ unix_plugin_check_address (void *cls, const void *addr, size_t addrlen) size_t addr_str_len; if ((NULL == addr) || (0 == addrlen) || - (sizeof (struct UnixAddress) > addrlen)) - { - GNUNET_break (0); - return GNUNET_SYSERR; - } - addrstr = (char *) &ua[1]; - addr_str_len = ntohl (ua->addrlen); + (sizeof(struct UnixAddress) > addrlen)) + { + GNUNET_break(0); + return GNUNET_SYSERR; + } + addrstr = (char *)&ua[1]; + addr_str_len = ntohl(ua->addrlen); if ('\0' != addrstr[addr_str_len - 1]) - { - GNUNET_break (0); - return GNUNET_SYSERR; - } - if (strlen (addrstr) + 1 != addr_str_len) - { - GNUNET_break (0); - return GNUNET_SYSERR; - } - - if (0 == strcmp (plugin->unix_socket_path, addrstr)) + { + GNUNET_break(0); + return GNUNET_SYSERR; + } + if (strlen(addrstr) + 1 != addr_str_len) + { + GNUNET_break(0); + return GNUNET_SYSERR; + } + + if (0 == strcmp(plugin->unix_socket_path, addrstr)) return GNUNET_OK; return GNUNET_SYSERR; } @@ -1477,23 +1466,23 @@ unix_plugin_check_address (void *cls, const void *addr, size_t addrlen) * @param asc_cls closure for @a asc */ static void -unix_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) +unix_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) { const char *ret; if ((NULL != addr) && (addrlen > 0)) - ret = unix_plugin_address_to_string (NULL, addr, addrlen); + ret = unix_plugin_address_to_string(NULL, addr, addrlen); else ret = NULL; - asc (asc_cls, ret, (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK); - asc (asc_cls, NULL, GNUNET_OK); + asc(asc_cls, ret, (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK); + asc(asc_cls, NULL, GNUNET_OK); } @@ -1510,11 +1499,11 @@ unix_plugin_address_pretty_printer (void *cls, * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure */ static int -unix_plugin_string_to_address (void *cls, - const char *addr, - uint16_t addrlen, - void **buf, - size_t *added) +unix_plugin_string_to_address(void *cls, + const char *addr, + uint16_t addrlen, + void **buf, + size_t *added) { struct UnixAddress *ua; char *address; @@ -1529,53 +1518,53 @@ unix_plugin_string_to_address (void *cls, optionstr = NULL; if ((NULL == addr) || (addrlen == 0)) - { - 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 (0 != strcmp (plugin, PLUGIN_NAME)) - { - GNUNET_break (0); - GNUNET_free (plugin); - return GNUNET_SYSERR; - } - - ua_size = sizeof (struct UnixAddress) + strlen (address) + 1; - ua = GNUNET_malloc (ua_size); - ua->options = htonl (options); - ua->addrlen = htonl (strlen (address) + 1); - GNUNET_memcpy (&ua[1], address, strlen (address) + 1); - GNUNET_free (plugin); + if (0 != strcmp(plugin, PLUGIN_NAME)) + { + GNUNET_break(0); + GNUNET_free(plugin); + return GNUNET_SYSERR; + } + + ua_size = sizeof(struct UnixAddress) + strlen(address) + 1; + ua = GNUNET_malloc(ua_size); + ua->options = htonl(options); + ua->addrlen = htonl(strlen(address) + 1); + GNUNET_memcpy(&ua[1], address, strlen(address) + 1); + GNUNET_free(plugin); (*buf) = ua; (*added) = ua_size; @@ -1589,7 +1578,7 @@ unix_plugin_string_to_address (void *cls, * @param cls the plugin */ static void -address_notification (void *cls) +address_notification(void *cls) { struct Plugin *plugin = cls; struct GNUNET_HELLO_Address *address; @@ -1597,24 +1586,24 @@ address_notification (void *cls) struct UnixAddress *ua; char *unix_path; - len = sizeof (struct UnixAddress) + strlen (plugin->unix_socket_path) + 1; - ua = GNUNET_malloc (len); - ua->options = htonl (plugin->myoptions); - ua->addrlen = htonl (strlen (plugin->unix_socket_path) + 1); - unix_path = (char *) &ua[1]; - GNUNET_memcpy (unix_path, - plugin->unix_socket_path, - strlen (plugin->unix_socket_path) + 1); + len = sizeof(struct UnixAddress) + strlen(plugin->unix_socket_path) + 1; + ua = GNUNET_malloc(len); + ua->options = htonl(plugin->myoptions); + ua->addrlen = htonl(strlen(plugin->unix_socket_path) + 1); + unix_path = (char *)&ua[1]; + GNUNET_memcpy(unix_path, + plugin->unix_socket_path, + strlen(plugin->unix_socket_path) + 1); plugin->address_update_task = NULL; - address = GNUNET_HELLO_address_allocate (plugin->env->my_identity, - PLUGIN_NAME, - ua, - len, - GNUNET_HELLO_ADDRESS_INFO_NONE); - plugin->env->notify_address (plugin->env->cls, GNUNET_YES, address); - GNUNET_free (ua); - GNUNET_free (address); + address = GNUNET_HELLO_address_allocate(plugin->env->my_identity, + PLUGIN_NAME, + ua, + len, + GNUNET_HELLO_ADDRESS_INFO_NONE); + plugin->env->notify_address(plugin->env->cls, GNUNET_YES, address); + GNUNET_free(ua); + GNUNET_free(address); } @@ -1627,14 +1616,14 @@ address_notification (void *cls) * @return #GNUNET_YES (always, continue to iterate) */ static int -get_session_delete_it (void *cls, - const struct GNUNET_PeerIdentity *key, - void *value) +get_session_delete_it(void *cls, + const struct GNUNET_PeerIdentity *key, + void *value) { struct Plugin *plugin = cls; struct GNUNET_ATS_Session *session = value; - unix_plugin_session_disconnect (plugin, session); + unix_plugin_session_disconnect(plugin, session); return GNUNET_YES; } @@ -1647,15 +1636,15 @@ get_session_delete_it (void *cls, * @return #GNUNET_OK on success, #GNUNET_SYSERR if the operation failed */ static void -unix_plugin_peer_disconnect (void *cls, - const struct GNUNET_PeerIdentity *target) +unix_plugin_peer_disconnect(void *cls, + const struct GNUNET_PeerIdentity *target) { struct Plugin *plugin = cls; - GNUNET_CONTAINER_multipeermap_get_multiple (plugin->session_map, - target, - &get_session_delete_it, - plugin); + GNUNET_CONTAINER_multipeermap_get_multiple(plugin->session_map, + target, + &get_session_delete_it, + plugin); } @@ -1669,15 +1658,15 @@ unix_plugin_peer_disconnect (void *cls, * @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; } @@ -1695,22 +1684,22 @@ send_session_info_iter (void *cls, * @param sic_cls closure for @a sic */ static void -unix_plugin_setup_monitor (void *cls, - GNUNET_TRANSPORT_SessionInfoCallback sic, - void *sic_cls) +unix_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->session_map, - &send_session_info_iter, - plugin); - /* signal end of first iteration */ - sic (sic_cls, NULL, NULL); - } + { + GNUNET_CONTAINER_multipeermap_iterate(plugin->session_map, + &send_session_info_iter, + plugin); + /* signal end of first iteration */ + sic(sic_cls, NULL, NULL); + } } @@ -1722,7 +1711,7 @@ unix_plugin_setup_monitor (void *cls, * @return NULL on error, plugin functions otherwise */ void * -libgnunet_plugin_transport_unix_init (void *cls) +libgnunet_plugin_transport_unix_init(void *cls) { struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; struct GNUNET_TRANSPORT_PluginFunctions *api; @@ -1730,45 +1719,45 @@ libgnunet_plugin_transport_unix_init (void *cls) int sockets_created; 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 = &unix_plugin_address_pretty_printer; - api->address_to_string = &unix_plugin_address_to_string; - api->string_to_address = &unix_plugin_string_to_address; - return api; - } - - plugin = GNUNET_new (struct Plugin); + { + /* 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 = &unix_plugin_address_pretty_printer; + api->address_to_string = &unix_plugin_address_to_string; + api->string_to_address = &unix_plugin_string_to_address; + return api; + } + + plugin = GNUNET_new(struct Plugin); if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_filename (env->cfg, - "transport-unix", - "UNIXPATH", - &plugin->unix_socket_path)) - { - GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, - "transport-unix", - "UNIXPATH"); - GNUNET_free (plugin); - return NULL; - } + GNUNET_CONFIGURATION_get_value_filename(env->cfg, + "transport-unix", + "UNIXPATH", + &plugin->unix_socket_path)) + { + GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, + "transport-unix", + "UNIXPATH"); + GNUNET_free(plugin); + return NULL; + } plugin->env = env; /* Initialize my flags */ #ifdef LINUX plugin->is_abstract = - GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg, - "testing", - "USE_ABSTRACT_SOCKETS"); + GNUNET_CONFIGURATION_get_value_yesno(plugin->env->cfg, + "testing", + "USE_ABSTRACT_SOCKETS"); #endif plugin->myoptions = UNIX_OPTIONS_NONE; if (GNUNET_YES == plugin->is_abstract) plugin->myoptions = UNIX_OPTIONS_USE_ABSTRACT_SOCKETS; - api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions); + api = GNUNET_new(struct GNUNET_TRANSPORT_PluginFunctions); api->cls = plugin; api->get_session = &unix_plugin_get_session; api->send = &unix_plugin_send; @@ -1783,18 +1772,18 @@ libgnunet_plugin_transport_unix_init (void *cls) api->get_network_for_address = &unix_plugin_get_network_for_address; api->update_session_timeout = &unix_plugin_update_session_timeout; api->setup_monitor = &unix_plugin_setup_monitor; - sockets_created = unix_transport_server_start (plugin); + sockets_created = unix_transport_server_start(plugin); if ((0 == sockets_created) || (GNUNET_SYSERR == sockets_created)) - { - LOG (GNUNET_ERROR_TYPE_WARNING, _ ("Failed to open UNIX listen socket\n")); - GNUNET_free (api); - GNUNET_free (plugin->unix_socket_path); - GNUNET_free (plugin); - return NULL; - } - plugin->session_map = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO); + { + LOG(GNUNET_ERROR_TYPE_WARNING, _("Failed to open UNIX listen socket\n")); + GNUNET_free(api); + GNUNET_free(plugin->unix_socket_path); + GNUNET_free(plugin); + return NULL; + } + plugin->session_map = GNUNET_CONTAINER_multipeermap_create(10, GNUNET_NO); plugin->address_update_task = - GNUNET_SCHEDULER_add_now (&address_notification, plugin); + GNUNET_SCHEDULER_add_now(&address_notification, plugin); return api; } @@ -1806,7 +1795,7 @@ libgnunet_plugin_transport_unix_init (void *cls) * @return NULL (always) */ void * -libgnunet_plugin_transport_unix_done (void *cls) +libgnunet_plugin_transport_unix_done(void *cls) { struct GNUNET_TRANSPORT_PluginFunctions *api = cls; struct Plugin *plugin = api->cls; @@ -1817,75 +1806,75 @@ libgnunet_plugin_transport_unix_done (void *cls) struct GNUNET_ATS_Session *session; if (NULL == plugin) - { - GNUNET_free (api); - return NULL; - } - len = sizeof (struct UnixAddress) + strlen (plugin->unix_socket_path) + 1; - ua = GNUNET_malloc (len); - ua->options = htonl (plugin->myoptions); - ua->addrlen = htonl (strlen (plugin->unix_socket_path) + 1); - GNUNET_memcpy (&ua[1], - plugin->unix_socket_path, - strlen (plugin->unix_socket_path) + 1); - address = GNUNET_HELLO_address_allocate (plugin->env->my_identity, - PLUGIN_NAME, - ua, - len, - GNUNET_HELLO_ADDRESS_INFO_NONE); - plugin->env->notify_address (plugin->env->cls, GNUNET_NO, address); - - GNUNET_free (address); - GNUNET_free (ua); + { + GNUNET_free(api); + return NULL; + } + len = sizeof(struct UnixAddress) + strlen(plugin->unix_socket_path) + 1; + ua = GNUNET_malloc(len); + ua->options = htonl(plugin->myoptions); + ua->addrlen = htonl(strlen(plugin->unix_socket_path) + 1); + GNUNET_memcpy(&ua[1], + plugin->unix_socket_path, + strlen(plugin->unix_socket_path) + 1); + address = GNUNET_HELLO_address_allocate(plugin->env->my_identity, + PLUGIN_NAME, + ua, + len, + GNUNET_HELLO_ADDRESS_INFO_NONE); + plugin->env->notify_address(plugin->env->cls, GNUNET_NO, address); + + GNUNET_free(address); + GNUNET_free(ua); while (NULL != (msgw = plugin->msg_head)) - { - GNUNET_CONTAINER_DLL_remove (plugin->msg_head, plugin->msg_tail, msgw); - session = msgw->session; - session->msgs_in_queue--; - GNUNET_assert (session->bytes_in_queue >= msgw->msgsize); - session->bytes_in_queue -= msgw->msgsize; - GNUNET_assert (plugin->bytes_in_queue >= msgw->msgsize); - plugin->bytes_in_queue -= msgw->msgsize; - if (NULL != msgw->cont) - msgw->cont (msgw->cont_cls, - &msgw->session->target, - GNUNET_SYSERR, - msgw->payload, - 0); - GNUNET_free (msgw->msg); - GNUNET_free (msgw); - } + { + GNUNET_CONTAINER_DLL_remove(plugin->msg_head, plugin->msg_tail, msgw); + session = msgw->session; + session->msgs_in_queue--; + GNUNET_assert(session->bytes_in_queue >= msgw->msgsize); + session->bytes_in_queue -= msgw->msgsize; + GNUNET_assert(plugin->bytes_in_queue >= msgw->msgsize); + plugin->bytes_in_queue -= msgw->msgsize; + if (NULL != msgw->cont) + msgw->cont(msgw->cont_cls, + &msgw->session->target, + GNUNET_SYSERR, + msgw->payload, + 0); + GNUNET_free(msgw->msg); + GNUNET_free(msgw); + } if (NULL != plugin->read_task) - { - GNUNET_SCHEDULER_cancel (plugin->read_task); - plugin->read_task = NULL; - } + { + GNUNET_SCHEDULER_cancel(plugin->read_task); + plugin->read_task = NULL; + } if (NULL != plugin->write_task) - { - GNUNET_SCHEDULER_cancel (plugin->write_task); - plugin->write_task = NULL; - } + { + GNUNET_SCHEDULER_cancel(plugin->write_task); + plugin->write_task = NULL; + } if (NULL != plugin->address_update_task) - { - GNUNET_SCHEDULER_cancel (plugin->address_update_task); - plugin->address_update_task = NULL; - } + { + GNUNET_SCHEDULER_cancel(plugin->address_update_task); + plugin->address_update_task = NULL; + } if (NULL != plugin->unix_sock.desc) - { - GNUNET_break (GNUNET_OK == - GNUNET_NETWORK_socket_close (plugin->unix_sock.desc)); - plugin->unix_sock.desc = NULL; - } - GNUNET_CONTAINER_multipeermap_iterate (plugin->session_map, - &get_session_delete_it, - plugin); - GNUNET_CONTAINER_multipeermap_destroy (plugin->session_map); - GNUNET_break (0 == plugin->bytes_in_queue); - GNUNET_free (plugin->unix_socket_path); - GNUNET_free (plugin); - GNUNET_free (api); + { + GNUNET_break(GNUNET_OK == + GNUNET_NETWORK_socket_close(plugin->unix_sock.desc)); + plugin->unix_sock.desc = NULL; + } + GNUNET_CONTAINER_multipeermap_iterate(plugin->session_map, + &get_session_delete_it, + plugin); + GNUNET_CONTAINER_multipeermap_destroy(plugin->session_map); + GNUNET_break(0 == plugin->bytes_in_queue); + GNUNET_free(plugin->unix_socket_path); + GNUNET_free(plugin); + GNUNET_free(api); return NULL; } -- cgit v1.2.3