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 ++++++++++++++++++------------------ src/gns/gnunet-gns.c | 4 +- src/include/gnunet_disk_lib.h | 189 +-- src/include/gnunet_os_lib.h | 134 ++- src/include/gnunet_scheduler_lib.h | 195 +-- src/include/gnunet_service_lib.h | 92 +- src/util/service.c | 53 +- 8 files changed, 1615 insertions(+), 1479 deletions(-) (limited to 'src') 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 diff --git a/src/gns/gnunet-gns.c b/src/gns/gnunet-gns.c index 1ddcbf090..5f4061f7d 100644 --- a/src/gns/gnunet-gns.c +++ b/src/gns/gnunet-gns.c @@ -213,8 +213,8 @@ run (void *cls, GNUNET_CLIENT_test (cfg, "arm")) { - fprintf (stderr, - _ ("GNUnet not running\n")); + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ("Cannot resolve using GNS: GNUnet peer not running\n")); global_ret = 2; return; } diff --git a/src/include/gnunet_disk_lib.h b/src/include/gnunet_disk_lib.h index d1e1e0333..9376a1059 100644 --- a/src/include/gnunet_disk_lib.h +++ b/src/include/gnunet_disk_lib.h @@ -38,7 +38,8 @@ struct GNUNET_DISK_PipeHandle; /** * Type of a handle. */ -enum GNUNET_FILE_Type { +enum GNUNET_FILE_Type +{ /** * Handle represents an event. */ @@ -58,7 +59,8 @@ enum GNUNET_FILE_Type { /** * Handle used to access files (and pipes). */ -struct GNUNET_DISK_FileHandle { +struct GNUNET_DISK_FileHandle +{ /** * File handle on Unix-like systems. */ @@ -86,7 +88,8 @@ extern "C" /** * Specifies how a file should be opened. */ -enum GNUNET_DISK_OpenFlags { +enum GNUNET_DISK_OpenFlags +{ /** * Open the file for reading */ @@ -126,7 +129,8 @@ enum GNUNET_DISK_OpenFlags { /** * Specifies what type of memory map is desired. */ -enum GNUNET_DISK_MapType { +enum GNUNET_DISK_MapType +{ /** * Read-only memory map. */ @@ -147,7 +151,8 @@ enum GNUNET_DISK_MapType { /** * File access permissions, UNIX-style. */ -enum GNUNET_DISK_AccessPermissions { +enum GNUNET_DISK_AccessPermissions +{ /** * Nobody is allowed to do anything to the file. */ @@ -204,7 +209,8 @@ enum GNUNET_DISK_AccessPermissions { * Constants for specifying how to seek. Do not change values or order, * some of the code depends on the specific numeric values! */ -enum GNUNET_DISK_Seek { +enum GNUNET_DISK_Seek +{ /** * Seek an absolute position (from the start of the file). */ @@ -225,7 +231,8 @@ enum GNUNET_DISK_Seek { /** * Enumeration identifying the two ends of a pipe. */ -enum GNUNET_DISK_PipeEnd { +enum GNUNET_DISK_PipeEnd +{ /** * The reading-end of a pipe. */ @@ -245,7 +252,7 @@ enum GNUNET_DISK_PipeEnd { * @return #GNUNET_YES if invalid, #GNUNET_NO if valid */ int -GNUNET_DISK_handle_invalid(const struct GNUNET_DISK_FileHandle *h); +GNUNET_DISK_handle_invalid (const struct GNUNET_DISK_FileHandle *h); /** @@ -257,7 +264,7 @@ GNUNET_DISK_handle_invalid(const struct GNUNET_DISK_FileHandle *h); * else (will print an error message in that case, too). */ int -GNUNET_DISK_file_test(const char *fil); +GNUNET_DISK_file_test (const char *fil); /** @@ -268,7 +275,7 @@ GNUNET_DISK_file_test(const char *fil); * @param fil name of the file to back up */ void -GNUNET_DISK_file_backup(const char *fil); +GNUNET_DISK_file_backup (const char *fil); /** @@ -279,8 +286,8 @@ GNUNET_DISK_file_backup(const char *fil); * @return the new position on success, GNUNET_SYSERR otherwise */ off_t -GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h, off_t offset, - enum GNUNET_DISK_Seek whence); +GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h, off_t offset, + enum GNUNET_DISK_Seek whence); /** @@ -298,10 +305,10 @@ GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h, off_t offset, * @return #GNUNET_SYSERR on error, #GNUNET_OK on success */ int -GNUNET_DISK_file_size(const char *filename, - uint64_t *size, - int include_symbolic_links, - int single_file_mode); +GNUNET_DISK_file_size (const char *filename, + uint64_t *size, + int include_symbolic_links, + int single_file_mode); /** @@ -320,9 +327,9 @@ GNUNET_DISK_file_size(const char *filename, * @return #GNUNET_OK on success */ int -GNUNET_DISK_file_get_identifiers(const char *filename, - uint64_t *dev, - uint64_t *ino); +GNUNET_DISK_file_get_identifiers (const char *filename, + uint64_t *dev, + uint64_t *ino); /** @@ -337,7 +344,7 @@ GNUNET_DISK_file_get_identifiers(const char *filename, * file on disk in directory for temporary files */ char * -GNUNET_DISK_mktemp(const char *t); +GNUNET_DISK_mktemp (const char *t); /** @@ -350,7 +357,7 @@ GNUNET_DISK_mktemp(const char *t); * @return NULL on error, otherwise name of freshly created directory */ char * -GNUNET_DISK_mkdtemp(const char *t); +GNUNET_DISK_mkdtemp (const char *t); /** @@ -366,9 +373,9 @@ GNUNET_DISK_mkdtemp(const char *t); * @return IO handle on success, NULL on error */ struct GNUNET_DISK_FileHandle * -GNUNET_DISK_file_open(const char *fn, - enum GNUNET_DISK_OpenFlags flags, - enum GNUNET_DISK_AccessPermissions perm); +GNUNET_DISK_file_open (const char *fn, + enum GNUNET_DISK_OpenFlags flags, + enum GNUNET_DISK_AccessPermissions perm); /** @@ -379,8 +386,8 @@ GNUNET_DISK_file_open(const char *fn, * @return #GNUNET_OK on success, #GNUNET_SYSERR on error */ int -GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, - off_t *size); +GNUNET_DISK_file_handle_size (struct GNUNET_DISK_FileHandle *fh, + off_t *size); /** @@ -393,10 +400,10 @@ GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, * @return handle to the new pipe, NULL on error */ struct GNUNET_DISK_PipeHandle * -GNUNET_DISK_pipe(int blocking_read, - int blocking_write, - int inherit_read, - int inherit_write); +GNUNET_DISK_pipe (int blocking_read, + int blocking_write, + int inherit_read, + int inherit_write); /** @@ -410,9 +417,9 @@ GNUNET_DISK_pipe(int blocking_read, * @return handle to the new pipe, NULL on error */ struct GNUNET_DISK_PipeHandle * -GNUNET_DISK_pipe_from_fd(int blocking_read, - int blocking_write, - int fd[2]); +GNUNET_DISK_pipe_from_fd (int blocking_read, + int blocking_write, + int fd[2]); /** @@ -421,7 +428,7 @@ GNUNET_DISK_pipe_from_fd(int blocking_read, * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise */ int -GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p); +GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p); /** @@ -432,8 +439,8 @@ GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p); * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise */ int -GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p, - enum GNUNET_DISK_PipeEnd end); +GNUNET_DISK_pipe_close_end (struct GNUNET_DISK_PipeHandle *p, + enum GNUNET_DISK_PipeEnd end); /** @@ -449,8 +456,8 @@ GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p, * (or if that end is not present or is closed). */ struct GNUNET_DISK_FileHandle * -GNUNET_DISK_pipe_detach_end(struct GNUNET_DISK_PipeHandle *p, - enum GNUNET_DISK_PipeEnd end); +GNUNET_DISK_pipe_detach_end (struct GNUNET_DISK_PipeHandle *p, + enum GNUNET_DISK_PipeEnd end); /** * Close an open file. @@ -459,7 +466,7 @@ GNUNET_DISK_pipe_detach_end(struct GNUNET_DISK_PipeHandle *p, * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise */ int -GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h); +GNUNET_DISK_file_close (struct GNUNET_DISK_FileHandle *h); /** @@ -470,8 +477,8 @@ GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h); * @return handle for the respective end */ const struct GNUNET_DISK_FileHandle * -GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p, - enum GNUNET_DISK_PipeEnd n); +GNUNET_DISK_pipe_handle (const struct GNUNET_DISK_PipeHandle *p, + enum GNUNET_DISK_PipeEnd n); /** * Update POSIX permissions mask of a file on disk. If both argumets @@ -483,9 +490,9 @@ GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p, * @param require_gid_match #GNUNET_YES means 770 unless @a require_uid_match is set */ void -GNUNET_DISK_fix_permissions(const char *fn, - int require_uid_match, - int require_gid_match); +GNUNET_DISK_fix_permissions (const char *fn, + int require_uid_match, + int require_gid_match); /** @@ -495,7 +502,7 @@ GNUNET_DISK_fix_permissions(const char *fn, * @return file handle corresponding to the descriptor */ struct GNUNET_DISK_FileHandle * -GNUNET_DISK_get_handle_from_int_fd(int fno); +GNUNET_DISK_get_handle_from_int_fd (int fno); /** @@ -505,7 +512,7 @@ GNUNET_DISK_get_handle_from_int_fd(int fno); * @return file handle corresponding to the descriptor */ struct GNUNET_DISK_FileHandle * -GNUNET_DISK_get_handle_from_native(FILE *fd); +GNUNET_DISK_get_handle_from_native (FILE *fd); /** @@ -517,9 +524,9 @@ GNUNET_DISK_get_handle_from_native(FILE *fd); * @return the number of bytes read on success, #GNUNET_SYSERR on failure */ ssize_t -GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, - void *result, - size_t len); +GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h, + void *result, + size_t len); /** @@ -533,9 +540,9 @@ GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, * @return the number of bytes read on success, #GNUNET_SYSERR on failure */ ssize_t -GNUNET_DISK_file_read_non_blocking(const struct GNUNET_DISK_FileHandle * h, - void *result, - size_t len); +GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle *h, + void *result, + size_t len); /** @@ -547,9 +554,9 @@ GNUNET_DISK_file_read_non_blocking(const struct GNUNET_DISK_FileHandle * h, * @return number of bytes read, #GNUNET_SYSERR on failure */ ssize_t -GNUNET_DISK_fn_read(const char *fn, - void *result, - size_t len); +GNUNET_DISK_fn_read (const char *fn, + void *result, + size_t len); /** @@ -561,9 +568,9 @@ GNUNET_DISK_fn_read(const char *fn, * @return number of bytes written on success, #GNUNET_SYSERR on error */ ssize_t -GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, - const void *buffer, - size_t n); +GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle *h, + const void *buffer, + size_t n); /** @@ -575,9 +582,9 @@ GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, * @return number of bytes written on success, #GNUNET_SYSERR on error */ ssize_t -GNUNET_DISK_file_write_blocking(const struct GNUNET_DISK_FileHandle *h, - const void *buffer, - size_t n); +GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle *h, + const void *buffer, + size_t n); /** @@ -591,10 +598,10 @@ GNUNET_DISK_file_write_blocking(const struct GNUNET_DISK_FileHandle *h, * @return number of bytes written on success, #GNUNET_SYSERR on error */ ssize_t -GNUNET_DISK_fn_write(const char *fn, - const void *buffer, - size_t n, - enum GNUNET_DISK_AccessPermissions mode); +GNUNET_DISK_fn_write (const char *fn, + const void *buffer, + size_t n, + enum GNUNET_DISK_AccessPermissions mode); /** @@ -605,8 +612,8 @@ GNUNET_DISK_fn_write(const char *fn, * @return #GNUNET_OK on success, #GNUNET_SYSERR on error */ int -GNUNET_DISK_file_copy(const char *src, - const char *dst); +GNUNET_DISK_file_copy (const char *src, + const char *dst); /** @@ -618,9 +625,9 @@ GNUNET_DISK_file_copy(const char *src, * @return the number of files found, -1 on error */ int -GNUNET_DISK_directory_scan(const char *dir_name, - GNUNET_FileNameCallback callback, - void *callback_cls); +GNUNET_DISK_directory_scan (const char *dir_name, + GNUNET_FileNameCallback callback, + void *callback_cls); /** @@ -632,7 +639,7 @@ GNUNET_DISK_directory_scan(const char *dir_name, * #GNUNET_NO if directory exists but is not writeable */ int -GNUNET_DISK_directory_create_for_file(const char *filename); +GNUNET_DISK_directory_create_for_file (const char *filename); /** @@ -648,7 +655,7 @@ GNUNET_DISK_directory_create_for_file(const char *filename); * does not exist or `stat`ed */ int -GNUNET_DISK_directory_test(const char *fil, int is_readable); +GNUNET_DISK_directory_test (const char *fil, int is_readable); /** @@ -659,7 +666,7 @@ GNUNET_DISK_directory_test(const char *fil, int is_readable); * @return #GNUNET_OK on success, #GNUNET_SYSERR on error */ int -GNUNET_DISK_directory_remove(const char *filename); +GNUNET_DISK_directory_remove (const char *filename); /** @@ -670,8 +677,8 @@ GNUNET_DISK_directory_remove(const char *filename); * @param option option with the dir name to purge */ void -GNUNET_DISK_purge_cfg_dir(const char *cfg_filename, - const char *option); +GNUNET_DISK_purge_cfg_dir (const char *cfg_filename, + const char *option); /** @@ -681,7 +688,7 @@ GNUNET_DISK_purge_cfg_dir(const char *cfg_filename, * @returns #GNUNET_SYSERR on failure, #GNUNET_OK otherwise */ int -GNUNET_DISK_directory_create(const char *dir); +GNUNET_DISK_directory_create (const char *dir); /** @@ -694,9 +701,9 @@ GNUNET_DISK_directory_create(const char *dir); * @return #GNUNET_OK on success, #GNUNET_SYSERR on error */ int -GNUNET_DISK_file_lock(struct GNUNET_DISK_FileHandle *fh, - off_t lock_start, - off_t lock_end, int excl); +GNUNET_DISK_file_lock (struct GNUNET_DISK_FileHandle *fh, + off_t lock_start, + off_t lock_end, int excl); /** @@ -708,9 +715,9 @@ GNUNET_DISK_file_lock(struct GNUNET_DISK_FileHandle *fh, * @return #GNUNET_OK on success, #GNUNET_SYSERR on error */ int -GNUNET_DISK_file_unlock(struct GNUNET_DISK_FileHandle *fh, - off_t unlock_start, - off_t unlock_end); +GNUNET_DISK_file_unlock (struct GNUNET_DISK_FileHandle *fh, + off_t unlock_start, + off_t unlock_end); /** @@ -718,7 +725,7 @@ GNUNET_DISK_file_unlock(struct GNUNET_DISK_FileHandle *fh, * @param fn the filename to canonicalize */ void -GNUNET_DISK_filename_canonicalize(char *fn); +GNUNET_DISK_filename_canonicalize (char *fn); /** @@ -728,8 +735,8 @@ GNUNET_DISK_filename_canonicalize(char *fn); * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure */ int -GNUNET_DISK_file_change_owner(const char *filename, - const char *user); +GNUNET_DISK_file_change_owner (const char *filename, + const char *user); /** @@ -747,10 +754,10 @@ struct GNUNET_DISK_MapHandle; * @return pointer to the mapped memory region, NULL on failure */ void * -GNUNET_DISK_file_map(const struct GNUNET_DISK_FileHandle *h, - struct GNUNET_DISK_MapHandle **m, - enum GNUNET_DISK_MapType access, - size_t len); +GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h, + struct GNUNET_DISK_MapHandle **m, + enum GNUNET_DISK_MapType access, + size_t len); /** @@ -760,7 +767,7 @@ GNUNET_DISK_file_map(const struct GNUNET_DISK_FileHandle *h, * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise */ int -GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h); +GNUNET_DISK_file_unmap (struct GNUNET_DISK_MapHandle *h); /** @@ -770,7 +777,7 @@ GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h); * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise */ int -GNUNET_DISK_file_sync(const struct GNUNET_DISK_FileHandle *h); +GNUNET_DISK_file_sync (const struct GNUNET_DISK_FileHandle *h); #if 0 /* keep Emacsens' auto-indent happy */ diff --git a/src/include/gnunet_os_lib.h b/src/include/gnunet_os_lib.h index e5bc7146b..e4c0d6cdb 100644 --- a/src/include/gnunet_os_lib.h +++ b/src/include/gnunet_os_lib.h @@ -65,7 +65,8 @@ extern "C" * Flags that determine which of the standard streams * should be inherited by the child process. */ -enum GNUNET_OS_InheritStdioFlags { +enum GNUNET_OS_InheritStdioFlags +{ /** * No standard streams should be inherited. */ @@ -112,7 +113,8 @@ struct GNUNET_OS_Process; /** * Possible installation paths to request */ -enum GNUNET_OS_InstallationPathKind { +enum GNUNET_OS_InstallationPathKind +{ /** * Return the "PREFIX" directory given to configure. */ @@ -166,7 +168,8 @@ enum GNUNET_OS_InstallationPathKind { /** * Process status types */ -enum GNUNET_OS_ProcessStatusType { +enum GNUNET_OS_ProcessStatusType +{ /** * The process is not known to the OS (or at * least not one of our children). @@ -199,7 +202,8 @@ enum GNUNET_OS_ProcessStatusType { * Project-specific data used to help the OS subsystem * find installation paths. */ -struct GNUNET_OS_ProjectData { +struct GNUNET_OS_ProjectData +{ /** * Name of a library that is installed in the "lib/" directory of * the project, such as "libgnunetutil". Used to locate the @@ -290,14 +294,14 @@ struct GNUNET_OS_ProjectData { * Return default project data used by 'libgnunetutil' for GNUnet. */ const struct GNUNET_OS_ProjectData * -GNUNET_OS_project_data_default(void); +GNUNET_OS_project_data_default (void); /** * @return current (actual) project data. */ const struct GNUNET_OS_ProjectData * -GNUNET_OS_project_data_get(void); +GNUNET_OS_project_data_get (void); /** @@ -306,7 +310,7 @@ GNUNET_OS_project_data_get(void); * @param pd project data used to determine paths. */ void -GNUNET_OS_init(const struct GNUNET_OS_ProjectData *pd); +GNUNET_OS_init (const struct GNUNET_OS_ProjectData *pd); /** @@ -318,7 +322,7 @@ GNUNET_OS_init(const struct GNUNET_OS_ProjectData *pd); * @return a pointer to the dir path (to be freed by the caller) */ char * -GNUNET_OS_installation_get_path(enum GNUNET_OS_InstallationPathKind dirkind); +GNUNET_OS_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind); /** @@ -330,7 +334,7 @@ GNUNET_OS_installation_get_path(enum GNUNET_OS_InstallationPathKind dirkind); * @return full path to the binary, if possible, otherwise copy of 'progname' */ char * -GNUNET_OS_get_libexec_binary_path(const char *progname); +GNUNET_OS_get_libexec_binary_path (const char *progname); /** @@ -346,8 +350,8 @@ GNUNET_OS_get_libexec_binary_path(const char *progname); * otherwise */ char * -GNUNET_OS_get_suid_binary_path(const struct GNUNET_CONFIGURATION_Handle *cfg, - const char *progname); +GNUNET_OS_get_suid_binary_path (const struct GNUNET_CONFIGURATION_Handle *cfg, + const char *progname); /** @@ -379,14 +383,16 @@ typedef int * @param proc_cls closure for @a proc */ void -GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc, - void *proc_cls); +GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc, + void *proc_cls); /** * @brief Get maximum string length returned by gethostname() */ #if HAVE_SYSCONF && defined(_SC_HOST_NAME_MAX) -#define GNUNET_OS_get_hostname_max_length() ({ int __sc_tmp = sysconf(_SC_HOST_NAME_MAX); __sc_tmp <= 0 ? 255 : __sc_tmp; }) +#define GNUNET_OS_get_hostname_max_length() ({ int __sc_tmp = sysconf ( \ + _SC_HOST_NAME_MAX); __sc_tmp <= \ + 0 ? 255 : __sc_tmp; }) #elif defined(HOST_NAME_MAX) #define GNUNET_OS_get_hostname_max_length() HOST_NAME_MAX #else @@ -403,7 +409,7 @@ GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc, * @return pointer to the process sturcutre for this process */ struct GNUNET_OS_Process * -GNUNET_OS_process_current(void); +GNUNET_OS_process_current (void); /** @@ -414,8 +420,8 @@ GNUNET_OS_process_current(void); * @return 0 on success, -1 on error */ int -GNUNET_OS_process_kill(struct GNUNET_OS_Process *proc, - int sig); +GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, + int sig); /** @@ -424,7 +430,7 @@ GNUNET_OS_process_kill(struct GNUNET_OS_Process *proc, * @param proc pointer to process structure */ void -GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc); +GNUNET_OS_process_destroy (struct GNUNET_OS_Process *proc); /** @@ -435,7 +441,7 @@ GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc); * @return the current process id */ pid_t -GNUNET_OS_process_get_pid(struct GNUNET_OS_Process *proc); +GNUNET_OS_process_get_pid (struct GNUNET_OS_Process *proc); /** @@ -451,13 +457,13 @@ GNUNET_OS_process_get_pid(struct GNUNET_OS_Process *proc); * @return pointer to process structure of the new process, NULL on error */ struct GNUNET_OS_Process * -GNUNET_OS_start_process_vap(int pipe_control, - enum GNUNET_OS_InheritStdioFlags std_inheritance, - struct GNUNET_DISK_PipeHandle *pipe_stdin, - struct GNUNET_DISK_PipeHandle *pipe_stdout, - struct GNUNET_DISK_PipeHandle *pipe_stderr, - const char *filename, - char *const argv[]); +GNUNET_OS_start_process_vap (int pipe_control, + enum GNUNET_OS_InheritStdioFlags std_inheritance, + struct GNUNET_DISK_PipeHandle *pipe_stdin, + struct GNUNET_DISK_PipeHandle *pipe_stdout, + struct GNUNET_DISK_PipeHandle *pipe_stderr, + const char *filename, + char *const argv[]); /** @@ -473,12 +479,12 @@ GNUNET_OS_start_process_vap(int pipe_control, * @return pointer to process structure of the new process, NULL on error */ struct GNUNET_OS_Process * -GNUNET_OS_start_process(int pipe_control, - enum GNUNET_OS_InheritStdioFlags std_inheritance, - struct GNUNET_DISK_PipeHandle *pipe_stdin, - struct GNUNET_DISK_PipeHandle *pipe_stdout, - struct GNUNET_DISK_PipeHandle *pipe_stderr, - const char *filename, ...); +GNUNET_OS_start_process (int pipe_control, + enum GNUNET_OS_InheritStdioFlags std_inheritance, + struct GNUNET_DISK_PipeHandle *pipe_stdin, + struct GNUNET_DISK_PipeHandle *pipe_stdout, + struct GNUNET_DISK_PipeHandle *pipe_stderr, + const char *filename, ...); /** @@ -494,12 +500,12 @@ GNUNET_OS_start_process(int pipe_control, * @return pointer to process structure of the new process, NULL on error */ struct GNUNET_OS_Process * -GNUNET_OS_start_process_va(int pipe_control, - enum GNUNET_OS_InheritStdioFlags std_inheritance, - struct GNUNET_DISK_PipeHandle *pipe_stdin, - struct GNUNET_DISK_PipeHandle *pipe_stdout, - struct GNUNET_DISK_PipeHandle *pipe_stderr, - const char *filename, va_list va); +GNUNET_OS_start_process_va (int pipe_control, + enum GNUNET_OS_InheritStdioFlags std_inheritance, + struct GNUNET_DISK_PipeHandle *pipe_stdin, + struct GNUNET_DISK_PipeHandle *pipe_stdout, + struct GNUNET_DISK_PipeHandle *pipe_stderr, + const char *filename, va_list va); /** * Start a process. @@ -514,11 +520,11 @@ GNUNET_OS_start_process_va(int pipe_control, * @return pointer to process structure of the new process, NULL on error */ struct GNUNET_OS_Process * -GNUNET_OS_start_process_v(int pipe_control, - enum GNUNET_OS_InheritStdioFlags std_inheritance, - const SOCKTYPE *lsocks, - const char *filename, - char *const argv[]); +GNUNET_OS_start_process_v (int pipe_control, + enum GNUNET_OS_InheritStdioFlags std_inheritance, + const SOCKTYPE *lsocks, + const char *filename, + char *const argv[]); /** @@ -540,10 +546,10 @@ GNUNET_OS_start_process_v(int pipe_control, * @return pointer to process structure of the new process, NULL on error */ struct GNUNET_OS_Process * -GNUNET_OS_start_process_s(int pipe_control, - unsigned int std_inheritance, - const SOCKTYPE * lsocks, - const char *filename, ...); +GNUNET_OS_start_process_s (int pipe_control, + unsigned int std_inheritance, + const SOCKTYPE *lsocks, + const char *filename, ...); /** @@ -568,7 +574,7 @@ typedef void * @param cmd handle to the process */ void -GNUNET_OS_command_stop(struct GNUNET_OS_CommandHandle *cmd); +GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd); /** @@ -583,11 +589,11 @@ GNUNET_OS_command_stop(struct GNUNET_OS_CommandHandle *cmd); * @return NULL on error */ struct GNUNET_OS_CommandHandle * -GNUNET_OS_command_run(GNUNET_OS_LineProcessor proc, - void *proc_cls, - struct GNUNET_TIME_Relative timeout, - const char *binary, - ...); +GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, + void *proc_cls, + struct GNUNET_TIME_Relative timeout, + const char *binary, + ...); /** @@ -600,9 +606,9 @@ GNUNET_OS_command_run(GNUNET_OS_LineProcessor proc, * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise */ int -GNUNET_OS_process_status(struct GNUNET_OS_Process *proc, - enum GNUNET_OS_ProcessStatusType *type, - unsigned long *code); +GNUNET_OS_process_status (struct GNUNET_OS_Process *proc, + enum GNUNET_OS_ProcessStatusType *type, + unsigned long *code); /** @@ -616,7 +622,7 @@ GNUNET_OS_process_status(struct GNUNET_OS_Process *proc, * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise */ int -GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc); +GNUNET_OS_process_wait (struct GNUNET_OS_Process *proc); @@ -630,9 +636,9 @@ GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc); * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise */ int -GNUNET_OS_process_wait_status(struct GNUNET_OS_Process *proc, - enum GNUNET_OS_ProcessStatusType *type, - unsigned long *code); +GNUNET_OS_process_wait_status (struct GNUNET_OS_Process *proc, + enum GNUNET_OS_ProcessStatusType *type, + unsigned long *code); /** @@ -644,7 +650,7 @@ GNUNET_OS_process_wait_status(struct GNUNET_OS_Process *proc, * @param cls closure (unused) */ void -GNUNET_OS_install_parent_control_handler(void *cls); +GNUNET_OS_install_parent_control_handler (void *cls); /** @@ -665,9 +671,9 @@ GNUNET_OS_install_parent_control_handler(void *cls); * #GNUNET_SYSERR on error (no such binary or not executable) */ int -GNUNET_OS_check_helper_binary(const char *binary, - int check_suid, - const char *params); +GNUNET_OS_check_helper_binary (const char *binary, + int check_suid, + const char *params); #if 0 /* keep Emacsens' auto-indent happy */ diff --git a/src/include/gnunet_scheduler_lib.h b/src/include/gnunet_scheduler_lib.h index 39b16a1b4..da968737e 100644 --- a/src/include/gnunet_scheduler_lib.h +++ b/src/include/gnunet_scheduler_lib.h @@ -52,7 +52,8 @@ struct GNUNET_SCHEDULER_Task; * Reasons why the schedule may have triggered * the task now. */ -enum GNUNET_SCHEDULER_Reason { +enum GNUNET_SCHEDULER_Reason +{ /** * This task is not ready. */ @@ -99,7 +100,8 @@ enum GNUNET_SCHEDULER_Reason { * Possible events on FDs, used as a bitmask. * Modelled after GPollFD. */ -enum GNUNET_SCHEDULER_EventType { +enum GNUNET_SCHEDULER_EventType +{ /** * No event (useful for timeout). */ @@ -140,7 +142,8 @@ enum GNUNET_SCHEDULER_EventType { /** * Information about an event relating to a file descriptor/socket. */ -struct GNUNET_SCHEDULER_FdInfo { +struct GNUNET_SCHEDULER_FdInfo +{ /** * GNUnet network socket the event is about, matches @a sock, * NULL if this is about a file handle or if no network @@ -170,7 +173,8 @@ struct GNUNET_SCHEDULER_FdInfo { /** * Context information passed to each scheduler task. */ -struct GNUNET_SCHEDULER_TaskContext { +struct GNUNET_SCHEDULER_TaskContext +{ /** * Reason why the task is run now */ @@ -219,8 +223,8 @@ struct GNUNET_SCHEDULER_TaskContext { * @param fdi information about the related FD */ void -GNUNET_SCHEDULER_task_ready(struct GNUNET_SCHEDULER_Task *task, - struct GNUNET_SCHEDULER_FdInfo *fdi); +GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task, + struct GNUNET_SCHEDULER_FdInfo *fdi); /** @@ -250,14 +254,15 @@ struct GNUNET_SCHEDULER_Handle; * if we are done running tasks (yield to block) */ int -GNUNET_SCHEDULER_do_work(struct GNUNET_SCHEDULER_Handle *sh); +GNUNET_SCHEDULER_do_work (struct GNUNET_SCHEDULER_Handle *sh); /** * API an external event loop has to implement for * #GNUNET_SCHEDULER_driver_init. */ -struct GNUNET_SCHEDULER_Driver { +struct GNUNET_SCHEDULER_Driver +{ /** * Closure to pass to the functions in this struct. */ @@ -348,7 +353,7 @@ typedef void * #GNUNET_SCHEDULER_driver_done */ struct GNUNET_SCHEDULER_Handle * -GNUNET_SCHEDULER_driver_init(const struct GNUNET_SCHEDULER_Driver *driver); +GNUNET_SCHEDULER_driver_init (const struct GNUNET_SCHEDULER_Driver *driver); /** @@ -366,7 +371,7 @@ GNUNET_SCHEDULER_driver_init(const struct GNUNET_SCHEDULER_Driver *driver); * @param sh the handle returned by #GNUNET_SCHEDULER_driver_init */ void -GNUNET_SCHEDULER_driver_done(struct GNUNET_SCHEDULER_Handle *sh); +GNUNET_SCHEDULER_driver_done (struct GNUNET_SCHEDULER_Handle *sh); /** @@ -375,7 +380,7 @@ GNUNET_SCHEDULER_driver_done(struct GNUNET_SCHEDULER_Handle *sh); * @return NULL on error */ struct GNUNET_SCHEDULER_Driver * -GNUNET_SCHEDULER_driver_select(void); +GNUNET_SCHEDULER_driver_select (void); /** @@ -412,8 +417,8 @@ typedef int * @param task_cls closure of @a task */ void -GNUNET_SCHEDULER_run(GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** * Initialize and run scheduler. This function will return when all @@ -427,9 +432,9 @@ GNUNET_SCHEDULER_run(GNUNET_SCHEDULER_TaskCallback task, * @param task_cls closure of @a task */ void -GNUNET_SCHEDULER_run_with_optional_signals(int install_signals, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_run_with_optional_signals (int install_signals, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -439,7 +444,7 @@ GNUNET_SCHEDULER_run_with_optional_signals(int install_signals, * will be delayed until the next shutdown signal. */ void -GNUNET_SCHEDULER_shutdown(void); +GNUNET_SCHEDULER_shutdown (void); /** @@ -454,7 +459,7 @@ GNUNET_SCHEDULER_shutdown(void); * @return number of tasks pending right now */ unsigned int -GNUNET_SCHEDULER_get_load(enum GNUNET_SCHEDULER_Priority p); +GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p); /** @@ -464,7 +469,7 @@ GNUNET_SCHEDULER_get_load(enum GNUNET_SCHEDULER_Priority p); * @return task context with information why the current task is run */ const struct GNUNET_SCHEDULER_TaskContext * -GNUNET_SCHEDULER_get_task_context(void); +GNUNET_SCHEDULER_get_task_context (void); /** @@ -480,7 +485,7 @@ GNUNET_SCHEDULER_get_task_context(void); * @return original closure of the task */ void * -GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task); +GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task); /** @@ -494,10 +499,13 @@ GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task); * @param priority priority to use for the task */ void -GNUNET_SCHEDULER_add_with_reason_and_priority(GNUNET_SCHEDULER_TaskCallback task, - void *task_cls, - enum GNUNET_SCHEDULER_Reason reason, - enum GNUNET_SCHEDULER_Priority priority); +GNUNET_SCHEDULER_add_with_reason_and_priority (GNUNET_SCHEDULER_TaskCallback + task, + void *task_cls, + enum GNUNET_SCHEDULER_Reason + reason, + enum GNUNET_SCHEDULER_Priority + priority); /** @@ -510,9 +518,9 @@ GNUNET_SCHEDULER_add_with_reason_and_priority(GNUNET_SCHEDULER_TaskCallback task * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -531,8 +539,8 @@ GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -546,8 +554,8 @@ GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -565,9 +573,9 @@ GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_now_with_lifeness(int lifeness, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -582,9 +590,9 @@ GNUNET_SCHEDULER_add_now_with_lifeness(int lifeness, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -599,9 +607,9 @@ GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_at (struct GNUNET_TIME_Absolute at, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -616,10 +624,11 @@ GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, - enum GNUNET_SCHEDULER_Priority priority, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay, + enum GNUNET_SCHEDULER_Priority + priority, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -634,10 +643,10 @@ GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_at_with_priority(struct GNUNET_TIME_Absolute at, - enum GNUNET_SCHEDULER_Priority priority, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at, + enum GNUNET_SCHEDULER_Priority priority, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -661,10 +670,10 @@ GNUNET_SCHEDULER_add_at_with_priority(struct GNUNET_TIME_Absolute at, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, - struct GNUNET_NETWORK_Handle *rfd, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay, + struct GNUNET_NETWORK_Handle *rfd, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -690,11 +699,12 @@ GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_read_net_with_priority(struct GNUNET_TIME_Relative delay, - enum GNUNET_SCHEDULER_Priority priority, - struct GNUNET_NETWORK_Handle *rfd, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay, + enum GNUNET_SCHEDULER_Priority + priority, + struct GNUNET_NETWORK_Handle *rfd, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -719,10 +729,10 @@ GNUNET_SCHEDULER_add_read_net_with_priority(struct GNUNET_TIME_Relative delay, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, - struct GNUNET_NETWORK_Handle *wfd, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay, + struct GNUNET_NETWORK_Handle *wfd, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -749,13 +759,13 @@ GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, * only valid until "task" is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_net_with_priority(struct GNUNET_TIME_Relative delay, - enum GNUNET_SCHEDULER_Priority priority, - struct GNUNET_NETWORK_Handle *fd, - int on_read, - int on_write, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_net_with_priority (struct GNUNET_TIME_Relative delay, + enum GNUNET_SCHEDULER_Priority priority, + struct GNUNET_NETWORK_Handle *fd, + int on_read, + int on_write, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -779,10 +789,10 @@ GNUNET_SCHEDULER_add_net_with_priority(struct GNUNET_TIME_Relative delay, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, - const struct GNUNET_DISK_FileHandle *rfd, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay, + const struct GNUNET_DISK_FileHandle *rfd, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -806,10 +816,10 @@ GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_write_file(struct GNUNET_TIME_Relative delay, - const struct GNUNET_DISK_FileHandle *wfd, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay, + const struct GNUNET_DISK_FileHandle *wfd, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -836,12 +846,15 @@ GNUNET_SCHEDULER_add_write_file(struct GNUNET_TIME_Relative delay, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_file_with_priority(struct GNUNET_TIME_Relative delay, - enum GNUNET_SCHEDULER_Priority priority, - const struct GNUNET_DISK_FileHandle *fd, - int on_read, int on_write, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_file_with_priority (struct GNUNET_TIME_Relative delay, + enum GNUNET_SCHEDULER_Priority + priority, + const struct + GNUNET_DISK_FileHandle *fd, + int on_read, + int on_write, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** @@ -876,12 +889,12 @@ GNUNET_SCHEDULER_add_file_with_priority(struct GNUNET_TIME_Relative delay, * only valid until @a task is started! */ struct GNUNET_SCHEDULER_Task * -GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, - struct GNUNET_TIME_Relative delay, - const struct GNUNET_NETWORK_FDSet *rs, - const struct GNUNET_NETWORK_FDSet *ws, - GNUNET_SCHEDULER_TaskCallback task, - void *task_cls); +GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio, + struct GNUNET_TIME_Relative delay, + const struct GNUNET_NETWORK_FDSet *rs, + const struct GNUNET_NETWORK_FDSet *ws, + GNUNET_SCHEDULER_TaskCallback task, + void *task_cls); /** * Sets the select function to use in the scheduler (scheduler_select). @@ -890,8 +903,8 @@ GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, * @param new_select_cls closure for @a new_select */ void -GNUNET_SCHEDULER_set_select(GNUNET_SCHEDULER_select new_select, - void *new_select_cls); +GNUNET_SCHEDULER_set_select (GNUNET_SCHEDULER_select new_select, + void *new_select_cls); @@ -908,7 +921,7 @@ GNUNET_SCHEDULER_set_select(GNUNET_SCHEDULER_select new_select, * @param aid the asynchronous scope id to enter */ void -GNUNET_SCHEDULER_begin_async_scope(struct GNUNET_AsyncScopeId *aid); +GNUNET_SCHEDULER_begin_async_scope (struct GNUNET_AsyncScopeId *aid); diff --git a/src/include/gnunet_service_lib.h b/src/include/gnunet_service_lib.h index 9cdf4d459..19a5fb89b 100644 --- a/src/include/gnunet_service_lib.h +++ b/src/include/gnunet_service_lib.h @@ -50,7 +50,8 @@ extern "C" /** * Options for the service (bitmask). */ -enum GNUNET_SERVICE_Options { +enum GNUNET_SERVICE_Options +{ /** * Use defaults. Terminates all client connections and the listen * sockets immediately upon receiving the shutdown signal. @@ -68,7 +69,18 @@ enum GNUNET_SERVICE_Options { * Trigger a SOFT server shutdown on signals, allowing active * non-monitor clients to complete their transactions. */ - GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN = 2 + GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN = 2, + + /** + * Bitmask over the shutdown options. + */ + GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK = 3, + + /** + * Instead of listening on lsocks passed by the parent, + * close them *after* opening our own listen socket(s). + */ + GNUNET_SERVICE_OPTION_CLOSE_LSOCKS = 4 }; @@ -164,12 +176,12 @@ typedef void * @return NULL on error */ struct GNUNET_SERVICE_Handle * -GNUNET_SERVICE_start(const char *service_name, - const struct GNUNET_CONFIGURATION_Handle *cfg, - GNUNET_SERVICE_ConnectHandler connect_cb, - GNUNET_SERVICE_DisconnectHandler disconnect_cb, - void *cls, - const struct GNUNET_MQ_MessageHandler *handlers); +GNUNET_SERVICE_start (const char *service_name, + const struct GNUNET_CONFIGURATION_Handle *cfg, + GNUNET_SERVICE_ConnectHandler connect_cb, + GNUNET_SERVICE_DisconnectHandler disconnect_cb, + void *cls, + const struct GNUNET_MQ_MessageHandler *handlers); /** @@ -178,7 +190,7 @@ GNUNET_SERVICE_start(const char *service_name, * @param srv service to stop */ void -GNUNET_SERVICE_stop(struct GNUNET_SERVICE_Handle *srv); +GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Handle *srv); /** @@ -223,15 +235,15 @@ GNUNET_SERVICE_stop(struct GNUNET_SERVICE_Handle *srv); * @return 0 on success, non-zero on error */ int -GNUNET_SERVICE_run_(int argc, - char *const *argv, - const char *service_name, - enum GNUNET_SERVICE_Options options, - GNUNET_SERVICE_InitCallback service_init_cb, - GNUNET_SERVICE_ConnectHandler connect_cb, - GNUNET_SERVICE_DisconnectHandler disconnect_cb, - void *cls, - const struct GNUNET_MQ_MessageHandler *handlers); +GNUNET_SERVICE_run_ (int argc, + char *const *argv, + const char *service_name, + enum GNUNET_SERVICE_Options options, + GNUNET_SERVICE_InitCallback service_init_cb, + GNUNET_SERVICE_ConnectHandler connect_cb, + GNUNET_SERVICE_DisconnectHandler disconnect_cb, + void *cls, + const struct GNUNET_MQ_MessageHandler *handlers); /** @@ -291,23 +303,24 @@ GNUNET_SERVICE_run_(int argc, * GNUNET_MQ_handler_end ()); * */ -#define GNUNET_SERVICE_MAIN(service_name, service_options, init_cb, connect_cb, disconnect_cb, cls, ...) \ +#define GNUNET_SERVICE_MAIN(service_name, service_options, init_cb, connect_cb, \ + disconnect_cb, cls, ...) \ int \ - main(int argc, \ - char *const *argv) \ + main (int argc, \ + char *const *argv) \ { \ struct GNUNET_MQ_MessageHandler mh[] = { \ __VA_ARGS__ \ }; \ - return GNUNET_SERVICE_run_(argc, \ - argv, \ - service_name, \ - service_options, \ - init_cb, \ - connect_cb, \ - disconnect_cb, \ - cls, \ - mh); \ + return GNUNET_SERVICE_run_ (argc, \ + argv, \ + service_name, \ + service_options, \ + init_cb, \ + connect_cb, \ + disconnect_cb, \ + cls, \ + mh); \ } @@ -318,7 +331,7 @@ GNUNET_SERVICE_run_(int argc, * @param sh service to stop accepting connections. */ void -GNUNET_SERVICE_suspend(struct GNUNET_SERVICE_Handle *sh); +GNUNET_SERVICE_suspend (struct GNUNET_SERVICE_Handle *sh); /** @@ -327,7 +340,7 @@ GNUNET_SERVICE_suspend(struct GNUNET_SERVICE_Handle *sh); * @param sh service to resume accepting connections. */ void -GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh); +GNUNET_SERVICE_resume (struct GNUNET_SERVICE_Handle *sh); /** @@ -337,7 +350,7 @@ GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh); * @param c the client to continue receiving from */ void -GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c); +GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c); /** @@ -347,7 +360,7 @@ GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c); * @return the message queue of @a c */ struct GNUNET_MQ_Handle * -GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c); +GNUNET_SERVICE_client_get_mq (struct GNUNET_SERVICE_Client *c); /** @@ -359,7 +372,8 @@ GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c); * @param c client for which to disable the warning */ void -GNUNET_SERVICE_client_disable_continue_warning(struct GNUNET_SERVICE_Client *c); +GNUNET_SERVICE_client_disable_continue_warning (struct + GNUNET_SERVICE_Client *c); /** @@ -378,7 +392,7 @@ GNUNET_SERVICE_client_disable_continue_warning(struct GNUNET_SERVICE_Client *c); * @param c client to disconnect now */ void -GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c); +GNUNET_SERVICE_client_drop (struct GNUNET_SERVICE_Client *c); /** @@ -387,7 +401,7 @@ GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c); * @param sh server to shutdown */ void -GNUNET_SERVICE_shutdown(struct GNUNET_SERVICE_Handle *sh); +GNUNET_SERVICE_shutdown (struct GNUNET_SERVICE_Handle *sh); /** @@ -403,7 +417,7 @@ GNUNET_SERVICE_shutdown(struct GNUNET_SERVICE_Handle *sh); * @param c client to mark as a monitor */ void -GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c); +GNUNET_SERVICE_client_mark_monitor (struct GNUNET_SERVICE_Client *c); /** @@ -414,7 +428,7 @@ GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c); * @param c client to persist the socket (never to be closed) */ void -GNUNET_SERVICE_client_persist(struct GNUNET_SERVICE_Client *c); +GNUNET_SERVICE_client_persist (struct GNUNET_SERVICE_Client *c); #if 0 /* keep Emacsens' auto-indent happy */ diff --git a/src/util/service.c b/src/util/service.c index 25c1ba338..21b99547c 100644 --- a/src/util/service.c +++ b/src/util/service.c @@ -175,6 +175,7 @@ struct GNUNET_SERVICE_Handle */ void *task_cls; + /** * IPv4 addresses that are not allowed to connect. */ @@ -408,18 +409,16 @@ service_shutdown (void *cls) { struct GNUNET_SERVICE_Handle *sh = cls; - switch (sh->options) + switch (sh->options & GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK) { case GNUNET_SERVICE_OPTION_NONE: GNUNET_SERVICE_shutdown (sh); break; - case GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN: /* This task should never be run if we are using the manual shutdown. */ GNUNET_assert (0); break; - case GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN: if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN)) do_suspend (sh, SUSPEND_STATE_SHUTDOWN); @@ -902,7 +901,8 @@ service_main (void *cls) { struct GNUNET_SERVICE_Handle *sh = cls; - if (GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN != sh->options) + if (GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN != + (sh->options & GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK)) GNUNET_SCHEDULER_add_shutdown (&service_shutdown, sh); do_resume (sh, SUSPEND_STATE_NONE); @@ -1361,15 +1361,12 @@ open_listen_socket (const struct sockaddr *server_addr, case AF_INET: port = ntohs (((const struct sockaddr_in *) server_addr)->sin_port); break; - case AF_INET6: port = ntohs (((const struct sockaddr_in6 *) server_addr)->sin6_port); break; - case AF_UNIX: port = 0; break; - default: GNUNET_break (0); port = 0; @@ -1463,13 +1460,16 @@ static int setup_service (struct GNUNET_SERVICE_Handle *sh) { int tolerant; + struct GNUNET_NETWORK_Handle **csocks = NULL; struct GNUNET_NETWORK_Handle **lsocks; const char *nfds; unsigned int cnt; int flags; char dummy[2]; - if (GNUNET_CONFIGURATION_have_value (sh->cfg, sh->service_name, "TOLERANT")) + if (GNUNET_CONFIGURATION_have_value (sh->cfg, + sh->service_name, + "TOLERANT")) { if (GNUNET_SYSERR == (tolerant = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg, @@ -1487,7 +1487,6 @@ setup_service (struct GNUNET_SERVICE_Handle *sh) tolerant = GNUNET_NO; lsocks = NULL; - errno = 0; if ((NULL != (nfds = getenv ("LISTEN_FDS"))) && (1 == sscanf (nfds, "%u%1s", &cnt, dummy)) && (cnt > 0) && @@ -1515,13 +1514,17 @@ setup_service (struct GNUNET_SERVICE_Handle *sh) } unsetenv ("LISTEN_FDS"); } + if ( (0 != (GNUNET_SERVICE_OPTION_CLOSE_LSOCKS & sh->options)) && + (NULL != lsocks) ) + { + csocks = lsocks; + lsocks = NULL; + } if (NULL != lsocks) { /* listen only on inherited sockets if we have any */ - struct GNUNET_NETWORK_Handle **ls; - - for (ls = lsocks; NULL != *ls; ls++) + for (struct GNUNET_NETWORK_Handle **ls = lsocks; NULL != *ls; ls++) { struct ServiceListenContext *slc; @@ -1567,10 +1570,17 @@ setup_service (struct GNUNET_SERVICE_Handle *sh) GNUNET_ERROR_TYPE_ERROR, _ ( "Could not bind to any of the ports I was supposed to, refusing to run!\n")); + GNUNET_free_non_null (csocks); return GNUNET_SYSERR; } } - + if (NULL != csocks) + { + /* close inherited sockets to signal parent that we are ready */ + for (struct GNUNET_NETWORK_Handle **ls = csocks; NULL != *ls; ls++) + GNUNET_NETWORK_socket_close (*ls); + GNUNET_free (csocks); + } sh->require_found = tolerant ? GNUNET_NO : GNUNET_YES; sh->match_uid = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg, sh->service_name, @@ -1981,9 +1991,8 @@ GNUNET_SERVICE_run_ (int argc, int ret; int err; const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get (); - - struct GNUNET_GETOPT_CommandLineOption service_options[] = - { GNUNET_GETOPT_option_cfgfile (&opt_cfg_filename), + struct GNUNET_GETOPT_CommandLineOption service_options[] = { + GNUNET_GETOPT_option_cfgfile (&opt_cfg_filename), GNUNET_GETOPT_option_flag ('d', "daemonize", gettext_noop ( @@ -1993,7 +2002,8 @@ GNUNET_SERVICE_run_ (int argc, GNUNET_GETOPT_option_loglevel (&loglev), GNUNET_GETOPT_option_logfile (&logfile), GNUNET_GETOPT_option_version (pd->version), - GNUNET_GETOPT_OPTION_END }; + GNUNET_GETOPT_OPTION_END + }; err = 1; memset (&sh, 0, sizeof(sh)); @@ -2036,7 +2046,10 @@ GNUNET_SERVICE_run_ (int argc, textdomain (pd->gettext_domain); } #endif - ret = GNUNET_GETOPT_run (service_name, service_options, argc, argv); + ret = GNUNET_GETOPT_run (service_name, + service_options, + argc, + argv); if (GNUNET_SYSERR == ret) goto shutdown; if (GNUNET_NO == ret) @@ -2044,7 +2057,9 @@ GNUNET_SERVICE_run_ (int argc, err = 0; goto shutdown; } - if (GNUNET_OK != GNUNET_log_setup (service_name, loglev, logfile)) + if (GNUNET_OK != GNUNET_log_setup (service_name, + loglev, + logfile)) { GNUNET_break (0); goto shutdown; -- cgit v1.2.3