From 83b19539f4d322b43683f5838b72e9ec2c8e6073 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Fri, 4 Nov 2011 14:00:32 +0000 Subject: curly wars / auto-indentation --- src/util/client.c | 804 +++++++++++++++++++++++++++--------------------------- 1 file changed, 396 insertions(+), 408 deletions(-) (limited to 'src/util/client.c') diff --git a/src/util/client.c b/src/util/client.c index d2f347947..e71ccdf39 100644 --- a/src/util/client.c +++ b/src/util/client.c @@ -259,8 +259,7 @@ struct GNUNET_CLIENT_Connection */ static struct GNUNET_CONNECTION_Handle * do_connect (const char *service_name, - const struct GNUNET_CONFIGURATION_Handle *cfg, - unsigned int attempt) + const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int attempt) { struct GNUNET_CONNECTION_Handle *sock; char *hostname; @@ -270,80 +269,78 @@ do_connect (const char *service_name, sock = NULL; #if AF_UNIX if (0 == (attempt % 2)) + { + /* on even rounds, try UNIX */ + unixpath = NULL; + if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "UNIXPATH", &unixpath)) && (0 < strlen (unixpath))) /* We have a non-NULL unixpath, does that mean it's valid? */ { - /* on even rounds, try UNIX */ - unixpath = NULL; - if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "UNIXPATH", &unixpath)) && (0 < strlen (unixpath))) /* We have a non-NULL unixpath, does that mean it's valid? */ - { - sock = - GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg, unixpath); - if (sock != NULL) - { + sock = GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg, unixpath); + if (sock != NULL) + { #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, "Connected to unixpath `%s'!\n", - unixpath); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Connected to unixpath `%s'!\n", + unixpath); #endif - GNUNET_free (unixpath); - return sock; - } - } - GNUNET_free_non_null (unixpath); + GNUNET_free (unixpath); + return sock; + } } + GNUNET_free_non_null (unixpath); + } #endif if ((GNUNET_OK != - GNUNET_CONFIGURATION_get_value_number (cfg, service_name, "PORT", - &port)) || (port > 65535) - || (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_string (cfg, service_name, - "HOSTNAME", &hostname))) - { - LOG (GNUNET_ERROR_TYPE_WARNING, - _ - ("Could not determine valid hostname and port for service `%s' from configuration.\n"), - service_name); - return NULL; - } + GNUNET_CONFIGURATION_get_value_number (cfg, service_name, "PORT", &port)) + || (port > 65535) || + (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "HOSTNAME", + &hostname))) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + _ + ("Could not determine valid hostname and port for service `%s' from configuration.\n"), + service_name); + return NULL; + } if (0 == strlen (hostname)) - { - GNUNET_free (hostname); - LOG (GNUNET_ERROR_TYPE_WARNING, - _("Need a non-empty hostname for service `%s'.\n"), service_name); - return NULL; - } + { + GNUNET_free (hostname); + LOG (GNUNET_ERROR_TYPE_WARNING, + _("Need a non-empty hostname for service `%s'.\n"), service_name); + return NULL; + } if (port == 0) - { + { #if AF_UNIX - if (0 != (attempt % 2)) - { - /* try UNIX */ - unixpath = NULL; - if ((GNUNET_OK == - GNUNET_CONFIGURATION_get_value_string (cfg, service_name, - "UNIXPATH", &unixpath)) - && (0 < strlen (unixpath))) - { - sock = - GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg, - unixpath); - if (sock != NULL) - { - GNUNET_free (unixpath); - GNUNET_free (hostname); - return sock; - } - } - GNUNET_free_non_null (unixpath); - } + if (0 != (attempt % 2)) + { + /* try UNIX */ + unixpath = NULL; + if ((GNUNET_OK == + GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "UNIXPATH", + &unixpath)) && + (0 < strlen (unixpath))) + { + sock = + GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg, unixpath); + if (sock != NULL) + { + GNUNET_free (unixpath); + GNUNET_free (hostname); + return sock; + } + } + GNUNET_free_non_null (unixpath); + } #endif #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Port is 0 for service `%s', UNIXPATH did not work, returning NULL!\n", - service_name); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Port is 0 for service `%s', UNIXPATH did not work, returning NULL!\n", + service_name); #endif - GNUNET_free (hostname); - return NULL; - } + GNUNET_free (hostname); + return NULL; + } sock = GNUNET_CONNECTION_create_from_connect (cfg, hostname, port); GNUNET_free (hostname); @@ -360,7 +357,7 @@ do_connect (const char *service_name, */ struct GNUNET_CLIENT_Connection * GNUNET_CLIENT_connect (const char *service_name, - const struct GNUNET_CONFIGURATION_Handle *cfg) + const struct GNUNET_CONFIGURATION_Handle *cfg) { struct GNUNET_CLIENT_Connection *ret; struct GNUNET_CONNECTION_Handle *sock; @@ -393,33 +390,33 @@ GNUNET_CLIENT_connect (const char *service_name, */ void GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock, - int finish_pending_write) + int finish_pending_write) { if (sock->in_receive == GNUNET_YES) - { - GNUNET_CONNECTION_receive_cancel (sock->sock); - sock->in_receive = GNUNET_NO; - } + { + GNUNET_CONNECTION_receive_cancel (sock->sock); + sock->in_receive = GNUNET_NO; + } if (sock->th != NULL) - { - GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th); - sock->th = NULL; - } + { + GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th); + sock->th = NULL; + } if (NULL != sock->sock) - { - GNUNET_CONNECTION_destroy (sock->sock, finish_pending_write); - sock->sock = NULL; - } + { + GNUNET_CONNECTION_destroy (sock->sock, finish_pending_write); + sock->sock = NULL; + } if (sock->receive_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel (sock->receive_task); - sock->receive_task = GNUNET_SCHEDULER_NO_TASK; - } + { + GNUNET_SCHEDULER_cancel (sock->receive_task); + sock->receive_task = GNUNET_SCHEDULER_NO_TASK; + } if (sock->tag != NULL) - { - GNUNET_free (sock->tag); - sock->tag = NULL; - } + { + GNUNET_free (sock->tag); + sock->tag = NULL; + } sock->receiver_handler = NULL; GNUNET_array_grow (sock->received_buf, sock->received_size, 0); GNUNET_free (sock->service_name); @@ -436,7 +433,7 @@ check_complete (struct GNUNET_CLIENT_Connection *conn) if ((conn->received_pos >= sizeof (struct GNUNET_MessageHeader)) && (conn->received_pos >= ntohs (((const struct GNUNET_MessageHeader *) conn->received_buf)-> - size))) + size))) conn->msg_complete = GNUNET_YES; } @@ -455,7 +452,7 @@ check_complete (struct GNUNET_CLIENT_Connection *conn) */ static void receive_helper (void *cls, const void *buf, size_t available, - const struct sockaddr *addr, socklen_t addrlen, int errCode) + const struct sockaddr *addr, socklen_t addrlen, int errCode) { struct GNUNET_CLIENT_Connection *conn = cls; struct GNUNET_TIME_Relative remaining; @@ -465,22 +462,22 @@ receive_helper (void *cls, const void *buf, size_t available, GNUNET_assert (conn->msg_complete == GNUNET_NO); conn->in_receive = GNUNET_NO; if ((available == 0) || (conn->sock == NULL) || (errCode != 0)) - { - /* signal timeout! */ + { + /* signal timeout! */ #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Timeout in receive_helper, available %u, conn->sock %s, errCode `%s'\n", - (unsigned int) available, - conn->sock == NULL ? "NULL" : "non-NULL", STRERROR (errCode)); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Timeout in receive_helper, available %u, conn->sock %s, errCode `%s'\n", + (unsigned int) available, conn->sock == NULL ? "NULL" : "non-NULL", + STRERROR (errCode)); #endif - if (NULL != (receive_handler = conn->receiver_handler)) - { - receive_handler_cls = conn->receiver_handler_cls; - conn->receiver_handler = NULL; - receive_handler (receive_handler_cls, NULL); - } - return; + if (NULL != (receive_handler = conn->receiver_handler)) + { + receive_handler_cls = conn->receiver_handler_cls; + conn->receiver_handler = NULL; + receive_handler (receive_handler_cls, NULL); } + return; + } /* FIXME: optimize for common fast case where buf contains the * entire message and we need no copying... */ @@ -489,22 +486,22 @@ receive_helper (void *cls, const void *buf, size_t available, /* slow path: append to array */ if (conn->received_size < conn->received_pos + available) GNUNET_array_grow (conn->received_buf, conn->received_size, - conn->received_pos + available); + conn->received_pos + available); memcpy (&conn->received_buf[conn->received_pos], buf, available); conn->received_pos += available; check_complete (conn); /* check for timeout */ remaining = GNUNET_TIME_absolute_get_remaining (conn->receive_timeout); if (remaining.rel_value == 0) - { - /* signal timeout! */ - if (NULL != conn->receiver_handler) - conn->receiver_handler (conn->receiver_handler_cls, NULL); - return; - } + { + /* signal timeout! */ + if (NULL != conn->receiver_handler) + conn->receiver_handler (conn->receiver_handler_cls, NULL); + return; + } /* back to receive -- either for more data or to call callback! */ GNUNET_CLIENT_receive (conn, conn->receiver_handler, - conn->receiver_handler_cls, remaining); + conn->receiver_handler_cls, remaining); } @@ -520,23 +517,22 @@ receive_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) struct GNUNET_CLIENT_Connection *sock = cls; GNUNET_CLIENT_MessageHandler handler = sock->receiver_handler; const struct GNUNET_MessageHeader *cmsg = - (const struct GNUNET_MessageHeader *) sock->received_buf; + (const struct GNUNET_MessageHeader *) sock->received_buf; void *handler_cls = sock->receiver_handler_cls; uint16_t msize = ntohs (cmsg->size); char mbuf[msize]; struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader *) mbuf; #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Received message of type %u and size %u\n", ntohs (cmsg->type), - msize); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Received message of type %u and size %u\n", + ntohs (cmsg->type), msize); #endif sock->receive_task = GNUNET_SCHEDULER_NO_TASK; GNUNET_assert (GNUNET_YES == sock->msg_complete); GNUNET_assert (sock->received_pos >= msize); memcpy (msg, cmsg, msize); memmove (sock->received_buf, &sock->received_buf[msize], - sock->received_pos - msize); + sock->received_pos - msize); sock->received_pos -= msize; sock->msg_complete = GNUNET_NO; sock->receiver_handler = NULL; @@ -556,36 +552,35 @@ receive_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) */ void GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock, - GNUNET_CLIENT_MessageHandler handler, - void *handler_cls, struct GNUNET_TIME_Relative timeout) + GNUNET_CLIENT_MessageHandler handler, void *handler_cls, + struct GNUNET_TIME_Relative timeout) { if (sock->sock == NULL) - { - /* already disconnected, fail instantly! */ - GNUNET_break (0); /* this should not happen in well-written code! */ - if (NULL != handler) - handler (handler_cls, NULL); - return; - } + { + /* already disconnected, fail instantly! */ + GNUNET_break (0); /* this should not happen in well-written code! */ + if (NULL != handler) + handler (handler_cls, NULL); + return; + } sock->receiver_handler = handler; sock->receiver_handler_cls = handler_cls; sock->receive_timeout = GNUNET_TIME_relative_to_absolute (timeout); if (GNUNET_YES == sock->msg_complete) - { - GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->receive_task); - sock->receive_task = GNUNET_SCHEDULER_add_now (&receive_task, sock); - } + { + GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->receive_task); + sock->receive_task = GNUNET_SCHEDULER_add_now (&receive_task, sock); + } else - { - GNUNET_assert (sock->in_receive == GNUNET_NO); - sock->in_receive = GNUNET_YES; + { + GNUNET_assert (sock->in_receive == GNUNET_NO); + sock->in_receive = GNUNET_YES; #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, "calling GNUNET_CONNECTION_receive\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "calling GNUNET_CONNECTION_receive\n"); #endif - GNUNET_CONNECTION_receive (sock->sock, - GNUNET_SERVER_MAX_MESSAGE_SIZE - 1, timeout, - &receive_helper, sock); - } + GNUNET_CONNECTION_receive (sock->sock, GNUNET_SERVER_MAX_MESSAGE_SIZE - 1, + timeout, &receive_helper, sock); + } } @@ -596,7 +591,7 @@ static void service_test_error (GNUNET_SCHEDULER_Task task, void *task_cls) { GNUNET_SCHEDULER_add_continuation (task, task_cls, - GNUNET_SCHEDULER_REASON_TIMEOUT); + GNUNET_SCHEDULER_REASON_TIMEOUT); } @@ -615,18 +610,18 @@ confirm_handler (void *cls, const struct GNUNET_MessageHeader *msg) * detail in the future, for example, is this the * correct service? FIXME! */ if (msg != NULL) - { + { #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Received confirmation that service is running.\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Received confirmation that service is running.\n"); #endif - GNUNET_SCHEDULER_add_continuation (conn->test_cb, conn->test_cb_cls, - GNUNET_SCHEDULER_REASON_PREREQ_DONE); - } + GNUNET_SCHEDULER_add_continuation (conn->test_cb, conn->test_cb_cls, + GNUNET_SCHEDULER_REASON_PREREQ_DONE); + } else - { - service_test_error (conn->test_cb, conn->test_cb_cls); - } + { + service_test_error (conn->test_cb, conn->test_cb_cls); + } GNUNET_CLIENT_disconnect (conn, GNUNET_NO); } @@ -647,14 +642,14 @@ write_test (void *cls, size_t size, void *buf) struct GNUNET_MessageHeader *msg; if (size < sizeof (struct GNUNET_MessageHeader)) - { + { #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, _("Failure to transmit TEST request.\n")); + LOG (GNUNET_ERROR_TYPE_DEBUG, _("Failure to transmit TEST request.\n")); #endif - service_test_error (conn->test_cb, conn->test_cb_cls); - GNUNET_CLIENT_disconnect (conn, GNUNET_NO); - return 0; /* client disconnected */ - } + service_test_error (conn->test_cb, conn->test_cb_cls); + GNUNET_CLIENT_disconnect (conn, GNUNET_NO); + return 0; /* client disconnected */ + } #if DEBUG_CLIENT LOG (GNUNET_ERROR_TYPE_DEBUG, "Transmitting `%s' request.\n", "TEST"); #endif @@ -662,8 +657,8 @@ write_test (void *cls, size_t size, void *buf) msg->type = htons (GNUNET_MESSAGE_TYPE_TEST); msg->size = htons (sizeof (struct GNUNET_MessageHeader)); GNUNET_CLIENT_receive (conn, &confirm_handler, conn, - GNUNET_TIME_absolute_get_remaining - (conn->test_deadline)); + GNUNET_TIME_absolute_get_remaining + (conn->test_deadline)); return sizeof (struct GNUNET_MessageHeader); } @@ -683,9 +678,9 @@ write_test (void *cls, size_t size, void *buf) */ void GNUNET_CLIENT_service_test (const char *service, - const struct GNUNET_CONFIGURATION_Handle *cfg, - struct GNUNET_TIME_Relative timeout, - GNUNET_SCHEDULER_Task task, void *task_cls) + const struct GNUNET_CONFIGURATION_Handle *cfg, + struct GNUNET_TIME_Relative timeout, + GNUNET_SCHEDULER_Task task, void *task_cls) { char *hostname; unsigned long long port; @@ -704,50 +699,49 @@ GNUNET_CLIENT_service_test (const char *service, char *unixpath; unixpath = NULL; - if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, service, "UNIXPATH", &unixpath)) && (0 < strlen (unixpath))) /* We have a non-NULL unixpath, does that mean it's valid? */ + if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, service, "UNIXPATH", &unixpath)) && (0 < strlen (unixpath))) /* We have a non-NULL unixpath, does that mean it's valid? */ + { + if (strlen (unixpath) >= sizeof (s_un.sun_path)) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + _("UNIXPATH `%s' too long, maximum length is %llu\n"), unixpath, + sizeof (s_un.sun_path)); + } + else { - if (strlen (unixpath) >= sizeof (s_un.sun_path)) - { - LOG (GNUNET_ERROR_TYPE_WARNING, - _("UNIXPATH `%s' too long, maximum length is %llu\n"), - unixpath, sizeof (s_un.sun_path)); - } - else - { - sock = GNUNET_NETWORK_socket_create (PF_UNIX, SOCK_STREAM, 0); - if (sock != NULL) - { - memset (&s_un, 0, sizeof (s_un)); - s_un.sun_family = AF_UNIX; - slen = strlen (unixpath) + 1; - if (slen >= sizeof (s_un.sun_path)) - slen = sizeof (s_un.sun_path) - 1; - memcpy (s_un.sun_path, unixpath, slen); - s_un.sun_path[slen] = '\0'; - slen = sizeof (struct sockaddr_un); + sock = GNUNET_NETWORK_socket_create (PF_UNIX, SOCK_STREAM, 0); + if (sock != NULL) + { + memset (&s_un, 0, sizeof (s_un)); + s_un.sun_family = AF_UNIX; + slen = strlen (unixpath) + 1; + if (slen >= sizeof (s_un.sun_path)) + slen = sizeof (s_un.sun_path) - 1; + memcpy (s_un.sun_path, unixpath, slen); + s_un.sun_path[slen] = '\0'; + slen = sizeof (struct sockaddr_un); #if LINUX - s_un.sun_path[0] = '\0'; + s_un.sun_path[0] = '\0'; #endif #if HAVE_SOCKADDR_IN_SIN_LEN - s_un.sun_len = (u_char) slen; + s_un.sun_len = (u_char) slen; #endif - if (GNUNET_OK != - GNUNET_NETWORK_socket_bind (sock, - (const struct sockaddr *) - &s_un, slen)) - { - /* failed to bind => service must be running */ - GNUNET_free (unixpath); - (void) GNUNET_NETWORK_socket_close (sock); - GNUNET_SCHEDULER_add_continuation (task, task_cls, - GNUNET_SCHEDULER_REASON_PREREQ_DONE); - return; - } - (void) GNUNET_NETWORK_socket_close (sock); - } - /* let's try IP */ - } + if (GNUNET_OK != + GNUNET_NETWORK_socket_bind (sock, (const struct sockaddr *) &s_un, + slen)) + { + /* failed to bind => service must be running */ + GNUNET_free (unixpath); + (void) GNUNET_NETWORK_socket_close (sock); + GNUNET_SCHEDULER_add_continuation (task, task_cls, + GNUNET_SCHEDULER_REASON_PREREQ_DONE); + return; + } + (void) GNUNET_NETWORK_socket_close (sock); + } + /* let's try IP */ } + } GNUNET_free_non_null (unixpath); } #endif @@ -758,124 +752,121 @@ GNUNET_CLIENT_service_test (const char *service, (port > 65535) || (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, service, "HOSTNAME", - &hostname))) - { - /* UNIXPATH failed (if possible) AND IP failed => error */ - service_test_error (task, task_cls); - return; - } + &hostname))) + { + /* UNIXPATH failed (if possible) AND IP failed => error */ + service_test_error (task, task_cls); + return; + } if (0 == strcmp ("localhost", hostname) #if !LINUX && 0 #endif - ) - { - /* can test using 'bind' */ - struct sockaddr_in s_in; + ) + { + /* can test using 'bind' */ + struct sockaddr_in s_in; - memset (&s_in, 0, sizeof (s_in)); + memset (&s_in, 0, sizeof (s_in)); #if HAVE_SOCKADDR_IN_SIN_LEN - s_in.sin_len = sizeof (struct sockaddr_in); + s_in.sin_len = sizeof (struct sockaddr_in); #endif - s_in.sin_family = AF_INET; - s_in.sin_port = htons (port); + s_in.sin_family = AF_INET; + s_in.sin_port = htons (port); - sock = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0); - if (sock != NULL) - { - if (GNUNET_OK != - GNUNET_NETWORK_socket_bind (sock, - (const struct sockaddr *) &s_in, - sizeof (s_in))) - { - /* failed to bind => service must be running */ - GNUNET_free (hostname); - (void) GNUNET_NETWORK_socket_close (sock); - GNUNET_SCHEDULER_add_continuation (task, task_cls, - GNUNET_SCHEDULER_REASON_PREREQ_DONE); - return; - } - (void) GNUNET_NETWORK_socket_close (sock); - } + sock = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0); + if (sock != NULL) + { + if (GNUNET_OK != + GNUNET_NETWORK_socket_bind (sock, (const struct sockaddr *) &s_in, + sizeof (s_in))) + { + /* failed to bind => service must be running */ + GNUNET_free (hostname); + (void) GNUNET_NETWORK_socket_close (sock); + GNUNET_SCHEDULER_add_continuation (task, task_cls, + GNUNET_SCHEDULER_REASON_PREREQ_DONE); + return; + } + (void) GNUNET_NETWORK_socket_close (sock); } + } if (0 == strcmp ("ip6-localhost", hostname) #if !LINUX && 0 #endif - ) - { - /* can test using 'bind' */ - struct sockaddr_in6 s_in6; + ) + { + /* can test using 'bind' */ + struct sockaddr_in6 s_in6; - memset (&s_in6, 0, sizeof (s_in6)); + memset (&s_in6, 0, sizeof (s_in6)); #if HAVE_SOCKADDR_IN_SIN_LEN - s_in6.sin6_len = sizeof (struct sockaddr_in6); + s_in6.sin6_len = sizeof (struct sockaddr_in6); #endif - s_in6.sin6_family = AF_INET6; - s_in6.sin6_port = htons (port); + s_in6.sin6_family = AF_INET6; + s_in6.sin6_port = htons (port); - sock = GNUNET_NETWORK_socket_create (AF_INET6, SOCK_STREAM, 0); - if (sock != NULL) - { - if (GNUNET_OK != - GNUNET_NETWORK_socket_bind (sock, - (const struct sockaddr *) &s_in6, - sizeof (s_in6))) - { - /* failed to bind => service must be running */ - GNUNET_free (hostname); - (void) GNUNET_NETWORK_socket_close (sock); - GNUNET_SCHEDULER_add_continuation (task, task_cls, - GNUNET_SCHEDULER_REASON_PREREQ_DONE); - return; - } - (void) GNUNET_NETWORK_socket_close (sock); - } + sock = GNUNET_NETWORK_socket_create (AF_INET6, SOCK_STREAM, 0); + if (sock != NULL) + { + if (GNUNET_OK != + GNUNET_NETWORK_socket_bind (sock, (const struct sockaddr *) &s_in6, + sizeof (s_in6))) + { + /* failed to bind => service must be running */ + GNUNET_free (hostname); + (void) GNUNET_NETWORK_socket_close (sock); + GNUNET_SCHEDULER_add_continuation (task, task_cls, + GNUNET_SCHEDULER_REASON_PREREQ_DONE); + return; + } + (void) GNUNET_NETWORK_socket_close (sock); } + } if (((0 == strcmp ("localhost", hostname)) || (0 == strcmp ("ip6-localhost", hostname))) #if !LINUX && 0 #endif - ) - { - /* all binds succeeded => claim service not running right now */ - GNUNET_free_non_null (hostname); - service_test_error (task, task_cls); - return; - } + ) + { + /* all binds succeeded => claim service not running right now */ + GNUNET_free_non_null (hostname); + service_test_error (task, task_cls); + return; + } GNUNET_free_non_null (hostname); /* non-localhost, try 'connect' method */ conn = GNUNET_CLIENT_connect (service, cfg); if (conn == NULL) - { - LOG (GNUNET_ERROR_TYPE_INFO, - _("Could not connect to service `%s', must not be running.\n"), - service); - service_test_error (task, task_cls); - return; - } + { + LOG (GNUNET_ERROR_TYPE_INFO, + _("Could not connect to service `%s', must not be running.\n"), + service); + service_test_error (task, task_cls); + return; + } conn->test_cb = task; conn->test_cb_cls = task_cls; conn->test_deadline = GNUNET_TIME_relative_to_absolute (timeout); if (NULL == GNUNET_CLIENT_notify_transmit_ready (conn, - sizeof (struct - GNUNET_MessageHeader), - timeout, GNUNET_YES, &write_test, - conn)) - { - LOG (GNUNET_ERROR_TYPE_WARNING, - _("Failure to transmit request to service `%s'\n"), service); - service_test_error (task, task_cls); - GNUNET_CLIENT_disconnect (conn, GNUNET_NO); - return; - } + sizeof (struct GNUNET_MessageHeader), + timeout, GNUNET_YES, &write_test, + conn)) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + _("Failure to transmit request to service `%s'\n"), service); + service_test_error (task, task_cls); + GNUNET_CLIENT_disconnect (conn, GNUNET_NO); + return; + } } @@ -889,7 +880,8 @@ GNUNET_CLIENT_service_test (const char *service, * @param buf where to write them * @return number of bytes written to buf */ -static size_t client_notify (void *cls, size_t size, void *buf); +static size_t +client_notify (void *cls, size_t size, void *buf); /** @@ -900,58 +892,57 @@ static size_t client_notify (void *cls, size_t size, void *buf); * @param tc unused */ static void -client_delayed_retry (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +client_delayed_retry (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct GNUNET_CLIENT_TransmitHandle *th = cls; struct GNUNET_TIME_Relative delay; th->reconnect_task = GNUNET_SCHEDULER_NO_TASK; if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) - { + { #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, "Transmission failed due to shutdown.\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Transmission failed due to shutdown.\n"); #endif - th->sock->th = NULL; - th->notify (th->notify_cls, 0, NULL); - GNUNET_free (th); - return; - } + th->sock->th = NULL; + th->notify (th->notify_cls, 0, NULL); + GNUNET_free (th); + return; + } th->sock->sock = - do_connect (th->sock->service_name, th->sock->cfg, th->sock->attempts++); + do_connect (th->sock->service_name, th->sock->cfg, th->sock->attempts++); if (NULL == th->sock->sock) - { - /* could happen if we're out of sockets */ - delay = - GNUNET_TIME_relative_min (GNUNET_TIME_absolute_get_remaining - (th->timeout), th->sock->back_off); - th->sock->back_off = - GNUNET_TIME_relative_min (GNUNET_TIME_relative_multiply - (th->sock->back_off, 2), - GNUNET_TIME_UNIT_SECONDS); + { + /* could happen if we're out of sockets */ + delay = + GNUNET_TIME_relative_min (GNUNET_TIME_absolute_get_remaining + (th->timeout), th->sock->back_off); + th->sock->back_off = + GNUNET_TIME_relative_min (GNUNET_TIME_relative_multiply + (th->sock->back_off, 2), + GNUNET_TIME_UNIT_SECONDS); #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Transmission failed %u times, trying again in %llums.\n", - MAX_ATTEMPTS - th->attempts_left, - (unsigned long long) delay.rel_value); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Transmission failed %u times, trying again in %llums.\n", + MAX_ATTEMPTS - th->attempts_left, + (unsigned long long) delay.rel_value); #endif - th->reconnect_task = - GNUNET_SCHEDULER_add_delayed (delay, &client_delayed_retry, th); - return; - } + th->reconnect_task = + GNUNET_SCHEDULER_add_delayed (delay, &client_delayed_retry, th); + return; + } th->th = - GNUNET_CONNECTION_notify_transmit_ready (th->sock->sock, th->size, - GNUNET_TIME_absolute_get_remaining - (th->timeout), &client_notify, - th); + GNUNET_CONNECTION_notify_transmit_ready (th->sock->sock, th->size, + GNUNET_TIME_absolute_get_remaining + (th->timeout), &client_notify, + th); if (th->th == NULL) - { - GNUNET_break (0); - th->sock->th = NULL; - th->notify (th->notify_cls, 0, NULL); - GNUNET_free (th); - return; - } + { + GNUNET_break (0); + th->sock->th = NULL; + th->notify (th->notify_cls, 0, NULL); + GNUNET_free (th); + return; + } } @@ -974,47 +965,47 @@ client_notify (void *cls, size_t size, void *buf) th->th = NULL; th->sock->th = NULL; if (buf == NULL) + { + delay = GNUNET_TIME_absolute_get_remaining (th->timeout); + delay.rel_value /= 2; + if ((0 != + (GNUNET_SCHEDULER_REASON_SHUTDOWN & GNUNET_SCHEDULER_get_reason ())) || + (GNUNET_YES != th->auto_retry) || (0 == --th->attempts_left) || + (delay.rel_value < 1)) { - delay = GNUNET_TIME_absolute_get_remaining (th->timeout); - delay.rel_value /= 2; - if ((0 != - (GNUNET_SCHEDULER_REASON_SHUTDOWN & - GNUNET_SCHEDULER_get_reason ())) || (GNUNET_YES != th->auto_retry) - || (0 == --th->attempts_left) || (delay.rel_value < 1)) - { #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Transmission failed %u times, giving up.\n", - MAX_ATTEMPTS - th->attempts_left); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Transmission failed %u times, giving up.\n", + MAX_ATTEMPTS - th->attempts_left); #endif - GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL)); - GNUNET_free (th); - return 0; - } - /* auto-retry */ + GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL)); + GNUNET_free (th); + return 0; + } + /* auto-retry */ #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Failed to connect to `%s', automatically trying again.\n", - th->sock->service_name); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Failed to connect to `%s', automatically trying again.\n", + th->sock->service_name); #endif - GNUNET_CONNECTION_destroy (th->sock->sock, GNUNET_NO); - th->sock->sock = NULL; - delay = GNUNET_TIME_relative_min (delay, th->sock->back_off); - th->sock->back_off = - GNUNET_TIME_relative_min (GNUNET_TIME_relative_multiply - (th->sock->back_off, 2), - GNUNET_TIME_UNIT_SECONDS); + GNUNET_CONNECTION_destroy (th->sock->sock, GNUNET_NO); + th->sock->sock = NULL; + delay = GNUNET_TIME_relative_min (delay, th->sock->back_off); + th->sock->back_off = + GNUNET_TIME_relative_min (GNUNET_TIME_relative_multiply + (th->sock->back_off, 2), + GNUNET_TIME_UNIT_SECONDS); #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Transmission failed %u times, trying again in %llums.\n", - MAX_ATTEMPTS - th->attempts_left, - (unsigned long long) delay.rel_value); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Transmission failed %u times, trying again in %llums.\n", + MAX_ATTEMPTS - th->attempts_left, + (unsigned long long) delay.rel_value); #endif - th->sock->th = th; - th->reconnect_task = - GNUNET_SCHEDULER_add_delayed (delay, &client_delayed_retry, th); - return 0; - } + th->sock->th = th; + th->reconnect_task = + GNUNET_SCHEDULER_add_delayed (delay, &client_delayed_retry, th); + return 0; + } GNUNET_assert (size >= th->size); ret = th->notify (th->notify_cls, size, buf); GNUNET_free (th); @@ -1043,21 +1034,21 @@ client_notify (void *cls, size_t size, void *buf) */ struct GNUNET_CLIENT_TransmitHandle * GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock, - size_t size, - struct GNUNET_TIME_Relative timeout, - int auto_retry, - GNUNET_CONNECTION_TransmitReadyNotify - notify, void *notify_cls) + size_t size, + struct GNUNET_TIME_Relative timeout, + int auto_retry, + GNUNET_CONNECTION_TransmitReadyNotify + notify, void *notify_cls) { struct GNUNET_CLIENT_TransmitHandle *th; if (NULL != sock->th) - { - /* If this breaks, you most likley called this function twice without waiting - * for completion or canceling the request */ - GNUNET_break (0); - return NULL; - } + { + /* If this breaks, you most likley called this function twice without waiting + * for completion or canceling the request */ + GNUNET_break (0); + return NULL; + } th = GNUNET_malloc (sizeof (struct GNUNET_CLIENT_TransmitHandle)); th->sock = sock; th->size = size; @@ -1068,25 +1059,25 @@ GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock, th->attempts_left = MAX_ATTEMPTS; sock->th = th; if (sock->sock == NULL) - { - th->reconnect_task = - GNUNET_SCHEDULER_add_delayed (sock->back_off, &client_delayed_retry, - th); + { + th->reconnect_task = + GNUNET_SCHEDULER_add_delayed (sock->back_off, &client_delayed_retry, + th); - } + } else + { + th->th = + GNUNET_CONNECTION_notify_transmit_ready (sock->sock, size, timeout, + &client_notify, th); + if (NULL == th->th) { - th->th = - GNUNET_CONNECTION_notify_transmit_ready (sock->sock, size, timeout, - &client_notify, th); - if (NULL == th->th) - { - GNUNET_break (0); - GNUNET_free (th); - sock->th = NULL; - return NULL; - } + GNUNET_break (0); + GNUNET_free (th); + sock->th = NULL; + return NULL; } + } return th; } @@ -1097,20 +1088,20 @@ GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock, * @param th handle from the original request. */ void -GNUNET_CLIENT_notify_transmit_ready_cancel (struct - GNUNET_CLIENT_TransmitHandle *th) +GNUNET_CLIENT_notify_transmit_ready_cancel (struct GNUNET_CLIENT_TransmitHandle + *th) { if (th->reconnect_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_assert (NULL == th->th); - GNUNET_SCHEDULER_cancel (th->reconnect_task); - th->reconnect_task = GNUNET_SCHEDULER_NO_TASK; - } + { + GNUNET_assert (NULL == th->th); + GNUNET_SCHEDULER_cancel (th->reconnect_task); + th->reconnect_task = GNUNET_SCHEDULER_NO_TASK; + } else - { - GNUNET_assert (NULL != th->th); - GNUNET_CONNECTION_notify_transmit_ready_cancel (th->th); - } + { + GNUNET_assert (NULL != th->th); + GNUNET_CONNECTION_notify_transmit_ready_cancel (th->th); + } th->sock->th = NULL; GNUNET_free (th); } @@ -1136,21 +1127,20 @@ transmit_for_response (void *cls, size_t size, void *buf) tc->sock->tag = NULL; msize = ntohs (tc->hdr->size); if (NULL == buf) - { + { #if DEBUG_CLIENT - LOG (GNUNET_ERROR_TYPE_DEBUG, - _ - ("Could not submit request, not expecting to receive a response.\n")); + LOG (GNUNET_ERROR_TYPE_DEBUG, + _("Could not submit request, not expecting to receive a response.\n")); #endif - if (NULL != tc->rn) - tc->rn (tc->rn_cls, NULL); - GNUNET_free (tc); - return 0; - } + if (NULL != tc->rn) + tc->rn (tc->rn_cls, NULL); + GNUNET_free (tc); + return 0; + } GNUNET_assert (size >= msize); memcpy (buf, tc->hdr, msize); GNUNET_CLIENT_receive (tc->sock, tc->rn, tc->rn_cls, - GNUNET_TIME_absolute_get_remaining (tc->timeout)); + GNUNET_TIME_absolute_get_remaining (tc->timeout)); GNUNET_free (tc); return msize; } @@ -1178,14 +1168,12 @@ transmit_for_response (void *cls, size_t size, void *buf) * is already pending */ int -GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection - *sock, - const struct GNUNET_MessageHeader - *hdr, - struct GNUNET_TIME_Relative timeout, - int auto_retry, - GNUNET_CLIENT_MessageHandler rn, - void *rn_cls) +GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *sock, + const struct GNUNET_MessageHeader *hdr, + struct GNUNET_TIME_Relative timeout, + int auto_retry, + GNUNET_CLIENT_MessageHandler rn, + void *rn_cls) { struct TransmitGetResponseContext *tc; uint16_t msize; @@ -1203,12 +1191,12 @@ GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection tc->rn_cls = rn_cls; if (NULL == GNUNET_CLIENT_notify_transmit_ready (sock, msize, timeout, auto_retry, - &transmit_for_response, tc)) - { - GNUNET_break (0); - GNUNET_free (tc); - return GNUNET_SYSERR; - } + &transmit_for_response, tc)) + { + GNUNET_break (0); + GNUNET_free (tc); + return GNUNET_SYSERR; + } sock->tag = tc; return GNUNET_OK; } -- cgit v1.2.3