From eadf4b7379049d32d7cfc5cffd4c88613f8a2a93 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Fri, 27 Sep 2019 22:33:50 +0200 Subject: indent --- src/util/client.c | 845 +++++++++++++++++++++++++++--------------------------- 1 file changed, 424 insertions(+), 421 deletions(-) (limited to 'src/util/client.c') diff --git a/src/util/client.c b/src/util/client.c index e3585af2e..5a77b9238 100644 --- a/src/util/client.c +++ b/src/util/client.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - Copyright (C) 2001-2016 GNUnet e.V. + Copyright (C) 2001-2016, 2019 GNUnet e.V. GNUnet is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published @@ -33,7 +33,7 @@ #include "gnunet_socks.h" -#define LOG(kind, ...) GNUNET_log_from(kind, "util-client", __VA_ARGS__) +#define LOG(kind, ...) GNUNET_log_from (kind, "util-client", __VA_ARGS__) /** * Timeout we use on TCP connect before trying another @@ -41,7 +41,8 @@ * is this value divided by the number of address families. * Default is 5s. */ -#define CONNECT_RETRY_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5) +#define CONNECT_RETRY_TIMEOUT GNUNET_TIME_relative_multiply ( \ + GNUNET_TIME_UNIT_SECONDS, 5) @@ -55,7 +56,8 @@ struct ClientState; * During connect, we try multiple possible IP addresses * to find out which one might work. */ -struct AddressProbe { +struct AddressProbe +{ /** * This is a linked list. */ @@ -96,7 +98,8 @@ struct AddressProbe { /** * Internal state for a client connected to a GNUnet service. */ -struct ClientState { +struct ClientState +{ /** * The connection handle, NULL if not live */ @@ -205,7 +208,7 @@ struct ClientState { * @param cls the `struct ClientState` to try to connect to the service */ static void -start_connect(void *cls); +start_connect (void *cls); /** @@ -215,26 +218,26 @@ start_connect(void *cls); * @param cstate the connection we tried to establish */ static void -connect_fail_continuation(struct ClientState *cstate) +connect_fail_continuation (struct ClientState *cstate) { - GNUNET_break(NULL == cstate->ap_head); - GNUNET_break(NULL == cstate->ap_tail); - GNUNET_break(NULL == cstate->dns_active); - GNUNET_break(NULL == cstate->sock); - GNUNET_assert(NULL == cstate->send_task); - GNUNET_assert(NULL == cstate->recv_task); + GNUNET_break (NULL == cstate->ap_head); + GNUNET_break (NULL == cstate->ap_tail); + GNUNET_break (NULL == cstate->dns_active); + GNUNET_break (NULL == cstate->sock); + GNUNET_assert (NULL == cstate->send_task); + GNUNET_assert (NULL == cstate->recv_task); // GNUNET_assert (NULL == cstate->proxy_handshake); - cstate->back_off = GNUNET_TIME_STD_BACKOFF(cstate->back_off); - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Failed to establish connection to `%s', no further addresses to try, will try again in %s.\n", - cstate->service_name, - GNUNET_STRINGS_relative_time_to_string(cstate->back_off, - GNUNET_YES)); + cstate->back_off = GNUNET_TIME_STD_BACKOFF (cstate->back_off); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Failed to establish connection to `%s', no further addresses to try, will try again in %s.\n", + cstate->service_name, + GNUNET_STRINGS_relative_time_to_string (cstate->back_off, + GNUNET_YES)); cstate->retry_task - = GNUNET_SCHEDULER_add_delayed(cstate->back_off, - &start_connect, - cstate); + = GNUNET_SCHEDULER_add_delayed (cstate->back_off, + &start_connect, + cstate); } @@ -244,7 +247,7 @@ connect_fail_continuation(struct ClientState *cstate) * @param cls the `struct ClientState` with the `msg` to transmit */ static void -transmit_ready(void *cls) +transmit_ready (void *cls) { struct ClientState *cstate = cls; ssize_t ret; @@ -255,56 +258,56 @@ transmit_ready(void *cls) cstate->send_task = NULL; if (GNUNET_YES == cstate->in_destroy) return; - pos = (const char *)cstate->msg; - len = ntohs(cstate->msg->size); - GNUNET_assert(cstate->msg_off < len); - LOG(GNUNET_ERROR_TYPE_DEBUG, - "message of type %u trying to send with socket %p (MQ: %p\n", - ntohs(cstate->msg->type), - cstate->sock, - cstate->mq); + pos = (const char *) cstate->msg; + len = ntohs (cstate->msg->size); + GNUNET_assert (cstate->msg_off < len); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "message of type %u trying to send with socket %p (MQ: %p\n", + ntohs (cstate->msg->type), + cstate->sock, + cstate->mq); RETRY: - ret = GNUNET_NETWORK_socket_send(cstate->sock, - &pos[cstate->msg_off], - len - cstate->msg_off); + ret = GNUNET_NETWORK_socket_send (cstate->sock, + &pos[cstate->msg_off], + len - cstate->msg_off); if (-1 == ret) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "Error during sending message of type %u\n", + ntohs (cstate->msg->type)); + if (EINTR == errno) { - LOG(GNUNET_ERROR_TYPE_WARNING, - "Error during sending message of type %u\n", - ntohs(cstate->msg->type)); - if (EINTR == errno) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Retrying message of type %u\n", - ntohs(cstate->msg->type)); - goto RETRY; - } - GNUNET_MQ_inject_error(cstate->mq, - GNUNET_MQ_ERROR_WRITE); - return; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Retrying message of type %u\n", + ntohs (cstate->msg->type)); + goto RETRY; } + GNUNET_MQ_inject_error (cstate->mq, + GNUNET_MQ_ERROR_WRITE); + return; + } notify_in_flight = (0 == cstate->msg_off); cstate->msg_off += ret; if (cstate->msg_off < len) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "rescheduling message of type %u\n", - ntohs(cstate->msg->type)); - cstate->send_task - = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, - cstate->sock, - &transmit_ready, - cstate); - if (notify_in_flight) - GNUNET_MQ_impl_send_in_flight(cstate->mq); - return; - } - LOG(GNUNET_ERROR_TYPE_DEBUG, - "sending message of type %u successful\n", - ntohs(cstate->msg->type)); + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "rescheduling message of type %u\n", + ntohs (cstate->msg->type)); + cstate->send_task + = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + cstate->sock, + &transmit_ready, + cstate); + if (notify_in_flight) + GNUNET_MQ_impl_send_in_flight (cstate->mq); + return; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "sending message of type %u successful\n", + ntohs (cstate->msg->type)); cstate->msg = NULL; - GNUNET_MQ_impl_send_continue(cstate->mq); + GNUNET_MQ_impl_send_continue (cstate->mq); } @@ -319,20 +322,20 @@ RETRY: * #GNUNET_SYSERR to stop further processing due to error */ static int -recv_message(void *cls, - const struct GNUNET_MessageHeader *msg) +recv_message (void *cls, + const struct GNUNET_MessageHeader *msg) { struct ClientState *cstate = cls; if (GNUNET_YES == cstate->in_destroy) return GNUNET_NO; - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Received message of type %u and size %u from %s\n", - ntohs(msg->type), - ntohs(msg->size), - cstate->service_name); - GNUNET_MQ_inject_message(cstate->mq, - msg); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Received message of type %u and size %u from %s\n", + ntohs (msg->type), + ntohs (msg->size), + cstate->service_name); + GNUNET_MQ_inject_message (cstate->mq, + msg); if (GNUNET_YES == cstate->in_destroy) return GNUNET_NO; return GNUNET_OK; @@ -345,20 +348,20 @@ recv_message(void *cls, * @param cstate handle of the client state to process */ static void -cancel_aps(struct ClientState *cstate) +cancel_aps (struct ClientState *cstate) { struct AddressProbe *pos; while (NULL != (pos = cstate->ap_head)) - { - GNUNET_break(GNUNET_OK == - GNUNET_NETWORK_socket_close(pos->sock)); - GNUNET_SCHEDULER_cancel(pos->task); - GNUNET_CONTAINER_DLL_remove(cstate->ap_head, - cstate->ap_tail, - pos); - GNUNET_free(pos); - } + { + GNUNET_break (GNUNET_OK == + GNUNET_NETWORK_socket_close (pos->sock)); + GNUNET_SCHEDULER_cancel (pos->task); + GNUNET_CONTAINER_DLL_remove (cstate->ap_head, + cstate->ap_tail, + pos); + GNUNET_free (pos); + } } @@ -370,51 +373,51 @@ cancel_aps(struct ClientState *cstate) * @param impl_state our `struct ClientState` */ static void -connection_client_destroy_impl(struct GNUNET_MQ_Handle *mq, - void *impl_state) +connection_client_destroy_impl (struct GNUNET_MQ_Handle *mq, + void *impl_state) { struct ClientState *cstate = impl_state; - (void)mq; + (void) mq; if (NULL != cstate->dns_active) - { - GNUNET_RESOLVER_request_cancel(cstate->dns_active); - cstate->dns_active = NULL; - } + { + GNUNET_RESOLVER_request_cancel (cstate->dns_active); + cstate->dns_active = NULL; + } if (NULL != cstate->send_task) - { - GNUNET_SCHEDULER_cancel(cstate->send_task); - cstate->send_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (cstate->send_task); + cstate->send_task = NULL; + } if (NULL != cstate->retry_task) - { - GNUNET_SCHEDULER_cancel(cstate->retry_task); - cstate->retry_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (cstate->retry_task); + cstate->retry_task = NULL; + } if (GNUNET_SYSERR == cstate->in_destroy) - { - /* defer destruction */ - cstate->in_destroy = GNUNET_YES; - cstate->mq = NULL; - return; - } + { + /* defer destruction */ + cstate->in_destroy = GNUNET_YES; + cstate->mq = NULL; + return; + } if (NULL != cstate->recv_task) - { - GNUNET_SCHEDULER_cancel(cstate->recv_task); - cstate->recv_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (cstate->recv_task); + cstate->recv_task = NULL; + } if (NULL != cstate->sock) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "destroying socket: %p\n", - cstate->sock); - GNUNET_NETWORK_socket_close(cstate->sock); - } - cancel_aps(cstate); - GNUNET_free(cstate->service_name); - GNUNET_free_non_null(cstate->hostname); - GNUNET_MST_destroy(cstate->mst); - GNUNET_free(cstate); + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "destroying socket: %p\n", + cstate->sock); + GNUNET_NETWORK_socket_close (cstate->sock); + } + cancel_aps (cstate); + GNUNET_free (cstate->service_name); + GNUNET_free_non_null (cstate->hostname); + GNUNET_MST_destroy (cstate->mst); + GNUNET_free (cstate); } @@ -424,39 +427,39 @@ connection_client_destroy_impl(struct GNUNET_MQ_Handle *mq, * @param cls `struct ClientState` with connection to read from */ static void -receive_ready(void *cls) +receive_ready (void *cls) { struct ClientState *cstate = cls; int ret; cstate->recv_task = NULL; cstate->in_destroy = GNUNET_SYSERR; - ret = GNUNET_MST_read(cstate->mst, - cstate->sock, - GNUNET_NO, - GNUNET_NO); + ret = GNUNET_MST_read (cstate->mst, + cstate->sock, + GNUNET_NO, + GNUNET_NO); if (GNUNET_SYSERR == ret) - { - if (NULL != cstate->mq) - GNUNET_MQ_inject_error(cstate->mq, - GNUNET_MQ_ERROR_READ); - if (GNUNET_YES == cstate->in_destroy) - connection_client_destroy_impl(cstate->mq, - cstate); - return; - } + { + if (NULL != cstate->mq) + GNUNET_MQ_inject_error (cstate->mq, + GNUNET_MQ_ERROR_READ); + if (GNUNET_YES == cstate->in_destroy) + connection_client_destroy_impl (cstate->mq, + cstate); + return; + } if (GNUNET_YES == cstate->in_destroy) - { - connection_client_destroy_impl(cstate->mq, - cstate); - return; - } + { + connection_client_destroy_impl (cstate->mq, + cstate); + return; + } cstate->in_destroy = GNUNET_NO; cstate->recv_task - = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - cstate->sock, - &receive_ready, - cstate); + = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + cstate->sock, + &receive_ready, + cstate); } @@ -466,23 +469,23 @@ receive_ready(void *cls) * @param cstate the connection we tried to establish */ static void -connect_success_continuation(struct ClientState *cstate) +connect_success_continuation (struct ClientState *cstate) { - GNUNET_assert(NULL == cstate->recv_task); + GNUNET_assert (NULL == cstate->recv_task); cstate->recv_task - = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - cstate->sock, - &receive_ready, - cstate); + = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + cstate->sock, + &receive_ready, + cstate); if (NULL != cstate->msg) - { - GNUNET_assert(NULL == cstate->send_task); - cstate->send_task - = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, - cstate->sock, - &transmit_ready, - cstate); - } + { + GNUNET_assert (NULL == cstate->send_task); + cstate->send_task + = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + cstate->sock, + &transmit_ready, + cstate); + } } @@ -494,8 +497,8 @@ connect_success_continuation(struct ClientState *cstate) * @return NULL on error, socket connected to UNIX otherwise */ static struct GNUNET_NETWORK_Handle * -try_unixpath(const char *service_name, - const struct GNUNET_CONFIGURATION_Handle *cfg) +try_unixpath (const char *service_name, + const struct GNUNET_CONFIGURATION_Handle *cfg) { #if AF_UNIX struct GNUNET_NETWORK_Handle *sock; @@ -504,67 +507,67 @@ try_unixpath(const char *service_name, unixpath = NULL; if ((GNUNET_OK == - GNUNET_CONFIGURATION_get_value_filename(cfg, - service_name, - "UNIXPATH", - &unixpath)) && - (0 < strlen(unixpath))) + GNUNET_CONFIGURATION_get_value_filename (cfg, + service_name, + "UNIXPATH", + &unixpath)) && + (0 < strlen (unixpath))) + { + /* We have a non-NULL unixpath, need to validate it */ + if (strlen (unixpath) >= sizeof(s_un.sun_path)) { - /* We have a non-NULL unixpath, need to validate it */ - if (strlen(unixpath) >= sizeof(s_un.sun_path)) - { - LOG(GNUNET_ERROR_TYPE_WARNING, - _("UNIXPATH `%s' too long, maximum length is %llu\n"), - unixpath, - (unsigned long long)sizeof(s_un.sun_path)); - unixpath = GNUNET_NETWORK_shorten_unixpath(unixpath); - LOG(GNUNET_ERROR_TYPE_INFO, - _("Using `%s' instead\n"), - unixpath); - if (NULL == unixpath) - return NULL; - } - memset(&s_un, - 0, - sizeof(s_un)); - s_un.sun_family = AF_UNIX; - GNUNET_strlcpy(s_un.sun_path, - unixpath, - sizeof(s_un.sun_path)); + LOG (GNUNET_ERROR_TYPE_WARNING, + _ ("UNIXPATH `%s' too long, maximum length is %llu\n"), + unixpath, + (unsigned long long) sizeof(s_un.sun_path)); + unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath); + LOG (GNUNET_ERROR_TYPE_INFO, + _ ("Using `%s' instead\n"), + unixpath); + if (NULL == unixpath) + return NULL; + } + memset (&s_un, + 0, + sizeof(s_un)); + s_un.sun_family = AF_UNIX; + GNUNET_strlcpy (s_un.sun_path, + unixpath, + sizeof(s_un.sun_path)); #ifdef LINUX - { - int abstract; - - abstract = GNUNET_CONFIGURATION_get_value_yesno(cfg, - "TESTING", - "USE_ABSTRACT_SOCKETS"); - if (GNUNET_YES == abstract) - s_un.sun_path[0] = '\0'; - } + { + int abstract; + + abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg, + "TESTING", + "USE_ABSTRACT_SOCKETS"); + if (GNUNET_YES == abstract) + s_un.sun_path[0] = '\0'; + } #endif #if HAVE_SOCKADDR_UN_SUN_LEN - s_un.sun_len = (u_char)sizeof(struct sockaddr_un); + s_un.sun_len = (u_char) sizeof(struct sockaddr_un); #endif - sock = GNUNET_NETWORK_socket_create(AF_UNIX, - SOCK_STREAM, - 0); - if ((NULL != sock) && - ((GNUNET_OK == - GNUNET_NETWORK_socket_connect(sock, - (struct sockaddr *)&s_un, - sizeof(s_un))) || - (EINPROGRESS == errno))) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Successfully connected to unixpath `%s'!\n", - unixpath); - GNUNET_free(unixpath); - return sock; - } - if (NULL != sock) - GNUNET_NETWORK_socket_close(sock); + sock = GNUNET_NETWORK_socket_create (AF_UNIX, + SOCK_STREAM, + 0); + if ((NULL != sock) && + ((GNUNET_OK == + GNUNET_NETWORK_socket_connect (sock, + (struct sockaddr *) &s_un, + sizeof(s_un))) || + (EINPROGRESS == errno))) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Successfully connected to unixpath `%s'!\n", + unixpath); + GNUNET_free (unixpath); + return sock; } - GNUNET_free_non_null(unixpath); + if (NULL != sock) + GNUNET_NETWORK_socket_close (sock); + } + GNUNET_free_non_null (unixpath); #endif return NULL; } @@ -577,7 +580,7 @@ try_unixpath(const char *service_name, * @param cls the `struct AddressProbe *` with the address that we are probing */ static void -connect_probe_continuation(void *cls) +connect_probe_continuation (void *cls) { struct AddressProbe *ap = cls; struct ClientState *cstate = ap->cstate; @@ -586,40 +589,40 @@ connect_probe_continuation(void *cls) socklen_t len; ap->task = NULL; - GNUNET_assert(NULL != ap->sock); - GNUNET_CONTAINER_DLL_remove(cstate->ap_head, - cstate->ap_tail, - ap); + GNUNET_assert (NULL != ap->sock); + GNUNET_CONTAINER_DLL_remove (cstate->ap_head, + cstate->ap_tail, + ap); len = sizeof(error); error = 0; - tc = GNUNET_SCHEDULER_get_task_context(); + tc = GNUNET_SCHEDULER_get_task_context (); if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) || (GNUNET_OK != - GNUNET_NETWORK_socket_getsockopt(ap->sock, - SOL_SOCKET, - SO_ERROR, - &error, - &len)) || + GNUNET_NETWORK_socket_getsockopt (ap->sock, + SOL_SOCKET, + SO_ERROR, + &error, + &len)) || (0 != error)) - { - GNUNET_break(GNUNET_OK == - GNUNET_NETWORK_socket_close(ap->sock)); - GNUNET_free(ap); - if ((NULL == cstate->ap_head) && - // (NULL == cstate->proxy_handshake) && - (NULL == cstate->dns_active)) - connect_fail_continuation(cstate); - return; - } - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Connection to `%s' succeeded!\n", - cstate->service_name); + { + GNUNET_break (GNUNET_OK == + GNUNET_NETWORK_socket_close (ap->sock)); + GNUNET_free (ap); + if ((NULL == cstate->ap_head) && + // (NULL == cstate->proxy_handshake) && + (NULL == cstate->dns_active)) + connect_fail_continuation (cstate); + return; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Connection to `%s' succeeded!\n", + cstate->service_name); /* trigger jobs that waited for the connection */ - GNUNET_assert(NULL == cstate->sock); + GNUNET_assert (NULL == cstate->sock); cstate->sock = ap->sock; - GNUNET_free(ap); - cancel_aps(cstate); - connect_success_continuation(cstate); + GNUNET_free (ap); + cancel_aps (cstate); + connect_success_continuation (cstate); } @@ -632,82 +635,82 @@ connect_probe_continuation(void *cls) * @param addrlen length of @a addr */ static void -try_connect_using_address(void *cls, - const struct sockaddr *addr, - socklen_t addrlen) +try_connect_using_address (void *cls, + const struct sockaddr *addr, + socklen_t addrlen) { struct ClientState *cstate = cls; struct AddressProbe *ap; if (NULL == addr) - { - cstate->dns_active = NULL; - if ((NULL == cstate->ap_head) && - // (NULL == cstate->proxy_handshake) && - (NULL == cstate->sock)) - connect_fail_continuation(cstate); - return; - } + { + cstate->dns_active = NULL; + if ((NULL == cstate->ap_head) && + // (NULL == cstate->proxy_handshake) && + (NULL == cstate->sock)) + connect_fail_continuation (cstate); + return; + } if (NULL != cstate->sock) return; /* already connected */ /* try to connect */ - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Trying to connect using address `%s:%u'\n", - GNUNET_a2s(addr, - addrlen), - cstate->port); - ap = GNUNET_malloc(sizeof(struct AddressProbe) + addrlen); - ap->addr = (const struct sockaddr *)&ap[1]; - GNUNET_memcpy(&ap[1], - addr, - addrlen); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Trying to connect using address `%s:%u'\n", + GNUNET_a2s (addr, + addrlen), + cstate->port); + ap = GNUNET_malloc (sizeof(struct AddressProbe) + addrlen); + ap->addr = (const struct sockaddr *) &ap[1]; + GNUNET_memcpy (&ap[1], + addr, + addrlen); ap->addrlen = addrlen; ap->cstate = cstate; switch (ap->addr->sa_family) - { - case AF_INET: - ((struct sockaddr_in *)ap->addr)->sin_port = htons(cstate->port); - break; - - case AF_INET6: - ((struct sockaddr_in6 *)ap->addr)->sin6_port = htons(cstate->port); - break; - - default: - GNUNET_break(0); - GNUNET_free(ap); - return; /* not supported by us */ - } - ap->sock = GNUNET_NETWORK_socket_create(ap->addr->sa_family, - SOCK_STREAM, - 0); + { + case AF_INET: + ((struct sockaddr_in *) ap->addr)->sin_port = htons (cstate->port); + break; + + case AF_INET6: + ((struct sockaddr_in6 *) ap->addr)->sin6_port = htons (cstate->port); + break; + + default: + GNUNET_break (0); + GNUNET_free (ap); + return; /* not supported by us */ + } + ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family, + SOCK_STREAM, + 0); if (NULL == ap->sock) - { - GNUNET_free(ap); - return; /* not supported by OS */ - } + { + GNUNET_free (ap); + return; /* not supported by OS */ + } if ((GNUNET_OK != - GNUNET_NETWORK_socket_connect(ap->sock, - ap->addr, - ap->addrlen)) && + GNUNET_NETWORK_socket_connect (ap->sock, + ap->addr, + ap->addrlen)) && (EINPROGRESS != errno)) - { - /* maybe refused / unsupported address, try next */ - GNUNET_log_strerror(GNUNET_ERROR_TYPE_INFO, - "connect"); - GNUNET_break(GNUNET_OK == - GNUNET_NETWORK_socket_close(ap->sock)); - GNUNET_free(ap); - return; - } - GNUNET_CONTAINER_DLL_insert(cstate->ap_head, - cstate->ap_tail, - ap); - ap->task = GNUNET_SCHEDULER_add_write_net(CONNECT_RETRY_TIMEOUT, - ap->sock, - &connect_probe_continuation, - ap); + { + /* maybe refused / unsupported address, try next */ + GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, + "connect"); + GNUNET_break (GNUNET_OK == + GNUNET_NETWORK_socket_close (ap->sock)); + GNUNET_free (ap); + return; + } + GNUNET_CONTAINER_DLL_insert (cstate->ap_head, + cstate->ap_tail, + ap); + ap->task = GNUNET_SCHEDULER_add_write_net (CONNECT_RETRY_TIMEOUT, + ap->sock, + &connect_probe_continuation, + ap); } @@ -720,8 +723,8 @@ try_connect_using_address(void *cls, * @return #GNUNET_OK if the configuration is valid, #GNUNET_SYSERR if not */ static int -test_service_configuration(const char *service_name, - const struct GNUNET_CONFIGURATION_Handle *cfg) +test_service_configuration (const char *service_name, + const struct GNUNET_CONFIGURATION_Handle *cfg) { int ret = GNUNET_SYSERR; char *hostname = NULL; @@ -731,45 +734,45 @@ test_service_configuration(const char *service_name, char *unixpath = NULL; if ((GNUNET_OK == - GNUNET_CONFIGURATION_get_value_filename(cfg, - service_name, - "UNIXPATH", - &unixpath)) && - (0 < strlen(unixpath))) + GNUNET_CONFIGURATION_get_value_filename (cfg, + service_name, + "UNIXPATH", + &unixpath)) && + (0 < strlen (unixpath))) ret = GNUNET_OK; else if ((GNUNET_OK == - GNUNET_CONFIGURATION_have_value(cfg, - service_name, - "UNIXPATH"))) - { - GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR, - service_name, - "UNIXPATH", - _("not a valid filename")); - return GNUNET_SYSERR; /* UNIXPATH specified but invalid! */ - } - GNUNET_free_non_null(unixpath); + GNUNET_CONFIGURATION_have_value (cfg, + service_name, + "UNIXPATH"))) + { + GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, + service_name, + "UNIXPATH", + _ ("not a valid filename")); + return GNUNET_SYSERR; /* UNIXPATH specified but invalid! */ + } + GNUNET_free_non_null (unixpath); #endif if ((GNUNET_YES == - GNUNET_CONFIGURATION_have_value(cfg, - service_name, - "PORT")) && + GNUNET_CONFIGURATION_have_value (cfg, + service_name, + "PORT")) && (GNUNET_OK == - GNUNET_CONFIGURATION_get_value_number(cfg, - service_name, - "PORT", - &port)) && + GNUNET_CONFIGURATION_get_value_number (cfg, + service_name, + "PORT", + &port)) && (port <= 65535) && (0 != port) && (GNUNET_OK == - GNUNET_CONFIGURATION_get_value_string(cfg, - service_name, - "HOSTNAME", - &hostname)) && - (0 != strlen(hostname))) + GNUNET_CONFIGURATION_get_value_string (cfg, + service_name, + "HOSTNAME", + &hostname)) && + (0 != strlen (hostname))) ret = GNUNET_OK; - GNUNET_free_non_null(hostname); + GNUNET_free_non_null (hostname); return ret; } @@ -780,7 +783,7 @@ test_service_configuration(const char *service_name, * @param cls the `struct ClientState` to try to connect to the service */ static void -start_connect(void *cls) +start_connect (void *cls) { struct ClientState *cstate = cls; @@ -788,41 +791,41 @@ start_connect(void *cls) #if 0 /* Never use a local source if a proxy is configured */ if (GNUNET_YES == - GNUNET_SOCKS_check_service(cstate->service_name, - cstate->cfg)) - { - socks_connect(cstate); - return; - } + GNUNET_SOCKS_check_service (cstate->service_name, + cstate->cfg)) + { + socks_connect (cstate); + return; + } #endif if ((0 == (cstate->attempts++ % 2)) || (0 == cstate->port) || (NULL == cstate->hostname)) + { + /* on even rounds, try UNIX first, or always + if we do not have a DNS name and TCP port. */ + cstate->sock = try_unixpath (cstate->service_name, + cstate->cfg); + if (NULL != cstate->sock) { - /* on even rounds, try UNIX first, or always - if we do not have a DNS name and TCP port. */ - cstate->sock = try_unixpath(cstate->service_name, - cstate->cfg); - if (NULL != cstate->sock) - { - connect_success_continuation(cstate); - return; - } + connect_success_continuation (cstate); + return; } + } if ((NULL == cstate->hostname) || (0 == cstate->port)) - { - /* All options failed. Boo! */ - connect_fail_continuation(cstate); - return; - } + { + /* All options failed. Boo! */ + connect_fail_continuation (cstate); + return; + } cstate->dns_active - = GNUNET_RESOLVER_ip_get(cstate->hostname, - AF_UNSPEC, - CONNECT_RETRY_TIMEOUT, - &try_connect_using_address, - cstate); + = GNUNET_RESOLVER_ip_get (cstate->hostname, + AF_UNSPEC, + CONNECT_RETRY_TIMEOUT, + &try_connect_using_address, + cstate); } @@ -834,30 +837,30 @@ start_connect(void *cls) * @param impl_state our `struct ClientState` */ static void -connection_client_send_impl(struct GNUNET_MQ_Handle *mq, - const struct GNUNET_MessageHeader *msg, - void *impl_state) +connection_client_send_impl (struct GNUNET_MQ_Handle *mq, + const struct GNUNET_MessageHeader *msg, + void *impl_state) { struct ClientState *cstate = impl_state; - (void)mq; + (void) mq; /* only one message at a time allowed */ - GNUNET_assert(NULL == cstate->msg); - GNUNET_assert(NULL == cstate->send_task); + GNUNET_assert (NULL == cstate->msg); + GNUNET_assert (NULL == cstate->send_task); cstate->msg = msg; cstate->msg_off = 0; if (NULL == cstate->sock) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "message of type %u waiting for socket\n", - ntohs(msg->type)); - return; /* still waiting for connection */ - } + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "message of type %u waiting for socket\n", + ntohs (msg->type)); + return; /* still waiting for connection */ + } cstate->send_task - = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, - cstate->sock, - &transmit_ready, - cstate); + = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + cstate->sock, + &transmit_ready, + cstate); } @@ -868,20 +871,20 @@ connection_client_send_impl(struct GNUNET_MQ_Handle *mq, * @param impl_state our `struct ClientState` */ static void -connection_client_cancel_impl(struct GNUNET_MQ_Handle *mq, - void *impl_state) +connection_client_cancel_impl (struct GNUNET_MQ_Handle *mq, + void *impl_state) { struct ClientState *cstate = impl_state; - (void)mq; - GNUNET_assert(NULL != cstate->msg); - GNUNET_assert(0 == cstate->msg_off); + (void) mq; + GNUNET_assert (NULL != cstate->msg); + GNUNET_assert (0 == cstate->msg_off); cstate->msg = NULL; if (NULL != cstate->send_task) - { - GNUNET_SCHEDULER_cancel(cstate->send_task); - cstate->send_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (cstate->send_task); + cstate->send_task = NULL; + } } @@ -897,57 +900,57 @@ connection_client_cancel_impl(struct GNUNET_MQ_Handle *mq, * @return the message queue, NULL on error */ struct GNUNET_MQ_Handle * -GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, - const char *service_name, - const struct GNUNET_MQ_MessageHandler *handlers, - GNUNET_MQ_ErrorHandler error_handler, - void *error_handler_cls) +GNUNET_CLIENT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, + const char *service_name, + const struct GNUNET_MQ_MessageHandler *handlers, + GNUNET_MQ_ErrorHandler error_handler, + void *error_handler_cls) { struct ClientState *cstate; if (GNUNET_OK != - test_service_configuration(service_name, - cfg)) + test_service_configuration (service_name, + cfg)) return NULL; - cstate = GNUNET_new(struct ClientState); - cstate->service_name = GNUNET_strdup(service_name); + cstate = GNUNET_new (struct ClientState); + cstate->service_name = GNUNET_strdup (service_name); cstate->cfg = cfg; - cstate->retry_task = GNUNET_SCHEDULER_add_now(&start_connect, - cstate); - cstate->mst = GNUNET_MST_create(&recv_message, - cstate); + cstate->retry_task = GNUNET_SCHEDULER_add_now (&start_connect, + cstate); + cstate->mst = GNUNET_MST_create (&recv_message, + cstate); if (GNUNET_YES == - GNUNET_CONFIGURATION_have_value(cfg, - service_name, - "PORT")) - { - if (!((GNUNET_OK != - GNUNET_CONFIGURATION_get_value_number(cfg, + GNUNET_CONFIGURATION_have_value (cfg, + service_name, + "PORT")) + { + if (! ((GNUNET_OK != + GNUNET_CONFIGURATION_get_value_number (cfg, service_name, "PORT", &cstate->port)) || - (cstate->port > 65535) || - (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_string(cfg, + (cstate->port > 65535) || + (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "HOSTNAME", &cstate->hostname))) && - (0 == strlen(cstate->hostname))) - { - GNUNET_free(cstate->hostname); - cstate->hostname = NULL; - LOG(GNUNET_ERROR_TYPE_WARNING, - _("Need a non-empty hostname for service `%s'.\n"), - service_name); - } + (0 == strlen (cstate->hostname))) + { + GNUNET_free (cstate->hostname); + cstate->hostname = NULL; + LOG (GNUNET_ERROR_TYPE_WARNING, + _ ("Need a non-empty hostname for service `%s'.\n"), + service_name); } - cstate->mq = GNUNET_MQ_queue_for_callbacks(&connection_client_send_impl, - &connection_client_destroy_impl, - &connection_client_cancel_impl, - cstate, - handlers, - error_handler, - error_handler_cls); + } + cstate->mq = GNUNET_MQ_queue_for_callbacks (&connection_client_send_impl, + &connection_client_destroy_impl, + &connection_client_cancel_impl, + cstate, + handlers, + error_handler, + error_handler_cls); return cstate->mq; } -- cgit v1.2.3