From 31aee41701fa2cd92ec566bd459e3425ee1f0b7d Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sat, 28 Sep 2019 00:56:33 +0200 Subject: handle arm -s completion nicely via signaling pipe --- src/arm/arm_api.c | 107 +- src/arm/gnunet-service-arm.c | 2320 +++++++++++++++++++++--------------------- 2 files changed, 1254 insertions(+), 1173 deletions(-) (limited to 'src/arm') diff --git a/src/arm/arm_api.c b/src/arm/arm_api.c index dc5c9c25b..da7268f67 100644 --- a/src/arm/arm_api.c +++ b/src/arm/arm_api.c @@ -84,6 +84,11 @@ struct GNUNET_ARM_Operation */ enum GNUNET_ARM_Result starting_ret; + /** + * File descriptor to close on operation stop, if not NULL. + */ + struct GNUNET_DISK_FileHandle *rfd; + /** * Is this an operation to stop the ARM service? */ @@ -203,19 +208,27 @@ reconnect_arm_later (struct GNUNET_ARM_Handle *h) h->currently_up = GNUNET_NO; GNUNET_assert (NULL == h->reconnect_task); h->reconnect_task = - GNUNET_SCHEDULER_add_delayed (h->retry_backoff, &reconnect_arm_task, h); + GNUNET_SCHEDULER_add_delayed (h->retry_backoff, + &reconnect_arm_task, + h); while (NULL != (op = h->operation_pending_head)) { if (NULL != op->result_cont) - op->result_cont (op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0); + op->result_cont (op->cont_cls, + GNUNET_ARM_REQUEST_DISCONNECTED, + 0); if (NULL != op->list_cont) - op->list_cont (op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0, NULL); + op->list_cont (op->cont_cls, + GNUNET_ARM_REQUEST_DISCONNECTED, + 0, + NULL); GNUNET_ARM_operation_cancel (op); } GNUNET_assert (NULL == h->operation_pending_head); h->retry_backoff = GNUNET_TIME_STD_BACKOFF (h->retry_backoff); if (NULL != h->conn_status) - h->conn_status (h->conn_status_cls, GNUNET_NO); + h->conn_status (h->conn_status_cls, + GNUNET_NO); } @@ -257,7 +270,8 @@ handle_arm_result (void *cls, void *result_cont_cls; id = GNUNET_ntohll (res->arm_msg.request_id); - op = find_op_by_id (h, id); + op = find_op_by_id (h, + id); if (NULL == op) { LOG (GNUNET_ERROR_TYPE_DEBUG, @@ -356,7 +370,9 @@ check_arm_list_result (void *cls, { uint16_t name_index = ntohs (ssm->name_index); uint16_t binary_index = ntohs (ssm->binary_index); - if (NULL == pool_get (pool_start, pool_size, name_index)) + if (NULL == pool_get (pool_start, + pool_size, + name_index)) { GNUNET_break_op (0); return GNUNET_NO; @@ -418,9 +434,11 @@ handle_arm_list_result (void *cls, const char *name; const char *binary; - GNUNET_assert (NULL != (name = pool_get (pool_start, pool_size, + GNUNET_assert (NULL != (name = pool_get (pool_start, + pool_size, name_index))); - GNUNET_assert (NULL != (binary = pool_get (pool_start, pool_size, + GNUNET_assert (NULL != (binary = pool_get (pool_start, + pool_size, binary_index))); list[i] = (struct GNUNET_ARM_ServiceInfo) { .name = name, @@ -630,11 +648,13 @@ GNUNET_ARM_disconnect (struct GNUNET_ARM_Handle *h) * * @param h the handle with configuration details * @param std_inheritance inheritance of std streams + * @param sigfd socket to pass to ARM for signalling * @return operation status code */ static enum GNUNET_ARM_Result start_arm_service (struct GNUNET_ARM_Handle *h, - enum GNUNET_OS_InheritStdioFlags std_inheritance) + enum GNUNET_OS_InheritStdioFlags std_inheritance, + struct GNUNET_DISK_FileHandle *sigfd) { struct GNUNET_OS_Process *proc; char *cbinary; @@ -643,7 +663,19 @@ start_arm_service (struct GNUNET_ARM_Handle *h, char *config; char *loprefix; char *lopostfix; + SOCKTYPE ld[2]; + SOCKTYPE *lsocks; + if (NULL == sigfd) + { + lsocks = NULL; + } + else + { + ld[0] = sigfd->fd; + ld[1] = -1; + lsocks = ld; + } if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (h->cfg, "arm", "PREFIX", @@ -700,7 +732,7 @@ start_arm_service (struct GNUNET_ARM_Handle *h, if (NULL == config) proc = GNUNET_OS_start_process_s (GNUNET_NO, std_inheritance, - NULL, + lsocks, loprefix, quotedbinary, /* no daemonization! */ @@ -709,7 +741,7 @@ start_arm_service (struct GNUNET_ARM_Handle *h, else proc = GNUNET_OS_start_process_s (GNUNET_NO, std_inheritance, - NULL, + lsocks, loprefix, quotedbinary, "-c", @@ -723,7 +755,7 @@ start_arm_service (struct GNUNET_ARM_Handle *h, if (NULL == config) proc = GNUNET_OS_start_process_s (GNUNET_NO, std_inheritance, - NULL, + lsocks, loprefix, quotedbinary, "-d", /* do daemonize */ @@ -732,7 +764,7 @@ start_arm_service (struct GNUNET_ARM_Handle *h, else proc = GNUNET_OS_start_process_s (GNUNET_NO, std_inheritance, - NULL, + lsocks, loprefix, quotedbinary, "-c", @@ -764,6 +796,16 @@ GNUNET_ARM_operation_cancel (struct GNUNET_ARM_Operation *op) { struct GNUNET_ARM_Handle *h = op->h; + if (NULL != op->async) + { + GNUNET_SCHEDULER_cancel (op->async); + op->async = NULL; + } + if (NULL != op->rfd) + { + GNUNET_DISK_file_close (op->rfd); + op->rfd = NULL; + } if (h->thm == op) { op->result_cont = NULL; @@ -895,6 +937,8 @@ GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h, { struct GNUNET_ARM_Operation *op; enum GNUNET_ARM_Result ret; + struct GNUNET_DISK_PipeHandle *sig; + struct GNUNET_DISK_FileHandle *wsig; LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting service `%s'\n", @@ -933,8 +977,22 @@ GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h, are unlikely to hammer 'gnunet-arm -s' on a busy system, the above check should catch 99.99% of the cases where ARM is already running. */ - LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting ARM service\n"); - ret = start_arm_service (h, std_inheritance); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Starting ARM service\n"); + if (NULL == (sig = GNUNET_DISK_pipe (GNUNET_NO, + GNUNET_NO, + GNUNET_NO, + GNUNET_YES))) + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, + "pipe"); + } + wsig = GNUNET_DISK_pipe_detach_end (sig, + GNUNET_DISK_PIPE_END_WRITE); + ret = start_arm_service (h, + std_inheritance, + wsig); + GNUNET_DISK_file_close (wsig); if (GNUNET_ARM_RESULT_STARTING == ret) reconnect_arm (h); op = GNUNET_new (struct GNUNET_ARM_Operation); @@ -945,8 +1003,23 @@ GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h, h->operation_pending_tail, op); op->starting_ret = ret; - op->async = GNUNET_SCHEDULER_add_now (¬ify_starting, - op); + if (NULL != sig) + { + op->rfd = GNUNET_DISK_pipe_detach_end (sig, + GNUNET_DISK_PIPE_END_READ); + /* Wait at most a minute for gnunet-service-arm to be up, as beyond + that something clearly just went wrong */ + op->async = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_MINUTES, + op->rfd, + ¬ify_starting, + op); + } + else + { + op->async = GNUNET_SCHEDULER_add_now (¬ify_starting, + op); + } + GNUNET_DISK_pipe_close (sig); return op; } diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c index 65404bbed..d13be6eb1 100644 --- a/src/arm/gnunet-service-arm.c +++ b/src/arm/gnunet-service-arm.c @@ -29,10 +29,10 @@ #include "gnunet_protocols.h" #include "arm.h" -#define LOG(kind, ...) GNUNET_log_from(kind, "util", __VA_ARGS__) +#define LOG(kind, ...) GNUNET_log_from (kind, "util", __VA_ARGS__) #define LOG_STRERROR(kind, syscall) \ - GNUNET_log_from_strerror(kind, "util", syscall) + GNUNET_log_from_strerror (kind, "util", syscall) #if HAVE_WAIT4 @@ -65,7 +65,8 @@ struct ServiceList; /** * Record with information about a listen socket we have open. */ -struct ServiceListeningInfo { +struct ServiceListeningInfo +{ /** * This is a linked list. */ @@ -106,7 +107,8 @@ struct ServiceListeningInfo { /** * List of our services. */ -struct ServiceList { +struct ServiceList +{ /** * This is a doubly-linked list. */ @@ -288,30 +290,30 @@ static struct GNUNET_NotificationContext *notifier; * parameter is ignore on systems other than LINUX */ static void -add_unixpath(struct sockaddr **saddrs, - socklen_t *saddrlens, - const char *unixpath, - int abstract) +add_unixpath (struct sockaddr **saddrs, + socklen_t *saddrlens, + const char *unixpath, + int abstract) { #ifdef AF_UNIX struct sockaddr_un *un; - un = GNUNET_new(struct sockaddr_un); + un = GNUNET_new (struct sockaddr_un); un->sun_family = AF_UNIX; - GNUNET_strlcpy(un->sun_path, unixpath, sizeof(un->sun_path)); + GNUNET_strlcpy (un->sun_path, unixpath, sizeof(un->sun_path)); #ifdef LINUX if (GNUNET_YES == abstract) un->sun_path[0] = '\0'; #endif #if HAVE_SOCKADDR_UN_SUN_LEN - un->sun_len = (u_char)sizeof(struct sockaddr_un); + un->sun_len = (u_char) sizeof(struct sockaddr_un); #endif - *saddrs = (struct sockaddr *)un; + *saddrs = (struct sockaddr *) un; *saddrlens = sizeof(struct sockaddr_un); #else /* this function should never be called * unless AF_UNIX is defined! */ - GNUNET_assert(0); + GNUNET_assert (0); #endif } @@ -337,10 +339,10 @@ add_unixpath(struct sockaddr **saddrs, * set to NULL). */ static int -get_server_addresses(const char *service_name, - const struct GNUNET_CONFIGURATION_Handle *cfg, - struct sockaddr ***addrs, - socklen_t **addr_lens) +get_server_addresses (const char *service_name, + const struct GNUNET_CONFIGURATION_Handle *cfg, + struct sockaddr ***addrs, + socklen_t **addr_lens) { int disablev6; struct GNUNET_NETWORK_Handle *desc; @@ -361,72 +363,72 @@ get_server_addresses(const char *service_name, *addrs = NULL; *addr_lens = NULL; desc = NULL; - if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "DISABLEV6")) - { - if (GNUNET_SYSERR == - (disablev6 = GNUNET_CONFIGURATION_get_value_yesno(cfg, - service_name, - "DISABLEV6"))) - return GNUNET_SYSERR; - } + if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "DISABLEV6")) + { + if (GNUNET_SYSERR == + (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (cfg, + service_name, + "DISABLEV6"))) + return GNUNET_SYSERR; + } else disablev6 = GNUNET_NO; - if (!disablev6) + if (! disablev6) + { + /* probe IPv6 support */ + desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0); + if (NULL == desc) { - /* probe IPv6 support */ - desc = GNUNET_NETWORK_socket_create(PF_INET6, SOCK_STREAM, 0); - if (NULL == desc) - { - if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || - (EACCES == errno)) - { - LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket"); - return GNUNET_SYSERR; - } - LOG(GNUNET_ERROR_TYPE_INFO, - _( - "Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"), - service_name, - strerror(errno)); - disablev6 = GNUNET_YES; - } - else - { - GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc)); - desc = NULL; - } + if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || + (EACCES == errno)) + { + LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket"); + return GNUNET_SYSERR; + } + LOG (GNUNET_ERROR_TYPE_INFO, + _ ( + "Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"), + service_name, + strerror (errno)); + disablev6 = GNUNET_YES; + } + else + { + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); + desc = NULL; } + } port = 0; - if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "PORT")) + if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT")) + { + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, + service_name, + "PORT", + &port)) { - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, - service_name, - "PORT", - &port)) - { - LOG(GNUNET_ERROR_TYPE_ERROR, - _("Require valid port number for service `%s' in configuration!\n"), - service_name); - } - if (port > 65535) - { - LOG(GNUNET_ERROR_TYPE_ERROR, - _("Require valid port number for service `%s' in configuration!\n"), - service_name); - return GNUNET_SYSERR; - } + LOG (GNUNET_ERROR_TYPE_ERROR, + _ ("Require valid port number for service `%s' in configuration!\n"), + service_name); } - - if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "BINDTO")) + if (port > 65535) { - GNUNET_break(GNUNET_OK == - GNUNET_CONFIGURATION_get_value_string(cfg, + LOG (GNUNET_ERROR_TYPE_ERROR, + _ ("Require valid port number for service `%s' in configuration!\n"), + service_name); + return GNUNET_SYSERR; + } + } + + if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO")) + { + GNUNET_break (GNUNET_OK == + GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "BINDTO", &hostname)); - } + } else hostname = NULL; @@ -434,235 +436,235 @@ get_server_addresses(const char *service_name, abstract = GNUNET_NO; #ifdef AF_UNIX if ((GNUNET_YES == - GNUNET_CONFIGURATION_have_value(cfg, service_name, "UNIXPATH")) && - (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg, - service_name, - "UNIXPATH", - &unixpath)) && - (0 < strlen(unixpath))) - { - /* probe UNIX support */ - struct sockaddr_un s_un; + GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) && + (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, + service_name, + "UNIXPATH", + &unixpath)) && + (0 < strlen (unixpath))) + { + /* probe UNIX support */ + struct sockaddr_un s_un; - 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 (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); + } #ifdef LINUX - abstract = GNUNET_CONFIGURATION_get_value_yesno(cfg, - "TESTING", - "USE_ABSTRACT_SOCKETS"); - if (GNUNET_SYSERR == abstract) - abstract = GNUNET_NO; + abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg, + "TESTING", + "USE_ABSTRACT_SOCKETS"); + if (GNUNET_SYSERR == abstract) + abstract = GNUNET_NO; #endif - if ((GNUNET_YES != abstract) && - (GNUNET_OK != GNUNET_DISK_directory_create_for_file(unixpath))) - GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath); - } + if ((GNUNET_YES != abstract) && + (GNUNET_OK != GNUNET_DISK_directory_create_for_file (unixpath))) + GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath); + } if (NULL != unixpath) + { + desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0); + if (NULL == desc) { - desc = GNUNET_NETWORK_socket_create(AF_UNIX, SOCK_STREAM, 0); - if (NULL == desc) - { - if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || - (EACCES == errno)) - { - LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket"); - GNUNET_free_non_null(hostname); - GNUNET_free(unixpath); - return GNUNET_SYSERR; - } - LOG(GNUNET_ERROR_TYPE_INFO, - _( - "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"), - service_name, - strerror(errno)); - GNUNET_free(unixpath); - unixpath = NULL; - } - else - { - GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc)); - desc = NULL; - } + if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || + (EACCES == errno)) + { + LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket"); + GNUNET_free_non_null (hostname); + GNUNET_free (unixpath); + return GNUNET_SYSERR; + } + LOG (GNUNET_ERROR_TYPE_INFO, + _ ( + "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"), + service_name, + strerror (errno)); + GNUNET_free (unixpath); + unixpath = NULL; + } + else + { + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); + desc = NULL; } + } #endif if ((0 == port) && (NULL == unixpath)) + { + if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg, + service_name, + "START_ON_DEMAND")) + LOG (GNUNET_ERROR_TYPE_ERROR, + _ ( + "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"), + service_name); + GNUNET_free_non_null (hostname); + return GNUNET_SYSERR; + } + if (0 == port) + { + saddrs = GNUNET_new_array (2, struct sockaddr *); + saddrlens = GNUNET_new_array (2, socklen_t); + add_unixpath (saddrs, saddrlens, unixpath, abstract); + GNUNET_free_non_null (unixpath); + GNUNET_free_non_null (hostname); + *addrs = saddrs; + *addr_lens = saddrlens; + return 1; + } + + if (NULL != hostname) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Resolving `%s' since that is where `%s' will bind to.\n", + hostname, + service_name); + memset (&hints, 0, sizeof(struct addrinfo)); + if (disablev6) + hints.ai_family = AF_INET; + hints.ai_protocol = IPPROTO_TCP; + if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) || + (NULL == res)) { - if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, - service_name, - "START_ON_DEMAND")) - LOG(GNUNET_ERROR_TYPE_ERROR, - _( - "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"), - service_name); - GNUNET_free_non_null(hostname); + LOG (GNUNET_ERROR_TYPE_ERROR, + _ ("Failed to resolve `%s': %s\n"), + hostname, + gai_strerror (ret)); + GNUNET_free (hostname); + GNUNET_free_non_null (unixpath); return GNUNET_SYSERR; } - if (0 == port) + next = res; + i = 0; + while (NULL != (pos = next)) { - saddrs = GNUNET_new_array(2, struct sockaddr *); - saddrlens = GNUNET_new_array(2, socklen_t); - add_unixpath(saddrs, saddrlens, unixpath, abstract); - GNUNET_free_non_null(unixpath); - GNUNET_free_non_null(hostname); - *addrs = saddrs; - *addr_lens = saddrlens; - return 1; + next = pos->ai_next; + if ((disablev6) && (pos->ai_family == AF_INET6)) + continue; + i++; } - - if (NULL != hostname) + if (0 == i) { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Resolving `%s' since that is where `%s' will bind to.\n", - hostname, - service_name); - memset(&hints, 0, sizeof(struct addrinfo)); - if (disablev6) - hints.ai_family = AF_INET; - hints.ai_protocol = IPPROTO_TCP; - if ((0 != (ret = getaddrinfo(hostname, NULL, &hints, &res))) || - (NULL == res)) - { - LOG(GNUNET_ERROR_TYPE_ERROR, - _("Failed to resolve `%s': %s\n"), - hostname, - gai_strerror(ret)); - GNUNET_free(hostname); - GNUNET_free_non_null(unixpath); - return GNUNET_SYSERR; - } - next = res; - i = 0; - while (NULL != (pos = next)) - { - next = pos->ai_next; - if ((disablev6) && (pos->ai_family == AF_INET6)) - continue; - i++; - } - if (0 == i) - { - LOG(GNUNET_ERROR_TYPE_ERROR, - _("Failed to find %saddress for `%s'.\n"), - disablev6 ? "IPv4 " : "", - hostname); - freeaddrinfo(res); - GNUNET_free(hostname); - GNUNET_free_non_null(unixpath); - return GNUNET_SYSERR; - } - resi = i; + LOG (GNUNET_ERROR_TYPE_ERROR, + _ ("Failed to find %saddress for `%s'.\n"), + disablev6 ? "IPv4 " : "", + hostname); + freeaddrinfo (res); + GNUNET_free (hostname); + GNUNET_free_non_null (unixpath); + return GNUNET_SYSERR; + } + resi = i; + if (NULL != unixpath) + resi++; + saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); + saddrlens = GNUNET_new_array (resi + 1, socklen_t); + i = 0; + if (NULL != unixpath) + { + add_unixpath (saddrs, saddrlens, unixpath, abstract); + i++; + } + next = res; + while (NULL != (pos = next)) + { + next = pos->ai_next; + if ((disablev6) && (AF_INET6 == pos->ai_family)) + continue; + if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol)) + continue; /* not TCP */ + if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype)) + continue; /* huh? */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Service `%s' will bind to `%s'\n", + service_name, + GNUNET_a2s (pos->ai_addr, pos->ai_addrlen)); + if (AF_INET == pos->ai_family) + { + GNUNET_assert (sizeof(struct sockaddr_in) == pos->ai_addrlen); + saddrlens[i] = pos->ai_addrlen; + saddrs[i] = GNUNET_malloc (saddrlens[i]); + GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); + ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); + } + else + { + GNUNET_assert (AF_INET6 == pos->ai_family); + GNUNET_assert (sizeof(struct sockaddr_in6) == pos->ai_addrlen); + saddrlens[i] = pos->ai_addrlen; + saddrs[i] = GNUNET_malloc (saddrlens[i]); + GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); + ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); + } + i++; + } + GNUNET_free (hostname); + freeaddrinfo (res); + resi = i; + } + else + { + /* will bind against everything, just set port */ + if (disablev6) + { + /* V4-only */ + resi = 1; if (NULL != unixpath) resi++; - saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); - saddrlens = GNUNET_new_array(resi + 1, socklen_t); i = 0; + saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); + saddrlens = GNUNET_new_array (resi + 1, socklen_t); if (NULL != unixpath) - { - add_unixpath(saddrs, saddrlens, unixpath, abstract); - i++; - } - next = res; - while (NULL != (pos = next)) - { - next = pos->ai_next; - if ((disablev6) && (AF_INET6 == pos->ai_family)) - continue; - if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol)) - continue; /* not TCP */ - if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype)) - continue; /* huh? */ - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Service `%s' will bind to `%s'\n", - service_name, - GNUNET_a2s(pos->ai_addr, pos->ai_addrlen)); - if (AF_INET == pos->ai_family) - { - GNUNET_assert(sizeof(struct sockaddr_in) == pos->ai_addrlen); - saddrlens[i] = pos->ai_addrlen; - saddrs[i] = GNUNET_malloc(saddrlens[i]); - GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]); - ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); - } - else - { - GNUNET_assert(AF_INET6 == pos->ai_family); - GNUNET_assert(sizeof(struct sockaddr_in6) == pos->ai_addrlen); - saddrlens[i] = pos->ai_addrlen; - saddrs[i] = GNUNET_malloc(saddrlens[i]); - GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]); - ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port); - } - i++; - } - GNUNET_free(hostname); - freeaddrinfo(res); - resi = i; - } - else - { - /* will bind against everything, just set port */ - if (disablev6) - { - /* V4-only */ - resi = 1; - if (NULL != unixpath) - resi++; - i = 0; - saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); - saddrlens = GNUNET_new_array(resi + 1, socklen_t); - if (NULL != unixpath) - { - add_unixpath(saddrs, saddrlens, unixpath, abstract); - i++; - } - saddrlens[i] = sizeof(struct sockaddr_in); - saddrs[i] = GNUNET_malloc(saddrlens[i]); + { + add_unixpath (saddrs, saddrlens, unixpath, abstract); + i++; + } + saddrlens[i] = sizeof(struct sockaddr_in); + saddrs[i] = GNUNET_malloc (saddrlens[i]); #if HAVE_SOCKADDR_IN_SIN_LEN - ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[i]; + ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i]; #endif - ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET; - ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); - } - else - { - /* dual stack */ - resi = 2; - if (NULL != unixpath) - resi++; - saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); - saddrlens = GNUNET_new_array(resi + 1, socklen_t); - i = 0; - if (NULL != unixpath) - { - add_unixpath(saddrs, saddrlens, unixpath, abstract); - i++; - } - saddrlens[i] = sizeof(struct sockaddr_in6); - saddrs[i] = GNUNET_malloc(saddrlens[i]); + ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; + ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); + } + else + { + /* dual stack */ + resi = 2; + if (NULL != unixpath) + resi++; + saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); + saddrlens = GNUNET_new_array (resi + 1, socklen_t); + i = 0; + if (NULL != unixpath) + { + add_unixpath (saddrs, saddrlens, unixpath, abstract); + i++; + } + saddrlens[i] = sizeof(struct sockaddr_in6); + saddrs[i] = GNUNET_malloc (saddrlens[i]); #if HAVE_SOCKADDR_IN_SIN_LEN - ((struct sockaddr_in6 *)saddrs[i])->sin6_len = saddrlens[0]; + ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0]; #endif - ((struct sockaddr_in6 *)saddrs[i])->sin6_family = AF_INET6; - ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port); - i++; - saddrlens[i] = sizeof(struct sockaddr_in); - saddrs[i] = GNUNET_malloc(saddrlens[i]); + ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6; + ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); + i++; + saddrlens[i] = sizeof(struct sockaddr_in); + saddrs[i] = GNUNET_malloc (saddrlens[i]); #if HAVE_SOCKADDR_IN_SIN_LEN - ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[1]; + ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1]; #endif - ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET; - ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); - } + ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; + ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); } - GNUNET_free_non_null(unixpath); + } + GNUNET_free_non_null (unixpath); *addrs = saddrs; *addr_lens = saddrlens; return resi; @@ -680,19 +682,19 @@ get_server_addresses(const char *service_name, * @return NULL if it was not found */ static void -signal_result(struct GNUNET_SERVICE_Client *client, - const char *name, - uint64_t request_id, - enum GNUNET_ARM_Result result) +signal_result (struct GNUNET_SERVICE_Client *client, + const char *name, + uint64_t request_id, + enum GNUNET_ARM_Result result) { struct GNUNET_MQ_Envelope *env; struct GNUNET_ARM_ResultMessage *msg; - (void)name; - env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_ARM_RESULT); - msg->result = htonl(result); - msg->arm_msg.request_id = GNUNET_htonll(request_id); - GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env); + (void) name; + env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_ARM_RESULT); + msg->result = htonl (result); + msg->arm_msg.request_id = GNUNET_htonll (request_id); + GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env); } @@ -705,34 +707,34 @@ signal_result(struct GNUNET_SERVICE_Client *client, * otherwise, send to all clients in the notifier */ static void -broadcast_status(const char *name, - enum GNUNET_ARM_ServiceMonitorStatus status, - struct GNUNET_SERVICE_Client *unicast) +broadcast_status (const char *name, + enum GNUNET_ARM_ServiceMonitorStatus status, + struct GNUNET_SERVICE_Client *unicast) { struct GNUNET_MQ_Envelope *env; struct GNUNET_ARM_StatusMessage *msg; size_t namelen; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Sending status %u of service `%s' to client\n", - (unsigned int)status, - name); - namelen = strlen(name) + 1; - env = GNUNET_MQ_msg_extra(msg, namelen, GNUNET_MESSAGE_TYPE_ARM_STATUS); - msg->status = htonl((uint32_t)(status)); - GNUNET_memcpy((char *)&msg[1], name, namelen); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending status %u of service `%s' to client\n", + (unsigned int) status, + name); + namelen = strlen (name) + 1; + env = GNUNET_MQ_msg_extra (msg, namelen, GNUNET_MESSAGE_TYPE_ARM_STATUS); + msg->status = htonl ((uint32_t) (status)); + GNUNET_memcpy ((char *) &msg[1], name, namelen); if (NULL == unicast) - { - if (NULL != notifier) - GNUNET_notification_context_broadcast(notifier, - &msg->header, - GNUNET_YES); - GNUNET_MQ_discard(env); - } + { + if (NULL != notifier) + GNUNET_notification_context_broadcast (notifier, + &msg->header, + GNUNET_YES); + GNUNET_MQ_discard (env); + } else - { - GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(unicast), env); - } + { + GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (unicast), env); + } } @@ -745,9 +747,9 @@ broadcast_status(const char *name, * being started. 0 if starting was not requested. */ static void -start_process(struct ServiceList *sl, - struct GNUNET_SERVICE_Client *client, - uint64_t request_id) +start_process (struct ServiceList *sl, + struct GNUNET_SERVICE_Client *client, + uint64_t request_id) { char *loprefix; char *options; @@ -763,192 +765,192 @@ start_process(struct ServiceList *sl, lsocks = NULL; ls = 0; for (sli = sl->listen_head; NULL != sli; sli = sli->next) + { + GNUNET_array_append (lsocks, + ls, + GNUNET_NETWORK_get_fd (sli->listen_socket)); + if (NULL != sli->accept_task) { - GNUNET_array_append(lsocks, - ls, - GNUNET_NETWORK_get_fd(sli->listen_socket)); - if (NULL != sli->accept_task) - { - GNUNET_SCHEDULER_cancel(sli->accept_task); - sli->accept_task = NULL; - } + GNUNET_SCHEDULER_cancel (sli->accept_task); + sli->accept_task = NULL; } + } - GNUNET_array_append(lsocks, ls, -1); + GNUNET_array_append (lsocks, ls, -1); /* obtain configuration */ - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, - sl->name, - "PREFIX", - &loprefix)) - loprefix = GNUNET_strdup(prefix_command); + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, + sl->name, + "PREFIX", + &loprefix)) + loprefix = GNUNET_strdup (prefix_command); else - loprefix = GNUNET_CONFIGURATION_expand_dollar(cfg, loprefix); - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, - sl->name, - "OPTIONS", - &options)) + loprefix = GNUNET_CONFIGURATION_expand_dollar (cfg, loprefix); + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, + sl->name, + "OPTIONS", + &options)) options = NULL; else - options = GNUNET_CONFIGURATION_expand_dollar(cfg, options); + options = GNUNET_CONFIGURATION_expand_dollar (cfg, options); { char *new_options; char *optpos; char *fin_options; - fin_options = GNUNET_strdup(final_option); + fin_options = GNUNET_strdup (final_option); /* replace '{}' with service name */ - while (NULL != (optpos = strstr(fin_options, "{}"))) - { - /* terminate string at opening parenthesis */ - *optpos = 0; - GNUNET_asprintf(&new_options, - "%s%s%s", - fin_options, - sl->name, - optpos + 2); - GNUNET_free(fin_options); - fin_options = new_options; - } + while (NULL != (optpos = strstr (fin_options, "{}"))) + { + /* terminate string at opening parenthesis */ + *optpos = 0; + GNUNET_asprintf (&new_options, + "%s%s%s", + fin_options, + sl->name, + optpos + 2); + GNUNET_free (fin_options); + fin_options = new_options; + } if (NULL != options) - { - /* combine "fin_options" with "options" */ - optpos = options; - GNUNET_asprintf(&options, "%s %s", fin_options, optpos); - GNUNET_free(fin_options); - GNUNET_free(optpos); - } + { + /* combine "fin_options" with "options" */ + optpos = options; + GNUNET_asprintf (&options, "%s %s", fin_options, optpos); + GNUNET_free (fin_options); + GNUNET_free (optpos); + } else - { - /* only have "fin_options", use that */ - options = fin_options; - } + { + /* only have "fin_options", use that */ + options = fin_options; + } } - options = GNUNET_CONFIGURATION_expand_dollar(cfg, options); - use_debug = GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "DEBUG"); + options = GNUNET_CONFIGURATION_expand_dollar (cfg, options); + use_debug = GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "DEBUG"); { const char *service_type = NULL; const char *choices[] = { "GNUNET", "SIMPLE", NULL }; is_simple_service = GNUNET_NO; - if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_choice(cfg, - sl->name, - "TYPE", - choices, - &service_type)) && - (0 == strcasecmp(service_type, "SIMPLE"))) + if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_choice (cfg, + sl->name, + "TYPE", + choices, + &service_type)) && + (0 == strcasecmp (service_type, "SIMPLE"))) is_simple_service = GNUNET_YES; } - GNUNET_assert(NULL == sl->proc); + GNUNET_assert (NULL == sl->proc); if (GNUNET_YES == is_simple_service) + { + /* A simple service will receive no GNUnet specific + command line options. */ + binary = GNUNET_strdup (sl->binary); + binary = GNUNET_CONFIGURATION_expand_dollar (cfg, binary); + GNUNET_asprintf ("edbinary, "\"%s\"", sl->binary); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Starting simple service `%s' using binary `%s'\n", + sl->name, + sl->binary); + /* FIXME: dollar expansion should only be done outside + * of ''-quoted strings, escaping should be considered. */ + if (NULL != options) + options = GNUNET_CONFIGURATION_expand_dollar (cfg, options); + sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, + GNUNET_OS_INHERIT_STD_OUT_AND_ERR, + lsocks, + loprefix, + quotedbinary, + options, + NULL); + } + else + { + /* actually start process */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Starting service `%s' using binary `%s' and configuration `%s'\n", + sl->name, + sl->binary, + sl->config); + binary = GNUNET_OS_get_libexec_binary_path (sl->binary); + GNUNET_asprintf ("edbinary, "\"%s\"", binary); + + if (GNUNET_YES == use_debug) { - /* A simple service will receive no GNUnet specific - command line options. */ - binary = GNUNET_strdup(sl->binary); - binary = GNUNET_CONFIGURATION_expand_dollar(cfg, binary); - GNUNET_asprintf("edbinary, "\"%s\"", sl->binary); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Starting simple service `%s' using binary `%s'\n", - sl->name, - sl->binary); - /* FIXME: dollar expansion should only be done outside - * of ''-quoted strings, escaping should be considered. */ - if (NULL != options) - options = GNUNET_CONFIGURATION_expand_dollar(cfg, options); - sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, - GNUNET_OS_INHERIT_STD_OUT_AND_ERR, - lsocks, - loprefix, - quotedbinary, - options, - NULL); + if (NULL == sl->config) + sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, + GNUNET_OS_INHERIT_STD_OUT_AND_ERR, + lsocks, + loprefix, + quotedbinary, + "-L", + "DEBUG", + options, + NULL); + else + sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, + GNUNET_OS_INHERIT_STD_OUT_AND_ERR, + lsocks, + loprefix, + quotedbinary, + "-c", + sl->config, + "-L", + "DEBUG", + options, + NULL); } - else + else { - /* actually start process */ - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Starting service `%s' using binary `%s' and configuration `%s'\n", - sl->name, - sl->binary, - sl->config); - binary = GNUNET_OS_get_libexec_binary_path(sl->binary); - GNUNET_asprintf("edbinary, "\"%s\"", binary); - - if (GNUNET_YES == use_debug) - { - if (NULL == sl->config) - sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, - GNUNET_OS_INHERIT_STD_OUT_AND_ERR, - lsocks, - loprefix, - quotedbinary, - "-L", - "DEBUG", - options, - NULL); - else - sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, - GNUNET_OS_INHERIT_STD_OUT_AND_ERR, - lsocks, - loprefix, - quotedbinary, - "-c", - sl->config, - "-L", - "DEBUG", - options, - NULL); - } + if (NULL == sl->config) + sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, + GNUNET_OS_INHERIT_STD_OUT_AND_ERR, + lsocks, + loprefix, + quotedbinary, + options, + NULL); else - { - if (NULL == sl->config) - sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, - GNUNET_OS_INHERIT_STD_OUT_AND_ERR, - lsocks, - loprefix, - quotedbinary, - options, - NULL); - else - sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, - GNUNET_OS_INHERIT_STD_OUT_AND_ERR, - lsocks, - loprefix, - quotedbinary, - "-c", - sl->config, - options, - NULL); - } + sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, + GNUNET_OS_INHERIT_STD_OUT_AND_ERR, + lsocks, + loprefix, + quotedbinary, + "-c", + sl->config, + options, + NULL); } - GNUNET_free(binary); - GNUNET_free(quotedbinary); + } + GNUNET_free (binary); + GNUNET_free (quotedbinary); sl->last_started_at = GNUNET_TIME_absolute_get (); if (NULL == sl->proc) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("Failed to start service `%s'\n"), - sl->name); - if (client) - signal_result(client, - sl->name, - request_id, - GNUNET_ARM_RESULT_START_FAILED); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("Failed to start service `%s'\n"), + sl->name); + if (client) + signal_result (client, + sl->name, + request_id, + GNUNET_ARM_RESULT_START_FAILED); + } else - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Starting service `%s'\n"), - sl->name); - broadcast_status(sl->name, GNUNET_ARM_SERVICE_STARTING, NULL); - if (client) - signal_result(client, sl->name, request_id, GNUNET_ARM_RESULT_STARTING); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Starting service `%s'\n"), + sl->name); + broadcast_status (sl->name, GNUNET_ARM_SERVICE_STARTING, NULL); + if (client) + signal_result (client, sl->name, request_id, GNUNET_ARM_RESULT_STARTING); + } /* clean up */ - GNUNET_free(loprefix); - GNUNET_free(options); - GNUNET_array_grow(lsocks, ls, 0); + GNUNET_free (loprefix); + GNUNET_free (options); + GNUNET_array_grow (lsocks, ls, 0); } @@ -960,17 +962,17 @@ start_process(struct ServiceList *sl, * @return NULL if it was not found */ static struct ServiceList * -find_service(const char *name) +find_service (const char *name) { struct ServiceList *sl; sl = running_head; while (sl != NULL) - { - if (0 == strcasecmp(sl->name, name)) - return sl; - sl = sl->next; - } + { + if (0 == strcasecmp (sl->name, name)) + return sl; + sl = sl->next; + } return NULL; } @@ -982,14 +984,14 @@ find_service(const char *name) * @param cls callback data, `struct ServiceListeningInfo` describing a listen socket */ static void -accept_connection(void *cls) +accept_connection (void *cls) { struct ServiceListeningInfo *sli = cls; struct ServiceList *sl = sli->sl; sli->accept_task = NULL; - GNUNET_assert(GNUNET_NO == in_shutdown); - start_process(sl, NULL, 0); + GNUNET_assert (GNUNET_NO == in_shutdown); + start_process (sl, NULL, 0); } @@ -1002,9 +1004,9 @@ accept_connection(void *cls) * @param sl service entry for the service in question */ static void -create_listen_socket(struct sockaddr *sa, - socklen_t addr_len, - struct ServiceList *sl) +create_listen_socket (struct sockaddr *sa, + socklen_t addr_len, + struct ServiceList *sl) { static int on = 1; struct GNUNET_NETWORK_Handle *sock; @@ -1014,107 +1016,107 @@ create_listen_socket(struct sockaddr *sa, int match_gid; switch (sa->sa_family) - { - case AF_INET: - sock = GNUNET_NETWORK_socket_create(PF_INET, SOCK_STREAM, 0); - break; - - case AF_INET6: - sock = GNUNET_NETWORK_socket_create(PF_INET6, SOCK_STREAM, 0); - break; - - case AF_UNIX: - if (0 == strcmp(GNUNET_a2s(sa, addr_len), - "@")) /* Do not bind to blank UNIX path! */ - return; - sock = GNUNET_NETWORK_socket_create(PF_UNIX, SOCK_STREAM, 0); - break; - - default: - GNUNET_break(0); - sock = NULL; - errno = EAFNOSUPPORT; - break; - } - if (NULL == sock) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("Unable to create socket for service `%s': %s\n"), - sl->name, - strerror(errno)); - GNUNET_free(sa); + { + case AF_INET: + sock = GNUNET_NETWORK_socket_create (PF_INET, SOCK_STREAM, 0); + break; + + case AF_INET6: + sock = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0); + break; + + case AF_UNIX: + if (0 == strcmp (GNUNET_a2s (sa, addr_len), + "@")) /* Do not bind to blank UNIX path! */ return; - } - if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(sock, - SOL_SOCKET, - SO_REUSEADDR, - &on, - sizeof(on))) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, - "setsockopt"); + sock = GNUNET_NETWORK_socket_create (PF_UNIX, SOCK_STREAM, 0); + break; + + default: + GNUNET_break (0); + sock = NULL; + errno = EAFNOSUPPORT; + break; + } + if (NULL == sock) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("Unable to create socket for service `%s': %s\n"), + sl->name, + strerror (errno)); + GNUNET_free (sa); + return; + } + if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (sock, + SOL_SOCKET, + SO_REUSEADDR, + &on, + sizeof(on))) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "setsockopt"); #ifdef IPV6_V6ONLY if ((sa->sa_family == AF_INET6) && - (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(sock, - IPPROTO_IPV6, - IPV6_V6ONLY, - &on, - sizeof(on)))) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, - "setsockopt"); + (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (sock, + IPPROTO_IPV6, + IPV6_V6ONLY, + &on, + sizeof(on)))) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "setsockopt"); #endif if (AF_UNIX == sa->sa_family) - GNUNET_NETWORK_unix_precheck((struct sockaddr_un *)sa); + GNUNET_NETWORK_unix_precheck ((struct sockaddr_un *) sa); if (GNUNET_OK != - GNUNET_NETWORK_socket_bind(sock, (const struct sockaddr *)sa, addr_len)) - { - GNUNET_log( - GNUNET_ERROR_TYPE_WARNING, - _( - "Unable to bind listening socket for service `%s' to address `%s': %s\n"), - sl->name, - GNUNET_a2s(sa, addr_len), - strerror(errno)); - GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock)); - GNUNET_free(sa); - return; - } + GNUNET_NETWORK_socket_bind (sock, (const struct sockaddr *) sa, addr_len)) + { + GNUNET_log ( + GNUNET_ERROR_TYPE_WARNING, + _ ( + "Unable to bind listening socket for service `%s' to address `%s': %s\n"), + sl->name, + GNUNET_a2s (sa, addr_len), + strerror (errno)); + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock)); + GNUNET_free (sa); + return; + } if ((AF_UNIX == sa->sa_family) #ifdef LINUX /* Permission settings are not required when abstract sockets are used */ - && ('\0' != ((const struct sockaddr_un *)sa)->sun_path[0]) + && ('\0' != ((const struct sockaddr_un *) sa)->sun_path[0]) #endif ) - { - match_uid = - GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "UNIX_MATCH_UID"); - match_gid = - GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "UNIX_MATCH_GID"); - GNUNET_DISK_fix_permissions(((const struct sockaddr_un *)sa)->sun_path, - match_uid, - match_gid); - } - if (GNUNET_OK != GNUNET_NETWORK_socket_listen(sock, 5)) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "listen"); - GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock)); - GNUNET_free(sa); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("ARM now monitors connections to service `%s' at `%s'\n"), - sl->name, - GNUNET_a2s(sa, addr_len)); - sli = GNUNET_new(struct ServiceListeningInfo); + { + match_uid = + GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "UNIX_MATCH_UID"); + match_gid = + GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "UNIX_MATCH_GID"); + GNUNET_DISK_fix_permissions (((const struct sockaddr_un *) sa)->sun_path, + match_uid, + match_gid); + } + if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5)) + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen"); + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock)); + GNUNET_free (sa); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("ARM now monitors connections to service `%s' at `%s'\n"), + sl->name, + GNUNET_a2s (sa, addr_len)); + sli = GNUNET_new (struct ServiceListeningInfo); sli->service_addr = sa; sli->service_addr_len = addr_len; sli->listen_socket = sock; sli->sl = sl; sli->accept_task = - GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - sock, - &accept_connection, - sli); - GNUNET_CONTAINER_DLL_insert(sl->listen_head, sl->listen_tail, sli); + GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + sock, + &accept_connection, + sli); + GNUNET_CONTAINER_DLL_insert (sl->listen_head, sl->listen_tail, sli); } @@ -1125,15 +1127,15 @@ create_listen_socket(struct sockaddr *sa, * @param sl entry to free */ static void -free_service(struct ServiceList *sl) +free_service (struct ServiceList *sl) { - GNUNET_assert(GNUNET_YES == in_shutdown); - GNUNET_CONTAINER_DLL_remove(running_head, running_tail, sl); - GNUNET_assert(NULL == sl->listen_head); - GNUNET_free_non_null(sl->config); - GNUNET_free_non_null(sl->binary); - GNUNET_free(sl->name); - GNUNET_free(sl); + GNUNET_assert (GNUNET_YES == in_shutdown); + GNUNET_CONTAINER_DLL_remove (running_head, running_tail, sl); + GNUNET_assert (NULL == sl->listen_head); + GNUNET_free_non_null (sl->config); + GNUNET_free_non_null (sl->binary); + GNUNET_free (sl->name); + GNUNET_free (sl); } @@ -1146,10 +1148,10 @@ free_service(struct ServiceList *sl) * #GNUNET_SYSERR to close it (signal serious error) */ static int -check_start(void *cls, const struct GNUNET_ARM_Message *amsg) +check_start (void *cls, const struct GNUNET_ARM_Message *amsg) { - (void)cls; - GNUNET_MQ_check_zero_termination(amsg); + (void) cls; + GNUNET_MQ_check_zero_termination (amsg); return GNUNET_OK; } @@ -1161,43 +1163,43 @@ check_start(void *cls, const struct GNUNET_ARM_Message *amsg) * @param amsg the actual message */ static void -handle_start(void *cls, const struct GNUNET_ARM_Message *amsg) +handle_start (void *cls, const struct GNUNET_ARM_Message *amsg) { struct GNUNET_SERVICE_Client *client = cls; const char *servicename; struct ServiceList *sl; uint64_t request_id; - request_id = GNUNET_ntohll(amsg->request_id); - servicename = (const char *)&amsg[1]; - GNUNET_SERVICE_client_continue(client); + request_id = GNUNET_ntohll (amsg->request_id); + servicename = (const char *) &amsg[1]; + GNUNET_SERVICE_client_continue (client); if (GNUNET_YES == in_shutdown) - { - signal_result(client, - servicename, - request_id, - GNUNET_ARM_RESULT_IN_SHUTDOWN); - return; - } - sl = find_service(servicename); + { + signal_result (client, + servicename, + request_id, + GNUNET_ARM_RESULT_IN_SHUTDOWN); + return; + } + sl = find_service (servicename); if (NULL == sl) - { - signal_result(client, - servicename, - request_id, - GNUNET_ARM_RESULT_IS_NOT_KNOWN); - return; - } + { + signal_result (client, + servicename, + request_id, + GNUNET_ARM_RESULT_IS_NOT_KNOWN); + return; + } sl->force_start = GNUNET_YES; if (NULL != sl->proc) - { - signal_result(client, - servicename, - request_id, - GNUNET_ARM_RESULT_IS_STARTED_ALREADY); - return; - } - start_process(sl, client, request_id); + { + signal_result (client, + servicename, + request_id, + GNUNET_ARM_RESULT_IS_STARTED_ALREADY); + return; + } + start_process (sl, client, request_id); } @@ -1207,11 +1209,11 @@ handle_start(void *cls, const struct GNUNET_ARM_Message *amsg) * @param cls closure (refers to service) */ static void -trigger_shutdown(void *cls) +trigger_shutdown (void *cls) { - (void)cls; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Triggering shutdown\n"); - GNUNET_SCHEDULER_shutdown(); + (void) cls; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Triggering shutdown\n"); + GNUNET_SCHEDULER_shutdown (); } @@ -1224,10 +1226,10 @@ trigger_shutdown(void *cls) * #GNUNET_SYSERR to close it (signal serious error) */ static int -check_stop(void *cls, const struct GNUNET_ARM_Message *amsg) +check_stop (void *cls, const struct GNUNET_ARM_Message *amsg) { - (void)cls; - GNUNET_MQ_check_zero_termination(amsg); + (void) cls; + GNUNET_MQ_check_zero_termination (amsg); return GNUNET_OK; } @@ -1239,72 +1241,72 @@ check_stop(void *cls, const struct GNUNET_ARM_Message *amsg) * @param amsg the actual message */ static void -handle_stop(void *cls, const struct GNUNET_ARM_Message *amsg) +handle_stop (void *cls, const struct GNUNET_ARM_Message *amsg) { struct GNUNET_SERVICE_Client *client = cls; struct ServiceList *sl; const char *servicename; uint64_t request_id; - request_id = GNUNET_ntohll(amsg->request_id); - servicename = (const char *)&amsg[1]; - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Preparing to stop `%s'\n"), - servicename); - GNUNET_SERVICE_client_continue(client); - if (0 == strcasecmp(servicename, "arm")) - { - broadcast_status(servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); - signal_result(client, servicename, request_id, GNUNET_ARM_RESULT_STOPPING); - GNUNET_SERVICE_client_persist(client); - GNUNET_SCHEDULER_add_now(&trigger_shutdown, NULL); - return; - } - sl = find_service(servicename); + request_id = GNUNET_ntohll (amsg->request_id); + servicename = (const char *) &amsg[1]; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Preparing to stop `%s'\n"), + servicename); + GNUNET_SERVICE_client_continue (client); + if (0 == strcasecmp (servicename, "arm")) + { + broadcast_status (servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); + signal_result (client, servicename, request_id, GNUNET_ARM_RESULT_STOPPING); + GNUNET_SERVICE_client_persist (client); + GNUNET_SCHEDULER_add_now (&trigger_shutdown, NULL); + return; + } + sl = find_service (servicename); if (NULL == sl) - { - signal_result(client, - servicename, - request_id, - GNUNET_ARM_RESULT_IS_NOT_KNOWN); - return; - } + { + signal_result (client, + servicename, + request_id, + GNUNET_ARM_RESULT_IS_NOT_KNOWN); + return; + } sl->force_start = GNUNET_NO; if (GNUNET_YES == in_shutdown) - { - /* shutdown in progress */ - signal_result(client, - servicename, - request_id, - GNUNET_ARM_RESULT_IN_SHUTDOWN); - return; - } + { + /* shutdown in progress */ + signal_result (client, + servicename, + request_id, + GNUNET_ARM_RESULT_IN_SHUTDOWN); + return; + } if (NULL != sl->killing_client) - { - /* killing already in progress */ - signal_result(client, - servicename, - request_id, - GNUNET_ARM_RESULT_IS_STOPPING_ALREADY); - return; - } + { + /* killing already in progress */ + signal_result (client, + servicename, + request_id, + GNUNET_ARM_RESULT_IS_STOPPING_ALREADY); + return; + } if (NULL == sl->proc) - { - /* process is down */ - signal_result(client, - servicename, - request_id, - GNUNET_ARM_RESULT_IS_STOPPED_ALREADY); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Sending kill signal to service `%s', waiting for process to die.\n", - servicename); - broadcast_status(servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); + { + /* process is down */ + signal_result (client, + servicename, + request_id, + GNUNET_ARM_RESULT_IS_STOPPED_ALREADY); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending kill signal to service `%s', waiting for process to die.\n", + servicename); + broadcast_status (servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); /* no signal_start - only when it's STOPPED */ - sl->killed_at = GNUNET_TIME_absolute_get(); - if (0 != GNUNET_OS_process_kill(sl->proc, GNUNET_TERM_SIG)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); + sl->killed_at = GNUNET_TIME_absolute_get (); + if (0 != GNUNET_OS_process_kill (sl->proc, GNUNET_TERM_SIG)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); sl->killing_client = client; sl->killing_client_request_id = request_id; } @@ -1322,7 +1324,7 @@ handle_stop(void *cls, const struct GNUNET_ARM_Message *amsg) * GNUNET_SYSERR otherwise */ static int -pool_write(char *pool_start, size_t pool_size, size_t *pool_pos, char *str) +pool_write (char *pool_start, size_t pool_size, size_t *pool_pos, char *str) { size_t next_pos = (*pool_pos) + strlen (str) + 1; @@ -1340,7 +1342,7 @@ pool_write(char *pool_start, size_t pool_size, size_t *pool_pos, char *str) * @param message the actual message */ static void -handle_list(void *cls, const struct GNUNET_ARM_Message *request) +handle_list (void *cls, const struct GNUNET_ARM_Message *request) { struct GNUNET_SERVICE_Client *client = cls; struct GNUNET_MQ_Envelope *env; @@ -1353,67 +1355,70 @@ handle_list(void *cls, const struct GNUNET_ARM_Message *request) char *pool_start; struct GNUNET_ARM_ServiceInfoMessage *ssm; - GNUNET_break_op(0 == ntohl(request->reserved)); + GNUNET_break_op (0 == ntohl (request->reserved)); count = 0; pool_size = 0; /* Do one pass over the list to compute the number of services * and the string pool size */ for (sl = running_head; NULL != sl; sl = sl->next) - { - pool_size += strlen(sl->name) + 1; - pool_size += strlen(sl->binary) + 1; - count++; - } + { + pool_size += strlen (sl->name) + 1; + pool_size += strlen (sl->binary) + 1; + count++; + } - extra_size = pool_size + (count * sizeof (struct GNUNET_ARM_ServiceInfoMessage)); - env = GNUNET_MQ_msg_extra(msg, - extra_size, - GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT); + extra_size = pool_size + (count * sizeof (struct + GNUNET_ARM_ServiceInfoMessage)); + env = GNUNET_MQ_msg_extra (msg, + extra_size, + GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT); msg->arm_msg.request_id = request->request_id; - msg->count = htons(count); + msg->count = htons (count); ssm = (struct GNUNET_ARM_ServiceInfoMessage *) &msg[1]; pool_start = (char *) (ssm + count); pool_pos = 0; for (sl = running_head; NULL != sl; sl = sl->next) + { + ssm->name_index = htons ((uint16_t) pool_pos); + GNUNET_assert (GNUNET_OK == pool_write (pool_start, pool_size, &pool_pos, + sl->name)); + ssm->binary_index = htons ((uint16_t) pool_pos); + GNUNET_assert (GNUNET_OK == pool_write (pool_start, pool_size, &pool_pos, + sl->binary)); + if (NULL == sl->proc) { - ssm->name_index = htons ((uint16_t) pool_pos); - GNUNET_assert (GNUNET_OK == pool_write (pool_start, pool_size, &pool_pos, sl->name)); - ssm->binary_index = htons ((uint16_t) pool_pos); - GNUNET_assert (GNUNET_OK == pool_write (pool_start, pool_size, &pool_pos, sl->binary)); - if (NULL == sl->proc) + if (0 == sl->last_started_at.abs_value_us) { - if (0 == sl->last_started_at.abs_value_us) - { - /* Process never started */ - ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STOPPED); - } - else if (0 == sl->last_exit_status) - { - ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_FINISHED); - } - else - { - ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_FAILED); - ssm->last_exit_status = htons (sl->last_exit_status); - } + /* Process never started */ + ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STOPPED); } - else if ((NULL != sl->killing_client) || (GNUNET_YES == in_shutdown)) + else if (0 == sl->last_exit_status) { - ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STOPPING); + ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_FINISHED); } else { - ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STARTED); + ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_FAILED); + ssm->last_exit_status = htons (sl->last_exit_status); } - ssm->last_started_at = GNUNET_TIME_absolute_hton (sl->last_started_at); - ssm->restart_at = GNUNET_TIME_absolute_hton (sl->restart_at); - ssm++; } - GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env); - GNUNET_SERVICE_client_continue(client); + else if ((NULL != sl->killing_client) || (GNUNET_YES == in_shutdown)) + { + ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STOPPING); + } + else + { + ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STARTED); + } + ssm->last_started_at = GNUNET_TIME_absolute_hton (sl->last_started_at); + ssm->restart_at = GNUNET_TIME_absolute_hton (sl->restart_at); + ssm++; + } + GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env); + GNUNET_SERVICE_client_continue (client); } @@ -1424,16 +1429,16 @@ handle_list(void *cls, const struct GNUNET_ARM_Message *request) * @param message the actual message */ static void -handle_test(void *cls, const struct GNUNET_MessageHeader *message) +handle_test (void *cls, const struct GNUNET_MessageHeader *message) { struct GNUNET_SERVICE_Client *client = cls; struct GNUNET_MQ_Envelope *env; struct GNUNET_MessageHeader *msg; - (void)message; - env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_ARM_TEST); - GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env); - GNUNET_SERVICE_client_continue(client); + (void) message; + env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_ARM_TEST); + GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env); + GNUNET_SERVICE_client_continue (client); } @@ -1442,24 +1447,24 @@ handle_test(void *cls, const struct GNUNET_MessageHeader *message) * tasks, signal handler and the server. */ static void -do_shutdown() +do_shutdown () { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Last shutdown phase\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Last shutdown phase\n"); if (NULL != notifier) - { - GNUNET_notification_context_destroy(notifier); - notifier = NULL; - } + { + GNUNET_notification_context_destroy (notifier); + notifier = NULL; + } if (NULL != service) - { - GNUNET_SERVICE_shutdown(service); - service = NULL; - } + { + GNUNET_SERVICE_shutdown (service); + service = NULL; + } if (NULL != child_death_task) - { - GNUNET_SCHEDULER_cancel(child_death_task); - child_death_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (child_death_task); + child_death_task = NULL; + } } @@ -1470,13 +1475,13 @@ do_shutdown() * @return number of active services found */ static unsigned int -list_count(struct ServiceList *running_head) +list_count (struct ServiceList *running_head) { struct ServiceList *i; unsigned int res; for (res = 0, i = running_head; NULL != i; i = i->next, res++) - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s\n", i->name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s\n", i->name); return res; } @@ -1487,61 +1492,61 @@ list_count(struct ServiceList *running_head) * @param cls closure, NULL if we need to self-restart */ static void -shutdown_task(void *cls) +shutdown_task (void *cls) { struct ServiceList *pos; struct ServiceList *nxt; struct ServiceListeningInfo *sli; - (void)cls; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "First shutdown phase\n"); + (void) cls; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "First shutdown phase\n"); if (NULL != child_restart_task) - { - GNUNET_SCHEDULER_cancel(child_restart_task); - child_restart_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (child_restart_task); + child_restart_task = NULL; + } in_shutdown = GNUNET_YES; /* first, stop listening */ for (pos = running_head; NULL != pos; pos = pos->next) + { + while (NULL != (sli = pos->listen_head)) { - while (NULL != (sli = pos->listen_head)) - { - GNUNET_CONTAINER_DLL_remove(pos->listen_head, pos->listen_tail, sli); - if (NULL != sli->accept_task) - { - GNUNET_SCHEDULER_cancel(sli->accept_task); - sli->accept_task = NULL; - } - GNUNET_break(GNUNET_OK == - GNUNET_NETWORK_socket_close(sli->listen_socket)); - GNUNET_free(sli->service_addr); - GNUNET_free(sli); - } + GNUNET_CONTAINER_DLL_remove (pos->listen_head, pos->listen_tail, sli); + if (NULL != sli->accept_task) + { + GNUNET_SCHEDULER_cancel (sli->accept_task); + sli->accept_task = NULL; + } + GNUNET_break (GNUNET_OK == + GNUNET_NETWORK_socket_close (sli->listen_socket)); + GNUNET_free (sli->service_addr); + GNUNET_free (sli); } + } /* then, shutdown all existing service processes */ nxt = running_head; while (NULL != (pos = nxt)) + { + nxt = pos->next; + if (NULL != pos->proc) { - nxt = pos->next; - if (NULL != pos->proc) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Stopping service `%s'\n", pos->name); - pos->killed_at = GNUNET_TIME_absolute_get(); - if (0 != GNUNET_OS_process_kill(pos->proc, GNUNET_TERM_SIG)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); - } - else - { - free_service(pos); - } + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping service `%s'\n", pos->name); + pos->killed_at = GNUNET_TIME_absolute_get (); + if (0 != GNUNET_OS_process_kill (pos->proc, GNUNET_TERM_SIG)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); + } + else + { + free_service (pos); } + } /* finally, should all service processes be already gone, terminate for real */ if (NULL == running_head) - do_shutdown(); + do_shutdown (); else - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Delaying shutdown, have %u childs still running\n", - list_count(running_head)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Delaying shutdown, have %u childs still running\n", + list_count (running_head)); } @@ -1551,73 +1556,73 @@ shutdown_task(void *cls) * @param cls closure, always NULL */ static void -delayed_restart_task(void *cls) +delayed_restart_task (void *cls) { struct ServiceList *sl; struct GNUNET_TIME_Relative lowestRestartDelay; struct ServiceListeningInfo *sli; - (void)cls; + (void) cls; child_restart_task = NULL; - GNUNET_assert(GNUNET_NO == in_shutdown); + GNUNET_assert (GNUNET_NO == in_shutdown); lowestRestartDelay = GNUNET_TIME_UNIT_FOREVER_REL; /* check for services that need to be restarted due to * configuration changes or because the last restart failed */ for (sl = running_head; NULL != sl; sl = sl->next) + { + if (NULL != sl->proc) + continue; + /* service is currently not running */ + if (0 == GNUNET_TIME_absolute_get_remaining (sl->restart_at).rel_value_us) { - if (NULL != sl->proc) - continue; - /* service is currently not running */ - if (0 == GNUNET_TIME_absolute_get_remaining(sl->restart_at).rel_value_us) - { - /* restart is now allowed */ - if (sl->force_start) - { - /* process should run by default, start immediately */ - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Restarting service `%s'.\n"), - sl->name); - start_process(sl, NULL, 0); - } - else - { - /* process is run on-demand, ensure it is re-started if there is demand */ - for (sli = sl->listen_head; NULL != sli; sli = sli->next) - if (NULL == sli->accept_task) - { - /* accept was actually paused, so start it again */ - sli->accept_task = - GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - sli->listen_socket, - &accept_connection, - sli); - } - } - } + /* restart is now allowed */ + if (sl->force_start) + { + /* process should run by default, start immediately */ + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Restarting service `%s'.\n"), + sl->name); + start_process (sl, NULL, 0); + } else - { - /* update calculation for earliest time to reactivate a service */ - lowestRestartDelay = - GNUNET_TIME_relative_min(lowestRestartDelay, - GNUNET_TIME_absolute_get_remaining( - sl->restart_at)); - } + { + /* process is run on-demand, ensure it is re-started if there is demand */ + for (sli = sl->listen_head; NULL != sli; sli = sli->next) + if (NULL == sli->accept_task) + { + /* accept was actually paused, so start it again */ + sli->accept_task = + GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + sli->listen_socket, + &accept_connection, + sli); + } + } } + else + { + /* update calculation for earliest time to reactivate a service */ + lowestRestartDelay = + GNUNET_TIME_relative_min (lowestRestartDelay, + GNUNET_TIME_absolute_get_remaining ( + sl->restart_at)); + } + } if (lowestRestartDelay.rel_value_us != GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Will restart process in %s\n", - GNUNET_STRINGS_relative_time_to_string(lowestRestartDelay, + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Will restart process in %s\n", + GNUNET_STRINGS_relative_time_to_string (lowestRestartDelay, GNUNET_YES)); - child_restart_task = - GNUNET_SCHEDULER_add_delayed_with_priority(lowestRestartDelay, - GNUNET_SCHEDULER_PRIORITY_IDLE, - &delayed_restart_task, - NULL); - } + child_restart_task = + GNUNET_SCHEDULER_add_delayed_with_priority (lowestRestartDelay, + GNUNET_SCHEDULER_PRIORITY_IDLE, + &delayed_restart_task, + NULL); + } } @@ -1628,7 +1633,7 @@ delayed_restart_task(void *cls) * @param cls closure, NULL */ static void -maint_child_death(void *cls) +maint_child_death (void *cls) { struct ServiceList *pos; struct ServiceList *next; @@ -1641,200 +1646,200 @@ maint_child_death(void *cls) unsigned long statusCode; const struct GNUNET_DISK_FileHandle *pr; - (void)cls; - pr = GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ); + (void) cls; + pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ); child_death_task = NULL; /* consume the signal */ - GNUNET_break(0 < GNUNET_DISK_file_read(pr, &c, sizeof(c))); + GNUNET_break (0 < GNUNET_DISK_file_read (pr, &c, sizeof(c))); /* check for services that died (WAITPID) */ next = running_head; while (NULL != (pos = next)) - { - next = pos->next; + { + next = pos->next; - if (NULL == pos->proc) - { - if (GNUNET_YES == in_shutdown) - free_service(pos); - continue; - } + if (NULL == pos->proc) + { + if (GNUNET_YES == in_shutdown) + free_service (pos); + continue; + } #if HAVE_WAIT4 - if (NULL != wait_file) - { - /* need to use 'wait4()' to obtain and log performance data */ - struct rusage ru; - int status; - pid_t pid; - - pid = GNUNET_OS_process_get_pid(pos->proc); - ret = wait4(pid, &status, WNOHANG, &ru); - if (ret <= 0) - continue; /* no process done */ - if (WIFEXITED(status)) - { - statusType = GNUNET_OS_PROCESS_EXITED; - statusCode = WEXITSTATUS(status); - } - else if (WIFSIGNALED(status)) - { - statusType = GNUNET_OS_PROCESS_SIGNALED; - statusCode = WTERMSIG(status); - } - else if (WIFSTOPPED(status)) - { - statusType = GNUNET_OS_PROCESS_SIGNALED; - statusCode = WSTOPSIG(status); - } + if (NULL != wait_file) + { + /* need to use 'wait4()' to obtain and log performance data */ + struct rusage ru; + int status; + pid_t pid; + + pid = GNUNET_OS_process_get_pid (pos->proc); + ret = wait4 (pid, &status, WNOHANG, &ru); + if (ret <= 0) + continue; /* no process done */ + if (WIFEXITED (status)) + { + statusType = GNUNET_OS_PROCESS_EXITED; + statusCode = WEXITSTATUS (status); + } + else if (WIFSIGNALED (status)) + { + statusType = GNUNET_OS_PROCESS_SIGNALED; + statusCode = WTERMSIG (status); + } + else if (WIFSTOPPED (status)) + { + statusType = GNUNET_OS_PROCESS_SIGNALED; + statusCode = WSTOPSIG (status); + } #ifdef WIFCONTINUED - else if (WIFCONTINUED(status)) - { - statusType = GNUNET_OS_PROCESS_RUNNING; - statusCode = 0; - } -#endif - else - { - statusType = GNUNET_OS_PROCESS_UNKNOWN; - statusCode = 0; - } - if ((GNUNET_OS_PROCESS_EXITED == statusType) || - (GNUNET_OS_PROCESS_SIGNALED == statusType)) - { - double utime = ru.ru_utime.tv_sec + (ru.ru_utime.tv_usec / 10e6); - double stime = ru.ru_stime.tv_sec + (ru.ru_stime.tv_usec / 10e6); - fprintf(wait_file, - "%s(%u) %.3f %.3f %llu %llu %llu %llu %llu\n", - pos->binary, - (unsigned int)pid, - utime, - stime, - (unsigned long long)ru.ru_maxrss, - (unsigned long long)ru.ru_inblock, - (unsigned long long)ru.ru_oublock, - (unsigned long long)ru.ru_nvcsw, - (unsigned long long)ru.ru_nivcsw); - } - } - else /* continue with JUST this "if" as "else" (intentionally no brackets!) */ + else if (WIFCONTINUED (status)) + { + statusType = GNUNET_OS_PROCESS_RUNNING; + statusCode = 0; + } #endif - if ((GNUNET_SYSERR == (ret = GNUNET_OS_process_status(pos->proc, - &statusType, - &statusCode))) || - (ret == GNUNET_NO) || (statusType == GNUNET_OS_PROCESS_STOPPED) || - (statusType == GNUNET_OS_PROCESS_UNKNOWN) || - (statusType == GNUNET_OS_PROCESS_RUNNING)) - continue; - - if (statusType == GNUNET_OS_PROCESS_EXITED) - { - statstr = _(/* process termination method */ "exit"); - statcode = statusCode; - } - else if (statusType == GNUNET_OS_PROCESS_SIGNALED) - { - statstr = _(/* process termination method */ "signal"); - statcode = statusCode; - } else - { - statstr = _(/* process termination method */ "unknown"); - statcode = 0; - } - if (0 != pos->killed_at.abs_value_us) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Service `%s' took %s to terminate\n"), + { + statusType = GNUNET_OS_PROCESS_UNKNOWN; + statusCode = 0; + } + if ((GNUNET_OS_PROCESS_EXITED == statusType) || + (GNUNET_OS_PROCESS_SIGNALED == statusType)) + { + double utime = ru.ru_utime.tv_sec + (ru.ru_utime.tv_usec / 10e6); + double stime = ru.ru_stime.tv_sec + (ru.ru_stime.tv_usec / 10e6); + fprintf (wait_file, + "%s(%u) %.3f %.3f %llu %llu %llu %llu %llu\n", + pos->binary, + (unsigned int) pid, + utime, + stime, + (unsigned long long) ru.ru_maxrss, + (unsigned long long) ru.ru_inblock, + (unsigned long long) ru.ru_oublock, + (unsigned long long) ru.ru_nvcsw, + (unsigned long long) ru.ru_nivcsw); + } + } + else /* continue with JUST this "if" as "else" (intentionally no brackets!) */ +#endif + if ((GNUNET_SYSERR == (ret = GNUNET_OS_process_status (pos->proc, + &statusType, + &statusCode))) || + (ret == GNUNET_NO) || (statusType == GNUNET_OS_PROCESS_STOPPED) || + (statusType == GNUNET_OS_PROCESS_UNKNOWN) || + (statusType == GNUNET_OS_PROCESS_RUNNING)) + continue; + + if (statusType == GNUNET_OS_PROCESS_EXITED) + { + statstr = _ (/* process termination method */ "exit"); + statcode = statusCode; + } + else if (statusType == GNUNET_OS_PROCESS_SIGNALED) + { + statstr = _ (/* process termination method */ "signal"); + statcode = statusCode; + } + else + { + statstr = _ (/* process termination method */ "unknown"); + statcode = 0; + } + if (0 != pos->killed_at.abs_value_us) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Service `%s' took %s to terminate\n"), + pos->name, + GNUNET_STRINGS_relative_time_to_string ( + GNUNET_TIME_absolute_get_duration (pos->killed_at), + GNUNET_YES)); + } + GNUNET_OS_process_destroy (pos->proc); + pos->proc = NULL; + broadcast_status (pos->name, GNUNET_ARM_SERVICE_STOPPED, NULL); + if (NULL != pos->killing_client) + { + signal_result (pos->killing_client, pos->name, - GNUNET_STRINGS_relative_time_to_string( - GNUNET_TIME_absolute_get_duration(pos->killed_at), - GNUNET_YES)); - } - GNUNET_OS_process_destroy(pos->proc); - pos->proc = NULL; - broadcast_status(pos->name, GNUNET_ARM_SERVICE_STOPPED, NULL); - if (NULL != pos->killing_client) - { - signal_result(pos->killing_client, - pos->name, - pos->killing_client_request_id, - GNUNET_ARM_RESULT_STOPPED); - pos->killing_client = NULL; - pos->killing_client_request_id = 0; - } - if (GNUNET_YES != in_shutdown) + pos->killing_client_request_id, + GNUNET_ARM_RESULT_STOPPED); + pos->killing_client = NULL; + pos->killing_client_request_id = 0; + } + if (GNUNET_YES != in_shutdown) + { + pos->last_exit_status = statcode; + if ((statusType == GNUNET_OS_PROCESS_EXITED) && (statcode == 0)) + { + /* process terminated normally, allow restart at any time */ + pos->restart_at.abs_value_us = 0; + GNUNET_log ( + GNUNET_ERROR_TYPE_INFO, + _ ("Service `%s' terminated normally, will restart at any time\n"), + pos->name); + /* process can still be re-started on-demand, ensure it is re-started if there is demand */ + for (sli = pos->listen_head; NULL != sli; sli = sli->next) { - pos->last_exit_status = statcode; - if ((statusType == GNUNET_OS_PROCESS_EXITED) && (statcode == 0)) - { - /* process terminated normally, allow restart at any time */ - pos->restart_at.abs_value_us = 0; - GNUNET_log( - GNUNET_ERROR_TYPE_INFO, - _("Service `%s' terminated normally, will restart at any time\n"), - pos->name); - /* process can still be re-started on-demand, ensure it is re-started if there is demand */ - for (sli = pos->listen_head; NULL != sli; sli = sli->next) - { - GNUNET_break(NULL == sli->accept_task); - sli->accept_task = - GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - sli->listen_socket, - &accept_connection, - sli); - } - } - else - { - GNUNET_log( - GNUNET_ERROR_TYPE_WARNING, - _("Service `%s' terminated with status %s/%d, will restart in %s\n"), - pos->name, - statstr, - statcode, - GNUNET_STRINGS_relative_time_to_string(pos->backoff, GNUNET_YES)); - { - /* Reduce backoff based on runtime of the process, - so that there is a cool-down if a process actually - runs for a while. */ - struct GNUNET_TIME_Relative runtime; - unsigned int minutes; - - runtime = GNUNET_TIME_absolute_get_duration(pos->restart_at); - minutes = - runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us; - if (minutes > 31) - pos->backoff = GNUNET_TIME_UNIT_ZERO; - else - pos->backoff.rel_value_us <<= minutes; - } - /* schedule restart */ - pos->restart_at = GNUNET_TIME_relative_to_absolute(pos->backoff); - pos->backoff = GNUNET_TIME_STD_BACKOFF(pos->backoff); - if (NULL != child_restart_task) - GNUNET_SCHEDULER_cancel(child_restart_task); - child_restart_task = - GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_IDLE, - &delayed_restart_task, - NULL); - } + GNUNET_break (NULL == sli->accept_task); + sli->accept_task = + GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + sli->listen_socket, + &accept_connection, + sli); } + } else + { + GNUNET_log ( + GNUNET_ERROR_TYPE_WARNING, + _ ("Service `%s' terminated with status %s/%d, will restart in %s\n"), + pos->name, + statstr, + statcode, + GNUNET_STRINGS_relative_time_to_string (pos->backoff, GNUNET_YES)); { - free_service(pos); + /* Reduce backoff based on runtime of the process, + so that there is a cool-down if a process actually + runs for a while. */ + struct GNUNET_TIME_Relative runtime; + unsigned int minutes; + + runtime = GNUNET_TIME_absolute_get_duration (pos->restart_at); + minutes = + runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us; + if (minutes > 31) + pos->backoff = GNUNET_TIME_UNIT_ZERO; + else + pos->backoff.rel_value_us <<= minutes; } + /* schedule restart */ + pos->restart_at = GNUNET_TIME_relative_to_absolute (pos->backoff); + pos->backoff = GNUNET_TIME_STD_BACKOFF (pos->backoff); + if (NULL != child_restart_task) + GNUNET_SCHEDULER_cancel (child_restart_task); + child_restart_task = + GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE, + &delayed_restart_task, + NULL); + } + } + else + { + free_service (pos); } + } child_death_task = - GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, - pr, - &maint_child_death, - NULL); + GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, + pr, + &maint_child_death, + NULL); if ((NULL == running_head) && (GNUNET_YES == in_shutdown)) - do_shutdown(); + do_shutdown (); else if (GNUNET_YES == in_shutdown) - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Delaying shutdown after child's death, still have %u children\n", - list_count(running_head)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Delaying shutdown after child's death, still have %u children\n", + list_count (running_head)); } @@ -1843,17 +1848,17 @@ maint_child_death(void *cls) * respective handler by writing to the trigger pipe. */ static void -sighandler_child_death() +sighandler_child_death () { static char c; int old_errno = errno; /* back-up errno */ - GNUNET_break( + GNUNET_break ( 1 == - GNUNET_DISK_file_write(GNUNET_DISK_pipe_handle(sigpipe, - GNUNET_DISK_PIPE_END_WRITE), - &c, - sizeof(c))); + GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (sigpipe, + GNUNET_DISK_PIPE_END_WRITE), + &c, + sizeof(c))); errno = old_errno; /* restore errno */ } @@ -1867,7 +1872,7 @@ sighandler_child_death() * @return #GNUNET_OK (continue) */ static void -setup_service(void *cls, const char *section) +setup_service (void *cls, const char *section) { struct ServiceList *sl; char *binary; @@ -1877,94 +1882,94 @@ setup_service(void *cls, const char *section) socklen_t *addr_lens; int ret; - (void)cls; - if (0 == strcasecmp(section, "arm")) + (void) cls; + if (0 == strcasecmp (section, "arm")) return; if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_string(cfg, section, "BINARY", &binary)) - { - /* not a service section */ - return; - } + GNUNET_CONFIGURATION_get_value_string (cfg, section, "BINARY", &binary)) + { + /* not a service section */ + return; + } if ((GNUNET_YES == - GNUNET_CONFIGURATION_have_value(cfg, section, "RUN_PER_USER")) && + GNUNET_CONFIGURATION_have_value (cfg, section, "RUN_PER_USER")) && (GNUNET_YES == - GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "RUN_PER_USER"))) + GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "RUN_PER_USER"))) + { + if (GNUNET_NO == start_user) { - if (GNUNET_NO == start_user) - { - GNUNET_free(binary); - return; /* user service, and we don't deal with those */ - } + GNUNET_free (binary); + return; /* user service, and we don't deal with those */ } + } else + { + if (GNUNET_NO == start_system) { - if (GNUNET_NO == start_system) - { - GNUNET_free(binary); - return; /* system service, and we don't deal with those */ - } + GNUNET_free (binary); + return; /* system service, and we don't deal with those */ } - sl = find_service(section); + } + sl = find_service (section); if (NULL != sl) - { - /* got the same section twice!? */ - GNUNET_break(0); - GNUNET_free(binary); - return; - } + { + /* got the same section twice!? */ + GNUNET_break (0); + GNUNET_free (binary); + return; + } config = NULL; - if (((GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg, - section, - "CONFIG", - &config)) && - (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg, - "PATHS", - "DEFAULTCONFIG", - &config))) || - (0 != stat(config, &sbuf))) + if (((GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, + section, + "CONFIG", + &config)) && + (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, + "PATHS", + "DEFAULTCONFIG", + &config))) || + (0 != stat (config, &sbuf))) + { + if (NULL != config) { - if (NULL != config) - { - GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_WARNING, - section, - "CONFIG", - strerror(errno)); - GNUNET_free(config); - config = NULL; - } + GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, + section, + "CONFIG", + strerror (errno)); + GNUNET_free (config); + config = NULL; } - sl = GNUNET_new(struct ServiceList); - sl->name = GNUNET_strdup(section); + } + sl = GNUNET_new (struct ServiceList); + sl->name = GNUNET_strdup (section); sl->binary = binary; sl->config = config; sl->backoff = GNUNET_TIME_UNIT_MILLISECONDS; sl->restart_at = GNUNET_TIME_UNIT_FOREVER_ABS; - if (GNUNET_CONFIGURATION_have_value(cfg, section, "PIPECONTROL")) + if (GNUNET_CONFIGURATION_have_value (cfg, section, "PIPECONTROL")) sl->pipe_control = - GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "PIPECONTROL"); - GNUNET_CONTAINER_DLL_insert(running_head, running_tail, sl); + GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "PIPECONTROL"); + GNUNET_CONTAINER_DLL_insert (running_head, running_tail, sl); if (GNUNET_YES == - GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "IMMEDIATE_START")) - { - sl->force_start = GNUNET_YES; - if (GNUNET_YES == - GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "NOARMBIND")) - return; - } + GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "IMMEDIATE_START")) + { + sl->force_start = GNUNET_YES; + if (GNUNET_YES == + GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "NOARMBIND")) + return; + } else - { - if (GNUNET_YES != - GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "START_ON_DEMAND")) - return; - } - if (0 >= (ret = get_server_addresses(section, cfg, &addrs, &addr_lens))) + { + if (GNUNET_YES != + GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "START_ON_DEMAND")) + return; + } + if (0 >= (ret = get_server_addresses (section, cfg, &addrs, &addr_lens))) return; /* this will free (or capture) addrs[i] */ - for (unsigned int i = 0; i < (unsigned int)ret; i++) - create_listen_socket(addrs[i], addr_lens[i], sl); - GNUNET_free(addrs); - GNUNET_free(addr_lens); + for (unsigned int i = 0; i < (unsigned int) ret; i++) + create_listen_socket (addrs[i], addr_lens[i], sl); + GNUNET_free (addrs); + GNUNET_free (addr_lens); } @@ -1977,16 +1982,16 @@ setup_service(void *cls, const char *section) * @return @a client */ static void * -client_connect_cb(void *cls, - struct GNUNET_SERVICE_Client *client, - struct GNUNET_MQ_Handle *mq) +client_connect_cb (void *cls, + struct GNUNET_SERVICE_Client *client, + struct GNUNET_MQ_Handle *mq) { /* All clients are considered to be of the "monitor" kind * (that is, they don't affect ARM shutdown). */ - (void)cls; - (void)mq; - GNUNET_SERVICE_client_mark_monitor(client); + (void) cls; + (void) mq; + GNUNET_SERVICE_client_mark_monitor (client); return client; } @@ -1999,12 +2004,12 @@ client_connect_cb(void *cls, * @param app_ctx must match @a client */ static void -client_disconnect_cb(void *cls, - struct GNUNET_SERVICE_Client *client, - void *app_ctx) +client_disconnect_cb (void *cls, + struct GNUNET_SERVICE_Client *client, + void *app_ctx) { - (void)cls; - GNUNET_assert(client == app_ctx); + (void) cls; + GNUNET_assert (client == app_ctx); for (struct ServiceList *sl = running_head; NULL != sl; sl = sl->next) if (sl->killing_client == client) sl->killing_client = NULL; @@ -2020,18 +2025,18 @@ client_disconnect_cb(void *cls, * #GNUNET_SYSERR to close it (signal serious error) */ static void -handle_monitor(void *cls, const struct GNUNET_MessageHeader *message) +handle_monitor (void *cls, const struct GNUNET_MessageHeader *message) { struct GNUNET_SERVICE_Client *client = cls; - (void)message; + (void) message; /* FIXME: might want to start by letting monitor know about services that are already running */ /* Removal is handled by the server implementation, internally. */ - GNUNET_notification_context_add(notifier, - GNUNET_SERVICE_client_get_mq(client)); - broadcast_status("arm", GNUNET_ARM_SERVICE_MONITORING_STARTED, client); - GNUNET_SERVICE_client_continue(client); + GNUNET_notification_context_add (notifier, + GNUNET_SERVICE_client_get_mq (client)); + broadcast_status ("arm", GNUNET_ARM_SERVICE_MONITORING_STARTED, client); + GNUNET_SERVICE_client_continue (client); } @@ -2043,71 +2048,71 @@ handle_monitor(void *cls, const struct GNUNET_MessageHeader *message) * @param c configuration to use */ static void -run(void *cls, - const struct GNUNET_CONFIGURATION_Handle *c, - struct GNUNET_SERVICE_Handle *serv) +run (void *cls, + const struct GNUNET_CONFIGURATION_Handle *c, + struct GNUNET_SERVICE_Handle *serv) { struct ServiceList *sl; - (void)cls; + (void) cls; cfg = c; service = serv; - GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); - child_death_task = GNUNET_SCHEDULER_add_read_file( + GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); + child_death_task = GNUNET_SCHEDULER_add_read_file ( GNUNET_TIME_UNIT_FOREVER_REL, - GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ), + GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ), &maint_child_death, NULL); #if HAVE_WAIT4 if (GNUNET_OK == - GNUNET_CONFIGURATION_get_value_filename(cfg, - "ARM", - "RESOURCE_DIAGNOSTICS", - &wait_filename)) + GNUNET_CONFIGURATION_get_value_filename (cfg, + "ARM", + "RESOURCE_DIAGNOSTICS", + &wait_filename)) + { + wait_file = fopen (wait_filename, "w"); + if (NULL == wait_file) { - wait_file = fopen(wait_filename, "w"); - if (NULL == wait_file) - { - GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, - "fopen", - wait_filename); - } + GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, + "fopen", + wait_filename); } + } #endif - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, - "ARM", - "GLOBAL_PREFIX", - &prefix_command)) - prefix_command = GNUNET_strdup(""); + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, + "ARM", + "GLOBAL_PREFIX", + &prefix_command)) + prefix_command = GNUNET_strdup (""); else - prefix_command = GNUNET_CONFIGURATION_expand_dollar(cfg, prefix_command); - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, - "ARM", - "GLOBAL_POSTFIX", - &final_option)) - final_option = GNUNET_strdup(""); + prefix_command = GNUNET_CONFIGURATION_expand_dollar (cfg, prefix_command); + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, + "ARM", + "GLOBAL_POSTFIX", + &final_option)) + final_option = GNUNET_strdup (""); else - final_option = GNUNET_CONFIGURATION_expand_dollar(cfg, final_option); + final_option = GNUNET_CONFIGURATION_expand_dollar (cfg, final_option); start_user = - GNUNET_CONFIGURATION_get_value_yesno(cfg, "ARM", "START_USER_SERVICES"); + GNUNET_CONFIGURATION_get_value_yesno (cfg, "ARM", "START_USER_SERVICES"); start_system = - GNUNET_CONFIGURATION_get_value_yesno(cfg, "ARM", "START_SYSTEM_SERVICES"); + GNUNET_CONFIGURATION_get_value_yesno (cfg, "ARM", "START_SYSTEM_SERVICES"); if ((GNUNET_NO == start_user) && (GNUNET_NO == start_system)) - { - GNUNET_log( - GNUNET_ERROR_TYPE_ERROR, - "Please configure either START_USER_SERVICES or START_SYSTEM_SERVICES or both.\n"); - GNUNET_SCHEDULER_shutdown(); - global_ret = 1; - return; - } - GNUNET_CONFIGURATION_iterate_sections(cfg, &setup_service, NULL); + { + GNUNET_log ( + GNUNET_ERROR_TYPE_ERROR, + "Please configure either START_USER_SERVICES or START_SYSTEM_SERVICES or both.\n"); + GNUNET_SCHEDULER_shutdown (); + global_ret = 1; + return; + } + GNUNET_CONFIGURATION_iterate_sections (cfg, &setup_service, NULL); /* start default services... */ for (sl = running_head; NULL != sl; sl = sl->next) if (GNUNET_YES == sl->force_start) - start_process(sl, NULL, 0); - notifier = GNUNET_notification_context_create(MAX_NOTIFY_QUEUE); + start_process (sl, NULL, 0); + notifier = GNUNET_notification_context_create (MAX_NOTIFY_QUEUE); } @@ -2119,61 +2124,64 @@ run(void *cls, * @return 0 ok, 1 on error */ int -main(int argc, char *const *argv) +main (int argc, char *const *argv) { struct GNUNET_SIGNAL_Context *shc_chld; - struct GNUNET_MQ_MessageHandler handlers[] = - { GNUNET_MQ_hd_var_size(start, - GNUNET_MESSAGE_TYPE_ARM_START, - struct GNUNET_ARM_Message, - NULL), - GNUNET_MQ_hd_var_size(stop, - GNUNET_MESSAGE_TYPE_ARM_STOP, - struct GNUNET_ARM_Message, - NULL), - GNUNET_MQ_hd_fixed_size(monitor, - GNUNET_MESSAGE_TYPE_ARM_MONITOR, - struct GNUNET_MessageHeader, - NULL), - GNUNET_MQ_hd_fixed_size(list, - GNUNET_MESSAGE_TYPE_ARM_LIST, - struct GNUNET_ARM_Message, - NULL), - GNUNET_MQ_hd_fixed_size(test, - GNUNET_MESSAGE_TYPE_ARM_TEST, - struct GNUNET_MessageHeader, - NULL), - GNUNET_MQ_handler_end() }; - - sigpipe = GNUNET_DISK_pipe(GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO); - GNUNET_assert(NULL != sigpipe); + struct GNUNET_MQ_MessageHandler handlers[] = { + GNUNET_MQ_hd_var_size (start, + GNUNET_MESSAGE_TYPE_ARM_START, + struct GNUNET_ARM_Message, + NULL), + GNUNET_MQ_hd_var_size (stop, + GNUNET_MESSAGE_TYPE_ARM_STOP, + struct GNUNET_ARM_Message, + NULL), + GNUNET_MQ_hd_fixed_size (monitor, + GNUNET_MESSAGE_TYPE_ARM_MONITOR, + struct GNUNET_MessageHeader, + NULL), + GNUNET_MQ_hd_fixed_size (list, + GNUNET_MESSAGE_TYPE_ARM_LIST, + struct GNUNET_ARM_Message, + NULL), + GNUNET_MQ_hd_fixed_size (test, + GNUNET_MESSAGE_TYPE_ARM_TEST, + struct GNUNET_MessageHeader, + NULL), + GNUNET_MQ_handler_end () + }; + + sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO); + GNUNET_assert (NULL != sigpipe); shc_chld = - GNUNET_SIGNAL_handler_install(GNUNET_SIGCHLD, &sighandler_child_death); - if (0 != GNUNET_SERVICE_run_(argc, - argv, - "arm", - GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN, - &run, - &client_connect_cb, - &client_disconnect_cb, - NULL, - handlers)) + GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, + &sighandler_child_death); + if (0 != GNUNET_SERVICE_run_ (argc, + argv, + "arm", + GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN + | GNUNET_SERVICE_OPTION_CLOSE_LSOCKS, + &run, + &client_connect_cb, + &client_disconnect_cb, + NULL, + handlers)) global_ret = 2; #if HAVE_WAIT4 if (NULL != wait_file) - { - fclose(wait_file); - wait_file = NULL; - } + { + fclose (wait_file); + wait_file = NULL; + } if (NULL != wait_filename) - { - GNUNET_free(wait_filename); - wait_filename = NULL; - } + { + GNUNET_free (wait_filename); + wait_filename = NULL; + } #endif - GNUNET_SIGNAL_handler_uninstall(shc_chld); + GNUNET_SIGNAL_handler_uninstall (shc_chld); shc_chld = NULL; - GNUNET_DISK_pipe_close(sigpipe); + GNUNET_DISK_pipe_close (sigpipe); sigpipe = NULL; return global_ret; } @@ -2185,11 +2193,11 @@ main(int argc, char *const *argv) /** * MINIMIZE heap size (way below 128k) since this process doesn't need much. */ -void __attribute__ ((constructor)) GNUNET_ARM_memory_init() +void __attribute__ ((constructor)) GNUNET_ARM_memory_init () { - mallopt(M_TRIM_THRESHOLD, 4 * 1024); - mallopt(M_TOP_PAD, 1 * 1024); - malloc_trim(0); + mallopt (M_TRIM_THRESHOLD, 4 * 1024); + mallopt (M_TOP_PAD, 1 * 1024); + malloc_trim (0); } #endif -- cgit v1.2.3