From 1c987d24785f7e612925a9f36da05272a9099c90 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Tue, 20 Aug 2019 16:35:26 +0200 Subject: fix ftbfs --- src/namestore/gnunet-service-namestore.c | 820 ++++++++++++------------------- 1 file changed, 323 insertions(+), 497 deletions(-) diff --git a/src/namestore/gnunet-service-namestore.c b/src/namestore/gnunet-service-namestore.c index 4d23b91c6..3a925b952 100644 --- a/src/namestore/gnunet-service-namestore.c +++ b/src/namestore/gnunet-service-namestore.c @@ -35,7 +35,8 @@ #include "gnunet_signatures.h" #include "namestore.h" -#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename) +#define LOG_STRERROR_FILE(kind, syscall, filename) \ + GNUNET_log_from_strerror_file (kind, "util", syscall, filename) /** * If a monitor takes more than 1 minute to process an event, print a warning. @@ -118,7 +119,6 @@ struct ZoneIteration * message and free the data structure once @e cache_ops is zero. */ int send_end; - }; @@ -227,7 +227,6 @@ struct ZoneMonitor * that time, we clear the flag again. */ int sa_waiting; - }; @@ -306,7 +305,6 @@ struct StoreActivity * Label nicely canonicalized (lower case). */ char *conv_name; - }; @@ -426,16 +424,13 @@ cleanup_task (void *cls) struct CacheOperation *cop; (void) cls; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Stopping namestore service\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping namestore service\n"); while (NULL != (cop = cop_head)) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Aborting incomplete namecache operation\n"); GNUNET_NAMECACHE_cancel (cop->qe); - GNUNET_CONTAINER_DLL_remove (cop_head, - cop_tail, - cop); + GNUNET_CONTAINER_DLL_remove (cop_head, cop_tail, cop); GNUNET_free (cop); } if (NULL != namecache) @@ -443,8 +438,7 @@ cleanup_task (void *cls) GNUNET_NAMECACHE_disconnect (namecache); namecache = NULL; } - GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, - GSN_database)); + GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, GSN_database)); GNUNET_free (db_lib_name); db_lib_name = NULL; if (NULL != monitor_nc) @@ -454,8 +448,7 @@ cleanup_task (void *cls) } if (NULL != statistics) { - GNUNET_STATISTICS_destroy (statistics, - GNUNET_NO); + GNUNET_STATISTICS_destroy (statistics, GNUNET_NO); statistics = NULL; } } @@ -469,9 +462,7 @@ cleanup_task (void *cls) static void free_store_activity (struct StoreActivity *sa) { - GNUNET_CONTAINER_DLL_remove (sa_head, - sa_tail, - sa); + GNUNET_CONTAINER_DLL_remove (sa_head, sa_tail, sa); GNUNET_free (sa->conv_name); GNUNET_free (sa); } @@ -491,7 +482,7 @@ free_store_activity (struct StoreActivity *sa) */ static void lookup_nick_it (void *cls, - uint64_t seq, + uint64_t seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key, const char *label, unsigned int rd_count, @@ -510,11 +501,10 @@ lookup_nick_it (void *cls, { if (GNUNET_GNSRECORD_TYPE_NICK == rd[c].record_type) { - (*res) = GNUNET_malloc (rd[c].data_size + sizeof (struct GNUNET_GNSRECORD_Data)); + (*res) = + GNUNET_malloc (rd[c].data_size + sizeof (struct GNUNET_GNSRECORD_Data)); (*res)->data = &(*res)[1]; - GNUNET_memcpy ((void *) (*res)->data, - rd[c].data, - rd[c].data_size); + GNUNET_memcpy ((void *) (*res)->data, rd[c].data, rd[c].data_size); (*res)->data_size = rd[c].data_size; (*res)->expiration_time = rd[c].expiration_time; (*res)->flags = rd[c].flags; @@ -534,21 +524,19 @@ lookup_nick_it (void *cls, */ static void cache_nick (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, - const struct GNUNET_GNSRECORD_Data *nick) + const struct GNUNET_GNSRECORD_Data *nick) { struct NickCache *oldest; oldest = NULL; - for (unsigned int i=0;ilast_used.abs_value_us > - pos->last_used.abs_value_us) ) + if ((NULL == oldest) || + (oldest->last_used.abs_value_us > pos->last_used.abs_value_us)) oldest = pos; - if (0 == GNUNET_memcmp (zone, - &pos->zone)) + if (0 == GNUNET_memcmp (zone, &pos->zone)) { oldest = pos; break; @@ -558,13 +546,10 @@ cache_nick (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, oldest->zone = *zone; if (NULL != nick) { - oldest->rd = GNUNET_malloc (sizeof (*nick) + - nick->data_size); + oldest->rd = GNUNET_malloc (sizeof (*nick) + nick->data_size); *oldest->rd = *nick; oldest->rd->data = &oldest->rd[1]; - memcpy (&oldest->rd[1], - nick->data, - nick->data_size); + memcpy (&oldest->rd[1], nick->data, nick->data_size); } else { @@ -588,22 +573,17 @@ get_nick_record (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone) int res; /* check cache first */ - for (unsigned int i=0;ird) && - (0 == GNUNET_memcmp (zone, - &pos->zone)) ) + if ((NULL != pos->rd) && (0 == GNUNET_memcmp (zone, &pos->zone))) { if (NULL == pos->rd) - return NULL; - nick = GNUNET_malloc (sizeof (*nick) + - pos->rd->data_size); + return NULL; + nick = GNUNET_malloc (sizeof (*nick) + pos->rd->data_size); *nick = *pos->rd; nick->data = &nick[1]; - memcpy (&nick[1], - pos->rd->data, - pos->rd->data_size); + memcpy (&nick[1], pos->rd->data, pos->rd->data_size); pos->last_used = GNUNET_TIME_absolute_get (); return nick; } @@ -611,38 +591,36 @@ get_nick_record (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone) nick = NULL; res = GSN_database->lookup_records (GSN_database->cls, - zone, + zone, GNUNET_GNS_EMPTY_LABEL_AT, &lookup_nick_it, - &nick); - if ( (GNUNET_OK != res) || - (NULL == nick) ) + &nick); + if ((GNUNET_OK != res) || (NULL == nick)) { +#if ! defined(GNUNET_CULL_LOGGING) static int do_log = GNUNET_LOG_CALL_STATUS; if (0 == do_log) - do_log - = GNUNET_get_log_call_status (GNUNET_ERROR_TYPE_DEBUG, - "namestore", - __FILE__, - __FUNCTION__, - __LINE__); + do_log = GNUNET_get_log_call_status (GNUNET_ERROR_TYPE_DEBUG, + "namestore", + __FILE__, + __FUNCTION__, + __LINE__); if (1 == do_log) { GNUNET_CRYPTO_ecdsa_key_get_public (zone, &pub); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, - "No nick name set for zone `%s'\n", - GNUNET_GNSRECORD_z2s (&pub)); + "No nick name set for zone `%s'\n", + GNUNET_GNSRECORD_z2s (&pub)); } +#endif /* update cache */ - cache_nick (zone, - NULL); + cache_nick (zone, NULL); return NULL; } /* update cache */ - cache_nick (zone, - nick); + cache_nick (zone, nick); return nick; } @@ -683,7 +661,7 @@ merge_with_nick_records (const struct GNUNET_GNSRECORD_Data *nick_rd, return; } req = sizeof (struct GNUNET_GNSRECORD_Data) + nick_rd->data_size; - for (unsigned int i=0; iflags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION)) { - if ((GNUNET_TIME_absolute_get().abs_value_us + orig->expiration_time) > + if ((GNUNET_TIME_absolute_get ().abs_value_us + orig->expiration_time) > latest_expiration) latest_expiration = orig->expiration_time; } @@ -714,21 +692,17 @@ merge_with_nick_records (const struct GNUNET_GNSRECORD_Data *nick_rd, latest_expiration = orig->expiration_time; target[i] = *orig; target[i].data = (void *) &data[data_offset]; - GNUNET_memcpy (&data[data_offset], - orig->data, - orig->data_size); + GNUNET_memcpy (&data[data_offset], orig->data, orig->data_size); data_offset += orig->data_size; } /* append nick */ target[rd2_length] = *nick_rd; target[rd2_length].expiration_time = latest_expiration; target[rd2_length].data = (void *) &data[data_offset]; - GNUNET_memcpy (&data[data_offset], - nick_rd->data, - nick_rd->data_size); + GNUNET_memcpy (&data[data_offset], nick_rd->data, nick_rd->data_size); data_offset += nick_rd->data_size; - GNUNET_assert (req == - (sizeof (struct GNUNET_GNSRECORD_Data)) * (*rdc_res) + data_offset); + GNUNET_assert (req == (sizeof (struct GNUNET_GNSRECORD_Data)) * (*rdc_res) + + data_offset); } @@ -745,11 +719,11 @@ merge_with_nick_records (const struct GNUNET_GNSRECORD_Data *nick_rd, */ static void send_lookup_response (struct NamestoreClient *nc, - uint32_t request_id, - const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, - const char *name, - unsigned int rd_count, - const struct GNUNET_GNSRECORD_Data *rd) + uint32_t request_id, + const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, + const char *name, + unsigned int rd_count, + const struct GNUNET_GNSRECORD_Data *rd) { struct GNUNET_MQ_Envelope *env; struct RecordResultMessage *zir_msg; @@ -762,20 +736,13 @@ send_lookup_response (struct NamestoreClient *nc, char *rd_ser; nick = get_nick_record (zone_key); - GNUNET_assert (-1 != - GNUNET_GNSRECORD_records_get_size (rd_count, - rd)); + GNUNET_assert (-1 != GNUNET_GNSRECORD_records_get_size (rd_count, rd)); - if ( (NULL != nick) && - (0 != strcmp (name, - GNUNET_GNS_EMPTY_LABEL_AT))) + if ((NULL != nick) && (0 != strcmp (name, GNUNET_GNS_EMPTY_LABEL_AT))) { - nick->flags = (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE; - merge_with_nick_records (nick, - rd_count, - rd, - &res_count, - &res); + nick->flags = + (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE; + merge_with_nick_records (nick, rd_count, rd, &res_count, &res); GNUNET_free (nick); } else @@ -784,14 +751,11 @@ send_lookup_response (struct NamestoreClient *nc, res = (struct GNUNET_GNSRECORD_Data *) rd; } - GNUNET_assert (-1 != - GNUNET_GNSRECORD_records_get_size (res_count, - res)); + GNUNET_assert (-1 != GNUNET_GNSRECORD_records_get_size (res_count, res)); name_len = strlen (name) + 1; - rd_ser_len = GNUNET_GNSRECORD_records_get_size (res_count, - res); + rd_ser_len = GNUNET_GNSRECORD_records_get_size (res_count, res); if (rd_ser_len < 0) { GNUNET_break (0); @@ -805,32 +769,27 @@ send_lookup_response (struct NamestoreClient *nc, return; } env = GNUNET_MQ_msg_extra (zir_msg, - name_len + rd_ser_len, - GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT); + name_len + rd_ser_len, + GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT); zir_msg->gns_header.r_id = htonl (request_id); zir_msg->name_len = htons (name_len); zir_msg->rd_count = htons (res_count); zir_msg->rd_len = htons ((uint16_t) rd_ser_len); zir_msg->private_key = *zone_key; name_tmp = (char *) &zir_msg[1]; - GNUNET_memcpy (name_tmp, - name, - name_len); + GNUNET_memcpy (name_tmp, name, name_len); rd_ser = &name_tmp[name_len]; - GNUNET_assert (rd_ser_len == - GNUNET_GNSRECORD_records_serialize (res_count, - res, - rd_ser_len, - rd_ser)); + GNUNET_assert ( + rd_ser_len == + GNUNET_GNSRECORD_records_serialize (res_count, res, rd_ser_len, rd_ser)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Sending RECORD_RESULT message with %u records\n", - res_count); + "Sending RECORD_RESULT message with %u records\n", + res_count); GNUNET_STATISTICS_update (statistics, "Record sets sent to clients", 1, GNUNET_NO); - GNUNET_MQ_send (nc->mq, - env); + GNUNET_MQ_send (nc->mq, env); if (rd != res) GNUNET_free (res); } @@ -844,26 +803,23 @@ send_lookup_response (struct NamestoreClient *nc, * @param rid client's request ID */ static void -send_store_response (struct NamestoreClient *nc, - int res, - uint32_t rid) +send_store_response (struct NamestoreClient *nc, int res, uint32_t rid) { struct GNUNET_MQ_Envelope *env; struct RecordStoreResponseMessage *rcr_msg; GNUNET_assert (NULL != nc); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Sending RECORD_STORE_RESPONSE message\n"); + "Sending RECORD_STORE_RESPONSE message\n"); GNUNET_STATISTICS_update (statistics, "Store requests completed", 1, GNUNET_NO); env = GNUNET_MQ_msg (rcr_msg, - GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE); + GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE); rcr_msg->gns_header.r_id = htonl (rid); rcr_msg->op_result = htonl (res); - GNUNET_MQ_send (nc->mq, - env); + GNUNET_MQ_send (nc->mq, env); } @@ -883,15 +839,11 @@ zone_iteration_done_client_continue (struct ZoneIteration *zi) if (! zi->send_end) return; /* send empty response to indicate end of list */ - env = GNUNET_MQ_msg (em, - GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END); + env = GNUNET_MQ_msg (em, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END); em->r_id = htonl (zi->request_id); - GNUNET_MQ_send (zi->nc->mq, - env); + GNUNET_MQ_send (zi->nc->mq, env); - GNUNET_CONTAINER_DLL_remove (zi->nc->op_head, - zi->nc->op_tail, - zi); + GNUNET_CONTAINER_DLL_remove (zi->nc->op_head, zi->nc->op_tail, zi); GNUNET_free (zi); } @@ -904,36 +856,29 @@ zone_iteration_done_client_continue (struct ZoneIteration *zi) * @param emsg error messages */ static void -finish_cache_operation (void *cls, - int32_t success, - const char *emsg) +finish_cache_operation (void *cls, int32_t success, const char *emsg) { struct CacheOperation *cop = cls; struct ZoneIteration *zi; if (NULL != emsg) GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("Failed to replicate block in namecache: %s\n"), + _ ("Failed to replicate block in namecache: %s\n"), emsg); else - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "CACHE operation completed\n"); - GNUNET_CONTAINER_DLL_remove (cop_head, - cop_tail, - cop); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CACHE operation completed\n"); + GNUNET_CONTAINER_DLL_remove (cop_head, cop_tail, cop); if (NULL != cop->nc) - send_store_response (cop->nc, - success, - cop->rid); + send_store_response (cop->nc, success, cop->rid); if (NULL != (zi = cop->zi)) + { + zi->cache_ops--; + if (0 == zi->cache_ops) { - zi->cache_ops--; - if (0 == zi->cache_ops) - { - /* unchoke zone iteration, cache has caught up */ - zone_iteration_done_client_continue (zi); - } + /* unchoke zone iteration, cache has caught up */ + zone_iteration_done_client_continue (zi); } + } GNUNET_free (cop); } @@ -952,7 +897,7 @@ finish_cache_operation (void *cls, */ static void refresh_block (struct NamestoreClient *nc, - struct ZoneIteration *zi, + struct ZoneIteration *zi, uint32_t rid, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, @@ -972,56 +917,43 @@ refresh_block (struct NamestoreClient *nc, res = (struct GNUNET_GNSRECORD_Data *) rd; /* fixme: a bit unclean... */ if (NULL != nick) { - nick->flags = (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE; - merge_with_nick_records (nick, - rd_count,rd, - &res_count, - &res); + nick->flags = + (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE; + merge_with_nick_records (nick, rd_count, rd, &res_count, &res); GNUNET_free (nick); } if (0 == res_count) { if (NULL != nc) - send_store_response (nc, - GNUNET_OK, - rid); + send_store_response (nc, GNUNET_OK, rid); return; /* no data, no need to update cache */ } if (GNUNET_YES == disable_namecache) { GNUNET_STATISTICS_update (statistics, - "Namecache updates skipped (NC disabled)", - 1, - GNUNET_NO); + "Namecache updates skipped (NC disabled)", + 1, + GNUNET_NO); if (NULL != nc) - send_store_response (nc, - GNUNET_OK, - rid); + send_store_response (nc, GNUNET_OK, rid); return; } - exp_time = GNUNET_GNSRECORD_record_get_expiration_time (res_count, - res); + exp_time = GNUNET_GNSRECORD_record_get_expiration_time (res_count, res); if (cache_keys) - block = GNUNET_GNSRECORD_block_create2 (zone_key, - exp_time, - name, - res, - res_count); + block = + GNUNET_GNSRECORD_block_create2 (zone_key, exp_time, name, res, res_count); else - block = GNUNET_GNSRECORD_block_create (zone_key, - exp_time, - name, - res, - res_count); + block = + GNUNET_GNSRECORD_block_create (zone_key, exp_time, name, res, res_count); GNUNET_assert (NULL != block); - GNUNET_CRYPTO_ecdsa_key_get_public (zone_key, - &pkey); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Caching block for label `%s' with %u records and expiration %s in zone `%s' in namecache\n", - name, - res_count, - GNUNET_STRINGS_absolute_time_to_string (exp_time), - GNUNET_GNSRECORD_z2s (&pkey)); + GNUNET_CRYPTO_ecdsa_key_get_public (zone_key, &pkey); + GNUNET_log ( + GNUNET_ERROR_TYPE_DEBUG, + "Caching block for label `%s' with %u records and expiration %s in zone `%s' in namecache\n", + name, + res_count, + GNUNET_STRINGS_absolute_time_to_string (exp_time), + GNUNET_GNSRECORD_z2s (&pkey)); GNUNET_STATISTICS_update (statistics, "Namecache updates pushed", 1, @@ -1032,9 +964,7 @@ refresh_block (struct NamestoreClient *nc, if (NULL != zi) zi->cache_ops++; cop->rid = rid; - GNUNET_CONTAINER_DLL_insert (cop_head, - cop_tail, - cop); + GNUNET_CONTAINER_DLL_insert (cop_head, cop_tail, cop); cop->qe = GNUNET_NAMECACHE_block_cache (namecache, block, &finish_cache_operation, @@ -1085,36 +1015,31 @@ continue_store_activity (struct StoreActivity *sa) name_tmp = (const char *) &rp_msg[1]; rd_ser = &name_tmp[name_len]; { - struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(rd_count)]; + struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)]; /* We did this before, must succeed again */ - GNUNET_assert (GNUNET_OK == - GNUNET_GNSRECORD_records_deserialize (rd_ser_len, - rd_ser, - rd_count, - rd)); - - for (struct ZoneMonitor *zm = sa->zm_pos; - NULL != zm; - zm = sa->zm_pos) + GNUNET_assert ( + GNUNET_OK == + GNUNET_GNSRECORD_records_deserialize (rd_ser_len, rd_ser, rd_count, rd)); + + for (struct ZoneMonitor *zm = sa->zm_pos; NULL != zm; zm = sa->zm_pos) { - if ( (0 != GNUNET_memcmp (&rp_msg->private_key, - &zm->zone)) && - (0 != GNUNET_memcmp (&zm->zone, - &zero)) ) - { - sa->zm_pos = zm->next; /* not interesting to this monitor */ - continue; - } + if ((0 != GNUNET_memcmp (&rp_msg->private_key, &zm->zone)) && + (0 != GNUNET_memcmp (&zm->zone, &zero))) + { + sa->zm_pos = zm->next; /* not interesting to this monitor */ + continue; + } if (zm->limit == zm->iteration_cnt) { zm->sa_waiting = GNUNET_YES; zm->sa_waiting_start = GNUNET_TIME_absolute_get (); if (NULL != zm->sa_wait_warning) GNUNET_SCHEDULER_cancel (zm->sa_wait_warning); - zm->sa_wait_warning = GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY, - &warn_monitor_slow, - zm); + zm->sa_wait_warning = + GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY, + &warn_monitor_slow, + zm); return; /* blocked on zone monitor */ } GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, @@ -1131,7 +1056,7 @@ continue_store_activity (struct StoreActivity *sa) } /* great, done with the monitors, unpack (again) for refresh_block operation */ refresh_block (sa->nc, - NULL, + NULL, rid, &rp_msg->private_key, sa->conv_name, @@ -1153,26 +1078,22 @@ continue_store_activity (struct StoreActivity *sa) */ static void client_disconnect_cb (void *cls, - struct GNUNET_SERVICE_Client *client, - void *app_ctx) + struct GNUNET_SERVICE_Client *client, + void *app_ctx) { struct NamestoreClient *nc = app_ctx; struct ZoneIteration *no; struct CacheOperation *cop; (void) cls; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Client %p disconnected\n", - client); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client); for (struct ZoneMonitor *zm = monitor_head; NULL != zm; zm = zm->next) { struct StoreActivity *san; if (nc != zm->nc) continue; - GNUNET_CONTAINER_DLL_remove (monitor_head, - monitor_tail, - zm); + GNUNET_CONTAINER_DLL_remove (monitor_head, monitor_tail, zm); if (NULL != zm->task) { GNUNET_SCHEDULER_cancel (zm->task); @@ -1207,9 +1128,7 @@ client_disconnect_cb (void *cls, } while (NULL != (no = nc->op_head)) { - GNUNET_CONTAINER_DLL_remove (nc->op_head, - nc->op_tail, - no); + GNUNET_CONTAINER_DLL_remove (nc->op_head, nc->op_tail, no); GNUNET_free (no); } for (cop = cop_head; NULL != cop; cop = cop->next) @@ -1229,15 +1148,13 @@ client_disconnect_cb (void *cls, */ static void * client_connect_cb (void *cls, - struct GNUNET_SERVICE_Client *client, - struct GNUNET_MQ_Handle *mq) + struct GNUNET_SERVICE_Client *client, + struct GNUNET_MQ_Handle *mq) { struct NamestoreClient *nc; (void) cls; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Client %p connected\n", - client); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client); nc = GNUNET_new (struct NamestoreClient); nc->client = client; nc->mq = mq; @@ -1297,7 +1214,7 @@ struct RecordLookupContext */ static void lookup_it (void *cls, - uint64_t seq, + uint64_t seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key, const char *label, unsigned int rd_count, @@ -1307,8 +1224,7 @@ lookup_it (void *cls, (void) private_key; GNUNET_assert (0 != seq); - if (0 != strcmp (label, - rlc->label)) + if (0 != strcmp (label, rlc->label)) return; rlc->found = GNUNET_YES; if (0 == rd_count) @@ -1318,9 +1234,7 @@ lookup_it (void *cls, rlc->res_rd = NULL; return; } - if ( (NULL != rlc->nick) && - (0 != strcmp (label, - GNUNET_GNS_EMPTY_LABEL_AT)) ) + if ((NULL != rlc->nick) && (0 != strcmp (label, GNUNET_GNS_EMPTY_LABEL_AT))) { /* Merge */ struct GNUNET_GNSRECORD_Data *rd_res; @@ -1328,36 +1242,31 @@ lookup_it (void *cls, rd_res = NULL; rdc_res = 0; - rlc->nick->flags = (rlc->nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE; - merge_with_nick_records (rlc->nick, - rd_count, - rd, - &rdc_res, - &rd_res); - rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rdc_res, - rd_res); + rlc->nick->flags = (rlc->nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ + GNUNET_GNSRECORD_RF_PRIVATE; + merge_with_nick_records (rlc->nick, rd_count, rd, &rdc_res, &rd_res); + rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rdc_res, rd_res); if (rlc->rd_ser_len < 0) { GNUNET_break (0); - GNUNET_free (rd_res); + GNUNET_free (rd_res); rlc->found = GNUNET_NO; rlc->rd_ser_len = 0; return; } rlc->res_rd_count = rdc_res; rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len); - if (rlc->rd_ser_len != - GNUNET_GNSRECORD_records_serialize (rdc_res, - rd_res, - rlc->rd_ser_len, - rlc->res_rd)) + if (rlc->rd_ser_len != GNUNET_GNSRECORD_records_serialize (rdc_res, + rd_res, + rlc->rd_ser_len, + rlc->res_rd)) { GNUNET_break (0); - GNUNET_free (rlc->res_rd); + GNUNET_free (rlc->res_rd); rlc->res_rd = NULL; rlc->res_rd_count = 0; rlc->rd_ser_len = 0; - GNUNET_free (rd_res); + GNUNET_free (rd_res); rlc->found = GNUNET_NO; return; } @@ -1367,8 +1276,7 @@ lookup_it (void *cls, } else { - rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, - rd); + rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd); if (rlc->rd_ser_len < 0) { GNUNET_break (0); @@ -1378,14 +1286,13 @@ lookup_it (void *cls, } rlc->res_rd_count = rd_count; rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len); - if (rlc->rd_ser_len != - GNUNET_GNSRECORD_records_serialize (rd_count, - rd, - rlc->rd_ser_len, - rlc->res_rd)) + if (rlc->rd_ser_len != GNUNET_GNSRECORD_records_serialize (rd_count, + rd, + rlc->rd_ser_len, + rlc->res_rd)) { GNUNET_break (0); - GNUNET_free (rlc->res_rd); + GNUNET_free (rlc->res_rd); rlc->res_rd = NULL; rlc->res_rd_count = 0; rlc->rd_ser_len = 0; @@ -1404,8 +1311,7 @@ lookup_it (void *cls, * @return #GNUNET_OK if @a ll_msg is well-formed */ static int -check_record_lookup (void *cls, - const struct LabelLookupMessage *ll_msg) +check_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg) { uint32_t name_len; size_t src_size; @@ -1430,8 +1336,7 @@ check_record_lookup (void *cls, * @param ll_msg message of type `struct LabelLookupMessage` */ static void -handle_record_lookup (void *cls, - const struct LabelLookupMessage *ll_msg) +handle_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg) { struct NamestoreClient *nc = cls; struct GNUNET_MQ_Envelope *env; @@ -1471,27 +1376,23 @@ handle_record_lookup (void *cls, &lookup_it, &rlc); GNUNET_free (conv_name); - env = GNUNET_MQ_msg_extra (llr_msg, - name_len + rlc.rd_ser_len, - GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE); + env = + GNUNET_MQ_msg_extra (llr_msg, + name_len + rlc.rd_ser_len, + GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE); llr_msg->gns_header.r_id = ll_msg->gns_header.r_id; llr_msg->private_key = ll_msg->zone; llr_msg->name_len = htons (name_len); llr_msg->rd_count = htons (rlc.res_rd_count); llr_msg->rd_len = htons (rlc.rd_ser_len); res_name = (char *) &llr_msg[1]; - if ((GNUNET_YES == rlc.found) && (GNUNET_OK == res)) + if ((GNUNET_YES == rlc.found) && (GNUNET_OK == res)) llr_msg->found = ntohs (GNUNET_YES); else llr_msg->found = ntohs (GNUNET_NO); - GNUNET_memcpy (&llr_msg[1], - name_tmp, - name_len); - GNUNET_memcpy (&res_name[name_len], - rlc.res_rd, - rlc.rd_ser_len); - GNUNET_MQ_send (nc->mq, - env); + GNUNET_memcpy (&llr_msg[1], name_tmp, name_len); + GNUNET_memcpy (&res_name[name_len], rlc.res_rd, rlc.rd_ser_len); + GNUNET_MQ_send (nc->mq, env); GNUNET_free_non_null (rlc.res_rd); } @@ -1504,8 +1405,7 @@ handle_record_lookup (void *cls, * @return #GNUNET_OK if @a rp_msg is well-formed */ static int -check_record_store (void *cls, - const struct RecordStoreMessage *rp_msg) +check_record_store (void *cls, const struct RecordStoreMessage *rp_msg) { size_t name_len; size_t msg_size; @@ -1523,14 +1423,13 @@ check_record_store (void *cls, GNUNET_break (0); return GNUNET_SYSERR; } - if ( (0 == name_len) || - (name_len > MAX_NAME_LEN) ) + if ((0 == name_len) || (name_len > MAX_NAME_LEN)) { GNUNET_break (0); return GNUNET_SYSERR; } name_tmp = (const char *) &rp_msg[1]; - if ('\0' != name_tmp[name_len -1]) + if ('\0' != name_tmp[name_len - 1]) { GNUNET_break (0); return GNUNET_SYSERR; @@ -1546,8 +1445,7 @@ check_record_store (void *cls, * @param rp_msg message of type `struct RecordStoreMessage` */ static void -handle_record_store (void *cls, - const struct RecordStoreMessage *rp_msg) +handle_record_store (void *cls, const struct RecordStoreMessage *rp_msg) { struct NamestoreClient *nc = cls; size_t name_len; @@ -1561,7 +1459,7 @@ handle_record_store (void *cls, struct StoreActivity *sa; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received NAMESTORE_RECORD_STORE message\n"); + "Received NAMESTORE_RECORD_STORE message\n"); rid = ntohl (rp_msg->gns_header.r_id); name_len = ntohs (rp_msg->name_len); rd_count = ntohs (rp_msg->rd_count); @@ -1570,13 +1468,10 @@ handle_record_store (void *cls, name_tmp = (const char *) &rp_msg[1]; rd_ser = &name_tmp[name_len]; { - struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(rd_count)]; + struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)]; if (GNUNET_OK != - GNUNET_GNSRECORD_records_deserialize (rd_ser_len, - rd_ser, - rd_count, - rd)) + GNUNET_GNSRECORD_records_deserialize (rd_ser_len, rd_ser, rd_count, rd)) { GNUNET_break (0); GNUNET_SERVICE_client_drop (nc->client); @@ -1598,16 +1493,15 @@ handle_record_store (void *cls, 1, GNUNET_NO); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Creating %u records for name `%s'\n", - (unsigned int) rd_count, - conv_name); - if ( (0 == rd_count) && - (GNUNET_NO == - GSN_database->lookup_records (GSN_database->cls, - &rp_msg->private_key, - conv_name, - NULL, - 0)) ) + "Creating %u records for name `%s'\n", + (unsigned int) rd_count, + conv_name); + if ((0 == rd_count) && + (GNUNET_NO == GSN_database->lookup_records (GSN_database->cls, + &rp_msg->private_key, + conv_name, + NULL, + 0))) { /* This name does not exist, so cannot be removed */ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, @@ -1619,50 +1513,43 @@ handle_record_store (void *cls, { /* remove "NICK" records, unless this is for the #GNUNET_GNS_EMPTY_LABEL_AT label */ - struct GNUNET_GNSRECORD_Data rd_clean[GNUNET_NZL(rd_count)]; + struct GNUNET_GNSRECORD_Data rd_clean[GNUNET_NZL (rd_count)]; unsigned int rd_clean_off; int have_nick; rd_clean_off = 0; have_nick = GNUNET_NO; - for (unsigned int i=0;iprivate_key, - &rd[i]); - have_nick = GNUNET_YES; - } + if ((0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT, conv_name)) && + (GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type)) + { + cache_nick (&rp_msg->private_key, &rd[i]); + have_nick = GNUNET_YES; + } } - if ( (0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT, - conv_name)) && - (GNUNET_NO == have_nick) ) + if ((0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT, conv_name)) && + (GNUNET_NO == have_nick)) { - /* remove nick record from cache, in case we have one there */ - cache_nick (&rp_msg->private_key, - NULL); + /* remove nick record from cache, in case we have one there */ + cache_nick (&rp_msg->private_key, NULL); } res = GSN_database->store_records (GSN_database->cls, - &rp_msg->private_key, - conv_name, - rd_clean_off, + &rp_msg->private_key, + conv_name, + rd_clean_off, rd_clean); } if (GNUNET_OK != res) { /* store not successful, not need to tell monitors */ - send_store_response (nc, - res, - rid); + send_store_response (nc, res, rid); GNUNET_SERVICE_client_continue (nc->client); GNUNET_free (conv_name); return; @@ -1670,14 +1557,10 @@ handle_record_store (void *cls, sa = GNUNET_malloc (sizeof (struct StoreActivity) + ntohs (rp_msg->gns_header.header.size)); - GNUNET_CONTAINER_DLL_insert (sa_head, - sa_tail, - sa); + GNUNET_CONTAINER_DLL_insert (sa_head, sa_tail, sa); sa->nc = nc; sa->rsm = (const struct RecordStoreMessage *) &sa[1]; - GNUNET_memcpy (&sa[1], - rp_msg, - ntohs (rp_msg->gns_header.header.size)); + GNUNET_memcpy (&sa[1], rp_msg, ntohs (rp_msg->gns_header.header.size)); sa->zm_pos = monitor_head; sa->conv_name = conv_name; continue_store_activity (sa); @@ -1722,11 +1605,11 @@ struct ZoneToNameCtx */ static void handle_zone_to_name_it (void *cls, - uint64_t seq, - const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, - const char *name, - unsigned int rd_count, - const struct GNUNET_GNSRECORD_Data *rd) + uint64_t seq, + const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, + const char *name, + unsigned int rd_count, + const struct GNUNET_GNSRECORD_Data *rd) { struct ZoneToNameCtx *ztn_ctx = cls; struct GNUNET_MQ_Envelope *env; @@ -1740,12 +1623,11 @@ handle_zone_to_name_it (void *cls, GNUNET_assert (0 != seq); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Found result for zone-to-name lookup: `%s'\n", - name); + "Found result for zone-to-name lookup: `%s'\n", + name); res = GNUNET_YES; name_len = (NULL == name) ? 0 : strlen (name) + 1; - rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, - rd); + rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd); if (rd_ser_len < 0) { GNUNET_break (0); @@ -1759,9 +1641,10 @@ handle_zone_to_name_it (void *cls, ztn_ctx->success = GNUNET_SYSERR; return; } - env = GNUNET_MQ_msg_extra (ztnr_msg, - name_len + rd_ser_len, - GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE); + env = + GNUNET_MQ_msg_extra (ztnr_msg, + name_len + rd_ser_len, + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE); ztnr_msg->gns_header.header.size = htons (msg_size); ztnr_msg->gns_header.r_id = htonl (ztn_ctx->rid); ztnr_msg->res = htons (res); @@ -1770,18 +1653,13 @@ handle_zone_to_name_it (void *cls, ztnr_msg->name_len = htons (name_len); ztnr_msg->zone = *zone_key; name_tmp = (char *) &ztnr_msg[1]; - GNUNET_memcpy (name_tmp, - name, - name_len); + GNUNET_memcpy (name_tmp, name, name_len); rd_tmp = &name_tmp[name_len]; - GNUNET_assert (rd_ser_len == - GNUNET_GNSRECORD_records_serialize (rd_count, - rd, - rd_ser_len, - rd_tmp)); + GNUNET_assert ( + rd_ser_len == + GNUNET_GNSRECORD_records_serialize (rd_count, rd, rd_ser_len, rd_tmp)); ztn_ctx->success = GNUNET_OK; - GNUNET_MQ_send (ztn_ctx->nc->mq, - env); + GNUNET_MQ_send (ztn_ctx->nc->mq, env); } @@ -1792,24 +1670,22 @@ handle_zone_to_name_it (void *cls, * @param ztn_msg message of type 'struct ZoneToNameMessage' */ static void -handle_zone_to_name (void *cls, - const struct ZoneToNameMessage *ztn_msg) +handle_zone_to_name (void *cls, const struct ZoneToNameMessage *ztn_msg) { struct NamestoreClient *nc = cls; struct ZoneToNameCtx ztn_ctx; struct GNUNET_MQ_Envelope *env; struct ZoneToNameResponseMessage *ztnr_msg; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received ZONE_TO_NAME message\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME message\n"); ztn_ctx.rid = ntohl (ztn_msg->gns_header.r_id); ztn_ctx.nc = nc; ztn_ctx.success = GNUNET_NO; - if (GNUNET_SYSERR == - GSN_database->zone_to_name (GSN_database->cls, - &ztn_msg->zone, - &ztn_msg->value_zone, - &handle_zone_to_name_it, &ztn_ctx)) + if (GNUNET_SYSERR == GSN_database->zone_to_name (GSN_database->cls, + &ztn_msg->zone, + &ztn_msg->value_zone, + &handle_zone_to_name_it, + &ztn_ctx)) { /* internal error, hang up instead of signalling something that might be wrong */ @@ -1823,11 +1699,10 @@ handle_zone_to_name (void *cls, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found no result for zone-to-name lookup.\n"); env = GNUNET_MQ_msg (ztnr_msg, - GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE); + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE); ztnr_msg->gns_header.r_id = ztn_msg->gns_header.r_id; ztnr_msg->res = htons (GNUNET_NO); - GNUNET_MQ_send (nc->mq, - env); + GNUNET_MQ_send (nc->mq, env); } GNUNET_SERVICE_client_continue (nc->client); } @@ -1848,7 +1723,6 @@ struct ZoneIterationProcResult * Number of results left to be returned in this iteration. */ uint64_t limit; - }; @@ -1864,25 +1738,22 @@ struct ZoneIterationProcResult */ static void zone_iterate_proc (void *cls, - uint64_t seq, - const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, - const char *name, - unsigned int rd_count, - const struct GNUNET_GNSRECORD_Data *rd) + uint64_t seq, + const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, + const char *name, + unsigned int rd_count, + const struct GNUNET_GNSRECORD_Data *rd) { struct ZoneIterationProcResult *proc = cls; int do_refresh_block; GNUNET_assert (0 != seq); - if ( (NULL == zone_key) && - (NULL == name) ) + if ((NULL == zone_key) && (NULL == name)) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Iteration done\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration done\n"); return; } - if ( (NULL == zone_key) || - (NULL == name) ) + if ((NULL == zone_key) || (NULL == name)) { /* what is this!? should never happen */ GNUNET_break (0); @@ -1905,20 +1776,14 @@ zone_iterate_proc (void *cls, do_refresh_block = GNUNET_NO; - for (unsigned int i=0;izi, - 0, - zone_key, - name, - rd_count, - rd); + refresh_block (NULL, proc->zi, 0, zone_key, name, rd_count, rd); } @@ -1929,16 +1794,13 @@ zone_iterate_proc (void *cls, * @param limit number of results to return in one pass */ static void -run_zone_iteration_round (struct ZoneIteration *zi, - uint64_t limit) +run_zone_iteration_round (struct ZoneIteration *zi, uint64_t limit) { struct ZoneIterationProcResult proc; struct GNUNET_TIME_Absolute start; struct GNUNET_TIME_Relative duration; - memset (&proc, - 0, - sizeof (proc)); + memset (&proc, 0, sizeof (proc)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asked to return up to %llu records at position %llu\n", (unsigned long long) limit, @@ -1949,15 +1811,14 @@ run_zone_iteration_round (struct ZoneIteration *zi, GNUNET_break (GNUNET_SYSERR != GSN_database->iterate_records (GSN_database->cls, (0 == GNUNET_is_zero (&zi->zone)) - ? NULL - : &zi->zone, + ? NULL + : &zi->zone, zi->seq, limit, &zone_iterate_proc, &proc)); duration = GNUNET_TIME_absolute_get_duration (start); - duration = GNUNET_TIME_relative_divide (duration, - limit - proc.limit); + duration = GNUNET_TIME_relative_divide (duration, limit - proc.limit); GNUNET_STATISTICS_set (statistics, "NAMESTORE iteration delay (μs/record)", duration.rel_value_us, @@ -1993,11 +1854,8 @@ handle_iteration_start (void *cls, zi->nc = nc; zi->zone = zis_msg->zone; - GNUNET_CONTAINER_DLL_insert (nc->op_head, - nc->op_tail, - zi); - run_zone_iteration_round (zi, - 1); + GNUNET_CONTAINER_DLL_insert (nc->op_head, nc->op_tail, zi); + run_zone_iteration_round (zi, 1); } @@ -2027,9 +1885,7 @@ handle_iteration_stop (void *cls, GNUNET_SERVICE_client_drop (nc->client); return; } - GNUNET_CONTAINER_DLL_remove (nc->op_head, - nc->op_tail, - zi); + GNUNET_CONTAINER_DLL_remove (nc->op_head, nc->op_tail, zi); GNUNET_free (zi); GNUNET_SERVICE_client_continue (nc->client); } @@ -2067,8 +1923,7 @@ handle_iteration_next (void *cls, GNUNET_SERVICE_client_drop (nc->client); return; } - run_zone_iteration_round (zi, - limit); + run_zone_iteration_round (zi, limit); } @@ -2082,8 +1937,7 @@ monitor_unblock (struct ZoneMonitor *zm) { struct StoreActivity *sa = sa_head; - while ( (NULL != sa) && - (zm->limit > zm->iteration_cnt) ) + while ((NULL != sa) && (zm->limit > zm->iteration_cnt)) { struct StoreActivity *sn = sa->next; @@ -2105,9 +1959,10 @@ monitor_unblock (struct ZoneMonitor *zm) zm->sa_waiting_start = GNUNET_TIME_absolute_get (); if (NULL != zm->sa_wait_warning) GNUNET_SCHEDULER_cancel (zm->sa_wait_warning); - zm->sa_wait_warning = GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY, - &warn_monitor_slow, - zm); + zm->sa_wait_warning = + GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY, + &warn_monitor_slow, + zm); } } @@ -2123,15 +1978,12 @@ monitor_sync (struct ZoneMonitor *zm) struct GNUNET_MQ_Envelope *env; struct GNUNET_MessageHeader *sync; - env = GNUNET_MQ_msg (sync, - GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC); - GNUNET_MQ_send (zm->nc->mq, - env); + env = GNUNET_MQ_msg (sync, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC); + GNUNET_MQ_send (zm->nc->mq, env); /* mark iteration done */ zm->in_first_iteration = GNUNET_NO; zm->iteration_cnt = 0; - if ( (zm->limit > 0) && - (zm->sa_waiting) ) + if ((zm->limit > 0) && (zm->sa_waiting)) monitor_unblock (zm); } @@ -2174,20 +2026,13 @@ monitor_iterate_cb (void *cls, GNUNET_NO); zm->limit--; zm->iteration_cnt--; - send_lookup_response (zm->nc, - 0, - zone_key, - name, - rd_count, - rd); - if ( (0 == zm->iteration_cnt) && - (0 != zm->limit) ) + send_lookup_response (zm->nc, 0, zone_key, name, rd_count, rd); + if ((0 == zm->iteration_cnt) && (0 != zm->limit)) { /* We are done with the current iteration batch, AND the client would right now accept more, so go again! */ GNUNET_assert (NULL == zm->task); - zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next, - zm); + zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next, zm); } } @@ -2199,29 +2044,23 @@ monitor_iterate_cb (void *cls, * @param zis_msg message from the client */ static void -handle_monitor_start (void *cls, - const struct ZoneMonitorStartMessage *zis_msg) +handle_monitor_start (void *cls, const struct ZoneMonitorStartMessage *zis_msg) { struct NamestoreClient *nc = cls; struct ZoneMonitor *zm; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received ZONE_MONITOR_START message\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_MONITOR_START message\n"); zm = GNUNET_new (struct ZoneMonitor); zm->nc = nc; zm->zone = zis_msg->zone; zm->limit = 1; zm->in_first_iteration = (GNUNET_YES == ntohl (zis_msg->iterate_first)); - GNUNET_CONTAINER_DLL_insert (monitor_head, - monitor_tail, - zm); + GNUNET_CONTAINER_DLL_insert (monitor_head, monitor_tail, zm); GNUNET_SERVICE_client_mark_monitor (nc->client); GNUNET_SERVICE_client_continue (nc->client); - GNUNET_notification_context_add (monitor_nc, - nc->mq); + GNUNET_notification_context_add (monitor_nc, nc->mq); if (zm->in_first_iteration) - zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next, - zm); + zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next, zm); else monitor_sync (zm); } @@ -2246,8 +2085,8 @@ monitor_iteration_next (void *cls) zm->iteration_cnt = zm->limit; /* use it all */ ret = GSN_database->iterate_records (GSN_database->cls, (0 == GNUNET_is_zero (&zm->zone)) - ? NULL - : &zm->zone, + ? NULL + : &zm->zone, zm->seq, zm->iteration_cnt, &monitor_iterate_cb, @@ -2273,8 +2112,7 @@ monitor_iteration_next (void *cls) * @param nm message from the client */ static void -handle_monitor_next (void *cls, - const struct ZoneMonitorNextMessage *nm) +handle_monitor_next (void *cls, const struct ZoneMonitorNextMessage *nm) { struct NamestoreClient *nc = cls; struct ZoneMonitor *zm; @@ -2301,18 +2139,15 @@ handle_monitor_next (void *cls, return; } zm->limit += inc; - if ( (zm->in_first_iteration) && - (zm->limit == inc) ) + if ((zm->in_first_iteration) && (zm->limit == inc)) { /* We are still iterating, and the previous iteration must have stopped due to the client's limit, so continue it! */ GNUNET_assert (NULL == zm->task); - zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next, - zm); + zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next, zm); } GNUNET_assert (zm->iteration_cnt <= zm->limit); - if ( (zm->limit > zm->iteration_cnt) && - (zm->sa_waiting) ) + if ((zm->limit > zm->iteration_cnt) && (zm->sa_waiting)) { monitor_unblock (zm); } @@ -2321,9 +2156,10 @@ handle_monitor_next (void *cls, if (NULL != zm->sa_wait_warning) GNUNET_SCHEDULER_cancel (zm->sa_wait_warning); zm->sa_waiting_start = GNUNET_TIME_absolute_get (); - zm->sa_wait_warning = GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY, - &warn_monitor_slow, - zm); + zm->sa_wait_warning = + GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY, + &warn_monitor_slow, + zm); } } @@ -2344,14 +2180,11 @@ run (void *cls, (void) cls; (void) service; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Starting namestore service\n"); - cache_keys = GNUNET_CONFIGURATION_get_value_yesno (cfg, - "namestore", - "CACHE_KEYS"); - disable_namecache = GNUNET_CONFIGURATION_get_value_yesno (cfg, - "namecache", - "DISABLE"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting namestore service\n"); + cache_keys = + GNUNET_CONFIGURATION_get_value_yesno (cfg, "namestore", "CACHE_KEYS"); + disable_namecache = + GNUNET_CONFIGURATION_get_value_yesno (cfg, "namecache", "DISABLE"); GSN_cfg = cfg; monitor_nc = GNUNET_notification_context_create (1); if (GNUNET_YES != disable_namecache) @@ -2360,24 +2193,17 @@ run (void *cls, GNUNET_assert (NULL != namecache); } /* Loading database plugin */ - if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_string (cfg, - "namestore", - "database", - &database)) - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "No database backend configured\n"); - - GNUNET_asprintf (&db_lib_name, - "libgnunet_plugin_namestore_%s", - database); - GSN_database = GNUNET_PLUGIN_load (db_lib_name, - (void *) GSN_cfg); + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, + "namestore", + "database", + &database)) + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No database backend configured\n"); + + GNUNET_asprintf (&db_lib_name, "libgnunet_plugin_namestore_%s", database); + GSN_database = GNUNET_PLUGIN_load (db_lib_name, (void *) GSN_cfg); GNUNET_free (database); - statistics = GNUNET_STATISTICS_create ("namestore", - cfg); - GNUNET_SCHEDULER_add_shutdown (&cleanup_task, - NULL); + statistics = GNUNET_STATISTICS_create ("namestore", cfg); + GNUNET_SCHEDULER_add_shutdown (&cleanup_task, NULL); if (NULL == GSN_database) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, @@ -2392,46 +2218,46 @@ run (void *cls, /** * Define "main" method using service macro. */ -GNUNET_SERVICE_MAIN -("namestore", - GNUNET_SERVICE_OPTION_NONE, - &run, - &client_connect_cb, - &client_disconnect_cb, - NULL, - GNUNET_MQ_hd_var_size (record_store, - GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE, - struct RecordStoreMessage, - NULL), - GNUNET_MQ_hd_var_size (record_lookup, - GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP, - struct LabelLookupMessage, - NULL), - GNUNET_MQ_hd_fixed_size (zone_to_name, - GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME, - struct ZoneToNameMessage, - NULL), - GNUNET_MQ_hd_fixed_size (iteration_start, - GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, - struct ZoneIterationStartMessage, - NULL), - GNUNET_MQ_hd_fixed_size (iteration_next, - GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT, - struct ZoneIterationNextMessage, - NULL), - GNUNET_MQ_hd_fixed_size (iteration_stop, - GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, - struct ZoneIterationStopMessage, - NULL), - GNUNET_MQ_hd_fixed_size (monitor_start, - GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START, - struct ZoneMonitorStartMessage, - NULL), - GNUNET_MQ_hd_fixed_size (monitor_next, - GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT, - struct ZoneMonitorNextMessage, - NULL), - GNUNET_MQ_handler_end ()); +GNUNET_SERVICE_MAIN ( + "namestore", + GNUNET_SERVICE_OPTION_NONE, + &run, + &client_connect_cb, + &client_disconnect_cb, + NULL, + GNUNET_MQ_hd_var_size (record_store, + GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE, + struct RecordStoreMessage, + NULL), + GNUNET_MQ_hd_var_size (record_lookup, + GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP, + struct LabelLookupMessage, + NULL), + GNUNET_MQ_hd_fixed_size (zone_to_name, + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME, + struct ZoneToNameMessage, + NULL), + GNUNET_MQ_hd_fixed_size (iteration_start, + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, + struct ZoneIterationStartMessage, + NULL), + GNUNET_MQ_hd_fixed_size (iteration_next, + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT, + struct ZoneIterationNextMessage, + NULL), + GNUNET_MQ_hd_fixed_size (iteration_stop, + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, + struct ZoneIterationStopMessage, + NULL), + GNUNET_MQ_hd_fixed_size (monitor_start, + GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START, + struct ZoneMonitorStartMessage, + NULL), + GNUNET_MQ_hd_fixed_size (monitor_next, + GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT, + struct ZoneMonitorNextMessage, + NULL), + GNUNET_MQ_handler_end ()); /* end of gnunet-service-namestore.c */ -- cgit v1.2.3