From c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sat, 5 Oct 2019 15:09:28 +0200 Subject: global reindent, now with uncrustify hook enabled --- src/hostlist/gnunet-daemon-hostlist.c | 267 +-- src/hostlist/gnunet-daemon-hostlist_client.c | 1765 ++++++++++---------- src/hostlist/gnunet-daemon-hostlist_client.h | 14 +- src/hostlist/gnunet-daemon-hostlist_server.c | 881 +++++----- src/hostlist/gnunet-daemon-hostlist_server.h | 12 +- src/hostlist/test_gnunet_daemon_hostlist.c | 226 +-- .../test_gnunet_daemon_hostlist_learning.c | 647 +++---- .../test_gnunet_daemon_hostlist_reconnect.c | 245 +-- 8 files changed, 2035 insertions(+), 2022 deletions(-) (limited to 'src/hostlist') diff --git a/src/hostlist/gnunet-daemon-hostlist.c b/src/hostlist/gnunet-daemon-hostlist.c index 7c1863dc0..bf6542d7f 100644 --- a/src/hostlist/gnunet-daemon-hostlist.c +++ b/src/hostlist/gnunet-daemon-hostlist.c @@ -102,7 +102,8 @@ GNUNET_NETWORK_STRUCT_BEGIN * unaligned!) * 4) address (address-length bytes; possibly unaligned!) */ -struct GNUNET_HOSTLIST_ADV_Message { +struct GNUNET_HOSTLIST_ADV_Message +{ /** * Type will be GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT. */ @@ -129,8 +130,8 @@ static struct GNUNET_PeerIdentity me; * @param my_identity our peer's identity */ static void -core_init(void *cls, - const struct GNUNET_PeerIdentity *my_identity) +core_init (void *cls, + const struct GNUNET_PeerIdentity *my_identity) { me = *my_identity; } @@ -144,26 +145,26 @@ core_init(void *cls, * @return #GNUNET_OK if message is well-formed */ static int -check_advertisement(void *cls, - const struct GNUNET_MessageHeader *message) +check_advertisement (void *cls, + const struct GNUNET_MessageHeader *message) { size_t size; size_t uri_size; const char *uri; - size = ntohs(message->size); + size = ntohs (message->size); if (size <= sizeof(struct GNUNET_MessageHeader)) - { - GNUNET_break_op(0); - return GNUNET_SYSERR; - } - uri = (const char *)&message[1]; + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } + uri = (const char *) &message[1]; uri_size = size - sizeof(struct GNUNET_MessageHeader); if (uri[uri_size - 1] != '\0') - { - GNUNET_break_op(0); - return GNUNET_SYSERR; - } + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -176,13 +177,13 @@ check_advertisement(void *cls, * @return #GNUNET_OK on success */ static void -handle_advertisement(void *cls, - const struct GNUNET_MessageHeader *message) +handle_advertisement (void *cls, + const struct GNUNET_MessageHeader *message) { - const char *uri = (const char *)&message[1]; + const char *uri = (const char *) &message[1]; - GNUNET_assert(NULL != client_adv_handler); - (void)(*client_adv_handler)(uri); + GNUNET_assert (NULL != client_adv_handler); + (void) (*client_adv_handler)(uri); } @@ -196,28 +197,28 @@ handle_advertisement(void *cls, * @return peer */ static void * -connect_handler(void *cls, - const struct GNUNET_PeerIdentity *peer, - struct GNUNET_MQ_Handle *mq) +connect_handler (void *cls, + const struct GNUNET_PeerIdentity *peer, + struct GNUNET_MQ_Handle *mq) { - if (0 == GNUNET_memcmp(&me, - peer)) + if (0 == GNUNET_memcmp (&me, + peer)) return NULL; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "A new peer connected, notifying client and server\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "A new peer connected, notifying client and server\n"); if (NULL != client_ch) - GNUNET_assert(NULL == - (*client_ch)(cls, - peer, - mq)); + GNUNET_assert (NULL == + (*client_ch)(cls, + peer, + mq)); #if HAVE_MHD if (NULL != server_ch) - GNUNET_assert(NULL == - (*server_ch)(cls, - peer, - mq)); + GNUNET_assert (NULL == + (*server_ch)(cls, + peer, + mq)); #endif - return (void *)peer; + return (void *) peer; } @@ -229,12 +230,12 @@ connect_handler(void *cls, * @param peer peer identity this notification is about */ static void -disconnect_handler(void *cls, - const struct GNUNET_PeerIdentity *peer, - void *internal_cls) +disconnect_handler (void *cls, + const struct GNUNET_PeerIdentity *peer, + void *internal_cls) { - if (0 == GNUNET_memcmp(&me, - peer)) + if (0 == GNUNET_memcmp (&me, + peer)) return; /* call hostlist client disconnect handler */ if (NULL != client_dh) @@ -251,31 +252,31 @@ disconnect_handler(void *cls, * @param cls NULL */ static void -cleaning_task(void *cls) +cleaning_task (void *cls) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Hostlist daemon is shutting down\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Hostlist daemon is shutting down\n"); if (NULL != core) - { - GNUNET_CORE_disconnect(core); - core = NULL; - } + { + GNUNET_CORE_disconnect (core); + core = NULL; + } if (bootstrapping) - { - GNUNET_HOSTLIST_client_stop(); - } + { + GNUNET_HOSTLIST_client_stop (); + } #if HAVE_MHD if (provide_hostlist) - { - GNUNET_HOSTLIST_server_stop(); - } + { + GNUNET_HOSTLIST_server_stop (); + } #endif if (NULL != stats) - { - GNUNET_STATISTICS_destroy(stats, - GNUNET_NO); - stats = NULL; - } + { + GNUNET_STATISTICS_destroy (stats, + GNUNET_NO); + stats = NULL; + } } @@ -288,72 +289,73 @@ cleaning_task(void *cls) * @param cfg configuration */ static void -run(void *cls, - char *const *args, - const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *cfg) +run (void *cls, + char *const *args, + const char *cfgfile, + const struct GNUNET_CONFIGURATION_Handle *cfg) { struct GNUNET_MQ_MessageHandler learn_handlers[] = { - GNUNET_MQ_hd_var_size(advertisement, - GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, - struct GNUNET_MessageHeader, - NULL), - GNUNET_MQ_handler_end() + GNUNET_MQ_hd_var_size (advertisement, + GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, + struct GNUNET_MessageHeader, + NULL), + GNUNET_MQ_handler_end () }; struct GNUNET_MQ_MessageHandler no_learn_handlers[] = { - GNUNET_MQ_handler_end() + GNUNET_MQ_handler_end () }; - if ((!bootstrapping) && (!learning) + if ((! bootstrapping) && (! learning) #if HAVE_MHD - && (!provide_hostlist) + && (! provide_hostlist) #endif ) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _("None of the functions for the hostlist daemon were enabled. I have no reason to run!\n")); - return; - } - stats = GNUNET_STATISTICS_create("hostlist", cfg); + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ( + "None of the functions for the hostlist daemon were enabled. I have no reason to run!\n")); + return; + } + stats = GNUNET_STATISTICS_create ("hostlist", cfg); if (NULL == stats) - { - GNUNET_break(0); - return; - } + { + GNUNET_break (0); + return; + } if (bootstrapping) - GNUNET_HOSTLIST_client_start(cfg, - stats, - &client_ch, - &client_dh, - &client_adv_handler, - learning); + GNUNET_HOSTLIST_client_start (cfg, + stats, + &client_ch, + &client_dh, + &client_adv_handler, + learning); core = - GNUNET_CORE_connect(cfg, - NULL, - &core_init, - &connect_handler, - &disconnect_handler, - learning ? learn_handlers : no_learn_handlers); + GNUNET_CORE_connect (cfg, + NULL, + &core_init, + &connect_handler, + &disconnect_handler, + learning ? learn_handlers : no_learn_handlers); #if HAVE_MHD if (provide_hostlist) - GNUNET_HOSTLIST_server_start(cfg, - stats, - core, - &server_ch, - advertising); + GNUNET_HOSTLIST_server_start (cfg, + stats, + core, + &server_ch, + advertising); #endif - GNUNET_SCHEDULER_add_shutdown(&cleaning_task, - NULL); + GNUNET_SCHEDULER_add_shutdown (&cleaning_task, + NULL); if (NULL == core) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("Failed to connect to `%s' service.\n"), "core"); - GNUNET_SCHEDULER_shutdown(); - return; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("Failed to connect to `%s' service.\n"), "core"); + GNUNET_SCHEDULER_shutdown (); + return; + } } @@ -365,46 +367,49 @@ run(void *cls, * @return 0 ok, 1 on error */ int -main(int argc, char *const *argv) +main (int argc, char *const *argv) { struct GNUNET_GETOPT_CommandLineOption options[] = { #if HAVE_MHD - GNUNET_GETOPT_option_flag('a', - "advertise", - gettext_noop("advertise our hostlist to other peers"), - &advertising), + GNUNET_GETOPT_option_flag ('a', + "advertise", + gettext_noop ( + "advertise our hostlist to other peers"), + &advertising), #endif - GNUNET_GETOPT_option_flag('b', - "bootstrap", - gettext_noop("bootstrap using hostlists (it is highly recommended that you always use this option)"), - &bootstrapping), - GNUNET_GETOPT_option_flag('e', - "enable-learning", - gettext_noop("enable learning about hostlist servers from other peers"), - &learning), + GNUNET_GETOPT_option_flag ('b', + "bootstrap", + gettext_noop ( + "bootstrap using hostlists (it is highly recommended that you always use this option)"), + &bootstrapping), + GNUNET_GETOPT_option_flag ('e', + "enable-learning", + gettext_noop ( + "enable learning about hostlist servers from other peers"), + &learning), #if HAVE_MHD - GNUNET_GETOPT_option_flag('p', - "provide-hostlist", - gettext_noop("provide a hostlist server"), - &provide_hostlist), + GNUNET_GETOPT_option_flag ('p', + "provide-hostlist", + gettext_noop ("provide a hostlist server"), + &provide_hostlist), #endif GNUNET_GETOPT_OPTION_END }; int ret; - if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) + if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) return 2; - GNUNET_log_setup("hostlist", "WARNING", NULL); + GNUNET_log_setup ("hostlist", "WARNING", NULL); ret = (GNUNET_OK == - GNUNET_PROGRAM_run(argc, argv, - "hostlist", - _("GNUnet hostlist server and client"), - options, - &run, NULL)) ? 0 : 1; - GNUNET_free((void*)argv); + GNUNET_PROGRAM_run (argc, argv, + "hostlist", + _ ("GNUnet hostlist server and client"), + options, + &run, NULL)) ? 0 : 1; + GNUNET_free ((void*) argv); return ret; } diff --git a/src/hostlist/gnunet-daemon-hostlist_client.c b/src/hostlist/gnunet-daemon-hostlist_client.c index af3fd6fce..564aef2bd 100644 --- a/src/hostlist/gnunet-daemon-hostlist_client.c +++ b/src/hostlist/gnunet-daemon-hostlist_client.c @@ -49,19 +49,19 @@ * Time interval hostlists are saved to disk */ #define SAVING_INTERVAL \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30) /** * Time interval between two hostlist tests */ #define TESTING_INTERVAL \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 3) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3) /** * Time interval for download dispatcher before a download is re-scheduled */ #define WAITING_INTERVAL \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1) /** * Defines concerning the hostlist quality metric @@ -91,7 +91,8 @@ /** * A single hostlist obtained by hostlist advertisements */ -struct Hostlist { +struct Hostlist +{ /** * previous entry, used to manage entries in a double linked list */ @@ -320,7 +321,7 @@ static struct GNUNET_PEERINFO_Handle *pi; * @return number of bytes that were processed (always size*nmemb) */ static size_t -callback_download(void *ptr, size_t size, size_t nmemb, void *ctx) +callback_download (void *ptr, size_t size, size_t nmemb, void *ctx) { static char download_buffer[GNUNET_MAX_MESSAGE_SIZE - 1]; const char *cbuf = ptr; @@ -333,85 +334,85 @@ callback_download(void *ptr, size_t size, size_t nmemb, void *ctx) total = size * nmemb; stat_bytes_downloaded += total; if ((total == 0) || (stat_bogus_url)) - { - return total; /* ok, no data or bogus data */ - } - - GNUNET_STATISTICS_update(stats, - gettext_noop( - "# bytes downloaded from hostlist servers"), - (int64_t)total, - GNUNET_NO); + { + return total; /* ok, no data or bogus data */ + } + + GNUNET_STATISTICS_update (stats, + gettext_noop ( + "# bytes downloaded from hostlist servers"), + (int64_t) total, + GNUNET_NO); left = total; while ((left > 0) || (download_pos > 0)) + { + cpy = GNUNET_MIN (left, GNUNET_MAX_MESSAGE_SIZE - 1 - download_pos); + GNUNET_memcpy (&download_buffer[download_pos], cbuf, cpy); + cbuf += cpy; + download_pos += cpy; + left -= cpy; + if (download_pos < sizeof(struct GNUNET_MessageHeader)) { - cpy = GNUNET_MIN(left, GNUNET_MAX_MESSAGE_SIZE - 1 - download_pos); - GNUNET_memcpy(&download_buffer[download_pos], cbuf, cpy); - cbuf += cpy; - download_pos += cpy; - left -= cpy; - if (download_pos < sizeof(struct GNUNET_MessageHeader)) - { - GNUNET_assert(0 == left); - break; - } - msg = (const struct GNUNET_MessageHeader *)download_buffer; - msize = ntohs(msg->size); - if (msize < sizeof(struct GNUNET_MessageHeader)) - { - GNUNET_STATISTICS_update( - stats, - gettext_noop("# invalid HELLOs downloaded from hostlist servers"), - 1, - GNUNET_NO); - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Invalid `%s' message received from hostlist at `%s'\n"), - "HELLO", - current_url); - stat_hellos_obtained++; - stat_bogus_url = 1; - return total; - } - if (download_pos < msize) - { - GNUNET_assert(left == 0); - break; - } - if (GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)msg) == msize) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Received valid `%s' message from hostlist server.\n", - "HELLO"); - GNUNET_STATISTICS_update( - stats, - gettext_noop("# valid HELLOs downloaded from hostlist servers"), - 1, - GNUNET_NO); - stat_hellos_obtained++; - (void) - GNUNET_PEERINFO_add_peer(pi, - (const struct GNUNET_HELLO_Message *)msg, - NULL, - NULL); - } - else - { - GNUNET_STATISTICS_update( - stats, - gettext_noop("# invalid HELLOs downloaded from hostlist servers"), - 1, - GNUNET_NO); - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Invalid `%s' message received from hostlist at `%s'\n"), - "HELLO", - current_url); - stat_bogus_url = GNUNET_YES; - stat_hellos_obtained++; - return total; - } - memmove(download_buffer, &download_buffer[msize], download_pos - msize); - download_pos -= msize; + GNUNET_assert (0 == left); + break; + } + msg = (const struct GNUNET_MessageHeader *) download_buffer; + msize = ntohs (msg->size); + if (msize < sizeof(struct GNUNET_MessageHeader)) + { + GNUNET_STATISTICS_update ( + stats, + gettext_noop ("# invalid HELLOs downloaded from hostlist servers"), + 1, + GNUNET_NO); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Invalid `%s' message received from hostlist at `%s'\n"), + "HELLO", + current_url); + stat_hellos_obtained++; + stat_bogus_url = 1; + return total; + } + if (download_pos < msize) + { + GNUNET_assert (left == 0); + break; + } + if (GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *) msg) == msize) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received valid `%s' message from hostlist server.\n", + "HELLO"); + GNUNET_STATISTICS_update ( + stats, + gettext_noop ("# valid HELLOs downloaded from hostlist servers"), + 1, + GNUNET_NO); + stat_hellos_obtained++; + (void) + GNUNET_PEERINFO_add_peer (pi, + (const struct GNUNET_HELLO_Message *) msg, + NULL, + NULL); } + else + { + GNUNET_STATISTICS_update ( + stats, + gettext_noop ("# invalid HELLOs downloaded from hostlist servers"), + 1, + GNUNET_NO); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Invalid `%s' message received from hostlist at `%s'\n"), + "HELLO", + current_url); + stat_bogus_url = GNUNET_YES; + stat_hellos_obtained++; + return total; + } + memmove (download_buffer, &download_buffer[msize], download_pos - msize); + download_pos -= msize; + } return total; } @@ -422,63 +423,63 @@ callback_download(void *ptr, size_t size, size_t nmemb, void *ctx) * @return NULL if there is no URL available */ static char * -get_bootstrap_server() +get_bootstrap_server () { char *servers; char *ret; size_t urls; size_t pos; - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, - "HOSTLIST", - "SERVERS", - &servers)) - { - GNUNET_log_config_missing(GNUNET_ERROR_TYPE_WARNING, - "hostlist", - "SERVERS"); - return NULL; - } + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, + "HOSTLIST", + "SERVERS", + &servers)) + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, + "hostlist", + "SERVERS"); + return NULL; + } urls = 0; - if (strlen(servers) > 0) + if (strlen (servers) > 0) + { + urls++; + pos = strlen (servers) - 1; + while (pos > 0) { - urls++; - pos = strlen(servers) - 1; - while (pos > 0) - { - if (servers[pos] == ' ') - urls++; - pos--; - } + if (servers[pos] == ' ') + urls++; + pos--; } + } if (urls == 0) - { - GNUNET_log_config_missing(GNUNET_ERROR_TYPE_WARNING, - "hostlist", - "SERVERS"); - GNUNET_free(servers); - return NULL; - } + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, + "hostlist", + "SERVERS"); + GNUNET_free (servers); + return NULL; + } - urls = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, urls) + 1; - pos = strlen(servers) - 1; + urls = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, urls) + 1; + pos = strlen (servers) - 1; while (pos > 0) + { + if (servers[pos] == ' ') { - if (servers[pos] == ' ') - { - urls--; - servers[pos] = '\0'; - } - if (urls == 0) - { - pos++; - break; - } - pos--; + urls--; + servers[pos] = '\0'; + } + if (urls == 0) + { + pos++; + break; } - ret = GNUNET_strdup(&servers[pos]); - GNUNET_free(servers); + pos--; + } + ret = GNUNET_strdup (&servers[pos]); + GNUNET_free (servers); return ret; } @@ -488,64 +489,64 @@ get_bootstrap_server() * @return uri to use, NULL if there is no URL available */ static char * -download_get_url() +download_get_url () { uint32_t index; unsigned int counter; struct Hostlist *pos; if (GNUNET_NO == stat_learning) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Using preconfigured bootstrap server\n"); - current_hostlist = NULL; - return get_bootstrap_server(); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Using preconfigured bootstrap server\n"); + current_hostlist = NULL; + return get_bootstrap_server (); + } if ((GNUNET_YES == stat_testing_hostlist) && (NULL != hostlist_to_test)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Testing new advertised hostlist if it is obtainable\n"); - current_hostlist = hostlist_to_test; - return GNUNET_strdup(hostlist_to_test->hostlist_uri); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Testing new advertised hostlist if it is obtainable\n"); + current_hostlist = hostlist_to_test; + return GNUNET_strdup (hostlist_to_test->hostlist_uri); + } if ((GNUNET_YES == stat_use_bootstrap) || (linked_list_size == 0)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Using preconfigured bootstrap server\n"); - current_hostlist = NULL; - return get_bootstrap_server(); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Using preconfigured bootstrap server\n"); + current_hostlist = NULL; + return get_bootstrap_server (); + } index = - GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, linked_list_size); + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, linked_list_size); counter = 0; pos = linked_list_head; while (counter < index) - { - pos = pos->next; - counter++; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Using learned hostlist `%s'\n", - pos->hostlist_uri); + { + pos = pos->next; + counter++; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Using learned hostlist `%s'\n", + pos->hostlist_uri); current_hostlist = pos; - return GNUNET_strdup(pos->hostlist_uri); + return GNUNET_strdup (pos->hostlist_uri); } #define CURL_EASY_SETOPT(c, a, b) \ do \ - { \ - ret = curl_easy_setopt(c, a, b); \ - if (CURLE_OK != ret) \ + { \ + ret = curl_easy_setopt (c, a, b); \ + if (CURLE_OK != ret) \ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, \ - _("%s failed at %s:%d: `%s'\n"), \ + _ ("%s failed at %s:%d: `%s'\n"), \ "curl_easy_setopt", \ __FILE__, \ __LINE__, \ - curl_easy_strerror(ret)); \ - } while (0) + curl_easy_strerror (ret)); \ + } while (0) /** @@ -554,7 +555,7 @@ download_get_url() * @param shutdown set if called because of shutdown, entries in linked list will be destroyed */ static void -save_hostlist_file(int shutdown); +save_hostlist_file (int shutdown); /** @@ -565,7 +566,7 @@ save_hostlist_file(int shutdown); * @return result */ static uint64_t -checked_add(uint64_t val1, uint64_t val2) +checked_add (uint64_t val1, uint64_t val2) { static uint64_t temp; static uint64_t maxv; @@ -588,7 +589,7 @@ checked_add(uint64_t val1, uint64_t val2) * @return result */ static uint64_t -checked_sub(uint64_t val1, uint64_t val2) +checked_sub (uint64_t val1, uint64_t val2) { if (val1 <= val2) return 0; @@ -603,17 +604,17 @@ checked_sub(uint64_t val1, uint64_t val2) * @return #GNUNET_YES if existing in linked list, #GNUNET_NO if not */ static int -linked_list_contains(const char *uri) +linked_list_contains (const char *uri) { struct Hostlist *pos; pos = linked_list_head; while (pos != NULL) - { - if (0 == strcmp(pos->hostlist_uri, uri)) - return GNUNET_YES; - pos = pos->next; - } + { + if (0 == strcmp (pos->hostlist_uri, uri)) + return GNUNET_YES; + pos = pos->next; + } return GNUNET_NO; } @@ -623,7 +624,7 @@ linked_list_contains(const char *uri) * @return hostlist with lowest quality */ static struct Hostlist * -linked_list_get_lowest_quality() +linked_list_get_lowest_quality () { struct Hostlist *pos; struct Hostlist *lowest; @@ -633,11 +634,11 @@ linked_list_get_lowest_quality() lowest = linked_list_head; pos = linked_list_head->next; while (pos != NULL) - { - if (pos->quality < lowest->quality) - lowest = pos; - pos = pos->next; - } + { + if (pos->quality < lowest->quality) + lowest = pos; + pos = pos->next; + } return lowest; } @@ -648,34 +649,34 @@ linked_list_get_lowest_quality() * quality is dismissed */ static void -insert_hostlist() +insert_hostlist () { struct Hostlist *lowest_quality; if (MAX_NUMBER_HOSTLISTS <= linked_list_size) - { - /* No free entries available, replace existing entry */ - lowest_quality = linked_list_get_lowest_quality(); - GNUNET_assert(lowest_quality != NULL); - GNUNET_log( - GNUNET_ERROR_TYPE_DEBUG, - "Removing hostlist with URI `%s' which has the worst quality of all (%llu)\n", - lowest_quality->hostlist_uri, - (unsigned long long)lowest_quality->quality); - GNUNET_CONTAINER_DLL_remove(linked_list_head, - linked_list_tail, - lowest_quality); - linked_list_size--; - GNUNET_free(lowest_quality); - } - GNUNET_CONTAINER_DLL_insert(linked_list_head, - linked_list_tail, - hostlist_to_test); + { + /* No free entries available, replace existing entry */ + lowest_quality = linked_list_get_lowest_quality (); + GNUNET_assert (lowest_quality != NULL); + GNUNET_log ( + GNUNET_ERROR_TYPE_DEBUG, + "Removing hostlist with URI `%s' which has the worst quality of all (%llu)\n", + lowest_quality->hostlist_uri, + (unsigned long long) lowest_quality->quality); + GNUNET_CONTAINER_DLL_remove (linked_list_head, + linked_list_tail, + lowest_quality); + linked_list_size--; + GNUNET_free (lowest_quality); + } + GNUNET_CONTAINER_DLL_insert (linked_list_head, + linked_list_tail, + hostlist_to_test); linked_list_size++; - GNUNET_STATISTICS_set(stats, - gettext_noop("# advertised hostlist URIs"), - linked_list_size, - GNUNET_NO); + GNUNET_STATISTICS_set (stats, + gettext_noop ("# advertised hostlist URIs"), + linked_list_size, + GNUNET_NO); stat_testing_hostlist = GNUNET_NO; } @@ -684,37 +685,37 @@ insert_hostlist() * Method updating hostlist statistics */ static void -update_hostlist() +update_hostlist () { char *stat; if (((stat_use_bootstrap == GNUNET_NO) && (NULL != current_hostlist)) || ((stat_testing_hostlist == GNUNET_YES) && (NULL != current_hostlist))) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Updating hostlist statics for URI `%s'\n", + current_hostlist->hostlist_uri); + current_hostlist->hello_count = stat_hellos_obtained; + current_hostlist->time_last_usage = GNUNET_TIME_absolute_get (); + current_hostlist->quality = + checked_add (current_hostlist->quality, + (stat_hellos_obtained * HOSTLIST_SUCCESSFUL_HELLO)); + if (GNUNET_YES == stat_download_successful) { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Updating hostlist statics for URI `%s'\n", - current_hostlist->hostlist_uri); - current_hostlist->hello_count = stat_hellos_obtained; - current_hostlist->time_last_usage = GNUNET_TIME_absolute_get(); + current_hostlist->times_used++; current_hostlist->quality = - checked_add(current_hostlist->quality, - (stat_hellos_obtained * HOSTLIST_SUCCESSFUL_HELLO)); - if (GNUNET_YES == stat_download_successful) - { - current_hostlist->times_used++; - current_hostlist->quality = - checked_add(current_hostlist->quality, HOSTLIST_SUCCESSFUL_DOWNLOAD); - GNUNET_asprintf(&stat, - gettext_noop("# advertised URI `%s' downloaded"), - current_hostlist->hostlist_uri); - - GNUNET_STATISTICS_update(stats, stat, 1, GNUNET_YES); - GNUNET_free(stat); - } - else - current_hostlist->quality = - checked_sub(current_hostlist->quality, HOSTLIST_FAILED_DOWNLOAD); + checked_add (current_hostlist->quality, HOSTLIST_SUCCESSFUL_DOWNLOAD); + GNUNET_asprintf (&stat, + gettext_noop ("# advertised URI `%s' downloaded"), + current_hostlist->hostlist_uri); + + GNUNET_STATISTICS_update (stats, stat, 1, GNUNET_YES); + GNUNET_free (stat); } + else + current_hostlist->quality = + checked_sub (current_hostlist->quality, HOSTLIST_FAILED_DOWNLOAD); + } current_hostlist = NULL; /* Alternating the usage of preconfigured and learned hostlists */ @@ -722,12 +723,12 @@ update_hostlist() return; if (GNUNET_YES == stat_learning) - { - if (stat_use_bootstrap == GNUNET_YES) - stat_use_bootstrap = GNUNET_NO; - else - stat_use_bootstrap = GNUNET_YES; - } + { + if (stat_use_bootstrap == GNUNET_YES) + stat_use_bootstrap = GNUNET_NO; + else + stat_use_bootstrap = GNUNET_YES; + } else stat_use_bootstrap = GNUNET_YES; } @@ -738,58 +739,58 @@ update_hostlist() * hostlist and schedule the next task. */ static void -clean_up() +clean_up () { CURLMcode mret; if ((stat_testing_hostlist == GNUNET_YES) && (GNUNET_NO == stat_download_successful) && (NULL != hostlist_to_test)) - { - GNUNET_log( - GNUNET_ERROR_TYPE_INFO, - _( - "Advertised hostlist with URI `%s' could not be downloaded. Advertised URI gets dismissed.\n"), - hostlist_to_test->hostlist_uri); - } + { + GNUNET_log ( + GNUNET_ERROR_TYPE_INFO, + _ ( + "Advertised hostlist with URI `%s' could not be downloaded. Advertised URI gets dismissed.\n"), + hostlist_to_test->hostlist_uri); + } if (stat_testing_hostlist == GNUNET_YES) - { - stat_testing_hostlist = GNUNET_NO; - } + { + stat_testing_hostlist = GNUNET_NO; + } if (NULL != hostlist_to_test) - { - GNUNET_free(hostlist_to_test); - hostlist_to_test = NULL; - } + { + GNUNET_free (hostlist_to_test); + hostlist_to_test = NULL; + } if (NULL != multi) + { + mret = curl_multi_remove_handle (multi, curl); + if (mret != CURLM_OK) { - mret = curl_multi_remove_handle(multi, curl); - if (mret != CURLM_OK) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("%s failed at %s:%d: `%s'\n"), - "curl_multi_remove_handle", - __FILE__, - __LINE__, - curl_multi_strerror(mret)); - } - mret = curl_multi_cleanup(multi); - if (mret != CURLM_OK) - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("%s failed at %s:%d: `%s'\n"), - "curl_multi_cleanup", - __FILE__, - __LINE__, - curl_multi_strerror(mret)); - multi = NULL; + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("%s failed at %s:%d: `%s'\n"), + "curl_multi_remove_handle", + __FILE__, + __LINE__, + curl_multi_strerror (mret)); } + mret = curl_multi_cleanup (multi); + if (mret != CURLM_OK) + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("%s failed at %s:%d: `%s'\n"), + "curl_multi_cleanup", + __FILE__, + __LINE__, + curl_multi_strerror (mret)); + multi = NULL; + } if (NULL != curl) - { - curl_easy_cleanup(curl); - curl = NULL; - } - GNUNET_free_non_null(current_url); + { + curl_easy_cleanup (curl); + curl = NULL; + } + GNUNET_free_non_null (current_url); current_url = NULL; stat_bytes_downloaded = 0; stat_download_in_progress = GNUNET_NO; @@ -804,7 +805,7 @@ clean_up() * @param tc task context, unused */ static void -task_download(void *cls); +task_download (void *cls); /** @@ -812,7 +813,7 @@ task_download(void *cls); * receiving task with the scheduler. */ static void -download_prepare() +download_prepare () { CURLMcode mret; fd_set rs; @@ -825,50 +826,50 @@ download_prepare() struct GNUNET_TIME_Relative rtime; max = -1; - FD_ZERO(&rs); - FD_ZERO(&ws); - FD_ZERO(&es); - mret = curl_multi_fdset(multi, &rs, &ws, &es, &max); + FD_ZERO (&rs); + FD_ZERO (&ws); + FD_ZERO (&es); + mret = curl_multi_fdset (multi, &rs, &ws, &es, &max); if (mret != CURLM_OK) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("%s failed at %s:%d: `%s'\n"), - "curl_multi_fdset", - __FILE__, - __LINE__, - curl_multi_strerror(mret)); - clean_up(); - return; - } - mret = curl_multi_timeout(multi, &timeout); + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("%s failed at %s:%d: `%s'\n"), + "curl_multi_fdset", + __FILE__, + __LINE__, + curl_multi_strerror (mret)); + clean_up (); + return; + } + mret = curl_multi_timeout (multi, &timeout); if (mret != CURLM_OK) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("%s failed at %s:%d: `%s'\n"), - "curl_multi_timeout", - __FILE__, - __LINE__, - curl_multi_strerror(mret)); - clean_up(); - return; - } - rtime = GNUNET_TIME_relative_min( - GNUNET_TIME_absolute_get_remaining(end_time), - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, timeout)); - grs = GNUNET_NETWORK_fdset_create(); - gws = GNUNET_NETWORK_fdset_create(); - GNUNET_NETWORK_fdset_copy_native(grs, &rs, max + 1); - GNUNET_NETWORK_fdset_copy_native(gws, &ws, max + 1); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Scheduling task for hostlist download using cURL\n"); - ti_download = GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT, - rtime, - grs, - gws, - &task_download, - multi); - GNUNET_NETWORK_fdset_destroy(gws); - GNUNET_NETWORK_fdset_destroy(grs); + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("%s failed at %s:%d: `%s'\n"), + "curl_multi_timeout", + __FILE__, + __LINE__, + curl_multi_strerror (mret)); + clean_up (); + return; + } + rtime = GNUNET_TIME_relative_min ( + GNUNET_TIME_absolute_get_remaining (end_time), + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, timeout)); + grs = GNUNET_NETWORK_fdset_create (); + gws = GNUNET_NETWORK_fdset_create (); + GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1); + GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Scheduling task for hostlist download using cURL\n"); + ti_download = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, + rtime, + grs, + gws, + &task_download, + multi); + GNUNET_NETWORK_fdset_destroy (gws); + GNUNET_NETWORK_fdset_destroy (grs); } @@ -879,95 +880,95 @@ download_prepare() * @param cls closure, unused */ static void -task_download(void *cls) +task_download (void *cls) { int running; struct CURLMsg *msg; CURLMcode mret; ti_download = NULL; - if (0 == GNUNET_TIME_absolute_get_remaining(end_time).rel_value_us) + if (0 == GNUNET_TIME_absolute_get_remaining (end_time).rel_value_us) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ("Timeout trying to download hostlist from `%s'\n"), + current_url); + update_hostlist (); + clean_up (); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Ready for processing hostlist client request\n"); + do + { + running = 0; + if (stat_bytes_downloaded > MAX_BYTES_PER_HOSTLISTS) { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _("Timeout trying to download hostlist from `%s'\n"), - current_url); - update_hostlist(); - clean_up(); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ( + "Download limit of %u bytes exceeded, stopping download\n"), + MAX_BYTES_PER_HOSTLISTS); + clean_up (); return; } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Ready for processing hostlist client request\n"); - do + mret = curl_multi_perform (multi, &running); + if (running == 0) { - running = 0; - if (stat_bytes_downloaded > MAX_BYTES_PER_HOSTLISTS) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _( - "Download limit of %u bytes exceeded, stopping download\n"), - MAX_BYTES_PER_HOSTLISTS); - clean_up(); - return; - } - mret = curl_multi_perform(multi, &running); - if (running == 0) + do + { + msg = curl_multi_info_read (multi, &running); + GNUNET_break (msg != NULL); + if (msg == NULL) + break; + switch (msg->msg) { - do + case CURLMSG_DONE: + if ((msg->data.result != CURLE_OK) && + (msg->data.result != CURLE_GOT_NOTHING)) + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ("Download of hostlist from `%s' failed: `%s'\n"), + current_url, + curl_easy_strerror (msg->data.result)); + else + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Download of hostlist `%s' completed.\n"), + current_url); + stat_download_successful = GNUNET_YES; + update_hostlist (); + if (GNUNET_YES == stat_testing_hostlist) { - msg = curl_multi_info_read(multi, &running); - GNUNET_break(msg != NULL); - if (msg == NULL) - break; - switch (msg->msg) - { - case CURLMSG_DONE: - if ((msg->data.result != CURLE_OK) && - (msg->data.result != CURLE_GOT_NOTHING)) - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _("Download of hostlist from `%s' failed: `%s'\n"), - current_url, - curl_easy_strerror(msg->data.result)); - else - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Download of hostlist `%s' completed.\n"), - current_url); - stat_download_successful = GNUNET_YES; - update_hostlist(); - if (GNUNET_YES == stat_testing_hostlist) - { - GNUNET_log( - GNUNET_ERROR_TYPE_INFO, - _("Adding successfully tested hostlist `%s' datastore.\n"), - current_url); - insert_hostlist(); - hostlist_to_test = NULL; - stat_testing_hostlist = GNUNET_NO; - } - } - clean_up(); - return; - - default: - break; - } + GNUNET_log ( + GNUNET_ERROR_TYPE_INFO, + _ ("Adding successfully tested hostlist `%s' datastore.\n"), + current_url); + insert_hostlist (); + hostlist_to_test = NULL; + stat_testing_hostlist = GNUNET_NO; } - while ((running > 0)); + } + clean_up (); + return; + + default: + break; } + } + while ((running > 0)); } + } while (mret == CURLM_CALL_MULTI_PERFORM); if (mret != CURLM_OK) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("%s failed at %s:%d: `%s'\n"), - "curl_multi_perform", - __FILE__, - __LINE__, - curl_multi_strerror(mret)); - clean_up(); - } - download_prepare(); + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("%s failed at %s:%d: `%s'\n"), + "curl_multi_perform", + __FILE__, + __LINE__, + curl_multi_strerror (mret)); + clean_up (); + } + download_prepare (); } @@ -976,133 +977,133 @@ task_download(void *cls) * data. */ static void -download_hostlist() +download_hostlist () { CURLcode ret; CURLMcode mret; - current_url = download_get_url(); + current_url = download_get_url (); if (current_url == NULL) return; - curl = curl_easy_init(); + curl = curl_easy_init (); multi = NULL; if (curl == NULL) - { - GNUNET_break(0); - clean_up(); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK, - _("Bootstrapping using hostlist at `%s'.\n"), - current_url); + { + GNUNET_break (0); + clean_up (); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK, + _ ("Bootstrapping using hostlist at `%s'.\n"), + current_url); stat_download_in_progress = GNUNET_YES; stat_download_successful = GNUNET_NO; stat_hellos_obtained = 0; stat_bytes_downloaded = 0; - GNUNET_STATISTICS_update(stats, - gettext_noop("# hostlist downloads initiated"), - 1, - GNUNET_NO); + GNUNET_STATISTICS_update (stats, + gettext_noop ("# hostlist downloads initiated"), + 1, + GNUNET_NO); if (NULL != proxy) - { - CURL_EASY_SETOPT(curl, CURLOPT_PROXY, proxy); - CURL_EASY_SETOPT(curl, CURLOPT_PROXYTYPE, proxy_type); - if (NULL != proxy_username) - CURL_EASY_SETOPT(curl, CURLOPT_PROXYUSERNAME, proxy_username); - if (NULL != proxy_password) - CURL_EASY_SETOPT(curl, CURLOPT_PROXYPASSWORD, proxy_password); - } + { + CURL_EASY_SETOPT (curl, CURLOPT_PROXY, proxy); + CURL_EASY_SETOPT (curl, CURLOPT_PROXYTYPE, proxy_type); + if (NULL != proxy_username) + CURL_EASY_SETOPT (curl, CURLOPT_PROXYUSERNAME, proxy_username); + if (NULL != proxy_password) + CURL_EASY_SETOPT (curl, CURLOPT_PROXYPASSWORD, proxy_password); + } download_pos = 0; stat_bogus_url = 0; - CURL_EASY_SETOPT(curl, CURLOPT_WRITEFUNCTION, &callback_download); + CURL_EASY_SETOPT (curl, CURLOPT_WRITEFUNCTION, &callback_download); if (ret != CURLE_OK) - { - clean_up(); - return; - } - CURL_EASY_SETOPT(curl, CURLOPT_WRITEDATA, NULL); + { + clean_up (); + return; + } + CURL_EASY_SETOPT (curl, CURLOPT_WRITEDATA, NULL); if (ret != CURLE_OK) - { - clean_up(); - return; - } - CURL_EASY_SETOPT(curl, CURLOPT_FOLLOWLOCATION, 1); - CURL_EASY_SETOPT(curl, - CURLOPT_REDIR_PROTOCOLS, - CURLPROTO_HTTP | CURLPROTO_HTTPS); - CURL_EASY_SETOPT(curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS); - CURL_EASY_SETOPT(curl, CURLOPT_MAXREDIRS, 4); + { + clean_up (); + return; + } + CURL_EASY_SETOPT (curl, CURLOPT_FOLLOWLOCATION, 1); + CURL_EASY_SETOPT (curl, + CURLOPT_REDIR_PROTOCOLS, + CURLPROTO_HTTP | CURLPROTO_HTTPS); + CURL_EASY_SETOPT (curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS); + CURL_EASY_SETOPT (curl, CURLOPT_MAXREDIRS, 4); /* no need to abort if the above failed */ - CURL_EASY_SETOPT(curl, CURLOPT_URL, current_url); + CURL_EASY_SETOPT (curl, CURLOPT_URL, current_url); if (ret != CURLE_OK) - { - clean_up(); - return; - } - CURL_EASY_SETOPT(curl, CURLOPT_FAILONERROR, 1); + { + clean_up (); + return; + } + CURL_EASY_SETOPT (curl, CURLOPT_FAILONERROR, 1); #if 0 - CURL_EASY_SETOPT(curl, CURLOPT_VERBOSE, 1); + CURL_EASY_SETOPT (curl, CURLOPT_VERBOSE, 1); #endif - CURL_EASY_SETOPT(curl, CURLOPT_BUFFERSIZE, GNUNET_MAX_MESSAGE_SIZE); - if (0 == strncmp(current_url, "http", 4)) - CURL_EASY_SETOPT(curl, CURLOPT_USERAGENT, "GNUnet"); - CURL_EASY_SETOPT(curl, CURLOPT_CONNECTTIMEOUT, 60L); - CURL_EASY_SETOPT(curl, CURLOPT_TIMEOUT, 60L); - multi = curl_multi_init(); + CURL_EASY_SETOPT (curl, CURLOPT_BUFFERSIZE, GNUNET_MAX_MESSAGE_SIZE); + if (0 == strncmp (current_url, "http", 4)) + CURL_EASY_SETOPT (curl, CURLOPT_USERAGENT, "GNUnet"); + CURL_EASY_SETOPT (curl, CURLOPT_CONNECTTIMEOUT, 60L); + CURL_EASY_SETOPT (curl, CURLOPT_TIMEOUT, 60L); + multi = curl_multi_init (); if (multi == NULL) - { - GNUNET_break(0); - /* clean_up (); */ - return; - } - mret = curl_multi_add_handle(multi, curl); + { + GNUNET_break (0); + /* clean_up (); */ + return; + } + mret = curl_multi_add_handle (multi, curl); if (mret != CURLM_OK) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("%s failed at %s:%d: `%s'\n"), - "curl_multi_add_handle", - __FILE__, - __LINE__, - curl_multi_strerror(mret)); - mret = curl_multi_cleanup(multi); - if (mret != CURLM_OK) - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("%s failed at %s:%d: `%s'\n"), - "curl_multi_cleanup", - __FILE__, - __LINE__, - curl_multi_strerror(mret)); - multi = NULL; - clean_up(); - return; - } - end_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES); - download_prepare(); + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("%s failed at %s:%d: `%s'\n"), + "curl_multi_add_handle", + __FILE__, + __LINE__, + curl_multi_strerror (mret)); + mret = curl_multi_cleanup (multi); + if (mret != CURLM_OK) + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("%s failed at %s:%d: `%s'\n"), + "curl_multi_cleanup", + __FILE__, + __LINE__, + curl_multi_strerror (mret)); + multi = NULL; + clean_up (); + return; + } + end_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); + download_prepare (); } static void -task_download_dispatcher(void *cls) +task_download_dispatcher (void *cls) { ti_download_dispatcher_task = NULL; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download is initiated...\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download is initiated...\n"); if (GNUNET_NO == stat_download_in_progress) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download can start immediately...\n"); - download_hostlist(); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download can start immediately...\n"); + download_hostlist (); + } else - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Download in progess, have to wait...\n"); - ti_download_dispatcher_task = - GNUNET_SCHEDULER_add_delayed(WAITING_INTERVAL, - &task_download_dispatcher, - NULL); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Download in progess, have to wait...\n"); + ti_download_dispatcher_task = + GNUNET_SCHEDULER_add_delayed (WAITING_INTERVAL, + &task_download_dispatcher, + NULL); + } } @@ -1112,49 +1113,49 @@ task_download_dispatcher(void *cls) * this task again for a later time. */ static void -task_check(void *cls) +task_check (void *cls) { static int once; struct GNUNET_TIME_Relative delay; ti_check_download = NULL; if (stats == NULL) - { - curl_global_cleanup(); - return; /* in shutdown */ - } + { + curl_global_cleanup (); + return; /* in shutdown */ + } if ((stat_connection_count < MIN_CONNECTIONS) && (NULL == ti_download_dispatcher_task)) ti_download_dispatcher_task = - GNUNET_SCHEDULER_add_now(&task_download_dispatcher, NULL); + GNUNET_SCHEDULER_add_now (&task_download_dispatcher, NULL); delay = hostlist_delay; if (0 == hostlist_delay.rel_value_us) hostlist_delay = GNUNET_TIME_UNIT_SECONDS; else - hostlist_delay = GNUNET_TIME_relative_multiply(hostlist_delay, 2); + hostlist_delay = GNUNET_TIME_relative_multiply (hostlist_delay, 2); if (hostlist_delay.rel_value_us > GNUNET_TIME_UNIT_HOURS.rel_value_us * (1 + stat_connection_count)) hostlist_delay = - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, - (1 + stat_connection_count)); - GNUNET_STATISTICS_set(stats, - gettext_noop( - "# milliseconds between hostlist downloads"), - hostlist_delay.rel_value_us / 1000LL, - GNUNET_YES); + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, + (1 + stat_connection_count)); + GNUNET_STATISTICS_set (stats, + gettext_noop ( + "# milliseconds between hostlist downloads"), + hostlist_delay.rel_value_us / 1000LL, + GNUNET_YES); if (0 == once) - { - delay = GNUNET_TIME_UNIT_ZERO; - once = 1; - } - GNUNET_log( + { + delay = GNUNET_TIME_UNIT_ZERO; + once = 1; + } + GNUNET_log ( GNUNET_ERROR_TYPE_INFO, - _("Have %u/%u connections. Will consider downloading hostlist in %s\n"), + _ ("Have %u/%u connections. Will consider downloading hostlist in %s\n"), stat_connection_count, MIN_CONNECTIONS, - GNUNET_STRINGS_relative_time_to_string(delay, GNUNET_YES)); - ti_check_download = GNUNET_SCHEDULER_add_delayed(delay, &task_check, NULL); + GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); + ti_check_download = GNUNET_SCHEDULER_add_delayed (delay, &task_check, NULL); } @@ -1164,12 +1165,12 @@ task_check(void *cls) * @param cls closure */ static void -task_testing_intervall_reset(void *cls) +task_testing_intervall_reset (void *cls) { ti_testing_intervall_task = NULL; stat_testing_allowed = GNUNET_OK; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Testing new hostlist advertisements is allowed again\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Testing new hostlist advertisements is allowed again\n"); } @@ -1179,17 +1180,17 @@ task_testing_intervall_reset(void *cls) * @param cls closure */ static void -task_hostlist_saving(void *cls) +task_hostlist_saving (void *cls) { ti_saving_task = NULL; - save_hostlist_file(GNUNET_NO); + save_hostlist_file (GNUNET_NO); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Hostlists will be saved to file again in %s\n", - GNUNET_STRINGS_relative_time_to_string(SAVING_INTERVAL, - GNUNET_YES)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Hostlists will be saved to file again in %s\n", + GNUNET_STRINGS_relative_time_to_string (SAVING_INTERVAL, + GNUNET_YES)); ti_saving_task = - GNUNET_SCHEDULER_add_delayed(SAVING_INTERVAL, &task_hostlist_saving, NULL); + GNUNET_SCHEDULER_add_delayed (SAVING_INTERVAL, &task_hostlist_saving, NULL); } @@ -1201,16 +1202,16 @@ task_hostlist_saving(void *cls) * @param mq message queue for transmissions to @a peer */ static void * -handler_connect(void *cls, - const struct GNUNET_PeerIdentity *peer, - struct GNUNET_MQ_Handle *mq) +handler_connect (void *cls, + const struct GNUNET_PeerIdentity *peer, + struct GNUNET_MQ_Handle *mq) { - GNUNET_assert(stat_connection_count < UINT_MAX); + GNUNET_assert (stat_connection_count < UINT_MAX); stat_connection_count++; - GNUNET_STATISTICS_update(stats, - gettext_noop("# active connections"), - 1, - GNUNET_NO); + GNUNET_STATISTICS_update (stats, + gettext_noop ("# active connections"), + 1, + GNUNET_NO); return NULL; } @@ -1222,16 +1223,16 @@ handler_connect(void *cls, * @param peer peer identity this notification is about */ static void -handler_disconnect(void *cls, - const struct GNUNET_PeerIdentity *peer, - void *internal_cls) +handler_disconnect (void *cls, + const struct GNUNET_PeerIdentity *peer, + void *internal_cls) { - GNUNET_assert(stat_connection_count > 0); + GNUNET_assert (stat_connection_count > 0); stat_connection_count--; - GNUNET_STATISTICS_update(stats, - gettext_noop("# active connections"), - -1, - GNUNET_NO); + GNUNET_STATISTICS_update (stats, + gettext_noop ("# active connections"), + -1, + GNUNET_NO); } @@ -1241,57 +1242,57 @@ handler_disconnect(void *cls, * @param uri the advertised URI */ static void -handler_advertisement(const char *uri) +handler_advertisement (const char *uri) { size_t uri_size; struct Hostlist *hostlist; - uri_size = strlen(uri) + 1; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Hostlist client recieved advertisement containing URI `%s'\n", - uri); - if (GNUNET_NO != linked_list_contains(uri)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "URI `%s' is already known\n", uri); - return; - } + uri_size = strlen (uri) + 1; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Hostlist client recieved advertisement containing URI `%s'\n", + uri); + if (GNUNET_NO != linked_list_contains (uri)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "URI `%s' is already known\n", uri); + return; + } if (GNUNET_NO == stat_testing_allowed) - { - GNUNET_log( - GNUNET_ERROR_TYPE_DEBUG, - "Currently not accepting new advertisements: interval between to advertisements is not reached\n"); - return; - } + { + GNUNET_log ( + GNUNET_ERROR_TYPE_DEBUG, + "Currently not accepting new advertisements: interval between to advertisements is not reached\n"); + return; + } if (GNUNET_YES == stat_testing_hostlist) - { - GNUNET_log( - GNUNET_ERROR_TYPE_DEBUG, - "Currently not accepting new advertisements: we are already testing a hostlist\n"); - return; - } + { + GNUNET_log ( + GNUNET_ERROR_TYPE_DEBUG, + "Currently not accepting new advertisements: we are already testing a hostlist\n"); + return; + } - hostlist = GNUNET_malloc(sizeof(struct Hostlist) + uri_size); - hostlist->hostlist_uri = (const char *)&hostlist[1]; - GNUNET_memcpy(&hostlist[1], uri, uri_size); - hostlist->time_creation = GNUNET_TIME_absolute_get(); + hostlist = GNUNET_malloc (sizeof(struct Hostlist) + uri_size); + hostlist->hostlist_uri = (const char *) &hostlist[1]; + GNUNET_memcpy (&hostlist[1], uri, uri_size); + hostlist->time_creation = GNUNET_TIME_absolute_get (); hostlist->quality = HOSTLIST_INITIAL; hostlist_to_test = hostlist; stat_testing_hostlist = GNUNET_YES; stat_testing_allowed = GNUNET_NO; ti_testing_intervall_task = - GNUNET_SCHEDULER_add_delayed(TESTING_INTERVAL, - &task_testing_intervall_reset, - NULL); + GNUNET_SCHEDULER_add_delayed (TESTING_INTERVAL, + &task_testing_intervall_reset, + NULL); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Testing new hostlist advertisements is locked for the next %s\n", - GNUNET_STRINGS_relative_time_to_string(TESTING_INTERVAL, - GNUNET_YES)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Testing new hostlist advertisements is locked for the next %s\n", + GNUNET_STRINGS_relative_time_to_string (TESTING_INTERVAL, + GNUNET_YES)); ti_download_dispatcher_task = - GNUNET_SCHEDULER_add_now(&task_download_dispatcher, NULL); + GNUNET_SCHEDULER_add_now (&task_download_dispatcher, NULL); } @@ -1304,18 +1305,18 @@ handler_advertisement(const char *uri) * successfully obtained, #GNUNET_SYSERR if not. */ static void -primary_task(void *cls, int success) +primary_task (void *cls, int success) { if (NULL != ti_check_download) - { - GNUNET_SCHEDULER_cancel(ti_check_download); - ti_check_download = NULL; - } + { + GNUNET_SCHEDULER_cancel (ti_check_download); + ti_check_download = NULL; + } sget = NULL; - GNUNET_assert(NULL != stats); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Statistics request done, scheduling hostlist download\n"); - ti_check_download = GNUNET_SCHEDULER_add_now(&task_check, NULL); + GNUNET_assert (NULL != stats); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Statistics request done, scheduling hostlist download\n"); + ti_check_download = GNUNET_SCHEDULER_add_now (&task_check, NULL); } @@ -1328,11 +1329,11 @@ primary_task(void *cls, int success) * successfully obtained, #GNUNET_SYSERR if not. */ static void -stat_timeout_task(void *cls) +stat_timeout_task (void *cls) { - GNUNET_STATISTICS_get_cancel(sget); + GNUNET_STATISTICS_get_cancel (sget); sget = NULL; - ti_check_download = GNUNET_SCHEDULER_add_now(&task_check, NULL); + ti_check_download = GNUNET_SCHEDULER_add_now (&task_check, NULL); } @@ -1346,17 +1347,17 @@ stat_timeout_task(void *cls) * @param is_persistent unused, will be #GNUNET_YES */ static int -process_stat(void *cls, - const char *subsystem, - const char *name, - uint64_t value, - int is_persistent) +process_stat (void *cls, + const char *subsystem, + const char *name, + uint64_t value, + int is_persistent) { hostlist_delay.rel_value_us = value * 1000LL; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Initial time between hostlist downloads is %s\n", - GNUNET_STRINGS_relative_time_to_string(hostlist_delay, - GNUNET_YES)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Initial time between hostlist downloads is %s\n", + GNUNET_STRINGS_relative_time_to_string (hostlist_delay, + GNUNET_YES)); return GNUNET_OK; } @@ -1365,7 +1366,7 @@ process_stat(void *cls, * Method to load persistent hostlist file during hostlist client startup */ static void -load_hostlist_file() +load_hostlist_file () { char *filename; char *uri; @@ -1380,87 +1381,87 @@ load_hostlist_file() struct GNUNET_BIO_ReadHandle *rh; uri = NULL; - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg, - "HOSTLIST", - "HOSTLISTFILE", - &filename)) - { - GNUNET_log_config_missing(GNUNET_ERROR_TYPE_WARNING, - "hostlist", - "HOSTLISTFILE"); - return; - } - - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Loading saved hostlist entries from file `%s' \n"), - filename); - if (GNUNET_NO == GNUNET_DISK_file_test(filename)) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Hostlist file `%s' does not exist\n"), - filename); - GNUNET_free(filename); - return; - } + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, + "HOSTLIST", + "HOSTLISTFILE", + &filename)) + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, + "hostlist", + "HOSTLISTFILE"); + return; + } + + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Loading saved hostlist entries from file `%s' \n"), + filename); + if (GNUNET_NO == GNUNET_DISK_file_test (filename)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Hostlist file `%s' does not exist\n"), + filename); + GNUNET_free (filename); + return; + } - rh = GNUNET_BIO_read_open(filename); + rh = GNUNET_BIO_read_open (filename); if (NULL == rh) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _( - "Could not open file `%s' for reading to load hostlists: %s\n"), - filename, - strerror(errno)); - GNUNET_free(filename); - return; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ( + "Could not open file `%s' for reading to load hostlists: %s\n"), + filename, + strerror (errno)); + GNUNET_free (filename); + return; + } counter = 0; - while ((GNUNET_OK == GNUNET_BIO_read_string(rh, "url", &uri, MAX_URL_LEN)) && + while ((GNUNET_OK == GNUNET_BIO_read_string (rh, "url", &uri, MAX_URL_LEN)) && (NULL != uri) && - (GNUNET_OK == GNUNET_BIO_read_int32(rh, ×_used)) && - (GNUNET_OK == GNUNET_BIO_read_int64(rh, &quality)) && - (GNUNET_OK == GNUNET_BIO_read_int64(rh, &last_used)) && - (GNUNET_OK == GNUNET_BIO_read_int64(rh, &created)) && - (GNUNET_OK == GNUNET_BIO_read_int32(rh, &hellos_returned))) - { - hostlist = GNUNET_malloc(sizeof(struct Hostlist) + strlen(uri) + 1); - hostlist->hello_count = hellos_returned; - hostlist->hostlist_uri = (const char *)&hostlist[1]; - GNUNET_memcpy(&hostlist[1], uri, strlen(uri) + 1); - hostlist->quality = quality; - hostlist->time_creation.abs_value_us = created; - hostlist->time_last_usage.abs_value_us = last_used; - GNUNET_CONTAINER_DLL_insert(linked_list_head, linked_list_tail, hostlist); - linked_list_size++; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Added hostlist entry eith URI `%s' \n", - hostlist->hostlist_uri); - GNUNET_free(uri); - uri = NULL; - counter++; - if (counter >= MAX_NUMBER_HOSTLISTS) - break; - } - - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("%u hostlist URIs loaded from file\n"), - counter); - GNUNET_STATISTICS_set(stats, - gettext_noop("# hostlist URIs read from file"), - counter, - GNUNET_YES); - GNUNET_STATISTICS_set(stats, - gettext_noop("# advertised hostlist URIs"), - linked_list_size, - GNUNET_NO); - - GNUNET_free_non_null(uri); + (GNUNET_OK == GNUNET_BIO_read_int32 (rh, ×_used)) && + (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &quality)) && + (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &last_used)) && + (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &created)) && + (GNUNET_OK == GNUNET_BIO_read_int32 (rh, &hellos_returned))) + { + hostlist = GNUNET_malloc (sizeof(struct Hostlist) + strlen (uri) + 1); + hostlist->hello_count = hellos_returned; + hostlist->hostlist_uri = (const char *) &hostlist[1]; + GNUNET_memcpy (&hostlist[1], uri, strlen (uri) + 1); + hostlist->quality = quality; + hostlist->time_creation.abs_value_us = created; + hostlist->time_last_usage.abs_value_us = last_used; + GNUNET_CONTAINER_DLL_insert (linked_list_head, linked_list_tail, hostlist); + linked_list_size++; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Added hostlist entry eith URI `%s' \n", + hostlist->hostlist_uri); + GNUNET_free (uri); + uri = NULL; + counter++; + if (counter >= MAX_NUMBER_HOSTLISTS) + break; + } + + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("%u hostlist URIs loaded from file\n"), + counter); + GNUNET_STATISTICS_set (stats, + gettext_noop ("# hostlist URIs read from file"), + counter, + GNUNET_YES); + GNUNET_STATISTICS_set (stats, + gettext_noop ("# advertised hostlist URIs"), + linked_list_size, + GNUNET_NO); + + GNUNET_free_non_null (uri); emsg = NULL; - (void)GNUNET_BIO_read_close(rh, &emsg); + (void) GNUNET_BIO_read_close (rh, &emsg); if (emsg != NULL) - GNUNET_free(emsg); - GNUNET_free(filename); + GNUNET_free (emsg); + GNUNET_free (filename); } @@ -1470,7 +1471,7 @@ load_hostlist_file() * @param shutdown set if called because of shutdown, entries in linked list will be destroyed */ static void -save_hostlist_file(int shutdown) +save_hostlist_file (int shutdown) { char *filename; struct Hostlist *pos; @@ -1478,80 +1479,80 @@ save_hostlist_file(int shutdown) int ok; uint32_t counter; - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg, - "HOSTLIST", - "HOSTLISTFILE", - &filename)) - { - GNUNET_log_config_missing(GNUNET_ERROR_TYPE_WARNING, - "hostlist", - "HOSTLISTFILE"); - return; - } - if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file(filename)) - { - GNUNET_free(filename); - return; - } - wh = GNUNET_BIO_write_open(filename); + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, + "HOSTLIST", + "HOSTLISTFILE", + &filename)) + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, + "hostlist", + "HOSTLISTFILE"); + return; + } + if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename)) + { + GNUNET_free (filename); + return; + } + wh = GNUNET_BIO_write_open (filename); if (NULL == wh) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _( - "Could not open file `%s' for writing to save hostlists: %s\n"), - filename, - strerror(errno)); - GNUNET_free(filename); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Writing %u hostlist URIs to `%s'\n"), - linked_list_size, - filename); + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ( + "Could not open file `%s' for writing to save hostlists: %s\n"), + filename, + strerror (errno)); + GNUNET_free (filename); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Writing %u hostlist URIs to `%s'\n"), + linked_list_size, + filename); /* add code to write hostlists to file using bio */ ok = GNUNET_YES; counter = 0; while (NULL != (pos = linked_list_head)) + { + if (GNUNET_YES == shutdown) { - if (GNUNET_YES == shutdown) - { - GNUNET_CONTAINER_DLL_remove(linked_list_head, linked_list_tail, pos); - linked_list_size--; - } - if (GNUNET_YES == ok) - { - if ((GNUNET_OK != GNUNET_BIO_write_string(wh, pos->hostlist_uri)) || - (GNUNET_OK != GNUNET_BIO_write_int32(wh, pos->times_used)) || - (GNUNET_OK != GNUNET_BIO_write_int64(wh, pos->quality)) || - (GNUNET_OK != - GNUNET_BIO_write_int64(wh, pos->time_last_usage.abs_value_us)) || - (GNUNET_OK != - GNUNET_BIO_write_int64(wh, pos->time_creation.abs_value_us)) || - (GNUNET_OK != GNUNET_BIO_write_int32(wh, pos->hello_count))) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _("Error writing hostlist URIs to file `%s'\n"), - filename); - ok = GNUNET_NO; - } - } - - if (GNUNET_YES == shutdown) - GNUNET_free(pos); - counter++; - if (counter >= MAX_NUMBER_HOSTLISTS) - break; + GNUNET_CONTAINER_DLL_remove (linked_list_head, linked_list_tail, pos); + linked_list_size--; + } + if (GNUNET_YES == ok) + { + if ((GNUNET_OK != GNUNET_BIO_write_string (wh, pos->hostlist_uri)) || + (GNUNET_OK != GNUNET_BIO_write_int32 (wh, pos->times_used)) || + (GNUNET_OK != GNUNET_BIO_write_int64 (wh, pos->quality)) || + (GNUNET_OK != + GNUNET_BIO_write_int64 (wh, pos->time_last_usage.abs_value_us)) || + (GNUNET_OK != + GNUNET_BIO_write_int64 (wh, pos->time_creation.abs_value_us)) || + (GNUNET_OK != GNUNET_BIO_write_int32 (wh, pos->hello_count))) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ("Error writing hostlist URIs to file `%s'\n"), + filename); + ok = GNUNET_NO; + } } - GNUNET_STATISTICS_set(stats, - gettext_noop("# hostlist URIs written to file"), - counter, - GNUNET_YES); - - if (GNUNET_OK != GNUNET_BIO_write_close(wh)) - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _("Error writing hostlist URIs to file `%s'\n"), - filename); - GNUNET_free(filename); + + if (GNUNET_YES == shutdown) + GNUNET_free (pos); + counter++; + if (counter >= MAX_NUMBER_HOSTLISTS) + break; + } + GNUNET_STATISTICS_set (stats, + gettext_noop ("# hostlist URIs written to file"), + counter, + GNUNET_YES); + + if (GNUNET_OK != GNUNET_BIO_write_close (wh)) + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ("Error writing hostlist URIs to file `%s'\n"), + filename); + GNUNET_free (filename); } @@ -1567,94 +1568,94 @@ save_hostlist_file(int shutdown) * @return #GNUNET_OK on success */ int -GNUNET_HOSTLIST_client_start(const struct GNUNET_CONFIGURATION_Handle *c, - struct GNUNET_STATISTICS_Handle *st, - GNUNET_CORE_ConnectEventHandler *ch, - GNUNET_CORE_DisconnectEventHandler *dh, - GNUNET_HOSTLIST_UriHandler *msgh, - int learn) +GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c, + struct GNUNET_STATISTICS_Handle *st, + GNUNET_CORE_ConnectEventHandler *ch, + GNUNET_CORE_DisconnectEventHandler *dh, + GNUNET_HOSTLIST_UriHandler *msgh, + int learn) { char *filename; char *proxytype_str; int result; - GNUNET_assert(NULL != st); - if (0 != curl_global_init(CURL_GLOBAL_WIN32)) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } + GNUNET_assert (NULL != st); + if (0 != curl_global_init (CURL_GLOBAL_WIN32)) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } cfg = c; stats = st; /* Read proxy configuration */ - pi = GNUNET_PEERINFO_connect(c); + pi = GNUNET_PEERINFO_connect (c); if (GNUNET_OK == - GNUNET_CONFIGURATION_get_value_string(cfg, "HOSTLIST", "PROXY", &proxy)) + GNUNET_CONFIGURATION_get_value_string (cfg, "HOSTLIST", "PROXY", &proxy)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found proxy host: `%s'\n", proxy); + /* proxy username */ + if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, + "HOSTLIST", + "PROXY_USERNAME", + &proxy_username)) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Found proxy host: `%s'\n", proxy); - /* proxy username */ - if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, - "HOSTLIST", - "PROXY_USERNAME", - &proxy_username)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Found proxy username name: `%s'\n", - proxy_username); - } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found proxy username name: `%s'\n", + proxy_username); + } - /* proxy password */ - if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, - "HOSTLIST", - "PROXY_PASSWORD", - &proxy_password)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Found proxy password name: `%s'\n", - proxy_password); - } + /* proxy password */ + if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, + "HOSTLIST", + "PROXY_PASSWORD", + &proxy_password)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found proxy password name: `%s'\n", + proxy_password); + } - /* proxy type */ - if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, - "HOSTLIST", - "PROXY_TYPE", - &proxytype_str)) - { - GNUNET_STRINGS_utf8_toupper(proxytype_str, proxytype_str); - proxy_type = CURLPROXY_HTTP; - if (0 == strcmp(proxytype_str, "HTTP")) - proxy_type = CURLPROXY_HTTP; - else if (0 == strcmp(proxytype_str, "HTTP_1_0")) - proxy_type = CURLPROXY_HTTP_1_0; - else if (0 == strcmp(proxytype_str, "SOCKS4")) - proxy_type = CURLPROXY_SOCKS4; - else if (0 == strcmp(proxytype_str, "SOCKS5")) - proxy_type = CURLPROXY_SOCKS5; - else if (0 == strcmp(proxytype_str, "SOCKS4A")) - proxy_type = CURLPROXY_SOCKS4A; - else if (0 == strcmp(proxytype_str, "SOCKS5_HOSTNAME")) - proxy_type = CURLPROXY_SOCKS5_HOSTNAME; - else - { - GNUNET_log( - GNUNET_ERROR_TYPE_ERROR, - _( - "Invalid proxy type: `%s', disabling proxy! Check configuration!\n"), - proxytype_str); - GNUNET_free(proxytype_str); - GNUNET_free(proxy); - proxy = NULL; - GNUNET_free_non_null(proxy_username); - proxy_username = NULL; - GNUNET_free_non_null(proxy_password); - proxy_password = NULL; - - return GNUNET_SYSERR; - } - } - GNUNET_free_non_null(proxytype_str); + /* proxy type */ + if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, + "HOSTLIST", + "PROXY_TYPE", + &proxytype_str)) + { + GNUNET_STRINGS_utf8_toupper (proxytype_str, proxytype_str); + proxy_type = CURLPROXY_HTTP; + if (0 == strcmp (proxytype_str, "HTTP")) + proxy_type = CURLPROXY_HTTP; + else if (0 == strcmp (proxytype_str, "HTTP_1_0")) + proxy_type = CURLPROXY_HTTP_1_0; + else if (0 == strcmp (proxytype_str, "SOCKS4")) + proxy_type = CURLPROXY_SOCKS4; + else if (0 == strcmp (proxytype_str, "SOCKS5")) + proxy_type = CURLPROXY_SOCKS5; + else if (0 == strcmp (proxytype_str, "SOCKS4A")) + proxy_type = CURLPROXY_SOCKS4A; + else if (0 == strcmp (proxytype_str, "SOCKS5_HOSTNAME")) + proxy_type = CURLPROXY_SOCKS5_HOSTNAME; + else + { + GNUNET_log ( + GNUNET_ERROR_TYPE_ERROR, + _ ( + "Invalid proxy type: `%s', disabling proxy! Check configuration!\n"), + proxytype_str); + GNUNET_free (proxytype_str); + GNUNET_free (proxy); + proxy = NULL; + GNUNET_free_non_null (proxy_username); + proxy_username = NULL; + GNUNET_free_non_null (proxy_password); + proxy_password = NULL; + + return GNUNET_SYSERR; + } } + GNUNET_free_non_null (proxytype_str); + } stat_learning = learn; *ch = &handler_connect; @@ -1666,67 +1667,67 @@ GNUNET_HOSTLIST_client_start(const struct GNUNET_CONFIGURATION_Handle *c, stat_testing_allowed = GNUNET_YES; if (GNUNET_YES == stat_learning) - { - *msgh = &handler_advertisement; - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Learning is enabled on this peer\n")); - load_hostlist_file(); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Hostlists will be saved to file again in %s\n", - GNUNET_STRINGS_relative_time_to_string(SAVING_INTERVAL, + { + *msgh = &handler_advertisement; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Learning is enabled on this peer\n")); + load_hostlist_file (); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Hostlists will be saved to file again in %s\n", + GNUNET_STRINGS_relative_time_to_string (SAVING_INTERVAL, GNUNET_YES)); - ti_saving_task = GNUNET_SCHEDULER_add_delayed(SAVING_INTERVAL, - &task_hostlist_saving, - NULL); - } + ti_saving_task = GNUNET_SCHEDULER_add_delayed (SAVING_INTERVAL, + &task_hostlist_saving, + NULL); + } else + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Learning is not enabled on this peer\n")); + *msgh = NULL; + if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, + "HOSTLIST", + "HOSTLISTFILE", + &filename)) { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Learning is not enabled on this peer\n")); - *msgh = NULL; - if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg, - "HOSTLIST", - "HOSTLISTFILE", - &filename)) - { - if (GNUNET_YES == GNUNET_DISK_file_test(filename)) - { - result = remove(filename); - if (0 == result) - GNUNET_log( - GNUNET_ERROR_TYPE_INFO, - _( - "Since learning is not enabled on this peer, hostlist file `%s' was removed\n"), - filename); - else - GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, - "remove", - filename); - } - } - GNUNET_free(filename); + if (GNUNET_YES == GNUNET_DISK_file_test (filename)) + { + result = remove (filename); + if (0 == result) + GNUNET_log ( + GNUNET_ERROR_TYPE_INFO, + _ ( + "Since learning is not enabled on this peer, hostlist file `%s' was removed\n"), + filename); + else + GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, + "remove", + filename); + } } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Loading stats value on hostlist download frequency\n"); - sget = GNUNET_STATISTICS_get(stats, - "hostlist", - gettext_noop( - "# milliseconds between hostlist downloads"), - &primary_task, - &process_stat, - NULL); + GNUNET_free (filename); + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Loading stats value on hostlist download frequency\n"); + sget = GNUNET_STATISTICS_get (stats, + "hostlist", + gettext_noop ( + "# milliseconds between hostlist downloads"), + &primary_task, + &process_stat, + NULL); if (NULL == sget) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Statistics request failed, scheduling hostlist download\n"); - ti_check_download = GNUNET_SCHEDULER_add_now(&task_check, NULL); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Statistics request failed, scheduling hostlist download\n"); + ti_check_download = GNUNET_SCHEDULER_add_now (&task_check, NULL); + } else - { - ti_check_download = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, - &stat_timeout_task, - NULL); - } + { + ti_check_download = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, + &stat_timeout_task, + NULL); + } return GNUNET_OK; } @@ -1735,56 +1736,56 @@ GNUNET_HOSTLIST_client_start(const struct GNUNET_CONFIGURATION_Handle *c, * Stop downloading hostlists from hostlist servers as necessary. */ void -GNUNET_HOSTLIST_client_stop() +GNUNET_HOSTLIST_client_stop () { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Hostlist client shutdown\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist client shutdown\n"); if (NULL != sget) - { - GNUNET_STATISTICS_get_cancel(sget); - sget = NULL; - } + { + GNUNET_STATISTICS_get_cancel (sget); + sget = NULL; + } stats = NULL; if (GNUNET_YES == stat_learning) - save_hostlist_file(GNUNET_YES); + save_hostlist_file (GNUNET_YES); if (NULL != ti_saving_task) - { - GNUNET_SCHEDULER_cancel(ti_saving_task); - ti_saving_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (ti_saving_task); + ti_saving_task = NULL; + } if (NULL != ti_download_dispatcher_task) - { - GNUNET_SCHEDULER_cancel(ti_download_dispatcher_task); - ti_download_dispatcher_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (ti_download_dispatcher_task); + ti_download_dispatcher_task = NULL; + } if (NULL != ti_testing_intervall_task) - { - GNUNET_SCHEDULER_cancel(ti_testing_intervall_task); - ti_testing_intervall_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (ti_testing_intervall_task); + ti_testing_intervall_task = NULL; + } if (NULL != ti_download) - { - GNUNET_SCHEDULER_cancel(ti_download); - ti_download = NULL; - update_hostlist(); - clean_up(); - } + { + GNUNET_SCHEDULER_cancel (ti_download); + ti_download = NULL; + update_hostlist (); + clean_up (); + } if (NULL != ti_check_download) - { - GNUNET_SCHEDULER_cancel(ti_check_download); - ti_check_download = NULL; - curl_global_cleanup(); - } - GNUNET_free_non_null(proxy); + { + GNUNET_SCHEDULER_cancel (ti_check_download); + ti_check_download = NULL; + curl_global_cleanup (); + } + GNUNET_free_non_null (proxy); proxy = NULL; - GNUNET_free_non_null(proxy_username); + GNUNET_free_non_null (proxy_username); proxy_username = NULL; - GNUNET_free_non_null(proxy_password); + GNUNET_free_non_null (proxy_password); proxy_password = NULL; if (NULL != pi) - { - GNUNET_PEERINFO_disconnect(pi); - pi = NULL; - } + { + GNUNET_PEERINFO_disconnect (pi); + pi = NULL; + } cfg = NULL; } diff --git a/src/hostlist/gnunet-daemon-hostlist_client.h b/src/hostlist/gnunet-daemon-hostlist_client.h index 4268b26dd..2ee40d961 100644 --- a/src/hostlist/gnunet-daemon-hostlist_client.h +++ b/src/hostlist/gnunet-daemon-hostlist_client.h @@ -51,19 +51,19 @@ typedef void * @return #GNUNET_OK on success */ int -GNUNET_HOSTLIST_client_start(const struct GNUNET_CONFIGURATION_Handle *c, - struct GNUNET_STATISTICS_Handle *st, - GNUNET_CORE_ConnectEventHandler *ch, - GNUNET_CORE_DisconnectEventHandler *dh, - GNUNET_HOSTLIST_UriHandler *msgh, - int learn); +GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c, + struct GNUNET_STATISTICS_Handle *st, + GNUNET_CORE_ConnectEventHandler *ch, + GNUNET_CORE_DisconnectEventHandler *dh, + GNUNET_HOSTLIST_UriHandler *msgh, + int learn); /** * Stop downloading hostlists from hostlist servers as necessary. */ void -GNUNET_HOSTLIST_client_stop(void); +GNUNET_HOSTLIST_client_stop (void); #endif diff --git a/src/hostlist/gnunet-daemon-hostlist_server.c b/src/hostlist/gnunet-daemon-hostlist_server.c index b4e0df34e..43513930a 100644 --- a/src/hostlist/gnunet-daemon-hostlist_server.c +++ b/src/hostlist/gnunet-daemon-hostlist_server.c @@ -39,7 +39,7 @@ * time out? */ #define GNUNET_ADV_TIMEOUT \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5) /** @@ -106,7 +106,8 @@ static char *hostlist_uri; /** * Context for #host_processor(). */ -struct HostSet { +struct HostSet +{ /** * Iterator used to build @e data (NULL when done). */ @@ -137,13 +138,13 @@ static struct HostSet *builder; * @param response response to add headers to */ static void -add_cors_headers(struct MHD_Response *response) +add_cors_headers (struct MHD_Response *response) { - MHD_add_response_header(response, "Access-Control-Allow-Origin", "*"); - MHD_add_response_header(response, - "Access-Control-Allow-Methods", - "GET, OPTIONS"); - MHD_add_response_header(response, "Access-Control-Max-Age", "86400"); + MHD_add_response_header (response, "Access-Control-Allow-Origin", "*"); + MHD_add_response_header (response, + "Access-Control-Allow-Methods", + "GET, OPTIONS"); + MHD_add_response_header (response, "Access-Control-Max-Age", "86400"); } @@ -151,27 +152,27 @@ add_cors_headers(struct MHD_Response *response) * Function that assembles our response. */ static void -finish_response() +finish_response () { if (NULL != response) - MHD_destroy_response(response); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Creating hostlist response with %u bytes\n", - (unsigned int)builder->size); - response = MHD_create_response_from_buffer(builder->size, - builder->data, - MHD_RESPMEM_MUST_FREE); - add_cors_headers(response); + MHD_destroy_response (response); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Creating hostlist response with %u bytes\n", + (unsigned int) builder->size); + response = MHD_create_response_from_buffer (builder->size, + builder->data, + MHD_RESPMEM_MUST_FREE); + add_cors_headers (response); if ((NULL == daemon_handle_v4) && (NULL == daemon_handle_v6)) - { - MHD_destroy_response(response); - response = NULL; - } - GNUNET_STATISTICS_set(stats, - gettext_noop("bytes in hostlist"), - builder->size, - GNUNET_YES); - GNUNET_free(builder); + { + MHD_destroy_response (response); + response = NULL; + } + GNUNET_STATISTICS_set (stats, + gettext_noop ("bytes in hostlist"), + builder->size, + GNUNET_YES); + GNUNET_free (builder); builder = NULL; } @@ -185,20 +186,20 @@ finish_response() * @return #GNUNET_SYSERR to stop iterating (unless expiration has occured) */ static int -check_has_addr(void *cls, - const struct GNUNET_HELLO_Address *address, - struct GNUNET_TIME_Absolute expiration) +check_has_addr (void *cls, + const struct GNUNET_HELLO_Address *address, + struct GNUNET_TIME_Absolute expiration) { int *arg = cls; - if (0 == GNUNET_TIME_absolute_get_remaining(expiration).rel_value_us) - { - GNUNET_STATISTICS_update(stats, - gettext_noop("expired addresses encountered"), - 1, - GNUNET_YES); - return GNUNET_YES; /* ignore this address */ - } + if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us) + { + GNUNET_STATISTICS_update (stats, + gettext_noop ("expired addresses encountered"), + 1, + GNUNET_YES); + return GNUNET_YES; /* ignore this address */ + } *arg = GNUNET_YES; return GNUNET_SYSERR; } @@ -214,73 +215,73 @@ check_has_addr(void *cls, * @param err_msg message */ static void -host_processor(void *cls, - const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_HELLO_Message *hello, - const char *err_msg) +host_processor (void *cls, + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_HELLO_Message *hello, + const char *err_msg) { size_t old; size_t s; int has_addr; if (NULL != err_msg) - { - GNUNET_assert(NULL == peer); - builder->pitr = NULL; - GNUNET_free_non_null(builder->data); - GNUNET_free(builder); - builder = NULL; - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Error in communication with PEERINFO service: %s\n"), - err_msg); - return; - } + { + GNUNET_assert (NULL == peer); + builder->pitr = NULL; + GNUNET_free_non_null (builder->data); + GNUNET_free (builder); + builder = NULL; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Error in communication with PEERINFO service: %s\n"), + err_msg); + return; + } if (NULL == peer) - { - builder->pitr = NULL; - finish_response(); - return; - } + { + builder->pitr = NULL; + finish_response (); + return; + } if (NULL == hello) return; has_addr = GNUNET_NO; - GNUNET_HELLO_iterate_addresses(hello, GNUNET_NO, &check_has_addr, &has_addr); + GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_has_addr, &has_addr); if (GNUNET_NO == has_addr) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "HELLO for peer `%4s' has no address, not suitable for hostlist!\n", - GNUNET_i2s(peer)); - GNUNET_STATISTICS_update(stats, - gettext_noop( - "HELLOs without addresses encountered (ignored)"), - 1, - GNUNET_NO); - return; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "HELLO for peer `%4s' has no address, not suitable for hostlist!\n", + GNUNET_i2s (peer)); + GNUNET_STATISTICS_update (stats, + gettext_noop ( + "HELLOs without addresses encountered (ignored)"), + 1, + GNUNET_NO); + return; + } old = builder->size; - s = GNUNET_HELLO_size(hello); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Received %u bytes of `%s' from peer `%s' for hostlist.\n", - (unsigned int)s, - "HELLO", - GNUNET_i2s(peer)); + s = GNUNET_HELLO_size (hello); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received %u bytes of `%s' from peer `%s' for hostlist.\n", + (unsigned int) s, + "HELLO", + GNUNET_i2s (peer)); if ((old + s >= GNUNET_MAX_MALLOC_CHECKED) || (old + s >= MAX_BYTES_PER_HOSTLISTS)) - { - /* too large, skip! */ - GNUNET_STATISTICS_update(stats, - gettext_noop( - "bytes not included in hostlist (size limit)"), - s, - GNUNET_NO); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Adding peer `%s' to hostlist (%u bytes)\n", - GNUNET_i2s(peer), - (unsigned int)s); - GNUNET_array_grow(builder->data, builder->size, old + s); - GNUNET_memcpy(&builder->data[old], hello, s); + { + /* too large, skip! */ + GNUNET_STATISTICS_update (stats, + gettext_noop ( + "bytes not included in hostlist (size limit)"), + s, + GNUNET_NO); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Adding peer `%s' to hostlist (%u bytes)\n", + GNUNET_i2s (peer), + (unsigned int) s); + GNUNET_array_grow (builder->data, builder->size, old + s); + GNUNET_memcpy (&builder->data[old], hello, s); } @@ -294,17 +295,17 @@ host_processor(void *cls, * @return #MHD_YES if connection is allowed, #MHD_NO if not (we are not ready) */ static int -accept_policy_callback(void *cls, - const struct sockaddr *addr, - socklen_t addrlen) +accept_policy_callback (void *cls, + const struct sockaddr *addr, + socklen_t addrlen) { if (NULL == response) - { - GNUNET_log( - GNUNET_ERROR_TYPE_DEBUG, - "Received request for hostlist, but I am not yet ready; rejecting!\n"); - return MHD_NO; - } + { + GNUNET_log ( + GNUNET_ERROR_TYPE_DEBUG, + "Received request for hostlist, but I am not yet ready; rejecting!\n"); + return MHD_NO; + } return MHD_YES; /* accept all */ } @@ -345,80 +346,80 @@ accept_policy_callback(void *cls, * error while handling the request */ static int -access_handler_callback(void *cls, - struct MHD_Connection *connection, - const char *url, - const char *method, - const char *version, - const char *upload_data, - size_t *upload_data_size, - void **con_cls) +access_handler_callback (void *cls, + struct MHD_Connection *connection, + const char *url, + const char *method, + const char *version, + const char *upload_data, + size_t *upload_data_size, + void **con_cls) { static int dummy; /* CORS pre-flight request */ - if (0 == strcmp(MHD_HTTP_METHOD_OPTIONS, method)) - { - struct MHD_Response *options_response; - int rc; - - options_response = - MHD_create_response_from_buffer(0, NULL, MHD_RESPMEM_PERSISTENT); - add_cors_headers(options_response); - rc = MHD_queue_response(connection, MHD_HTTP_OK, options_response); - MHD_destroy_response(options_response); - return rc; - } - if (0 != strcmp(method, MHD_HTTP_METHOD_GET)) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _("Refusing `%s' request to hostlist server\n"), - method); - GNUNET_STATISTICS_update(stats, - gettext_noop( - "hostlist requests refused (not HTTP GET)"), - 1, - GNUNET_YES); - return MHD_NO; - } + if (0 == strcmp (MHD_HTTP_METHOD_OPTIONS, method)) + { + struct MHD_Response *options_response; + int rc; + + options_response = + MHD_create_response_from_buffer (0, NULL, MHD_RESPMEM_PERSISTENT); + add_cors_headers (options_response); + rc = MHD_queue_response (connection, MHD_HTTP_OK, options_response); + MHD_destroy_response (options_response); + return rc; + } + if (0 != strcmp (method, MHD_HTTP_METHOD_GET)) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ("Refusing `%s' request to hostlist server\n"), + method); + GNUNET_STATISTICS_update (stats, + gettext_noop ( + "hostlist requests refused (not HTTP GET)"), + 1, + GNUNET_YES); + return MHD_NO; + } if (NULL == *con_cls) - { - (*con_cls) = &dummy; - return MHD_YES; - } + { + (*con_cls) = &dummy; + return MHD_YES; + } if (0 != *upload_data_size) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _("Refusing `%s' request with %llu bytes of upload data\n"), - method, - (unsigned long long)*upload_data_size); - GNUNET_STATISTICS_update(stats, - gettext_noop( - "hostlist requests refused (upload data)"), - 1, - GNUNET_YES); - return MHD_NO; /* do not support upload data */ - } + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ("Refusing `%s' request with %llu bytes of upload data\n"), + method, + (unsigned long long) *upload_data_size); + GNUNET_STATISTICS_update (stats, + gettext_noop ( + "hostlist requests refused (upload data)"), + 1, + GNUNET_YES); + return MHD_NO; /* do not support upload data */ + } if (NULL == response) - { - GNUNET_log( - GNUNET_ERROR_TYPE_WARNING, - _( - "Could not handle hostlist request since I do not have a response yet\n")); - GNUNET_STATISTICS_update(stats, - gettext_noop( - "hostlist requests refused (not ready)"), - 1, - GNUNET_YES); - return MHD_NO; /* internal error, no response yet */ - } - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Received request for our hostlist\n")); - GNUNET_STATISTICS_update(stats, - gettext_noop("hostlist requests processed"), - 1, - GNUNET_YES); - return MHD_queue_response(connection, MHD_HTTP_OK, response); + { + GNUNET_log ( + GNUNET_ERROR_TYPE_WARNING, + _ ( + "Could not handle hostlist request since I do not have a response yet\n")); + GNUNET_STATISTICS_update (stats, + gettext_noop ( + "hostlist requests refused (not ready)"), + 1, + GNUNET_YES); + return MHD_NO; /* internal error, no response yet */ + } + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Received request for our hostlist\n")); + GNUNET_STATISTICS_update (stats, + gettext_noop ("hostlist requests processed"), + 1, + GNUNET_YES); + return MHD_queue_response (connection, MHD_HTTP_OK, response); } @@ -432,33 +433,33 @@ access_handler_callback(void *cls, * @return number of bytes copied to @a buf */ static void -adv_transmit(struct GNUNET_MQ_Handle *mq) +adv_transmit (struct GNUNET_MQ_Handle *mq) { static uint64_t hostlist_adv_count; size_t uri_size; /* Including \0 termination! */ struct GNUNET_MessageHeader *header; struct GNUNET_MQ_Envelope *env; - uri_size = strlen(hostlist_uri) + 1; - env = GNUNET_MQ_msg_extra(header, - uri_size, - GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT); - GNUNET_memcpy(&header[1], hostlist_uri, uri_size); - GNUNET_MQ_env_set_options(env, - GNUNET_MQ_PREF_CORK_ALLOWED | - GNUNET_MQ_PREF_UNRELIABLE); - GNUNET_MQ_send(mq, env); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Sent advertisement message: Copied %u bytes into buffer!\n", - (unsigned int)uri_size); + uri_size = strlen (hostlist_uri) + 1; + env = GNUNET_MQ_msg_extra (header, + uri_size, + GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT); + GNUNET_memcpy (&header[1], hostlist_uri, uri_size); + GNUNET_MQ_env_set_options (env, + GNUNET_MQ_PREF_CORK_ALLOWED + | GNUNET_MQ_PREF_UNRELIABLE); + GNUNET_MQ_send (mq, env); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sent advertisement message: Copied %u bytes into buffer!\n", + (unsigned int) uri_size); hostlist_adv_count++; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - " # Sent advertisement message: %llu\n", - (unsigned long long)hostlist_adv_count); - GNUNET_STATISTICS_update(stats, - gettext_noop("# hostlist advertisements send"), - 1, - GNUNET_NO); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + " # Sent advertisement message: %llu\n", + (unsigned long long) hostlist_adv_count); + GNUNET_STATISTICS_update (stats, + gettext_noop ("# hostlist advertisements send"), + 1, + GNUNET_NO); } @@ -471,34 +472,34 @@ adv_transmit(struct GNUNET_MQ_Handle *mq) * @return NULL (must!) */ static void * -connect_handler(void *cls, - const struct GNUNET_PeerIdentity *peer, - struct GNUNET_MQ_Handle *mq) +connect_handler (void *cls, + const struct GNUNET_PeerIdentity *peer, + struct GNUNET_MQ_Handle *mq) { size_t size; - if (!advertising) + if (! advertising) return NULL; if (NULL == hostlist_uri) return NULL; - size = strlen(hostlist_uri) + 1; + size = strlen (hostlist_uri) + 1; if (size + sizeof(struct GNUNET_MessageHeader) >= GNUNET_MAX_MESSAGE_SIZE) - { - GNUNET_break(0); - return NULL; - } + { + GNUNET_break (0); + return NULL; + } size += sizeof(struct GNUNET_MessageHeader); if (NULL == core) - { - GNUNET_break(0); - return NULL; - } - GNUNET_log( + { + GNUNET_break (0); + return NULL; + } + GNUNET_log ( GNUNET_ERROR_TYPE_DEBUG, "Asked CORE to transmit advertisement message with a size of %u bytes to peer `%s'\n", - (unsigned int)size, - GNUNET_i2s(peer)); - adv_transmit(mq); + (unsigned int) size, + GNUNET_i2s (peer)); + adv_transmit (mq); return NULL; } @@ -513,36 +514,36 @@ connect_handler(void *cls, * @param err_msg NULL if successful, otherwise contains error message */ static void -process_notify(void *cls, - const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_HELLO_Message *hello, - const char *err_msg) +process_notify (void *cls, + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_HELLO_Message *hello, + const char *err_msg) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Peerinfo is notifying us to rebuild our hostlist\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Peerinfo is notifying us to rebuild our hostlist\n"); if (NULL != err_msg) - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Error in communication with PEERINFO service: %s\n"), - err_msg); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Error in communication with PEERINFO service: %s\n"), + err_msg); if (NULL != builder) + { + /* restart re-build already in progress ... */ + if (NULL != builder->pitr) { - /* restart re-build already in progress ... */ - if (NULL != builder->pitr) - { - GNUNET_PEERINFO_iterate_cancel(builder->pitr); - builder->pitr = NULL; - } - GNUNET_free_non_null(builder->data); - builder->size = 0; - builder->data = NULL; + GNUNET_PEERINFO_iterate_cancel (builder->pitr); + builder->pitr = NULL; } + GNUNET_free_non_null (builder->data); + builder->size = 0; + builder->data = NULL; + } else - { - builder = GNUNET_new(struct HostSet); - } - GNUNET_assert(NULL != peerinfo); + { + builder = GNUNET_new (struct HostSet); + } + GNUNET_assert (NULL != peerinfo); builder->pitr = - GNUNET_PEERINFO_iterate(peerinfo, GNUNET_NO, NULL, &host_processor, NULL); + GNUNET_PEERINFO_iterate (peerinfo, GNUNET_NO, NULL, &host_processor, NULL); } @@ -551,7 +552,7 @@ process_notify(void *cls, * starts the task waiting for them. */ static struct GNUNET_SCHEDULER_Task * -prepare_daemon(struct MHD_Daemon *daemon_handle); +prepare_daemon (struct MHD_Daemon *daemon_handle); /** @@ -561,7 +562,7 @@ prepare_daemon(struct MHD_Daemon *daemon_handle); * @param cls the `struct MHD_Daemon` of the HTTP server to run */ static void -run_daemon(void *cls) +run_daemon (void *cls) { struct MHD_Daemon *daemon_handle = cls; @@ -569,11 +570,11 @@ run_daemon(void *cls) hostlist_task_v4 = NULL; else hostlist_task_v6 = NULL; - GNUNET_assert(MHD_YES == MHD_run(daemon_handle)); + GNUNET_assert (MHD_YES == MHD_run (daemon_handle)); if (daemon_handle == daemon_handle_v4) - hostlist_task_v4 = prepare_daemon(daemon_handle); + hostlist_task_v4 = prepare_daemon (daemon_handle); else - hostlist_task_v6 = prepare_daemon(daemon_handle); + hostlist_task_v6 = prepare_daemon (daemon_handle); } @@ -584,7 +585,7 @@ run_daemon(void *cls) * @param daemon_handle HTTP server to prepare to run */ static struct GNUNET_SCHEDULER_Task * -prepare_daemon(struct MHD_Daemon *daemon_handle) +prepare_daemon (struct MHD_Daemon *daemon_handle) { struct GNUNET_SCHEDULER_Task *ret; fd_set rs; @@ -597,28 +598,28 @@ prepare_daemon(struct MHD_Daemon *daemon_handle) int haveto; struct GNUNET_TIME_Relative tv; - FD_ZERO(&rs); - FD_ZERO(&ws); - FD_ZERO(&es); - wrs = GNUNET_NETWORK_fdset_create(); - wws = GNUNET_NETWORK_fdset_create(); + FD_ZERO (&rs); + FD_ZERO (&ws); + FD_ZERO (&es); + wrs = GNUNET_NETWORK_fdset_create (); + wws = GNUNET_NETWORK_fdset_create (); max = -1; - GNUNET_assert(MHD_YES == MHD_get_fdset(daemon_handle, &rs, &ws, &es, &max)); - haveto = MHD_get_timeout(daemon_handle, &timeout); + GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es, &max)); + haveto = MHD_get_timeout (daemon_handle, &timeout); if (haveto == MHD_YES) - tv.rel_value_us = (uint64_t)timeout * 1000LL; + tv.rel_value_us = (uint64_t) timeout * 1000LL; else tv = GNUNET_TIME_UNIT_FOREVER_REL; - GNUNET_NETWORK_fdset_copy_native(wrs, &rs, max + 1); - GNUNET_NETWORK_fdset_copy_native(wws, &ws, max + 1); - ret = GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_HIGH, - tv, - wrs, - wws, - &run_daemon, - daemon_handle); - GNUNET_NETWORK_fdset_destroy(wrs); - GNUNET_NETWORK_fdset_destroy(wws); + GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1); + GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1); + ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH, + tv, + wrs, + wws, + &run_daemon, + daemon_handle); + GNUNET_NETWORK_fdset_destroy (wrs); + GNUNET_NETWORK_fdset_destroy (wws); return ret; } @@ -634,11 +635,11 @@ prepare_daemon(struct MHD_Daemon *daemon_handle) * @return #GNUNET_OK on success */ int -GNUNET_HOSTLIST_server_start(const struct GNUNET_CONFIGURATION_Handle *c, - struct GNUNET_STATISTICS_Handle *st, - struct GNUNET_CORE_Handle *co, - GNUNET_CORE_ConnectEventHandler *server_ch, - int advertise) +GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, + struct GNUNET_STATISTICS_Handle *st, + struct GNUNET_CORE_Handle *co, + GNUNET_CORE_ConnectEventHandler *server_ch, + int advertise) { unsigned long long port; char *hostname; @@ -653,189 +654,189 @@ GNUNET_HOSTLIST_server_start(const struct GNUNET_CONFIGURATION_Handle *c, const struct sockaddr *sa6; advertising = advertise; - if (!advertising) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Advertising not enabled on this hostlist server\n"); - } + if (! advertising) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Advertising not enabled on this hostlist server\n"); + } else - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Advertising enabled on this hostlist server\n"); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Advertising enabled on this hostlist server\n"); + } cfg = c; stats = st; - peerinfo = GNUNET_PEERINFO_connect(cfg); + peerinfo = GNUNET_PEERINFO_connect (cfg); if (NULL == peerinfo) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("Could not access PEERINFO service. Exiting.\n")); - return GNUNET_SYSERR; - } - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, - "HOSTLIST", - "HTTPPORT", - &port)) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("Could not access PEERINFO service. Exiting.\n")); + return GNUNET_SYSERR; + } + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, + "HOSTLIST", + "HTTPPORT", + &port)) return GNUNET_SYSERR; if ((0 == port) || (port > UINT16_MAX)) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("Invalid port number %llu. Exiting.\n"), - port); - return GNUNET_SYSERR; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("Invalid port number %llu. Exiting.\n"), + port); + return GNUNET_SYSERR; + } if (GNUNET_SYSERR == - GNUNET_CONFIGURATION_get_value_string(cfg, - "HOSTLIST", - "EXTERNAL_DNS_NAME", - &hostname)) - hostname = GNUNET_RESOLVER_local_fqdn_get(); - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Hostlist service starts on %s:%llu\n"), - hostname, - port); + GNUNET_CONFIGURATION_get_value_string (cfg, + "HOSTLIST", + "EXTERNAL_DNS_NAME", + &hostname)) + hostname = GNUNET_RESOLVER_local_fqdn_get (); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Hostlist service starts on %s:%llu\n"), + hostname, + port); if (NULL != hostname) + { + size = strlen (hostname); + if (size + 15 > MAX_URL_LEN) { - size = strlen(hostname); - if (size + 15 > MAX_URL_LEN) - { - GNUNET_break(0); - } - else - { - GNUNET_asprintf(&hostlist_uri, - "http://%s:%u/", - hostname, - (unsigned int)port); - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Address to obtain hostlist: `%s'\n"), - hostlist_uri); - } - GNUNET_free(hostname); + GNUNET_break (0); } + else + { + GNUNET_asprintf (&hostlist_uri, + "http://%s:%u/", + hostname, + (unsigned int) port); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Address to obtain hostlist: `%s'\n"), + hostlist_uri); + } + GNUNET_free (hostname); + } - if (GNUNET_CONFIGURATION_have_value(cfg, "HOSTLIST", "BINDTOIPV4")) + if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV4")) + { + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, + "HOSTLIST", + "BINDTOIP", + &ipv4)) { - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, - "HOSTLIST", - "BINDTOIP", - &ipv4)) - { - GNUNET_log( - GNUNET_ERROR_TYPE_WARNING, - _("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n")); - } + GNUNET_log ( + GNUNET_ERROR_TYPE_WARNING, + _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n")); } + } else ipv4 = NULL; - if (GNUNET_CONFIGURATION_have_value(cfg, "HOSTLIST", "BINDTOIPV6")) - { - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, - "HOSTLIST", - "BINDTOIP", - &ipv6)) - { - GNUNET_log( - GNUNET_ERROR_TYPE_WARNING, - _("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n")); - } + if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV6")) + { + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, + "HOSTLIST", + "BINDTOIP", + &ipv6)) + { + GNUNET_log ( + GNUNET_ERROR_TYPE_WARNING, + _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n")); } + } else ipv6 = NULL; sa4 = NULL; if (NULL != ipv4) + { + if (1 == inet_pton (AF_INET, ipv4, &i4)) { - if (1 == inet_pton(AF_INET, ipv4, &i4)) - { - memset(&v4, 0, sizeof(v4)); - v4.sin_family = AF_INET; - v4.sin_addr = i4; - v4.sin_port = htons(port); + memset (&v4, 0, sizeof(v4)); + v4.sin_family = AF_INET; + v4.sin_addr = i4; + v4.sin_port = htons (port); #if HAVE_SOCKADDR_IN_SIN_LEN - v4.sin_len = sizeof(v4); + v4.sin_len = sizeof(v4); #endif - sa4 = (const struct sockaddr *)&v4; - } - else - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _( - "`%s' is not a valid IPv4 address! Ignoring BINDTOIPV4.\n"), - ipv4); - GNUNET_free(ipv4); - } + sa4 = (const struct sockaddr *) &v4; + } + else + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ( + "`%s' is not a valid IPv4 address! Ignoring BINDTOIPV4.\n"), + ipv4); + GNUNET_free (ipv4); + } sa6 = NULL; if (NULL != ipv6) + { + if (1 == inet_pton (AF_INET6, ipv6, &i6)) { - if (1 == inet_pton(AF_INET6, ipv6, &i6)) - { - memset(&v6, 0, sizeof(v6)); - v6.sin6_family = AF_INET6; - v6.sin6_addr = i6; - v6.sin6_port = htons(port); + memset (&v6, 0, sizeof(v6)); + v6.sin6_family = AF_INET6; + v6.sin6_addr = i6; + v6.sin6_port = htons (port); #if HAVE_SOCKADDR_IN_SIN_LEN - v6.sin6_len = sizeof(v6); + v6.sin6_len = sizeof(v6); #endif - sa6 = (const struct sockaddr *)&v6; - } - else - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _( - "`%s' is not a valid IPv6 address! Ignoring BINDTOIPV6.\n"), - ipv6); - GNUNET_free(ipv6); - } - - daemon_handle_v6 = MHD_start_daemon(MHD_USE_IPv6 | MHD_USE_DEBUG, - (uint16_t)port, - &accept_policy_callback, - NULL, - &access_handler_callback, - NULL, - MHD_OPTION_CONNECTION_LIMIT, - (unsigned int)128, - MHD_OPTION_PER_IP_CONNECTION_LIMIT, - (unsigned int)32, - MHD_OPTION_CONNECTION_TIMEOUT, - (unsigned int)16, - MHD_OPTION_CONNECTION_MEMORY_LIMIT, - (size_t)(16 * 1024), - MHD_OPTION_SOCK_ADDR, - sa6, - MHD_OPTION_END); - daemon_handle_v4 = MHD_start_daemon(MHD_NO_FLAG | MHD_USE_DEBUG, - (uint16_t)port, - &accept_policy_callback, - NULL, - &access_handler_callback, - NULL, - MHD_OPTION_CONNECTION_LIMIT, - (unsigned int)128, - MHD_OPTION_PER_IP_CONNECTION_LIMIT, - (unsigned int)32, - MHD_OPTION_CONNECTION_TIMEOUT, - (unsigned int)16, - MHD_OPTION_CONNECTION_MEMORY_LIMIT, - (size_t)(16 * 1024), - MHD_OPTION_SOCK_ADDR, - sa4, - MHD_OPTION_END); + sa6 = (const struct sockaddr *) &v6; + } + else + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ( + "`%s' is not a valid IPv6 address! Ignoring BINDTOIPV6.\n"), + ipv6); + GNUNET_free (ipv6); + } + + daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 | MHD_USE_DEBUG, + (uint16_t) port, + &accept_policy_callback, + NULL, + &access_handler_callback, + NULL, + MHD_OPTION_CONNECTION_LIMIT, + (unsigned int) 128, + MHD_OPTION_PER_IP_CONNECTION_LIMIT, + (unsigned int) 32, + MHD_OPTION_CONNECTION_TIMEOUT, + (unsigned int) 16, + MHD_OPTION_CONNECTION_MEMORY_LIMIT, + (size_t) (16 * 1024), + MHD_OPTION_SOCK_ADDR, + sa6, + MHD_OPTION_END); + daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG | MHD_USE_DEBUG, + (uint16_t) port, + &accept_policy_callback, + NULL, + &access_handler_callback, + NULL, + MHD_OPTION_CONNECTION_LIMIT, + (unsigned int) 128, + MHD_OPTION_PER_IP_CONNECTION_LIMIT, + (unsigned int) 32, + MHD_OPTION_CONNECTION_TIMEOUT, + (unsigned int) 16, + MHD_OPTION_CONNECTION_MEMORY_LIMIT, + (size_t) (16 * 1024), + MHD_OPTION_SOCK_ADDR, + sa4, + MHD_OPTION_END); if ((NULL == daemon_handle_v6) && (NULL == daemon_handle_v4)) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("Could not start hostlist HTTP server on port %u\n"), - (unsigned short)port); - return GNUNET_SYSERR; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("Could not start hostlist HTTP server on port %u\n"), + (unsigned short) port); + return GNUNET_SYSERR; + } core = co; *server_ch = &connect_handler; if (NULL != daemon_handle_v4) - hostlist_task_v4 = prepare_daemon(daemon_handle_v4); + hostlist_task_v4 = prepare_daemon (daemon_handle_v4); if (NULL != daemon_handle_v6) - hostlist_task_v6 = prepare_daemon(daemon_handle_v6); - notify = GNUNET_PEERINFO_notify(cfg, GNUNET_NO, &process_notify, NULL); + hostlist_task_v6 = prepare_daemon (daemon_handle_v6); + notify = GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_notify, NULL); return GNUNET_OK; } @@ -844,55 +845,55 @@ GNUNET_HOSTLIST_server_start(const struct GNUNET_CONFIGURATION_Handle *c, * Stop server offering our hostlist. */ void -GNUNET_HOSTLIST_server_stop() +GNUNET_HOSTLIST_server_stop () { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n"); if (NULL != hostlist_task_v6) - { - GNUNET_SCHEDULER_cancel(hostlist_task_v6); - hostlist_task_v6 = NULL; - } + { + GNUNET_SCHEDULER_cancel (hostlist_task_v6); + hostlist_task_v6 = NULL; + } if (NULL != hostlist_task_v4) - { - GNUNET_SCHEDULER_cancel(hostlist_task_v4); - hostlist_task_v4 = NULL; - } + { + GNUNET_SCHEDULER_cancel (hostlist_task_v4); + hostlist_task_v4 = NULL; + } if (NULL != daemon_handle_v4) - { - MHD_stop_daemon(daemon_handle_v4); - daemon_handle_v4 = NULL; - } + { + MHD_stop_daemon (daemon_handle_v4); + daemon_handle_v4 = NULL; + } if (NULL != daemon_handle_v6) - { - MHD_stop_daemon(daemon_handle_v6); - daemon_handle_v6 = NULL; - } + { + MHD_stop_daemon (daemon_handle_v6); + daemon_handle_v6 = NULL; + } if (NULL != response) - { - MHD_destroy_response(response); - response = NULL; - } + { + MHD_destroy_response (response); + response = NULL; + } if (NULL != notify) - { - GNUNET_PEERINFO_notify_cancel(notify); - notify = NULL; - } + { + GNUNET_PEERINFO_notify_cancel (notify); + notify = NULL; + } if (NULL != builder) + { + if (NULL != builder->pitr) { - if (NULL != builder->pitr) - { - GNUNET_PEERINFO_iterate_cancel(builder->pitr); - builder->pitr = NULL; - } - GNUNET_free_non_null(builder->data); - GNUNET_free(builder); - builder = NULL; + GNUNET_PEERINFO_iterate_cancel (builder->pitr); + builder->pitr = NULL; } + GNUNET_free_non_null (builder->data); + GNUNET_free (builder); + builder = NULL; + } if (NULL != peerinfo) - { - GNUNET_PEERINFO_disconnect(peerinfo); - peerinfo = NULL; - } + { + GNUNET_PEERINFO_disconnect (peerinfo); + peerinfo = NULL; + } cfg = NULL; stats = NULL; core = NULL; diff --git a/src/hostlist/gnunet-daemon-hostlist_server.h b/src/hostlist/gnunet-daemon-hostlist_server.h index 407675b41..13ba21e82 100644 --- a/src/hostlist/gnunet-daemon-hostlist_server.h +++ b/src/hostlist/gnunet-daemon-hostlist_server.h @@ -43,18 +43,18 @@ * @return #GNUNET_OK on success */ int -GNUNET_HOSTLIST_server_start(const struct GNUNET_CONFIGURATION_Handle *c, - struct GNUNET_STATISTICS_Handle *st, - struct GNUNET_CORE_Handle *core, - GNUNET_CORE_ConnectEventHandler *server_ch, - int advertise); +GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, + struct GNUNET_STATISTICS_Handle *st, + struct GNUNET_CORE_Handle *core, + GNUNET_CORE_ConnectEventHandler *server_ch, + int advertise); /** * Stop server offering our hostlist. */ void -GNUNET_HOSTLIST_server_stop(void); +GNUNET_HOSTLIST_server_stop (void); #endif diff --git a/src/hostlist/test_gnunet_daemon_hostlist.c b/src/hostlist/test_gnunet_daemon_hostlist.c index d6853c184..182340f9b 100644 --- a/src/hostlist/test_gnunet_daemon_hostlist.c +++ b/src/hostlist/test_gnunet_daemon_hostlist.c @@ -32,13 +32,14 @@ /** * How long until we give up on transmitting the message? */ -#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 150) +#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 150) static int ok; static struct GNUNET_SCHEDULER_Task *timeout_task; -struct PeerContext { +struct PeerContext +{ struct GNUNET_CONFIGURATION_Handle *cfg; struct GNUNET_TRANSPORT_CoreHandle *th; struct GNUNET_MessageHeader *hello; @@ -52,29 +53,29 @@ static struct PeerContext p2; static void -clean_up(void *cls) +clean_up (void *cls) { if (NULL != p1.th) + { + if (NULL != p1.ghh) { - if (NULL != p1.ghh) - { - GNUNET_TRANSPORT_hello_get_cancel(p1.ghh); - p1.ghh = NULL; - } - GNUNET_TRANSPORT_core_disconnect(p1.th); - p1.th = NULL; + GNUNET_TRANSPORT_hello_get_cancel (p1.ghh); + p1.ghh = NULL; } + GNUNET_TRANSPORT_core_disconnect (p1.th); + p1.th = NULL; + } if (NULL != p2.th) + { + if (NULL != p2.ghh) { - if (NULL != p2.ghh) - { - GNUNET_TRANSPORT_hello_get_cancel(p2.ghh); - p2.ghh = NULL; - } - GNUNET_TRANSPORT_core_disconnect(p2.th); - p2.th = NULL; + GNUNET_TRANSPORT_hello_get_cancel (p2.ghh); + p2.ghh = NULL; } - GNUNET_SCHEDULER_shutdown(); + GNUNET_TRANSPORT_core_disconnect (p2.th); + p2.th = NULL; + } + GNUNET_SCHEDULER_shutdown (); } @@ -82,12 +83,12 @@ clean_up(void *cls) * Timeout, give up. */ static void -timeout_error(void *cls) +timeout_error (void *cls) { timeout_task = NULL; - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Timeout trying to connect peers, test failed.\n"); - clean_up(NULL); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Timeout trying to connect peers, test failed.\n"); + clean_up (NULL); } @@ -100,92 +101,92 @@ timeout_error(void *cls) * @param mq message queue to send messages to the peer */ static void * -notify_connect(void *cls, - const struct GNUNET_PeerIdentity *peer, - struct GNUNET_MQ_Handle *mq) +notify_connect (void *cls, + const struct GNUNET_PeerIdentity *peer, + struct GNUNET_MQ_Handle *mq) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peers connected, shutting down.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected, shutting down.\n"); ok = 0; if (NULL != timeout_task) - { - GNUNET_SCHEDULER_cancel(timeout_task); - timeout_task = NULL; - } - GNUNET_SCHEDULER_add_now(&clean_up, NULL); + { + GNUNET_SCHEDULER_cancel (timeout_task); + timeout_task = NULL; + } + GNUNET_SCHEDULER_add_now (&clean_up, NULL); return NULL; } static void -process_hello(void *cls, const struct GNUNET_MessageHeader *message) +process_hello (void *cls, const struct GNUNET_MessageHeader *message) { struct PeerContext *p = cls; - GNUNET_TRANSPORT_hello_get_cancel(p->ghh); + GNUNET_TRANSPORT_hello_get_cancel (p->ghh); p->ghh = NULL; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Received HELLO, starting hostlist service.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received HELLO, starting hostlist service.\n"); } static void -setup_peer(struct PeerContext *p, const char *cfgname) +setup_peer (struct PeerContext *p, const char *cfgname) { char *binary; - binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-arm"); - p->cfg = GNUNET_CONFIGURATION_create(); - p->arm_proc = GNUNET_OS_start_process(GNUNET_YES, - GNUNET_OS_INHERIT_STD_OUT_AND_ERR, - NULL, - NULL, - NULL, - binary, - "gnunet-service-arm", - "-c", - cfgname, - NULL); - GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_load(p->cfg, cfgname)); - p->th = GNUNET_TRANSPORT_core_connect(p->cfg, - NULL, - NULL, - p, - ¬ify_connect, - NULL, - NULL); - GNUNET_assert(NULL != p->th); - p->ghh = GNUNET_TRANSPORT_hello_get(p->cfg, - GNUNET_TRANSPORT_AC_ANY, - &process_hello, - p); - GNUNET_free(binary); + binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm"); + p->cfg = GNUNET_CONFIGURATION_create (); + p->arm_proc = GNUNET_OS_start_process (GNUNET_YES, + GNUNET_OS_INHERIT_STD_OUT_AND_ERR, + NULL, + NULL, + NULL, + binary, + "gnunet-service-arm", + "-c", + cfgname, + NULL); + GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); + p->th = GNUNET_TRANSPORT_core_connect (p->cfg, + NULL, + NULL, + p, + ¬ify_connect, + NULL, + NULL); + GNUNET_assert (NULL != p->th); + p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg, + GNUNET_TRANSPORT_AC_ANY, + &process_hello, + p); + GNUNET_free (binary); } static void -waitpid_task(void *cls) +waitpid_task (void *cls) { struct PeerContext *p = cls; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Killing ARM process.\n"); - if (0 != GNUNET_OS_process_kill(p->arm_proc, GNUNET_TERM_SIG)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); - if (GNUNET_OK != GNUNET_OS_process_wait(p->arm_proc)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "waitpid"); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "ARM process %u stopped\n", - GNUNET_OS_process_get_pid(p->arm_proc)); - GNUNET_OS_process_destroy(p->arm_proc); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Killing ARM process.\n"); + if (0 != GNUNET_OS_process_kill (p->arm_proc, GNUNET_TERM_SIG)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); + if (GNUNET_OK != GNUNET_OS_process_wait (p->arm_proc)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "ARM process %u stopped\n", + GNUNET_OS_process_get_pid (p->arm_proc)); + GNUNET_OS_process_destroy (p->arm_proc); p->arm_proc = NULL; - GNUNET_CONFIGURATION_destroy(p->cfg); + GNUNET_CONFIGURATION_destroy (p->cfg); } static void -stop_arm(struct PeerContext *p) +stop_arm (struct PeerContext *p) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Asking ARM to stop core service\n"); - GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &waitpid_task, p); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking ARM to stop core service\n"); + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &waitpid_task, p); } @@ -193,68 +194,69 @@ stop_arm(struct PeerContext *p) * Try again to connect to transport service. */ static void -shutdown_task(void *cls) +shutdown_task (void *cls) { - stop_arm(&p1); - stop_arm(&p2); + stop_arm (&p1); + stop_arm (&p2); } static void -run(void *cls, - char *const *args, - const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *cfg) +run (void *cls, + char *const *args, + const char *cfgfile, + const struct GNUNET_CONFIGURATION_Handle *cfg) { - GNUNET_assert(ok == 1); + GNUNET_assert (ok == 1); ok++; - timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT, &timeout_error, NULL); - GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); - setup_peer(&p1, "test_gnunet_daemon_hostlist_peer1.conf"); - setup_peer(&p2, "test_gnunet_daemon_hostlist_peer2.conf"); + timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_error, NULL); + GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); + setup_peer (&p1, "test_gnunet_daemon_hostlist_peer1.conf"); + setup_peer (&p2, "test_gnunet_daemon_hostlist_peer2.conf"); } static int -check() +check () { char *const argv[] = { "test-gnunet-daemon-hostlist", "-c", "test_gnunet_daemon_hostlist_data.conf", NULL }; - struct GNUNET_GETOPT_CommandLineOption options[] = { GNUNET_GETOPT_OPTION_END }; + struct GNUNET_GETOPT_CommandLineOption options[] = + { GNUNET_GETOPT_OPTION_END }; ok = 1; - GNUNET_PROGRAM_run((sizeof(argv) / sizeof(char *)) - 1, - argv, - "test-gnunet-daemon-hostlist", - "nohelp", - options, - &run, - &ok); + GNUNET_PROGRAM_run ((sizeof(argv) / sizeof(char *)) - 1, + argv, + "test-gnunet-daemon-hostlist", + "nohelp", + options, + &run, + &ok); return ok; } int -main(int argc, char *argv[]) +main (int argc, char *argv[]) { int ret; - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer1.conf", - "GNUNET_TEST_HOME"); - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer2.conf", - "GNUNET_TEST_HOME"); - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_data.conf", - "GNUNET_TEST_HOME"); - GNUNET_log_setup("test-gnunet-daemon-hostlist", "WARNING", NULL); - ret = check(); - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer1.conf", - "GNUNET_TEST_HOME"); - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer2.conf", - "GNUNET_TEST_HOME"); - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_data.conf", - "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer1.conf", + "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer2.conf", + "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_data.conf", + "GNUNET_TEST_HOME"); + GNUNET_log_setup ("test-gnunet-daemon-hostlist", "WARNING", NULL); + ret = check (); + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer1.conf", + "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer2.conf", + "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_data.conf", + "GNUNET_TEST_HOME"); return ret; } diff --git a/src/hostlist/test_gnunet_daemon_hostlist_learning.c b/src/hostlist/test_gnunet_daemon_hostlist_learning.c index fa72ac828..f9fabab10 100644 --- a/src/hostlist/test_gnunet_daemon_hostlist_learning.c +++ b/src/hostlist/test_gnunet_daemon_hostlist_learning.c @@ -35,12 +35,14 @@ /** * How long until wait until testcases fails */ -#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 180) +#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 180) -#define CHECK_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1) +#define CHECK_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, \ + 1) -struct PeerContext { +struct PeerContext +{ struct GNUNET_CONFIGURATION_Handle *cfg; struct GNUNET_MessageHeader *hello; struct GNUNET_CORE_Handle *core; @@ -78,86 +80,86 @@ static struct GNUNET_STATISTICS_GetHandle *advsent_stat; static void -shutdown_testcase() +shutdown_testcase () { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Shutdown testcase....\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Shutdown testcase....\n"); if (NULL != timeout_task) - { - GNUNET_SCHEDULER_cancel(timeout_task); - timeout_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (timeout_task); + timeout_task = NULL; + } if (NULL != download_stats) - { - GNUNET_STATISTICS_get_cancel(download_stats); - download_stats = NULL; - } + { + GNUNET_STATISTICS_get_cancel (download_stats); + download_stats = NULL; + } if (NULL != urisrecv_stat) - { - GNUNET_STATISTICS_get_cancel(urisrecv_stat); - urisrecv_stat = NULL; - } + { + GNUNET_STATISTICS_get_cancel (urisrecv_stat); + urisrecv_stat = NULL; + } if (NULL != advsent_stat) - { - GNUNET_STATISTICS_get_cancel(advsent_stat); - advsent_stat = NULL; - } + { + GNUNET_STATISTICS_get_cancel (advsent_stat); + advsent_stat = NULL; + } if (NULL != adv_peer.stats) - { - GNUNET_STATISTICS_destroy(adv_peer.stats, GNUNET_NO); - adv_peer.stats = NULL; - } + { + GNUNET_STATISTICS_destroy (adv_peer.stats, GNUNET_NO); + adv_peer.stats = NULL; + } if (NULL != learn_peer.stats) - { - GNUNET_STATISTICS_destroy(learn_peer.stats, GNUNET_NO); - learn_peer.stats = NULL; - } + { + GNUNET_STATISTICS_destroy (learn_peer.stats, GNUNET_NO); + learn_peer.stats = NULL; + } if (NULL != check_task) - { - GNUNET_SCHEDULER_cancel(check_task); - check_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (check_task); + check_task = NULL; + } if (NULL != current_adv_uri) - { - GNUNET_free(current_adv_uri); - current_adv_uri = NULL; - } + { + GNUNET_free (current_adv_uri); + current_adv_uri = NULL; + } if (NULL != adv_peer.core) - { - GNUNET_CORE_disconnect(adv_peer.core); - adv_peer.core = NULL; - } + { + GNUNET_CORE_disconnect (adv_peer.core); + adv_peer.core = NULL; + } if (NULL != learn_peer.core) - { - GNUNET_CORE_disconnect(learn_peer.core); - learn_peer.core = NULL; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Killing hostlist server ARM process.\n"); - if (0 != GNUNET_OS_process_kill(adv_peer.arm_proc, - GNUNET_TERM_SIG)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, - "kill"); + { + GNUNET_CORE_disconnect (learn_peer.core); + learn_peer.core = NULL; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Killing hostlist server ARM process.\n"); + if (0 != GNUNET_OS_process_kill (adv_peer.arm_proc, + GNUNET_TERM_SIG)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, + "kill"); if (GNUNET_OK != - GNUNET_OS_process_wait(adv_peer.arm_proc)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, - "waitpid"); - GNUNET_OS_process_destroy(adv_peer.arm_proc); + GNUNET_OS_process_wait (adv_peer.arm_proc)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, + "waitpid"); + GNUNET_OS_process_destroy (adv_peer.arm_proc); adv_peer.arm_proc = NULL; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Killing hostlist client ARM process.\n"); - if (0 != GNUNET_OS_process_kill(learn_peer.arm_proc, - GNUNET_TERM_SIG)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, - "kill"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Killing hostlist client ARM process.\n"); + if (0 != GNUNET_OS_process_kill (learn_peer.arm_proc, + GNUNET_TERM_SIG)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, + "kill"); if (GNUNET_OK != - GNUNET_OS_process_wait(learn_peer.arm_proc)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, - "waitpid"); - GNUNET_OS_process_destroy(learn_peer.arm_proc); + GNUNET_OS_process_wait (learn_peer.arm_proc)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, + "waitpid"); + GNUNET_OS_process_destroy (learn_peer.arm_proc); learn_peer.arm_proc = NULL; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Shutdown complete....\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Shutdown complete....\n"); } @@ -165,112 +167,112 @@ shutdown_testcase() * Timeout, give up. */ static void -timeout_error(void *cls) +timeout_error (void *cls) { timeout_task = NULL; - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Timeout while executing testcase, test failed.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Timeout while executing testcase, test failed.\n"); timeout = GNUNET_YES; - shutdown_testcase(); + shutdown_testcase (); } static void -process_downloads_done(void *cls, int success) +process_downloads_done (void *cls, int success) { download_stats = NULL; } static void -do_shutdown(void *cls) +do_shutdown (void *cls) { - shutdown_testcase(); + shutdown_testcase (); } static int -process_downloads(void *cls, - const char *subsystem, - const char *name, - uint64_t value, - int is_persistent) +process_downloads (void *cls, + const char *subsystem, + const char *name, + uint64_t value, + int is_persistent) { if ((value >= 2) && (GNUNET_NO == learned_hostlist_downloaded)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Peer has successfully downloaded advertised URI\n"); + learned_hostlist_downloaded = GNUNET_YES; + if ((learned_hostlist_saved == GNUNET_YES) && (adv_sent == GNUNET_YES)) { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Peer has successfully downloaded advertised URI\n"); - learned_hostlist_downloaded = GNUNET_YES; - if ((learned_hostlist_saved == GNUNET_YES) && (adv_sent == GNUNET_YES)) - { - GNUNET_SCHEDULER_add_now(&do_shutdown, NULL); - } + GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); } + } return GNUNET_OK; } static void -process_uris_recv_done(void *cls, int success) +process_uris_recv_done (void *cls, int success) { urisrecv_stat = NULL; } static int -process_uris_recv(void *cls, - const char *subsystem, - const char *name, - uint64_t value, - int is_persistent) +process_uris_recv (void *cls, + const char *subsystem, + const char *name, + uint64_t value, + int is_persistent) { struct PeerContext *pc = cls; if ((pc == &learn_peer) && (value == 1) && (learned_hostlist_saved == GNUNET_NO)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Peer has successfully saved advertised URI\n"); + learned_hostlist_saved = GNUNET_YES; + if ((learned_hostlist_downloaded == GNUNET_YES) && + (adv_sent == GNUNET_YES)) { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Peer has successfully saved advertised URI\n"); - learned_hostlist_saved = GNUNET_YES; - if ((learned_hostlist_downloaded == GNUNET_YES) && - (adv_sent == GNUNET_YES)) - { - GNUNET_SCHEDULER_add_now(&do_shutdown, - NULL); - } + GNUNET_SCHEDULER_add_now (&do_shutdown, + NULL); } + } return GNUNET_OK; } static void -process_adv_sent_done(void *cls, int success) +process_adv_sent_done (void *cls, int success) { advsent_stat = NULL; } static int -process_adv_sent(void *cls, - const char *subsystem, - const char *name, - uint64_t value, - int is_persistent) +process_adv_sent (void *cls, + const char *subsystem, + const char *name, + uint64_t value, + int is_persistent) { if ((value >= 1) && (adv_sent == GNUNET_NO)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Server has successfully sent advertisement\n"); + adv_sent = GNUNET_YES; + if ((learned_hostlist_downloaded == GNUNET_YES) && + (learned_hostlist_saved == GNUNET_YES)) { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Server has successfully sent advertisement\n"); - adv_sent = GNUNET_YES; - if ((learned_hostlist_downloaded == GNUNET_YES) && - (learned_hostlist_saved == GNUNET_YES)) - { - GNUNET_SCHEDULER_add_now(&do_shutdown, - NULL); - } + GNUNET_SCHEDULER_add_now (&do_shutdown, + NULL); } + } return GNUNET_OK; } @@ -279,70 +281,71 @@ process_adv_sent(void *cls, * Check the server statistics regularly */ static void -check_statistics(void *cls) +check_statistics (void *cls) { char *stat; check_task = NULL; - GNUNET_asprintf(&stat, - gettext_noop("# advertised URI `%s' downloaded"), - current_adv_uri); + GNUNET_asprintf (&stat, + gettext_noop ("# advertised URI `%s' downloaded"), + current_adv_uri); if (NULL != learn_peer.stats) - { - if (NULL != download_stats) - GNUNET_STATISTICS_get_cancel(download_stats); - download_stats = - GNUNET_STATISTICS_get(learn_peer.stats, - "hostlist", - stat, - &process_downloads_done, - &process_downloads, - &learn_peer); - if (NULL != urisrecv_stat) - GNUNET_STATISTICS_get_cancel(urisrecv_stat); - urisrecv_stat = - GNUNET_STATISTICS_get(learn_peer.stats, "hostlist", - gettext_noop("# advertised hostlist URIs"), - &process_uris_recv_done, &process_uris_recv, - &learn_peer); - } - GNUNET_free(stat); + { + if (NULL != download_stats) + GNUNET_STATISTICS_get_cancel (download_stats); + download_stats = + GNUNET_STATISTICS_get (learn_peer.stats, + "hostlist", + stat, + &process_downloads_done, + &process_downloads, + &learn_peer); + if (NULL != urisrecv_stat) + GNUNET_STATISTICS_get_cancel (urisrecv_stat); + urisrecv_stat = + GNUNET_STATISTICS_get (learn_peer.stats, "hostlist", + gettext_noop ("# advertised hostlist URIs"), + &process_uris_recv_done, &process_uris_recv, + &learn_peer); + } + GNUNET_free (stat); if (NULL != adv_peer.stats) - { - if (NULL != advsent_stat) - GNUNET_STATISTICS_get_cancel(advsent_stat); - advsent_stat = - GNUNET_STATISTICS_get(adv_peer.stats, "hostlist", - gettext_noop("# hostlist advertisements send"), - &process_adv_sent_done, - &process_adv_sent, - NULL); - } + { + if (NULL != advsent_stat) + GNUNET_STATISTICS_get_cancel (advsent_stat); + advsent_stat = + GNUNET_STATISTICS_get (adv_peer.stats, "hostlist", + gettext_noop ("# hostlist advertisements send"), + &process_adv_sent_done, + &process_adv_sent, + NULL); + } check_task = - GNUNET_SCHEDULER_add_delayed(CHECK_INTERVAL, - &check_statistics, - NULL); + GNUNET_SCHEDULER_add_delayed (CHECK_INTERVAL, + &check_statistics, + NULL); } static int -check_ad_arrive(void *cls, - const struct GNUNET_MessageHeader *message) +check_ad_arrive (void *cls, + const struct GNUNET_MessageHeader *message) { - const char *end = (const char *)&message[1]; - - if ('\0' != end[ntohs(message->size) - sizeof(struct GNUNET_MessageHeader) - 1]) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } + const char *end = (const char *) &message[1]; + + if ('\0' != end[ntohs (message->size) - sizeof(struct GNUNET_MessageHeader) + - 1]) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } return GNUNET_OK; } static void -handle_ad_arrive(void *cls, - const struct GNUNET_MessageHeader *message) +handle_ad_arrive (void *cls, + const struct GNUNET_MessageHeader *message) { char *hostname; char *expected_uri; @@ -350,132 +353,132 @@ handle_ad_arrive(void *cls, const char *end; if (GNUNET_SYSERR == - GNUNET_CONFIGURATION_get_value_number(adv_peer.cfg, - "HOSTLIST", - "HTTPPORT", - &port)) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Could not read advertising server's configuration\n"); - return; - } + GNUNET_CONFIGURATION_get_value_number (adv_peer.cfg, + "HOSTLIST", + "HTTPPORT", + &port)) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Could not read advertising server's configuration\n"); + return; + } if (GNUNET_SYSERR == - GNUNET_CONFIGURATION_get_value_string(adv_peer.cfg, - "HOSTLIST", - "EXTERNAL_DNS_NAME", - &hostname)) - hostname = GNUNET_RESOLVER_local_fqdn_get(); - GNUNET_asprintf(&expected_uri, - "http://%s:%u/", - hostname != NULL ? hostname : "localhost", - (unsigned int)port); - end = (const char *)&message[1]; - current_adv_uri = GNUNET_strdup(end); - if (0 == strcmp(expected_uri, - current_adv_uri)) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Received hostlist advertisement with URI `%s' as expected\n", - current_adv_uri); - adv_arrived = GNUNET_YES; - adv_sent = GNUNET_YES; - } + GNUNET_CONFIGURATION_get_value_string (adv_peer.cfg, + "HOSTLIST", + "EXTERNAL_DNS_NAME", + &hostname)) + hostname = GNUNET_RESOLVER_local_fqdn_get (); + GNUNET_asprintf (&expected_uri, + "http://%s:%u/", + hostname != NULL ? hostname : "localhost", + (unsigned int) port); + end = (const char *) &message[1]; + current_adv_uri = GNUNET_strdup (end); + if (0 == strcmp (expected_uri, + current_adv_uri)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Received hostlist advertisement with URI `%s' as expected\n", + current_adv_uri); + adv_arrived = GNUNET_YES; + adv_sent = GNUNET_YES; + } else - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Expected URI `%s' and received URI `%s' differ\n", - expected_uri, - current_adv_uri); - GNUNET_free(expected_uri); - GNUNET_free_non_null(hostname); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Expected URI `%s' and received URI `%s' differ\n", + expected_uri, + current_adv_uri); + GNUNET_free (expected_uri); + GNUNET_free_non_null (hostname); } static void -setup_learn_peer(struct PeerContext *p, - const char *cfgname) +setup_learn_peer (struct PeerContext *p, + const char *cfgname) { struct GNUNET_MQ_MessageHandler learn_handlers[] = { - GNUNET_MQ_hd_var_size(ad_arrive, - GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, - struct GNUNET_MessageHeader, - NULL), - GNUNET_MQ_handler_end() + GNUNET_MQ_hd_var_size (ad_arrive, + GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, + struct GNUNET_MessageHeader, + NULL), + GNUNET_MQ_handler_end () }; char *filename; unsigned int result; char *binary; - binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-arm"); - p->cfg = GNUNET_CONFIGURATION_create(); + binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm"); + p->cfg = GNUNET_CONFIGURATION_create (); p->arm_proc = - GNUNET_OS_start_process(GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, - NULL, NULL, NULL, - binary, - "gnunet-service-arm", - "-c", cfgname, NULL); - GNUNET_assert(GNUNET_OK == - GNUNET_CONFIGURATION_load(p->cfg, - cfgname)); + GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, + NULL, NULL, NULL, + binary, + "gnunet-service-arm", + "-c", cfgname, NULL); + GNUNET_assert (GNUNET_OK == + GNUNET_CONFIGURATION_load (p->cfg, + cfgname)); if (GNUNET_OK == - GNUNET_CONFIGURATION_get_value_string(p->cfg, - "HOSTLIST", - "HOSTLISTFILE", - &filename)) + GNUNET_CONFIGURATION_get_value_string (p->cfg, + "HOSTLIST", + "HOSTLISTFILE", + &filename)) + { + if (GNUNET_YES == GNUNET_DISK_file_test (filename)) { - if (GNUNET_YES == GNUNET_DISK_file_test(filename)) - { - result = unlink(filename); - if (result == 0) - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - _("Hostlist file `%s' was removed\n"), - filename); - } - GNUNET_free(filename); + result = unlink (filename); + if (result == 0) + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _ ("Hostlist file `%s' was removed\n"), + filename); } - p->core = GNUNET_CORE_connect(p->cfg, - NULL, - NULL, - NULL, - NULL, - learn_handlers); - GNUNET_assert(NULL != p->core); - p->stats = GNUNET_STATISTICS_create("hostlist", - p->cfg); - GNUNET_assert(NULL != p->stats); - GNUNET_free(binary); + GNUNET_free (filename); + } + p->core = GNUNET_CORE_connect (p->cfg, + NULL, + NULL, + NULL, + NULL, + learn_handlers); + GNUNET_assert (NULL != p->core); + p->stats = GNUNET_STATISTICS_create ("hostlist", + p->cfg); + GNUNET_assert (NULL != p->stats); + GNUNET_free (binary); } static void -setup_adv_peer(struct PeerContext *p, - const char *cfgname) +setup_adv_peer (struct PeerContext *p, + const char *cfgname) { char *binary; - binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-arm"); - p->cfg = GNUNET_CONFIGURATION_create(); + binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm"); + p->cfg = GNUNET_CONFIGURATION_create (); p->arm_proc = - GNUNET_OS_start_process(GNUNET_YES, - GNUNET_OS_INHERIT_STD_OUT_AND_ERR, - NULL, NULL, NULL, - binary, - "gnunet-service-arm", - "-c", cfgname, NULL); - GNUNET_assert(GNUNET_OK == - GNUNET_CONFIGURATION_load(p->cfg, - cfgname)); - p->stats = GNUNET_STATISTICS_create("hostlist", p->cfg); - GNUNET_assert(NULL != p->stats); - GNUNET_free(binary); + GNUNET_OS_start_process (GNUNET_YES, + GNUNET_OS_INHERIT_STD_OUT_AND_ERR, + NULL, NULL, NULL, + binary, + "gnunet-service-arm", + "-c", cfgname, NULL); + GNUNET_assert (GNUNET_OK == + GNUNET_CONFIGURATION_load (p->cfg, + cfgname)); + p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg); + GNUNET_assert (NULL != p->stats); + GNUNET_free (binary); } static void -run(void *cls, - char *const *args, - const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *c) +run (void *cls, + char *const *args, + const char *cfgfile, + const struct GNUNET_CONFIGURATION_Handle *c) { timeout = GNUNET_NO; adv_sent = GNUNET_NO; @@ -486,22 +489,22 @@ run(void *cls, cfg = c; - setup_adv_peer(&adv_peer, - "test_learning_adv_peer.conf"); - setup_learn_peer(&learn_peer, - "test_learning_learn_peer.conf"); - timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT, - &timeout_error, - NULL); + setup_adv_peer (&adv_peer, + "test_learning_adv_peer.conf"); + setup_learn_peer (&learn_peer, + "test_learning_learn_peer.conf"); + timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, + &timeout_error, + NULL); check_task = - GNUNET_SCHEDULER_add_delayed(CHECK_INTERVAL, - &check_statistics, - NULL); + GNUNET_SCHEDULER_add_delayed (CHECK_INTERVAL, + &check_statistics, + NULL); } static int -check() +check () { unsigned int failed; @@ -514,44 +517,44 @@ check() GNUNET_GETOPT_OPTION_END }; - GNUNET_PROGRAM_run((sizeof(argv) / sizeof(char *)) - 1, - argv, - "test-gnunet-daemon-hostlist-learning", - "nohelp", - options, - &run, - NULL); + GNUNET_PROGRAM_run ((sizeof(argv) / sizeof(char *)) - 1, + argv, + "test-gnunet-daemon-hostlist-learning", + "nohelp", + options, + &run, + NULL); failed = GNUNET_NO; if (timeout == GNUNET_YES) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Testcase timeout\n"); - failed = GNUNET_YES; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Testcase timeout\n"); + failed = GNUNET_YES; + } if (adv_arrived != GNUNET_YES) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Learning peer did not receive advertisement from server\n"); - failed = GNUNET_YES; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Learning peer did not receive advertisement from server\n"); + failed = GNUNET_YES; + } if (learned_hostlist_saved == GNUNET_NO) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Advertised hostlist was not saved in datastore\n"); - failed = GNUNET_YES; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Advertised hostlist was not saved in datastore\n"); + failed = GNUNET_YES; + } if (learned_hostlist_downloaded == GNUNET_NO) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Advertised hostlist could not be downloaded from server\n"); - failed = GNUNET_YES; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Advertised hostlist could not be downloaded from server\n"); + failed = GNUNET_YES; + } if (adv_sent == GNUNET_NO) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Advertised was not sent from server to client\n"); - failed = GNUNET_YES; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Advertised was not sent from server to client\n"); + failed = GNUNET_YES; + } if (GNUNET_YES == failed) return GNUNET_YES; return GNUNET_NO; @@ -559,29 +562,29 @@ check() int -main(int argc, char *argv[]) +main (int argc, char *argv[]) { int ret; - GNUNET_DISK_purge_cfg_dir("test_learning_learn_peer.conf", - "GNUNET_TEST_HOME"); - GNUNET_DISK_purge_cfg_dir("test_learning_adv_peer.conf", - "GNUNET_TEST_HOME"); - GNUNET_log_setup("test-gnunet-daemon-hostlist", - "WARNING", - NULL); - ret = check(); - GNUNET_DISK_purge_cfg_dir("test_learning_learn_peer.conf", - "GNUNET_TEST_HOME"); - GNUNET_DISK_purge_cfg_dir("test_learning_adv_peer.conf", - "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_learning_learn_peer.conf", + "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_learning_adv_peer.conf", + "GNUNET_TEST_HOME"); + GNUNET_log_setup ("test-gnunet-daemon-hostlist", + "WARNING", + NULL); + ret = check (); + GNUNET_DISK_purge_cfg_dir ("test_learning_learn_peer.conf", + "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_learning_adv_peer.conf", + "GNUNET_TEST_HOME"); if (GNUNET_YES == - GNUNET_DISK_file_test("hostlists_learn_peer.file")) - { - if (0 == unlink("hostlists_learn_peer.file")) - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Hostlist file hostlists_learn_peer.file was removed\n"); - } + GNUNET_DISK_file_test ("hostlists_learn_peer.file")) + { + if (0 == unlink ("hostlists_learn_peer.file")) + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Hostlist file hostlists_learn_peer.file was removed\n"); + } return ret; } diff --git a/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c b/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c index 783da1d20..ce17cfe4d 100644 --- a/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c +++ b/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c @@ -32,13 +32,14 @@ /** * How long until we give up on transmitting the message? */ -#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 150) +#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 150) static int ok; static struct GNUNET_SCHEDULER_Task *timeout_task; -struct PeerContext { +struct PeerContext +{ struct GNUNET_CONFIGURATION_Handle *cfg; struct GNUNET_TRANSPORT_CoreHandle *th; struct GNUNET_MessageHeader *hello; @@ -55,12 +56,12 @@ static struct PeerContext p2; * Timeout, give up. */ static void -timeout_error(void *cls) +timeout_error (void *cls) { timeout_task = NULL; - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Timeout trying to connect peers, test failed.\n"); - GNUNET_SCHEDULER_shutdown(); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Timeout trying to connect peers, test failed.\n"); + GNUNET_SCHEDULER_shutdown (); } @@ -74,87 +75,87 @@ timeout_error(void *cls) * @return NULL */ static void * -notify_connect(void *cls, - const struct GNUNET_PeerIdentity *peer, - struct GNUNET_MQ_Handle *mq) +notify_connect (void *cls, + const struct GNUNET_PeerIdentity *peer, + struct GNUNET_MQ_Handle *mq) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peers connected, shutting down.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected, shutting down.\n"); ok = 0; - GNUNET_SCHEDULER_shutdown(); + GNUNET_SCHEDULER_shutdown (); return NULL; } static void -process_hello(void *cls, const struct GNUNET_MessageHeader *message) +process_hello (void *cls, const struct GNUNET_MessageHeader *message) { struct PeerContext *p = cls; - GNUNET_TRANSPORT_hello_get_cancel(p->ghh); + GNUNET_TRANSPORT_hello_get_cancel (p->ghh); p->ghh = NULL; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Received HELLO, starting hostlist service.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received HELLO, starting hostlist service.\n"); } static void -setup_peer(struct PeerContext *p, const char *cfgname) +setup_peer (struct PeerContext *p, const char *cfgname) { char *binary; - binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-arm"); - p->cfg = GNUNET_CONFIGURATION_create(); - p->arm_proc = GNUNET_OS_start_process(GNUNET_YES, - GNUNET_OS_INHERIT_STD_OUT_AND_ERR, - NULL, - NULL, - NULL, - binary, - "gnunet-service-arm", - "-c", - cfgname, - NULL); - GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_load(p->cfg, cfgname)); - p->th = GNUNET_TRANSPORT_core_connect(p->cfg, - NULL, - NULL, - p, - ¬ify_connect, - NULL, - NULL); - GNUNET_assert(NULL != p->th); - p->ghh = GNUNET_TRANSPORT_hello_get(p->cfg, - GNUNET_TRANSPORT_AC_ANY, - &process_hello, - p); - GNUNET_free(binary); + binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm"); + p->cfg = GNUNET_CONFIGURATION_create (); + p->arm_proc = GNUNET_OS_start_process (GNUNET_YES, + GNUNET_OS_INHERIT_STD_OUT_AND_ERR, + NULL, + NULL, + NULL, + binary, + "gnunet-service-arm", + "-c", + cfgname, + NULL); + GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); + p->th = GNUNET_TRANSPORT_core_connect (p->cfg, + NULL, + NULL, + p, + ¬ify_connect, + NULL, + NULL); + GNUNET_assert (NULL != p->th); + p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg, + GNUNET_TRANSPORT_AC_ANY, + &process_hello, + p); + GNUNET_free (binary); } static void -waitpid_task(void *cls) +waitpid_task (void *cls) { struct PeerContext *p = cls; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Killing ARM process.\n"); - if (0 != GNUNET_OS_process_kill(p->arm_proc, GNUNET_TERM_SIG)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); - if (GNUNET_OK != GNUNET_OS_process_wait(p->arm_proc)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "waitpid"); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "ARM process %u stopped\n", - GNUNET_OS_process_get_pid(p->arm_proc)); - GNUNET_OS_process_destroy(p->arm_proc); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Killing ARM process.\n"); + if (0 != GNUNET_OS_process_kill (p->arm_proc, GNUNET_TERM_SIG)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); + if (GNUNET_OK != GNUNET_OS_process_wait (p->arm_proc)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "ARM process %u stopped\n", + GNUNET_OS_process_get_pid (p->arm_proc)); + GNUNET_OS_process_destroy (p->arm_proc); p->arm_proc = NULL; - GNUNET_CONFIGURATION_destroy(p->cfg); + GNUNET_CONFIGURATION_destroy (p->cfg); } static void -stop_arm(struct PeerContext *p) +stop_arm (struct PeerContext *p) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Asking ARM to stop core service\n"); - GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &waitpid_task, p); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking ARM to stop core service\n"); + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &waitpid_task, p); } @@ -162,55 +163,55 @@ stop_arm(struct PeerContext *p) * Try again to connect to transport service. */ static void -shutdown_task(void *cls) +shutdown_task (void *cls) { if (NULL != timeout_task) - { - GNUNET_SCHEDULER_cancel(timeout_task); - timeout_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (timeout_task); + timeout_task = NULL; + } if (NULL != p1.ghh) - { - GNUNET_TRANSPORT_hello_get_cancel(p1.ghh); - p1.ghh = NULL; - } + { + GNUNET_TRANSPORT_hello_get_cancel (p1.ghh); + p1.ghh = NULL; + } if (NULL != p1.th) - { - GNUNET_TRANSPORT_core_disconnect(p1.th); - p1.th = NULL; - } + { + GNUNET_TRANSPORT_core_disconnect (p1.th); + p1.th = NULL; + } if (NULL != p2.ghh) - { - GNUNET_TRANSPORT_hello_get_cancel(p2.ghh); - p2.ghh = NULL; - } + { + GNUNET_TRANSPORT_hello_get_cancel (p2.ghh); + p2.ghh = NULL; + } if (NULL != p2.th) - { - GNUNET_TRANSPORT_core_disconnect(p2.th); - p2.th = NULL; - } - stop_arm(&p1); - stop_arm(&p2); + { + GNUNET_TRANSPORT_core_disconnect (p2.th); + p2.th = NULL; + } + stop_arm (&p1); + stop_arm (&p2); } static void -run(void *cls, - char *const *args, - const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *cfg) +run (void *cls, + char *const *args, + const char *cfgfile, + const struct GNUNET_CONFIGURATION_Handle *cfg) { - GNUNET_assert(ok == 1); + GNUNET_assert (ok == 1); ok++; - timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT, &timeout_error, NULL); - GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); - setup_peer(&p1, "test_gnunet_daemon_hostlist_peer1.conf"); - setup_peer(&p2, "test_gnunet_daemon_hostlist_peer2.conf"); + timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_error, NULL); + GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); + setup_peer (&p1, "test_gnunet_daemon_hostlist_peer1.conf"); + setup_peer (&p2, "test_gnunet_daemon_hostlist_peer2.conf"); } int -main(int argcx, char *argvx[]) +main (int argcx, char *argvx[]) { static char *const argv[] = { "test-gnunet-daemon-hostlist", "-c", @@ -220,41 +221,41 @@ main(int argcx, char *argvx[]) GNUNET_GETOPT_OPTION_END }; - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer1.conf", - "GNUNET_TEST_HOME"); - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer2.conf", - "GNUNET_TEST_HOME"); - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_data.conf", - "GNUNET_TEST_HOME"); - GNUNET_log_setup("test-gnunet-daemon-hostlist", "WARNING", NULL); + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer1.conf", + "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer2.conf", + "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_data.conf", + "GNUNET_TEST_HOME"); + GNUNET_log_setup ("test-gnunet-daemon-hostlist", "WARNING", NULL); ok = 1; - GNUNET_PROGRAM_run((sizeof(argv) / sizeof(char *)) - 1, - argv, - "test-gnunet-daemon-hostlist", - "nohelp", - options, - &run, - &ok); + GNUNET_PROGRAM_run ((sizeof(argv) / sizeof(char *)) - 1, + argv, + "test-gnunet-daemon-hostlist", + "nohelp", + options, + &run, + &ok); if (0 == ok) - { - fprintf(stderr, "%s", "."); - /* now do it again */ - ok = 1; - GNUNET_PROGRAM_run((sizeof(argv) / sizeof(char *)) - 1, - argv, - "test-gnunet-daemon-hostlist", - "nohelp", - options, - &run, - &ok); - fprintf(stderr, "%s", ".\n"); - } - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer1.conf", - "GNUNET_TEST_HOME"); - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer2.conf", - "GNUNET_TEST_HOME"); - GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_data.conf", - "GNUNET_TEST_HOME"); + { + fprintf (stderr, "%s", "."); + /* now do it again */ + ok = 1; + GNUNET_PROGRAM_run ((sizeof(argv) / sizeof(char *)) - 1, + argv, + "test-gnunet-daemon-hostlist", + "nohelp", + options, + &run, + &ok); + fprintf (stderr, "%s", ".\n"); + } + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer1.conf", + "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer2.conf", + "GNUNET_TEST_HOME"); + GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_data.conf", + "GNUNET_TEST_HOME"); return ok; } -- cgit v1.2.3