From 58002acac13b2eef407a20ee3ddc5f458cd5e483 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Tue, 4 Jun 2019 11:57:59 +0200 Subject: [PATCH] nicer loop structure --- src/namestore/gnunet-zoneimport.c | 844 +++++++++-------------- src/peerstore/gnunet-service-peerstore.c | 264 +++---- src/peerstore/peerstore_api.c | 247 +++---- src/regex/regex_internal.c | 717 +++++++++---------- src/statistics/gnunet-statistics.c | 387 +++++------ 5 files changed, 1073 insertions(+), 1386 deletions(-) diff --git a/src/namestore/gnunet-zoneimport.c b/src/namestore/gnunet-zoneimport.c index f36106332..4c5205ab3 100644 --- a/src/namestore/gnunet-zoneimport.c +++ b/src/namestore/gnunet-zoneimport.c @@ -56,7 +56,8 @@ /** * How long do we wait at least between series of requests? */ -#define SERIES_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 10) +#define SERIES_DELAY \ + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 10) /** * How long do DNS records have to last at least after being imported? @@ -97,7 +98,6 @@ struct Zone * Private key of the zone. */ struct GNUNET_CRYPTO_EcdsaPrivateKey key; - }; @@ -120,7 +120,6 @@ struct Record * GNS record. */ struct GNUNET_GNSRECORD_Data grd; - }; @@ -367,9 +366,8 @@ static struct GNUNET_TIME_Relative idle_time; * @param cls closure * @param rec a DNS record */ -typedef void -(*RecordProcessor) (void *cls, - const struct GNUNET_DNSPARSER_Record *rec); +typedef void (*RecordProcessor) (void *cls, + const struct GNUNET_DNSPARSER_Record *rec); /** @@ -382,29 +380,26 @@ typedef void */ static void for_all_records (const struct GNUNET_DNSPARSER_Packet *p, - RecordProcessor rp, - void *rp_cls) + RecordProcessor rp, + void *rp_cls) { - for (unsigned int i=0;inum_answers;i++) + for (unsigned int i = 0; i < p->num_answers; i++) { struct GNUNET_DNSPARSER_Record *rs = &p->answers[i]; - rp (rp_cls, - rs); + rp (rp_cls, rs); } - for (unsigned int i=0;inum_authority_records;i++) + for (unsigned int i = 0; i < p->num_authority_records; i++) { struct GNUNET_DNSPARSER_Record *rs = &p->authority_records[i]; - rp (rp_cls, - rs); + rp (rp_cls, rs); } - for (unsigned int i=0;inum_additional_records;i++) + for (unsigned int i = 0; i < p->num_additional_records; i++) { struct GNUNET_DNSPARSER_Record *rs = &p->additional_records[i]; - rp (rp_cls, - rs); + rp (rp_cls, rs); } } @@ -422,8 +417,7 @@ get_label (struct Request *req) static char label[64]; const char *dot; - dot = strchr (req->hostname, - (unsigned char) '.'); + dot = strchr (req->hostname, (unsigned char) '.'); if (NULL == dot) { GNUNET_break (0); @@ -434,9 +428,7 @@ get_label (struct Request *req) GNUNET_break (0); return NULL; } - GNUNET_memcpy (label, - req->hostname, - dot - req->hostname); + GNUNET_memcpy (label, req->hostname, dot - req->hostname); label[dot - req->hostname] = '\0'; return label; } @@ -451,8 +443,7 @@ get_label (struct Request *req) * allocated query buffer */ static void * -build_dns_query (struct Request *req, - size_t *raw_size) +build_dns_query (struct Request *req, size_t *raw_size) { static char raw[512]; char *rawp; @@ -464,16 +455,11 @@ build_dns_query (struct Request *req, q.type = GNUNET_DNSPARSER_TYPE_NS; q.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; - memset (&p, - 0, - sizeof (p)); + memset (&p, 0, sizeof (p)); p.num_queries = 1; p.queries = &q; p.id = req->id; - ret = GNUNET_DNSPARSER_pack (&p, - UINT16_MAX, - &rawp, - raw_size); + ret = GNUNET_DNSPARSER_pack (&p, UINT16_MAX, &rawp, raw_size); if (GNUNET_OK != ret) { if (GNUNET_NO == ret) @@ -494,15 +480,12 @@ build_dns_query (struct Request *req, GNUNET_free (rawp); return NULL; } - GNUNET_memcpy (raw, - rawp, - *raw_size); + GNUNET_memcpy (raw, rawp, *raw_size); GNUNET_free (rawp); return raw; } - /** * Free records associated with @a req. * @@ -516,9 +499,7 @@ free_records (struct Request *req) /* Free records */ while (NULL != (rec = req->rec_head)) { - GNUNET_CONTAINER_DLL_remove (req->rec_head, - req->rec_tail, - rec); + GNUNET_CONTAINER_DLL_remove (req->rec_head, req->rec_tail, rec); GNUNET_free (rec); } } @@ -554,17 +535,14 @@ process_queue (void *cls); static void insert_sorted (struct Request *req) { - req->hn = GNUNET_CONTAINER_heap_insert (req_heap, - req, - req->expires.abs_value_us); + req->hn = + GNUNET_CONTAINER_heap_insert (req_heap, req, req->expires.abs_value_us); if (req == GNUNET_CONTAINER_heap_peek (req_heap)) { if (NULL != t) GNUNET_SCHEDULER_cancel (t); sleep_time_reg_proc = GNUNET_TIME_absolute_get (); - t = GNUNET_SCHEDULER_add_at (req->expires, - &process_queue, - NULL); + t = GNUNET_SCHEDULER_add_at (req->expires, &process_queue, NULL); } } @@ -580,10 +558,10 @@ insert_sorted (struct Request *req) */ static void add_record (struct Request *req, - uint32_t type, - struct GNUNET_TIME_Absolute expiration_time, - const void *data, - size_t data_len) + uint32_t type, + struct GNUNET_TIME_Absolute expiration_time, + const void *data, + size_t data_len) { struct Record *rec; @@ -593,12 +571,8 @@ add_record (struct Request *req, rec->grd.data_size = data_len; rec->grd.record_type = type; rec->grd.flags = GNUNET_GNSRECORD_RF_NONE; - GNUNET_memcpy (&rec[1], - data, - data_len); - GNUNET_CONTAINER_DLL_insert (req->rec_head, - req->rec_tail, - rec); + GNUNET_memcpy (&rec[1], data, data_len); + GNUNET_CONTAINER_DLL_insert (req->rec_head, req->rec_tail, rec); } @@ -631,20 +605,18 @@ struct GlueClosure * @param rec record that may contain glue information */ static void -check_for_glue (void *cls, - const struct GNUNET_DNSPARSER_Record *rec) +check_for_glue (void *cls, const struct GNUNET_DNSPARSER_Record *rec) { struct GlueClosure *gc = cls; char dst[65536]; size_t dst_len; size_t off; - char ip[INET6_ADDRSTRLEN+1]; + char ip[INET6_ADDRSTRLEN + 1]; socklen_t ip_size = (socklen_t) sizeof (ip); struct GNUNET_TIME_Absolute expiration_time; struct GNUNET_TIME_Relative left; - if (0 != strcasecmp (rec->name, - gc->ns)) + if (0 != strcasecmp (rec->name, gc->ns)) return; expiration_time = rec->expiration_time; left = GNUNET_TIME_absolute_get_remaining (expiration_time); @@ -652,7 +624,8 @@ check_for_glue (void *cls, return; /* ignore expired glue records */ /* if expiration window is too short, bump it to configured minimum */ if (left.rel_value_us < minimum_expiration_time.rel_value_us) - expiration_time = GNUNET_TIME_relative_to_absolute (minimum_expiration_time); + expiration_time = + GNUNET_TIME_relative_to_absolute (minimum_expiration_time); dst_len = sizeof (dst); off = 0; switch (rec->type) @@ -663,31 +636,23 @@ check_for_glue (void *cls, GNUNET_break (0); return; } - if (NULL == - inet_ntop (AF_INET, - rec->data.raw.data, - ip, - ip_size)) + if (NULL == inet_ntop (AF_INET, rec->data.raw.data, ip, ip_size)) { GNUNET_break (0); return; } - if ( (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_name (dst, - dst_len, - &off, - gc->req->hostname)) && - (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_name (dst, - dst_len, - &off, - ip)) ) + if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst, + dst_len, + &off, + gc->req->hostname)) && + (GNUNET_OK == + GNUNET_DNSPARSER_builder_add_name (dst, dst_len, &off, ip))) { add_record (gc->req, - GNUNET_GNSRECORD_TYPE_GNS2DNS, - expiration_time, - dst, - off); + GNUNET_GNSRECORD_TYPE_GNS2DNS, + expiration_time, + dst, + off); gc->found = GNUNET_YES; } break; @@ -697,51 +662,41 @@ check_for_glue (void *cls, GNUNET_break (0); return; } - if (NULL == - inet_ntop (AF_INET6, - rec->data.raw.data, - ip, - ip_size)) + if (NULL == inet_ntop (AF_INET6, rec->data.raw.data, ip, ip_size)) { GNUNET_break (0); return; } - if ( (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_name (dst, - dst_len, - &off, - gc->req->hostname)) && - (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_name (dst, - dst_len, - &off, - ip)) ) + if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst, + dst_len, + &off, + gc->req->hostname)) && + (GNUNET_OK == + GNUNET_DNSPARSER_builder_add_name (dst, dst_len, &off, ip))) { add_record (gc->req, - GNUNET_GNSRECORD_TYPE_GNS2DNS, - expiration_time, - dst, - off); + GNUNET_GNSRECORD_TYPE_GNS2DNS, + expiration_time, + dst, + off); gc->found = GNUNET_YES; } break; case GNUNET_DNSPARSER_TYPE_CNAME: - if ( (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_name (dst, - dst_len, - &off, - gc->req->hostname)) && - (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_name (dst, - dst_len, - &off, - rec->data.hostname)) ) + if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst, + dst_len, + &off, + gc->req->hostname)) && + (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst, + dst_len, + &off, + rec->data.hostname))) { add_record (gc->req, - GNUNET_GNSRECORD_TYPE_GNS2DNS, - expiration_time, - dst, - off); + GNUNET_GNSRECORD_TYPE_GNS2DNS, + expiration_time, + dst, + off); gc->found = GNUNET_YES; } break; @@ -777,8 +732,7 @@ struct ProcessRecordContext * @param rec response */ static void -process_record (void *cls, - const struct GNUNET_DNSPARSER_Record *rec) +process_record (void *cls, const struct GNUNET_DNSPARSER_Record *rec) { struct ProcessRecordContext *prc = cls; struct Request *req = prc->req; @@ -791,14 +745,14 @@ process_record (void *cls, dst_len = sizeof (dst); off = 0; records++; - if (0 != strcasecmp (rec->name, - req->hostname)) + if (0 != strcasecmp (rec->name, req->hostname)) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "DNS returned record from zone `%s' of type %u while resolving `%s'\n", - rec->name, - (unsigned int) rec->type, - req->hostname); + GNUNET_log ( + GNUNET_ERROR_TYPE_DEBUG, + "DNS returned record from zone `%s' of type %u while resolving `%s'\n", + rec->name, + (unsigned int) rec->type, + req->hostname); return; /* does not match hostname, might be glue, but not useful for this pass! */ } @@ -807,8 +761,8 @@ process_record (void *cls, if (0 == left.rel_value_us) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "DNS returned expired record for `%s'\n", - req->hostname); + "DNS returned expired record for `%s'\n", + req->hostname); GNUNET_STATISTICS_update (stats, "# expired records obtained from DNS", 1, @@ -822,68 +776,59 @@ process_record (void *cls, req->hostname); /* if expiration window is too short, bump it to configured minimum */ if (left.rel_value_us < minimum_expiration_time.rel_value_us) - expiration_time = GNUNET_TIME_relative_to_absolute (minimum_expiration_time); + expiration_time = + GNUNET_TIME_relative_to_absolute (minimum_expiration_time); switch (rec->type) { - case GNUNET_DNSPARSER_TYPE_NS: + case GNUNET_DNSPARSER_TYPE_NS: { + struct GlueClosure gc; + + /* check for glue */ + gc.req = req; + gc.ns = rec->data.hostname; + gc.found = GNUNET_NO; + for_all_records (prc->p, &check_for_glue, &gc); + if ((GNUNET_NO == gc.found) && + (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst, + dst_len, + &off, + req->hostname)) && + (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst, + dst_len, + &off, + rec->data.hostname))) { - struct GlueClosure gc; - - /* check for glue */ - gc.req = req; - gc.ns = rec->data.hostname; - gc.found = GNUNET_NO; - for_all_records (prc->p, - &check_for_glue, - &gc); - if ( (GNUNET_NO == gc.found) && - (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_name (dst, - dst_len, - &off, - req->hostname)) && - (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_name (dst, - dst_len, - &off, - rec->data.hostname)) ) - { - /* FIXME: actually check if this is out-of-bailiwick, + /* FIXME: actually check if this is out-of-bailiwick, and if not request explicit resolution... */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Converted OOB (`%s') NS record for `%s'\n", - rec->data.hostname, - rec->name); - add_record (req, - GNUNET_GNSRECORD_TYPE_GNS2DNS, - expiration_time, - dst, - off); - } - else - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Converted NS record for `%s' using glue\n", - rec->name); - } - break; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Converted OOB (`%s') NS record for `%s'\n", + rec->data.hostname, + rec->name); + add_record (req, + GNUNET_GNSRECORD_TYPE_GNS2DNS, + expiration_time, + dst, + off); + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Converted NS record for `%s' using glue\n", + rec->name); } + break; + } case GNUNET_DNSPARSER_TYPE_CNAME: - if (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_name (dst, - dst_len, - &off, - rec->data.hostname)) + if (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst, + dst_len, + &off, + rec->data.hostname)) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Converting CNAME (`%s') record for `%s'\n", - rec->data.hostname, - rec->name); - add_record (req, - rec->type, - expiration_time, - dst, - off); + "Converting CNAME (`%s') record for `%s'\n", + rec->data.hostname, + rec->name); + add_record (req, rec->type, expiration_time, dst, off); } break; case GNUNET_DNSPARSER_TYPE_DNAME: @@ -895,90 +840,57 @@ process_record (void *cls, break; case GNUNET_DNSPARSER_TYPE_MX: if (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_mx (dst, - dst_len, - &off, - rec->data.mx)) + GNUNET_DNSPARSER_builder_add_mx (dst, dst_len, &off, rec->data.mx)) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Converting MX (`%s') record for `%s'\n", - rec->data.mx->mxhost, - rec->name); - add_record (req, - rec->type, - expiration_time, - dst, - off); + "Converting MX (`%s') record for `%s'\n", + rec->data.mx->mxhost, + rec->name); + add_record (req, rec->type, expiration_time, dst, off); } break; case GNUNET_DNSPARSER_TYPE_SOA: if (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_soa (dst, - dst_len, - &off, - rec->data.soa)) + GNUNET_DNSPARSER_builder_add_soa (dst, dst_len, &off, rec->data.soa)) { /* NOTE: GNS does not really use SOAs */ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Converting SOA record for `%s'\n", - rec->name); - add_record (req, - rec->type, - expiration_time, - dst, - off); + "Converting SOA record for `%s'\n", + rec->name); + add_record (req, rec->type, expiration_time, dst, off); } break; case GNUNET_DNSPARSER_TYPE_SRV: if (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_srv (dst, - dst_len, - &off, - rec->data.srv)) + GNUNET_DNSPARSER_builder_add_srv (dst, dst_len, &off, rec->data.srv)) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Converting SRV record for `%s'\n", - rec->name); - add_record (req, - rec->type, - expiration_time, - dst, - off); + "Converting SRV record for `%s'\n", + rec->name); + add_record (req, rec->type, expiration_time, dst, off); } break; case GNUNET_DNSPARSER_TYPE_PTR: - if (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_name (dst, - dst_len, - &off, - rec->data.hostname)) + if (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst, + dst_len, + &off, + rec->data.hostname)) { /* !?: what does a PTR record do in a regular TLD??? */ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Converting PTR record for `%s' (weird)\n", - rec->name); - add_record (req, - rec->type, - expiration_time, - dst, - off); + "Converting PTR record for `%s' (weird)\n", + rec->name); + add_record (req, rec->type, expiration_time, dst, off); } break; case GNUNET_DNSPARSER_TYPE_CERT: if (GNUNET_OK == - GNUNET_DNSPARSER_builder_add_cert (dst, - dst_len, - &off, - rec->data.cert)) + GNUNET_DNSPARSER_builder_add_cert (dst, dst_len, &off, rec->data.cert)) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Converting CERT record for `%s'\n", - rec->name); - add_record (req, - rec->type, - expiration_time, - dst, - off); + "Converting CERT record for `%s'\n", + rec->name); + add_record (req, rec->type, expiration_time, dst, off); } break; /* Rest is 'raw' encoded and just needs to be copied IF @@ -989,14 +901,14 @@ process_record (void *cls, case GNUNET_DNSPARSER_TYPE_TXT: default: GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Converting record of type %u for `%s'\n", - (unsigned int) rec->type, - rec->name); + "Converting record of type %u for `%s'\n", + (unsigned int) rec->type, + rec->name); add_record (req, - rec->type, - expiration_time, - rec->data.raw.data, - rec->data.raw.data_len); + rec->type, + expiration_time, + rec->data.raw.data, + rec->data.raw.data_len); break; } } @@ -1013,9 +925,7 @@ process_record (void *cls, * @param emsg NULL on success, otherwise an error message */ static void -store_completed_cb (void *cls, - int32_t success, - const char *emsg) +store_completed_cb (void *cls, int32_t success, const char *emsg) { static struct GNUNET_TIME_Absolute last; struct Request *req = cls; @@ -1024,15 +934,15 @@ store_completed_cb (void *cls, if (GNUNET_SYSERR == success) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Failed to store zone data for `%s': %s\n", - req->hostname, - emsg); + "Failed to store zone data for `%s': %s\n", + req->hostname, + emsg); } else { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Stored records under `%s' (%d)\n", - req->hostname, + "Stored records under `%s' (%d)\n", + req->hostname, success); } total_reg_proc_dns_ns++; /* finished regular processing */ @@ -1045,8 +955,7 @@ store_completed_cb (void *cls, struct GNUNET_TIME_Relative ns_latency; ns_latency = GNUNET_TIME_absolute_get_duration (req->op_start_time); - total_ns_latency = GNUNET_TIME_relative_add (total_ns_latency, - ns_latency); + total_ns_latency = GNUNET_TIME_relative_add (total_ns_latency, ns_latency); if (0 == total_ns_latency_cnt) last = GNUNET_TIME_absolute_get (); total_ns_latency_cnt++; @@ -1057,25 +966,25 @@ store_completed_cb (void *cls, delta = GNUNET_TIME_absolute_get_duration (last); last = GNUNET_TIME_absolute_get (); fprintf (stderr, - "Processed 1000 records in %s\n", - GNUNET_STRINGS_relative_time_to_string (delta, - GNUNET_YES)); + "Processed 1000 records in %s\n", + GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES)); GNUNET_STATISTICS_set (stats, "# average NAMESTORE PUT latency (μs)", - total_ns_latency.rel_value_us / total_ns_latency_cnt, + total_ns_latency.rel_value_us / + total_ns_latency_cnt, GNUNET_NO); } } /* compute and publish overall velocity */ - if (0 == (total_reg_proc_dns_ns % 100) ) + if (0 == (total_reg_proc_dns_ns % 100)) { struct GNUNET_TIME_Relative runtime; runtime = GNUNET_TIME_absolute_get_duration (start_time_reg_proc); - runtime = GNUNET_TIME_relative_subtract (runtime, - idle_time); - runtime = GNUNET_TIME_relative_divide (runtime, - total_reg_proc_dns + total_reg_proc_dns_ns); + runtime = GNUNET_TIME_relative_subtract (runtime, idle_time); + runtime = + GNUNET_TIME_relative_divide (runtime, + total_reg_proc_dns + total_reg_proc_dns_ns); GNUNET_STATISTICS_set (stats, "# Regular processing completed without NAMESTORE", total_reg_proc_dns, @@ -1097,8 +1006,7 @@ store_completed_cb (void *cls, if (NULL == t) { sleep_time_reg_proc = GNUNET_TIME_absolute_get (); - t = GNUNET_SCHEDULER_add_now (&process_queue, - NULL); + t = GNUNET_SCHEDULER_add_now (&process_queue, NULL); } } @@ -1124,31 +1032,22 @@ process_result (void *cls, if (NULL == dns) { /* stub gave up */ - GNUNET_CONTAINER_DLL_remove (req_head, - req_tail, - req); + GNUNET_CONTAINER_DLL_remove (req_head, req_tail, req); pending--; if (NULL == t) { sleep_time_reg_proc = GNUNET_TIME_absolute_get (); - t = GNUNET_SCHEDULER_add_now (&process_queue, - NULL); + t = GNUNET_SCHEDULER_add_now (&process_queue, NULL); } GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Stub gave up on DNS reply for `%s'\n", req->hostname); - GNUNET_STATISTICS_update (stats, - "# DNS lookups timed out", - 1, - GNUNET_NO); + GNUNET_STATISTICS_update (stats, "# DNS lookups timed out", 1, GNUNET_NO); if (req->issue_num > MAX_RETRIES) { failures++; free_request (req); - GNUNET_STATISTICS_update (stats, - "# requests given up on", - 1, - GNUNET_NO); + GNUNET_STATISTICS_update (stats, "# requests given up on", 1, GNUNET_NO); return; } total_reg_proc_dns++; @@ -1160,43 +1059,30 @@ process_result (void *cls, { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DNS ID did not match request, ignoring reply\n"); - GNUNET_STATISTICS_update (stats, - "# DNS ID mismatches", - 1, - GNUNET_NO); + GNUNET_STATISTICS_update (stats, "# DNS ID mismatches", 1, GNUNET_NO); return; } - GNUNET_CONTAINER_DLL_remove (req_head, - req_tail, - req); + GNUNET_CONTAINER_DLL_remove (req_head, req_tail, req); GNUNET_DNSSTUB_resolve_cancel (req->rs); req->rs = NULL; pending--; - p = GNUNET_DNSPARSER_parse ((const char *) dns, - dns_len); + p = GNUNET_DNSPARSER_parse ((const char *) dns, dns_len); if (NULL == p) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to parse DNS reply for `%s'\n", req->hostname); - GNUNET_STATISTICS_update (stats, - "# DNS parser errors", - 1, - GNUNET_NO); + GNUNET_STATISTICS_update (stats, "# DNS parser errors", 1, GNUNET_NO); if (NULL == t) { sleep_time_reg_proc = GNUNET_TIME_absolute_get (); - t = GNUNET_SCHEDULER_add_now (&process_queue, - NULL); + t = GNUNET_SCHEDULER_add_now (&process_queue, NULL); } if (req->issue_num > MAX_RETRIES) { failures++; free_request (req); - GNUNET_STATISTICS_update (stats, - "# requests given up on", - 1, - GNUNET_NO); + GNUNET_STATISTICS_update (stats, "# requests given up on", 1, GNUNET_NO); return; } insert_sorted (req); @@ -1205,14 +1091,9 @@ process_result (void *cls, /* import new records */ req->issue_num = 0; /* success, reset counter! */ { - struct ProcessRecordContext prc = { - .req = req, - .p = p - }; - - for_all_records (p, - &process_record, - &prc); + struct ProcessRecordContext prc = {.req = req, .p = p}; + + for_all_records (p, &process_record, &prc); } GNUNET_DNSPARSER_free_packet (p); /* count records found, determine minimum expiration time */ @@ -1221,14 +1102,15 @@ process_result (void *cls, struct GNUNET_TIME_Relative dns_latency; dns_latency = GNUNET_TIME_absolute_get_duration (req->op_start_time); - total_dns_latency = GNUNET_TIME_relative_add (total_dns_latency, - dns_latency); + total_dns_latency = + GNUNET_TIME_relative_add (total_dns_latency, dns_latency); total_dns_latency_cnt++; if (0 == (total_dns_latency_cnt % 1000)) { GNUNET_STATISTICS_set (stats, "# average DNS lookup latency (μs)", - total_dns_latency.rel_value_us / total_dns_latency_cnt, + total_dns_latency.rel_value_us / + total_dns_latency_cnt, GNUNET_NO); } } @@ -1238,20 +1120,18 @@ process_result (void *cls, struct GNUNET_TIME_Absolute at; at.abs_value_us = rec->grd.expiration_time; - req->expires = GNUNET_TIME_absolute_min (req->expires, - at); + req->expires = GNUNET_TIME_absolute_min (req->expires, at); rd_count++; } GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Obtained %u records for `%s'\n", - rd_count, - req->hostname); + "Obtained %u records for `%s'\n", + rd_count, + req->hostname); /* Instead of going for SOA, simplified for now to look each day in case we got an empty response */ if (0 == rd_count) { - req->expires - = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_DAYS); + req->expires = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_DAYS); GNUNET_STATISTICS_update (stats, "# empty DNS replies (usually NXDOMAIN)", 1, @@ -1263,21 +1143,21 @@ process_result (void *cls, } /* convert records to namestore import format */ { - struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(rd_count)]; + struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)]; unsigned int off = 0; /* convert linked list into array */ - for (rec = req->rec_head; NULL != rec; rec =rec->next) + for (rec = req->rec_head; NULL != rec; rec = rec->next) rd[off++] = rec->grd; pending_rs++; req->op_start_time = GNUNET_TIME_absolute_get (); req->qe = GNUNET_NAMESTORE_records_store (ns, - &req->zone->key, - get_label (req), - rd_count, - rd, - &store_completed_cb, - req); + &req->zone->key, + get_label (req), + rd_count, + rd, + &store_completed_cb, + req); GNUNET_assert (NULL != req->qe); } insert_sorted (req); @@ -1300,8 +1180,7 @@ process_queue (void *cls) (void) cls; delay = GNUNET_TIME_absolute_get_duration (sleep_time_reg_proc); - idle_time = GNUNET_TIME_relative_add (idle_time, - delay); + idle_time = GNUNET_TIME_relative_add (idle_time, delay); series = 0; t = NULL; while (pending + pending_rs < THRESH) @@ -1318,18 +1197,14 @@ process_queue (void *cls) } if (GNUNET_TIME_absolute_get_remaining (req->expires).rel_value_us > 0) break; - GNUNET_assert (req == - GNUNET_CONTAINER_heap_remove_root (req_heap)); + GNUNET_assert (req == GNUNET_CONTAINER_heap_remove_root (req_heap)); req->hn = NULL; - GNUNET_CONTAINER_DLL_insert (req_head, - req_tail, - req); + GNUNET_CONTAINER_DLL_insert (req_head, req_tail, req); GNUNET_assert (NULL == req->rs); GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Requesting resolution for `%s'\n", req->hostname); - raw = build_dns_query (req, - &raw_size); + raw = build_dns_query (req, &raw_size); if (NULL == raw) { GNUNET_break (0); @@ -1337,11 +1212,7 @@ process_queue (void *cls) continue; } req->op_start_time = GNUNET_TIME_absolute_get (); - req->rs = GNUNET_DNSSTUB_resolve (ctx, - raw, - raw_size, - &process_result, - req); + req->rs = GNUNET_DNSSTUB_resolve (ctx, raw, raw_size, &process_result, req); GNUNET_assert (NULL != req->rs); req->issue_num++; lookups++; @@ -1353,41 +1224,36 @@ process_queue (void *cls) if (pending + pending_rs >= THRESH) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Stopped processing queue (%u+%u/%u)]\n", - pending, - pending_rs, - THRESH); + "Stopped processing queue (%u+%u/%u)]\n", + pending, + pending_rs, + THRESH); return; /* wait for replies */ } req = GNUNET_CONTAINER_heap_peek (req_heap); if (NULL == req) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Stopped processing queue: empty queue\n"); + "Stopped processing queue: empty queue\n"); return; } if (GNUNET_TIME_absolute_get_remaining (req->expires).rel_value_us > 0) { GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Waiting until %s for next record (`%s') to expire\n", - GNUNET_STRINGS_absolute_time_to_string (req->expires), - req->hostname); + "Waiting until %s for next record (`%s') to expire\n", + GNUNET_STRINGS_absolute_time_to_string (req->expires), + req->hostname); if (NULL != t) GNUNET_SCHEDULER_cancel (t); sleep_time_reg_proc = GNUNET_TIME_absolute_get (); - t = GNUNET_SCHEDULER_add_at (req->expires, - &process_queue, - NULL); + t = GNUNET_SCHEDULER_add_at (req->expires, &process_queue, NULL); return; } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Throttling\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Throttling\n"); if (NULL != t) GNUNET_SCHEDULER_cancel (t); sleep_time_reg_proc = GNUNET_TIME_absolute_get (); - t = GNUNET_SCHEDULER_add_delayed (SERIES_DELAY, - &process_queue, - NULL); + t = GNUNET_SCHEDULER_add_delayed (SERIES_DELAY, &process_queue, NULL); } @@ -1401,9 +1267,7 @@ process_queue (void *cls) * @return #GNUNET_OK */ static int -free_request_it (void *cls, - const struct GNUNET_HashCode *key, - void *value) +free_request_it (void *cls, const struct GNUNET_HashCode *key, void *value) { struct Request *req = value; @@ -1438,9 +1302,7 @@ do_shutdown (void *cls) } while (NULL != (req = req_head)) { - GNUNET_CONTAINER_DLL_remove (req_head, - req_tail, - req); + GNUNET_CONTAINER_DLL_remove (req_head, req_tail, req); if (NULL != req->qe) GNUNET_NAMESTORE_cancel (req->qe); free_request (req); @@ -1474,17 +1336,13 @@ do_shutdown (void *cls) } if (NULL != ns_pending) { - GNUNET_CONTAINER_multihashmap_iterate (ns_pending, - &free_request_it, - NULL); + GNUNET_CONTAINER_multihashmap_iterate (ns_pending, &free_request_it, NULL); GNUNET_CONTAINER_multihashmap_destroy (ns_pending); ns_pending = NULL; } while (NULL != (zone = zone_head)) { - GNUNET_CONTAINER_DLL_remove (zone_head, - zone_tail, - zone); + GNUNET_CONTAINER_DLL_remove (zone_head, zone_tail, zone); GNUNET_free (zone->domain); GNUNET_free (zone); } @@ -1518,8 +1376,8 @@ ns_lookup_error_cb (void *cls) struct Zone *zone = cls; GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Failed to load data from namestore for zone `%s'\n", - zone->domain); + "Failed to load data from namestore for zone `%s'\n", + zone->domain); zone_it = NULL; ns_iterator_trigger_next = 0; iterate_zones (NULL); @@ -1537,10 +1395,10 @@ ns_lookup_error_cb (void *cls) */ static void ns_lookup_result_cb (void *cls, - const struct GNUNET_CRYPTO_EcdsaPrivateKey *key, - const char *label, - unsigned int rd_count, - const struct GNUNET_GNSRECORD_Data *rd) + const struct GNUNET_CRYPTO_EcdsaPrivateKey *key, + const char *label, + unsigned int rd_count, + const struct GNUNET_GNSRECORD_Data *rd) { struct Zone *zone = cls; struct Request *req; @@ -1549,8 +1407,8 @@ ns_lookup_result_cb (void *cls, ns_iterator_trigger_next--; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Obtained NAMESTORE reply, %llu left in round\n", - (unsigned long long) ns_iterator_trigger_next); + "Obtained NAMESTORE reply, %llu left in round\n", + (unsigned long long) ns_iterator_trigger_next); if (0 == ns_iterator_trigger_next) { ns_iterator_trigger_next = NS_BATCH_SIZE; @@ -1558,19 +1416,12 @@ ns_lookup_result_cb (void *cls, "# NAMESTORE records requested from cache", ns_iterator_trigger_next, GNUNET_NO); - GNUNET_NAMESTORE_zone_iterator_next (zone_it, - ns_iterator_trigger_next); + GNUNET_NAMESTORE_zone_iterator_next (zone_it, ns_iterator_trigger_next); } - GNUNET_asprintf (&fqdn, - "%s.%s", - label, - zone->domain); - GNUNET_CRYPTO_hash (fqdn, - strlen (fqdn) + 1, - &hc); + GNUNET_asprintf (&fqdn, "%s.%s", label, zone->domain); + GNUNET_CRYPTO_hash (fqdn, strlen (fqdn) + 1, &hc); GNUNET_free (fqdn); - req = GNUNET_CONTAINER_multihashmap_get (ns_pending, - &hc); + req = GNUNET_CONTAINER_multihashmap_get (ns_pending, &hc); if (NULL == req) { GNUNET_log (GNUNET_ERROR_TYPE_INFO, @@ -1580,14 +1431,10 @@ ns_lookup_result_cb (void *cls, return; } GNUNET_assert (GNUNET_OK == - GNUNET_CONTAINER_multihashmap_remove (ns_pending, - &hc, - req)); - GNUNET_break (0 == GNUNET_memcmp (key, - &req->zone->key)); - GNUNET_break (0 == strcasecmp (label, - get_label (req))); - for (unsigned int i=0;izone->key)); + GNUNET_break (0 == strcasecmp (label, get_label (req))); + for (unsigned int i = 0; i < rd_count; i++) { struct GNUNET_TIME_Absolute at; @@ -1602,17 +1449,13 @@ ns_lookup_result_cb (void *cls, { at.abs_value_us = rd->expiration_time; } - add_record (req, - rd->record_type, - at, - rd->data, - rd->data_size); + add_record (req, rd->record_type, at, rd->data, rd->data_size); } if (0 == rd_count) { GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Empty record set in namestore for `%s'\n", - req->hostname); + "Empty record set in namestore for `%s'\n", + req->hostname); } else { @@ -1620,30 +1463,27 @@ ns_lookup_result_cb (void *cls, cached++; req->expires = GNUNET_TIME_UNIT_FOREVER_ABS; - for (struct Record *rec = req->rec_head; - NULL != rec; - rec = rec->next) + for (struct Record *rec = req->rec_head; NULL != rec; rec = rec->next) { struct GNUNET_TIME_Absolute at; at.abs_value_us = rec->grd.expiration_time; - req->expires = GNUNET_TIME_absolute_min (req->expires, - at); + req->expires = GNUNET_TIME_absolute_min (req->expires, at); pos++; } if (0 == pos) req->expires = GNUNET_TIME_UNIT_ZERO_ABS; GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Hot-start with %u existing records for `%s'\n", - pos, + pos, req->hostname); } free_records (req); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Adding `%s' to worklist to start at %s\n", - req->hostname, - GNUNET_STRINGS_absolute_time_to_string (req->expires)); + "Adding `%s' to worklist to start at %s\n", + req->hostname, + GNUNET_STRINGS_absolute_time_to_string (req->expires)); insert_sorted (req); } @@ -1662,8 +1502,7 @@ queue (const char *hostname) size_t hlen; struct GNUNET_HashCode hc; - if (GNUNET_OK != - GNUNET_DNSPARSER_check_name (hostname)) + if (GNUNET_OK != GNUNET_DNSPARSER_check_name (hostname)) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Refusing invalid hostname `%s'\n", @@ -1671,8 +1510,7 @@ queue (const char *hostname) rejects++; return; } - dot = strchr (hostname, - (unsigned char) '.'); + dot = strchr (hostname, (unsigned char) '.'); if (NULL == dot) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, @@ -1682,8 +1520,7 @@ queue (const char *hostname) return; } for (zone = zone_head; NULL != zone; zone = zone->next) - if (0 == strcmp (zone->domain, - dot + 1)) + if (0 == strcmp (zone->domain, dot + 1)) break; if (NULL == zone) { @@ -1698,19 +1535,15 @@ queue (const char *hostname) req = GNUNET_malloc (sizeof (struct Request) + hlen); req->zone = zone; req->hostname = (char *) &req[1]; - GNUNET_memcpy (req->hostname, - hostname, - hlen); + GNUNET_memcpy (req->hostname, hostname, hlen); req->id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, - UINT16_MAX); - GNUNET_CRYPTO_hash (req->hostname, - hlen, - &hc); - if (GNUNET_OK != - GNUNET_CONTAINER_multihashmap_put (ns_pending, - &hc, - req, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) + UINT16_MAX); + GNUNET_CRYPTO_hash (req->hostname, hlen, &hc); + if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put ( + ns_pending, + &hc, + req, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Duplicate hostname `%s' ignored\n", @@ -1733,9 +1566,7 @@ queue (const char *hostname) * @return #GNUNET_OK (continue to iterate) */ static int -move_to_queue (void *cls, - const struct GNUNET_HashCode *key, - void *value) +move_to_queue (void *cls, const struct GNUNET_HashCode *key, void *value) { struct Request *req = value; @@ -1766,9 +1597,9 @@ iterate_zones (void *cls) last->domain); /* subtract left-overs from previous iteration */ GNUNET_STATISTICS_update (stats, - "# NAMESTORE records requested from cache", - (long long) (- ns_iterator_trigger_next), - GNUNET_NO); + "# NAMESTORE records requested from cache", + (long long) (-ns_iterator_trigger_next), + GNUNET_NO); ns_iterator_trigger_next = 0; } GNUNET_assert (NULL != zone_tail); @@ -1777,14 +1608,12 @@ iterate_zones (void *cls) /* Done iterating over relevant zones in NAMESTORE, move rest of hash map to work queue as well. */ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Finished all NAMESTORE iterations!\n"); + "Finished all NAMESTORE iterations!\n"); GNUNET_STATISTICS_set (stats, - "# Domain names without cached reply", - GNUNET_CONTAINER_multihashmap_size (ns_pending), - GNUNET_NO); - GNUNET_CONTAINER_multihashmap_iterate (ns_pending, - &move_to_queue, - NULL); + "# Domain names without cached reply", + GNUNET_CONTAINER_multihashmap_size (ns_pending), + GNUNET_NO); + GNUNET_CONTAINER_multihashmap_iterate (ns_pending, &move_to_queue, NULL); GNUNET_CONTAINER_multihashmap_destroy (ns_pending); ns_pending = NULL; start_time_reg_proc = GNUNET_TIME_absolute_get (); @@ -1801,14 +1630,11 @@ iterate_zones (void *cls) last->domain); /* subtract left-overs from previous iteration */ GNUNET_STATISTICS_update (stats, - "# NAMESTORE records requested from cache", - 1, - GNUNET_NO); + "# NAMESTORE records requested from cache", + 1, + GNUNET_NO); ns_iterator_trigger_next = 1; - GNUNET_STATISTICS_update (stats, - "# zones iterated", - 1, - GNUNET_NO); + GNUNET_STATISTICS_update (stats, "# zones iterated", 1, GNUNET_NO); zone_it = GNUNET_NAMESTORE_zone_iteration_start (ns, &last->key, &ns_lookup_error_cb, @@ -1817,7 +1643,6 @@ iterate_zones (void *cls) last, &iterate_zones, NULL); - } @@ -1840,13 +1665,10 @@ process_stdin (void *cls) GNUNET_IDENTITY_disconnect (id); id = NULL; } - while (NULL != - fgets (hn, - sizeof (hn), - stdin)) + while (NULL != fgets (hn, sizeof (hn), stdin)) { - if (strlen(hn) > 0) - hn[strlen(hn)-1] = '\0'; /* eat newline */ + if (strlen (hn) > 0) + hn[strlen (hn) - 1] = '\0'; /* eat newline */ if (0 == idot) last = GNUNET_TIME_absolute_get (); idot++; @@ -1857,23 +1679,16 @@ process_stdin (void *cls) delta = GNUNET_TIME_absolute_get_duration (last); last = GNUNET_TIME_absolute_get (); fprintf (stderr, - "Read 100000 domain names in %s\n", - GNUNET_STRINGS_relative_time_to_string (delta, - GNUNET_YES)); - GNUNET_STATISTICS_set (stats, - "# domain names provided", - idot, - GNUNET_NO); + "Read 100000 domain names in %s\n", + GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES)); + GNUNET_STATISTICS_set (stats, "# domain names provided", idot, GNUNET_NO); } queue (hn); } fprintf (stderr, "Done reading %llu domain names\n", (unsigned long long) idot); - GNUNET_STATISTICS_set (stats, - "# domain names provided", - idot, - GNUNET_NO); + GNUNET_STATISTICS_set (stats, "# domain names provided", idot, GNUNET_NO); iterate_zones (NULL); } @@ -1905,7 +1720,7 @@ process_stdin (void *cls) * cleaned up). * * @param cls closure - * @param ego ego handle + * @param ego ego handle, NULL for end of list * @param ctx context for application to store data for this ego * (during the lifetime of this process, initially NULL) * @param name name assigned by the user for this ego, @@ -1914,26 +1729,25 @@ process_stdin (void *cls) */ static void identity_cb (void *cls, - struct GNUNET_IDENTITY_Ego *ego, - void **ctx, - const char *name) + struct GNUNET_IDENTITY_Ego *ego, + void **ctx, + const char *name) { (void) cls; (void) ctx; + if (NULL == ego) { - if (NULL != zone_head) + /* end of iteration */ + if (NULL == zone_head) { - t = GNUNET_SCHEDULER_add_now (&process_stdin, - NULL); - } - else - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "No zone found\n"); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No zone found\n"); GNUNET_SCHEDULER_shutdown (); return; } + /* zone_head non-null, process hostnames from stdin */ + t = GNUNET_SCHEDULER_add_now (&process_stdin, NULL); + return; } if (NULL != name) { @@ -1942,9 +1756,7 @@ identity_cb (void *cls, zone = GNUNET_new (struct Zone); zone->key = *GNUNET_IDENTITY_ego_get_private_key (ego); zone->domain = GNUNET_strdup (name); - GNUNET_CONTAINER_DLL_insert (zone_head, - zone_tail, - zone); + GNUNET_CONTAINER_DLL_insert (zone_head, zone_tail, zone); } } @@ -1967,22 +1779,18 @@ run (void *cls, (void) cls; (void) args; (void) cfgfile; - stats = GNUNET_STATISTICS_create ("zoneimport", - cfg); + stats = GNUNET_STATISTICS_create ("zoneimport", cfg); req_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); - ns_pending = GNUNET_CONTAINER_multihashmap_create (map_size, - GNUNET_NO); + ns_pending = GNUNET_CONTAINER_multihashmap_create (map_size, GNUNET_NO); if (NULL == ns_pending) { - fprintf (stderr, - "Failed to allocate memory for main hash map\n"); + fprintf (stderr, "Failed to allocate memory for main hash map\n"); return; } ctx = GNUNET_DNSSTUB_start (256); if (NULL == ctx) { - fprintf (stderr, - "Failed to initialize GNUnet DNS STUB\n"); + fprintf (stderr, "Failed to initialize GNUnet DNS STUB\n"); return; } if (NULL == args[0]) @@ -1991,31 +1799,24 @@ run (void *cls, "You must provide a list of DNS resolvers on the command line\n"); return; } - for (unsigned int i=0;NULL != args[i];i++) + for (unsigned int i = 0; NULL != args[i]; i++) { - if (GNUNET_OK != - GNUNET_DNSSTUB_add_dns_ip (ctx, - args[i])) + if (GNUNET_OK != GNUNET_DNSSTUB_add_dns_ip (ctx, args[i])) { - fprintf (stderr, - "Failed to use `%s' for DNS resolver\n", - args[i]); + fprintf (stderr, "Failed to use `%s' for DNS resolver\n", args[i]); return; } } - GNUNET_SCHEDULER_add_shutdown (&do_shutdown, - NULL); + GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); ns = GNUNET_NAMESTORE_connect (cfg); if (NULL == ns) { GNUNET_SCHEDULER_shutdown (); return; } - id = GNUNET_IDENTITY_connect (cfg, - &identity_cb, - NULL); + id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL); } @@ -2027,38 +1828,35 @@ run (void *cls, * @return 0 on success */ int -main (int argc, - char *const*argv) +main (int argc, char *const *argv) { - struct GNUNET_GETOPT_CommandLineOption options[] = { - GNUNET_GETOPT_option_uint ('s', - "size", - "MAPSIZE", - gettext_noop ("size to use for the main hash map"), - &map_size), - GNUNET_GETOPT_option_relative_time ('m', - "minimum-expiration", - "RELATIVETIME", - gettext_noop ("minimum expiration time we assume for imported records"), - &minimum_expiration_time), - GNUNET_GETOPT_OPTION_END - }; + struct GNUNET_GETOPT_CommandLineOption options[] = + {GNUNET_GETOPT_option_uint ('s', + "size", + "MAPSIZE", + gettext_noop ( + "size to use for the main hash map"), + &map_size), + GNUNET_GETOPT_option_relative_time ( + 'm', + "minimum-expiration", + "RELATIVETIME", + gettext_noop ("minimum expiration time we assume for imported records"), + &minimum_expiration_time), + 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; - if (GNUNET_OK != - (ret = GNUNET_PROGRAM_run (argc, - argv, - "gnunet-zoneimport", - "import DNS zone into namestore", - options, - &run, - NULL))) + if (GNUNET_OK != (ret = GNUNET_PROGRAM_run (argc, + argv, + "gnunet-zoneimport", + "import DNS zone into namestore", + options, + &run, + NULL))) return ret; - GNUNET_free ((void*) argv); + GNUNET_free ((void *) argv); fprintf (stderr, "Rejected %u names, had %u cached, did %u lookups, stored %u record sets\n" "Found %u records, %u lookups failed, %u/%u pending on shutdown\n", diff --git a/src/peerstore/gnunet-service-peerstore.c b/src/peerstore/gnunet-service-peerstore.c index 9bce542b9..ed1c35535 100644 --- a/src/peerstore/gnunet-service-peerstore.c +++ b/src/peerstore/gnunet-service-peerstore.c @@ -11,7 +11,7 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . @@ -33,7 +33,7 @@ /** * Interval for expired records cleanup (in seconds) */ -#define EXPIRED_RECORDS_CLEANUP_INTERVAL 300 /* 5mins */ +#define EXPIRED_RECORDS_CLEANUP_INTERVAL 300 /* 5mins */ /** * Our configuration. @@ -79,9 +79,7 @@ do_shutdown () { if (NULL != db_lib_name) { - GNUNET_break (NULL == - GNUNET_PLUGIN_unload (db_lib_name, - db)); + GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, db)); GNUNET_free (db_lib_name); db_lib_name = NULL; } @@ -108,15 +106,14 @@ static void shutdown_task (void *cls) { in_shutdown = GNUNET_YES; - if (0 == num_clients) /* Only when no connected clients. */ + if (0 == num_clients) /* Only when no connected clients. */ do_shutdown (); } /* Forward declaration */ static void -expire_records_continuation (void *cls, - int success); +expire_records_continuation (void *cls, int success); /** @@ -131,16 +128,16 @@ cleanup_expired_records (void *cls) GNUNET_assert (NULL != db); ret = db->expire_records (db->cls, GNUNET_TIME_absolute_get (), - &expire_records_continuation, + &expire_records_continuation, NULL); if (GNUNET_OK != ret) { GNUNET_assert (NULL == expire_task); - expire_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, - EXPIRED_RECORDS_CLEANUP_INTERVAL), - &cleanup_expired_records, - NULL); + expire_task = GNUNET_SCHEDULER_add_delayed ( + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, + EXPIRED_RECORDS_CLEANUP_INTERVAL), + &cleanup_expired_records, + NULL); } } @@ -152,19 +149,16 @@ cleanup_expired_records (void *cls) * @param success count of records deleted or #GNUNET_SYSERR */ static void -expire_records_continuation (void *cls, - int success) +expire_records_continuation (void *cls, int success) { if (success > 0) - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "%d records expired.\n", - success); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%d records expired.\n", success); GNUNET_assert (NULL == expire_task); - expire_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, - EXPIRED_RECORDS_CLEANUP_INTERVAL), - &cleanup_expired_records, - NULL); + expire_task = GNUNET_SCHEDULER_add_delayed ( + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, + EXPIRED_RECORDS_CLEANUP_INTERVAL), + &cleanup_expired_records, + NULL); } @@ -195,15 +189,12 @@ client_connect_cb (void *cls, * @return #GNUNET_OK to continue iterating */ static int -client_disconnect_it (void *cls, - const struct GNUNET_HashCode *key, - void *value) +client_disconnect_it (void *cls, const struct GNUNET_HashCode *key, void *value) { if (value == cls) { - GNUNET_CONTAINER_multihashmap_remove (watchers, - key, - value); + GNUNET_assert (GNUNET_YES == + GNUNET_CONTAINER_multihashmap_remove (watchers, key, value)); num_clients++; } return GNUNET_OK; @@ -221,15 +212,13 @@ client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "A client disconnected, cleaning up.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "A client disconnected, cleaning up.\n"); if (NULL != watchers) GNUNET_CONTAINER_multihashmap_iterate (watchers, &client_disconnect_it, client); num_clients--; - if ( (0 == num_clients) && - in_shutdown) + if ((0 == num_clients) && in_shutdown) do_shutdown (); } @@ -255,10 +244,8 @@ record_iterator (void *cls, /* No more records */ struct GNUNET_MessageHeader *endmsg; - env = GNUNET_MQ_msg (endmsg, - GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END); - GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (cls_record->client), - env); + env = GNUNET_MQ_msg (endmsg, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END); + GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (cls_record->client), env); if (NULL == emsg) { GNUNET_SERVICE_client_continue (cls_record->client); @@ -266,25 +253,23 @@ record_iterator (void *cls, else { GNUNET_break (0); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Failed to iterate: %s\n", - emsg); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate: %s\n", emsg); GNUNET_SERVICE_client_drop (cls_record->client); } PEERSTORE_destroy_record (cls_record); return; } - env = PEERSTORE_create_record_mq_envelope (record->sub_system, - &record->peer, - record->key, - record->value, - record->value_size, - record->expiry, - 0, - GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD); - GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (cls_record->client), - env); + env = PEERSTORE_create_record_mq_envelope ( + record->sub_system, + &record->peer, + record->key, + record->value, + record->value_size, + record->expiry, + 0, + GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD); + GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (cls_record->client), env); } @@ -298,26 +283,23 @@ record_iterator (void *cls, * @return #GNUNET_YES to continue iterating */ static int -watch_notifier_it (void *cls, - const struct GNUNET_HashCode *key, - void *value) +watch_notifier_it (void *cls, const struct GNUNET_HashCode *key, void *value) { struct GNUNET_PEERSTORE_Record *record = cls; struct GNUNET_SERVICE_Client *client = value; struct GNUNET_MQ_Envelope *env; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Found a watcher to update.\n"); - env = PEERSTORE_create_record_mq_envelope (record->sub_system, - &record->peer, - record->key, - record->value, - record->value_size, - record->expiry, - 0, - GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD); - GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), - env); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found a watcher to update.\n"); + env = PEERSTORE_create_record_mq_envelope ( + record->sub_system, + &record->peer, + record->key, + record->value, + record->value_size, + record->expiry, + 0, + GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD); + GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env); return GNUNET_YES; } @@ -332,10 +314,7 @@ watch_notifier (struct GNUNET_PEERSTORE_Record *record) { struct GNUNET_HashCode keyhash; - PEERSTORE_hash_key (record->sub_system, - &record->peer, - record->key, - &keyhash); + PEERSTORE_hash_key (record->sub_system, &record->peer, record->key, &keyhash); GNUNET_CONTAINER_multihashmap_get_multiple (watchers, &keyhash, &watch_notifier_it, @@ -350,17 +329,13 @@ watch_notifier (struct GNUNET_PEERSTORE_Record *record) * @param hm the actual message */ static void -handle_watch_cancel (void *cls, - const struct StoreKeyHashMessage *hm) +handle_watch_cancel (void *cls, const struct StoreKeyHashMessage *hm) { struct GNUNET_SERVICE_Client *client = cls; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received a watch cancel request.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received a watch cancel request.\n"); if (GNUNET_OK != - GNUNET_CONTAINER_multihashmap_remove (watchers, - &hm->keyhash, - client)) + GNUNET_CONTAINER_multihashmap_remove (watchers, &hm->keyhash, client)) { GNUNET_break (0); GNUNET_SERVICE_client_drop (client); @@ -378,13 +353,11 @@ handle_watch_cancel (void *cls, * @param hm the actual message */ static void -handle_watch (void *cls, - const struct StoreKeyHashMessage *hm) +handle_watch (void *cls, const struct StoreKeyHashMessage *hm) { struct GNUNET_SERVICE_Client *client = cls; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received a watch request.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received a watch request.\n"); num_clients--; /* do not count watchers */ GNUNET_SERVICE_client_mark_monitor (client); GNUNET_CONTAINER_multihashmap_put (watchers, @@ -403,8 +376,7 @@ handle_watch (void *cls, * @return #GNUNET_OK if @a srm is well-formed */ static int -check_iterate (void *cls, - const struct StoreRecordMessage *srm) +check_iterate (void *cls, const struct StoreRecordMessage *srm) { struct GNUNET_PEERSTORE_Record *record; @@ -432,8 +404,7 @@ check_iterate (void *cls, * @param srm the actual message */ static void -handle_iterate (void *cls, - const struct StoreRecordMessage *srm) +handle_iterate (void *cls, const struct StoreRecordMessage *srm) { struct GNUNET_SERVICE_Client *client = cls; struct GNUNET_PEERSTORE_Record *record; @@ -467,8 +438,7 @@ handle_iterate (void *cls, * @param success result */ static void -store_record_continuation (void *cls, - int success) +store_record_continuation (void *cls, int success) { struct GNUNET_PEERSTORE_Record *record = cls; @@ -494,8 +464,7 @@ store_record_continuation (void *cls, * @return #GNUNET_OK if @a srm is well-formed */ static int -check_store (void *cls, - const struct StoreRecordMessage *srm) +check_store (void *cls, const struct StoreRecordMessage *srm) { struct GNUNET_PEERSTORE_Record *record; @@ -505,8 +474,7 @@ check_store (void *cls, GNUNET_break (0); return GNUNET_SYSERR; } - if ( (NULL == record->sub_system) || - (NULL == record->key) ) + if ((NULL == record->sub_system) || (NULL == record->key)) { GNUNET_break (0); PEERSTORE_destroy_record (record); @@ -524,31 +492,30 @@ check_store (void *cls, * @param srm the actual message */ static void -handle_store (void *cls, - const struct StoreRecordMessage *srm) +handle_store (void *cls, const struct StoreRecordMessage *srm) { struct GNUNET_SERVICE_Client *client = cls; struct GNUNET_PEERSTORE_Record *record; record = PEERSTORE_parse_record_message (srm); - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Received a store request. Sub system `%s' Peer `%s Key `%s' Options: %u.\n", - record->sub_system, - GNUNET_i2s (&record->peer), - record->key, - (uint32_t) ntohl (srm->options)); + GNUNET_log ( + GNUNET_ERROR_TYPE_INFO, + "Received a store request. Sub system `%s' Peer `%s Key `%s' Options: %u.\n", + record->sub_system, + GNUNET_i2s (&record->peer), + record->key, + (uint32_t) ntohl (srm->options)); record->client = client; - if (GNUNET_OK != - db->store_record (db->cls, - record->sub_system, - &record->peer, - record->key, - record->value, - record->value_size, - record->expiry, - ntohl (srm->options), - &store_record_continuation, - record)) + if (GNUNET_OK != db->store_record (db->cls, + record->sub_system, + &record->peer, + record->key, + record->value, + record->value_size, + record->expiry, + ntohl (srm->options), + &store_record_continuation, + record)) { GNUNET_break (0); PEERSTORE_destroy_record (record); @@ -574,11 +541,10 @@ run (void *cls, in_shutdown = GNUNET_NO; cfg = c; - if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_string (cfg, - "peerstore", - "DATABASE", - &database)) + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, + "peerstore", + "DATABASE", + &database)) { GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "peerstore", @@ -586,56 +552,50 @@ run (void *cls, GNUNET_SCHEDULER_shutdown (); return; } - GNUNET_asprintf (&db_lib_name, - "libgnunet_plugin_peerstore_%s", - database); - db = GNUNET_PLUGIN_load (db_lib_name, - (void *) cfg); + GNUNET_asprintf (&db_lib_name, "libgnunet_plugin_peerstore_%s", database); + db = GNUNET_PLUGIN_load (db_lib_name, (void *) cfg); GNUNET_free (database); if (NULL == db) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - _("Could not load database backend `%s'\n"), - db_lib_name); + _ ("Could not load database backend `%s'\n"), + db_lib_name); GNUNET_SCHEDULER_shutdown (); return; } - watchers = GNUNET_CONTAINER_multihashmap_create (10, - GNUNET_NO); - expire_task = GNUNET_SCHEDULER_add_now (&cleanup_expired_records, - NULL); - GNUNET_SCHEDULER_add_shutdown (&shutdown_task, - NULL); + watchers = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO); + expire_task = GNUNET_SCHEDULER_add_now (&cleanup_expired_records, NULL); + GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); } /** * Define "main" method using service macro. */ -GNUNET_SERVICE_MAIN -("peerstore", - GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, - &run, - &client_connect_cb, - &client_disconnect_cb, - NULL, - GNUNET_MQ_hd_var_size (store, - GNUNET_MESSAGE_TYPE_PEERSTORE_STORE, - struct StoreRecordMessage, - NULL), - GNUNET_MQ_hd_var_size (iterate, - GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE, - struct StoreRecordMessage, - NULL), - GNUNET_MQ_hd_fixed_size (watch, - GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH, - struct StoreKeyHashMessage, - NULL), - GNUNET_MQ_hd_fixed_size (watch_cancel, - GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL, - struct StoreKeyHashMessage, - NULL), - GNUNET_MQ_handler_end ()); +GNUNET_SERVICE_MAIN ( + "peerstore", + GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, + &run, + &client_connect_cb, + &client_disconnect_cb, + NULL, + GNUNET_MQ_hd_var_size (store, + GNUNET_MESSAGE_TYPE_PEERSTORE_STORE, + struct StoreRecordMessage, + NULL), + GNUNET_MQ_hd_var_size (iterate, + GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE, + struct StoreRecordMessage, + NULL), + GNUNET_MQ_hd_fixed_size (watch, + GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH, + struct StoreKeyHashMessage, + NULL), + GNUNET_MQ_hd_fixed_size (watch_cancel, + GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL, + struct StoreKeyHashMessage, + NULL), + GNUNET_MQ_handler_end ()); /* end of gnunet-service-peerstore.c */ diff --git a/src/peerstore/peerstore_api.c b/src/peerstore/peerstore_api.c index 02f3e287a..64bc3ae72 100644 --- a/src/peerstore/peerstore_api.c +++ b/src/peerstore/peerstore_api.c @@ -28,7 +28,7 @@ #include "peerstore.h" #include "peerstore_common.h" -#define LOG(kind,...) GNUNET_log_from (kind, "peerstore-api",__VA_ARGS__) +#define LOG(kind, ...) GNUNET_log_from (kind, "peerstore-api", __VA_ARGS__) /******************************************************************************/ /************************ DATA STRUCTURES ****************************/ @@ -89,7 +89,6 @@ struct GNUNET_PEERSTORE_Handle * Are we in the process of disconnecting but need to sync first? */ int disconnecting; - }; /** @@ -156,7 +155,6 @@ struct GNUNET_PEERSTORE_StoreContext * Options for the store operation. */ enum GNUNET_PEERSTORE_StoreOption options; - }; /** @@ -208,7 +206,6 @@ struct GNUNET_PEERSTORE_IterateContext * #GNUNET_YES if we are currently processing records. */ int iterating; - }; /** @@ -245,7 +242,6 @@ struct GNUNET_PEERSTORE_WatchContext * Hash of the combined key */ struct GNUNET_HashCode keyhash; - }; /******************************************************************************/ @@ -271,8 +267,7 @@ disconnect (struct GNUNET_PEERSTORE_Handle *h) { struct GNUNET_PEERSTORE_IterateContext *next; - for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; - NULL != ic; + for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic; ic = next) { next = ic->next; @@ -285,9 +280,7 @@ disconnect (struct GNUNET_PEERSTORE_Handle *h) icb_cls = ic->callback_cls; GNUNET_PEERSTORE_iterate_cancel (ic); if (NULL != icb) - icb (icb_cls, - NULL, - "Iteration canceled due to reconnection"); + icb (icb_cls, NULL, "Iteration canceled due to reconnection"); } } @@ -312,17 +305,13 @@ disconnect_and_schedule_reconnect (struct GNUNET_PEERSTORE_Handle *h) disconnect (h); LOG (GNUNET_ERROR_TYPE_DEBUG, "Scheduling task to reconnect to PEERSTORE service in %s.\n", - GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay, - GNUNET_YES)); + GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay, GNUNET_YES)); h->reconnect_task = - GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, - &reconnect, - h); + GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h); h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay); } - /** * Callback after MQ envelope is sent * @@ -352,8 +341,7 @@ store_request_sent (void *cls) * Function called when we had trouble talking to the service. */ static void -handle_client_error (void *cls, - enum GNUNET_MQ_Error error) +handle_client_error (void *cls, enum GNUNET_MQ_Error error) { struct GNUNET_PEERSTORE_Handle *h = cls; @@ -373,9 +361,7 @@ handle_client_error (void *cls, * @return #GNUNET_YES (continue to iterate) */ static int -rewatch_it (void *cls, - const struct GNUNET_HashCode *key, - void *value) +rewatch_it (void *cls, const struct GNUNET_HashCode *key, void *value) { struct GNUNET_PEERSTORE_Handle *h = cls; struct GNUNET_PEERSTORE_WatchContext *wc = value; @@ -398,9 +384,7 @@ rewatch_it (void *cls, * @return #GNUNET_YES to continue iteration */ static int -destroy_watch (void *cls, - const struct GNUNET_HashCode *key, - void *value) +destroy_watch (void *cls, const struct GNUNET_HashCode *key, void *value) { struct GNUNET_PEERSTORE_WatchContext *wc = value; @@ -461,8 +445,7 @@ GNUNET_PEERSTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg) * @param sync_first send any pending STORE requests before disconnecting */ void -GNUNET_PEERSTORE_disconnect (struct GNUNET_PEERSTORE_Handle *h, - int sync_first) +GNUNET_PEERSTORE_disconnect (struct GNUNET_PEERSTORE_Handle *h, int sync_first) { struct GNUNET_PEERSTORE_IterateContext *ic; struct GNUNET_PEERSTORE_StoreContext *sc; @@ -515,8 +498,7 @@ GNUNET_PEERSTORE_store_cancel (struct GNUNET_PEERSTORE_StoreContext *sc) GNUNET_free (sc->value); GNUNET_free (sc->key); GNUNET_free (sc); - if ( (GNUNET_YES == h->disconnecting) && - (NULL == h->store_head) ) + if ((GNUNET_YES == h->disconnecting) && (NULL == h->store_head)) final_disconnect (h); } @@ -542,7 +524,8 @@ GNUNET_PEERSTORE_store (struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, - const void *value, size_t size, + const void *value, + size_t size, struct GNUNET_TIME_Absolute expiry, enum GNUNET_PEERSTORE_StoreOption options, GNUNET_PEERSTORE_Continuation cont, @@ -553,10 +536,19 @@ GNUNET_PEERSTORE_store (struct GNUNET_PEERSTORE_Handle *h, LOG (GNUNET_ERROR_TYPE_DEBUG, "Storing value (size: %lu) for subsytem `%s', peer `%s', key `%s'\n", - size, sub_system, GNUNET_i2s (peer), key); - ev = PEERSTORE_create_record_mq_envelope (sub_system, peer, key, value, size, - expiry, options, - GNUNET_MESSAGE_TYPE_PEERSTORE_STORE); + size, + sub_system, + GNUNET_i2s (peer), + key); + ev = + PEERSTORE_create_record_mq_envelope (sub_system, + peer, + key, + value, + size, + expiry, + options, + GNUNET_MESSAGE_TYPE_PEERSTORE_STORE); sc = GNUNET_new (struct GNUNET_PEERSTORE_StoreContext); sc->sub_system = GNUNET_strdup (sub_system); @@ -574,7 +566,6 @@ GNUNET_PEERSTORE_store (struct GNUNET_PEERSTORE_Handle *h, GNUNET_MQ_notify_sent (ev, &store_request_sent, sc); GNUNET_MQ_send (h->mq, ev); return sc; - } @@ -590,8 +581,7 @@ GNUNET_PEERSTORE_store (struct GNUNET_PEERSTORE_Handle *h, * @param msg message received */ static void -handle_iterate_end (void *cls, - const struct GNUNET_MessageHeader *msg) +handle_iterate_end (void *cls, const struct GNUNET_MessageHeader *msg) { struct GNUNET_PEERSTORE_Handle *h = cls; struct GNUNET_PEERSTORE_IterateContext *ic; @@ -602,7 +592,7 @@ handle_iterate_end (void *cls, if (NULL == ic) { LOG (GNUNET_ERROR_TYPE_ERROR, - _("Unexpected iteration response, this should not happen.\n")); + _ ("Unexpected iteration response, this should not happen.\n")); disconnect_and_schedule_reconnect (h); return; } @@ -611,9 +601,7 @@ handle_iterate_end (void *cls, ic->iterating = GNUNET_NO; GNUNET_PEERSTORE_iterate_cancel (ic); if (NULL != callback) - callback (callback_cls, - NULL, - NULL); + callback (callback_cls, NULL, NULL); h->reconnect_delay = GNUNET_TIME_UNIT_ZERO; } @@ -626,8 +614,7 @@ handle_iterate_end (void *cls, * @param msg message received */ static int -check_iterate_result (void *cls, - const struct StoreRecordMessage *msg) +check_iterate_result (void *cls, const struct StoreRecordMessage *msg) { /* we defer validation to #handle_iterate_result */ return GNUNET_OK; @@ -641,8 +628,7 @@ check_iterate_result (void *cls, * @param msg message received */ static void -handle_iterate_result (void *cls, - const struct StoreRecordMessage *msg) +handle_iterate_result (void *cls, const struct StoreRecordMessage *msg) { struct GNUNET_PEERSTORE_Handle *h = cls; struct GNUNET_PEERSTORE_IterateContext *ic; @@ -654,7 +640,7 @@ handle_iterate_result (void *cls, if (NULL == ic) { LOG (GNUNET_ERROR_TYPE_ERROR, - _("Unexpected iteration response, this should not happen.\n")); + _ ("Unexpected iteration response, this should not happen.\n")); disconnect_and_schedule_reconnect (h); return; } @@ -668,13 +654,11 @@ handle_iterate_result (void *cls, { callback (callback_cls, NULL, - _("Received a malformed response from service.")); + _ ("Received a malformed response from service.")); } else { - callback (callback_cls, - record, - NULL); + callback (callback_cls, record, NULL); PEERSTORE_destroy_record (record); } } @@ -691,9 +675,7 @@ GNUNET_PEERSTORE_iterate_cancel (struct GNUNET_PEERSTORE_IterateContext *ic) { if (GNUNET_NO == ic->iterating) { - GNUNET_CONTAINER_DLL_remove (ic->h->iterate_head, - ic->h->iterate_tail, - ic); + GNUNET_CONTAINER_DLL_remove (ic->h->iterate_head, ic->h->iterate_tail, ic); GNUNET_free (ic->sub_system); GNUNET_free_non_null (ic->key); GNUNET_free (ic); @@ -725,13 +707,15 @@ GNUNET_PEERSTORE_iterate (struct GNUNET_PEERSTORE_Handle *h, struct GNUNET_MQ_Envelope *ev; struct GNUNET_PEERSTORE_IterateContext *ic; - ev = PEERSTORE_create_record_mq_envelope (sub_system, - peer, - key, - NULL, 0, - GNUNET_TIME_UNIT_FOREVER_ABS, - 0, - GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE); + ev = + PEERSTORE_create_record_mq_envelope (sub_system, + peer, + key, + NULL, + 0, + GNUNET_TIME_UNIT_FOREVER_ABS, + 0, + GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE); ic = GNUNET_new (struct GNUNET_PEERSTORE_IterateContext); ic->callback = callback; ic->callback_cls = callback_cls; @@ -741,9 +725,7 @@ GNUNET_PEERSTORE_iterate (struct GNUNET_PEERSTORE_Handle *h, ic->peer = *peer; if (NULL != key) ic->key = GNUNET_strdup (key); - GNUNET_CONTAINER_DLL_insert_tail (h->iterate_head, - h->iterate_tail, - ic); + GNUNET_CONTAINER_DLL_insert_tail (h->iterate_head, h->iterate_tail, ic); LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending an iterate request for sub system `%s'\n", sub_system); @@ -763,8 +745,7 @@ GNUNET_PEERSTORE_iterate (struct GNUNET_PEERSTORE_Handle *h, * @param msg message received */ static int -check_watch_record (void *cls, - const struct StoreRecordMessage *msg) +check_watch_record (void *cls, const struct StoreRecordMessage *msg) { /* we defer validation to #handle_watch_result */ return GNUNET_OK; @@ -778,41 +759,33 @@ check_watch_record (void *cls, * @param msg message received */ static void -handle_watch_record (void *cls, - const struct StoreRecordMessage *msg) +handle_watch_record (void *cls, const struct StoreRecordMessage *msg) { struct GNUNET_PEERSTORE_Handle *h = cls; struct GNUNET_PEERSTORE_Record *record; struct GNUNET_HashCode keyhash; struct GNUNET_PEERSTORE_WatchContext *wc; - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Received a watch record from service.\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Received a watch record from service.\n"); record = PEERSTORE_parse_record_message (msg); if (NULL == record) { disconnect_and_schedule_reconnect (h); return; } - PEERSTORE_hash_key (record->sub_system, - &record->peer, - record->key, - &keyhash); + PEERSTORE_hash_key (record->sub_system, &record->peer, record->key, &keyhash); // FIXME: what if there are multiple watches for the same key? - wc = GNUNET_CONTAINER_multihashmap_get (h->watches, - &keyhash); + wc = GNUNET_CONTAINER_multihashmap_get (h->watches, &keyhash); if (NULL == wc) { LOG (GNUNET_ERROR_TYPE_ERROR, - _("Received a watch result for a non existing watch.\n")); + _ ("Received a watch result for a non existing watch.\n")); PEERSTORE_destroy_record (record); disconnect_and_schedule_reconnect (h); return; } if (NULL != wc->callback) - wc->callback (wc->callback_cls, - record, - NULL); + wc->callback (wc->callback_cls, record, NULL); h->reconnect_delay = GNUNET_TIME_UNIT_ZERO; PEERSTORE_destroy_record (record); } @@ -827,26 +800,24 @@ static void reconnect (void *cls) { struct GNUNET_PEERSTORE_Handle *h = cls; - struct GNUNET_MQ_MessageHandler mq_handlers[] = { - GNUNET_MQ_hd_fixed_size (iterate_end, - GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END, - struct GNUNET_MessageHeader, - h), - GNUNET_MQ_hd_var_size (iterate_result, - GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD, - struct StoreRecordMessage, - h), - GNUNET_MQ_hd_var_size (watch_record, - GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD, - struct StoreRecordMessage, - h), - GNUNET_MQ_handler_end () - }; + struct GNUNET_MQ_MessageHandler mq_handlers[] = + {GNUNET_MQ_hd_fixed_size (iterate_end, + GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END, + struct GNUNET_MessageHeader, + h), + GNUNET_MQ_hd_var_size (iterate_result, + GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD, + struct StoreRecordMessage, + h), + GNUNET_MQ_hd_var_size (watch_record, + GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD, + struct StoreRecordMessage, + h), + GNUNET_MQ_handler_end ()}; struct GNUNET_MQ_Envelope *ev; h->reconnect_task = NULL; - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Reconnecting...\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting...\n"); h->mq = GNUNET_CLIENT_connect (h->cfg, "peerstore", mq_handlers, @@ -857,39 +828,35 @@ reconnect (void *cls) LOG (GNUNET_ERROR_TYPE_DEBUG, "Resending pending requests after reconnect.\n"); if (NULL != h->watches) - GNUNET_CONTAINER_multihashmap_iterate (h->watches, - &rewatch_it, - h); - for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; - NULL != ic; + GNUNET_CONTAINER_multihashmap_iterate (h->watches, &rewatch_it, h); + for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic; ic = ic->next) { - ev = PEERSTORE_create_record_mq_envelope (ic->sub_system, - &ic->peer, - ic->key, - NULL, 0, - GNUNET_TIME_UNIT_FOREVER_ABS, - 0, - GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE); + ev = + PEERSTORE_create_record_mq_envelope (ic->sub_system, + &ic->peer, + ic->key, + NULL, + 0, + GNUNET_TIME_UNIT_FOREVER_ABS, + 0, + GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE); GNUNET_MQ_send (h->mq, ev); } - for (struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head; - NULL != sc; + for (struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head; NULL != sc; sc = sc->next) { - ev = PEERSTORE_create_record_mq_envelope (sc->sub_system, - &sc->peer, - sc->key, - sc->value, - sc->size, - sc->expiry, - sc->options, - GNUNET_MESSAGE_TYPE_PEERSTORE_STORE); - GNUNET_MQ_notify_sent (ev, - &store_request_sent, - sc); - GNUNET_MQ_send (h->mq, - ev); + ev = + PEERSTORE_create_record_mq_envelope (sc->sub_system, + &sc->peer, + sc->key, + sc->value, + sc->size, + sc->expiry, + sc->options, + GNUNET_MESSAGE_TYPE_PEERSTORE_STORE); + GNUNET_MQ_notify_sent (ev, &store_request_sent, sc); + GNUNET_MQ_send (h->mq, ev); } } @@ -906,15 +873,13 @@ GNUNET_PEERSTORE_watch_cancel (struct GNUNET_PEERSTORE_WatchContext *wc) struct GNUNET_MQ_Envelope *ev; struct StoreKeyHashMessage *hm; - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Canceling watch.\n"); - ev = GNUNET_MQ_msg (hm, - GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Canceling watch.\n"); + ev = GNUNET_MQ_msg (hm, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL); hm->keyhash = wc->keyhash; GNUNET_MQ_send (h->mq, ev); - GNUNET_CONTAINER_multihashmap_remove (h->watches, - &wc->keyhash, - wc); + GNUNET_assert ( + GNUNET_YES == + GNUNET_CONTAINER_multihashmap_remove (h->watches, &wc->keyhash, wc)); GNUNET_free (wc); } @@ -943,32 +908,26 @@ GNUNET_PEERSTORE_watch (struct GNUNET_PEERSTORE_Handle *h, struct StoreKeyHashMessage *hm; struct GNUNET_PEERSTORE_WatchContext *wc; - ev = GNUNET_MQ_msg (hm, - GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH); - PEERSTORE_hash_key (sub_system, - peer, - key, - &hm->keyhash); + ev = GNUNET_MQ_msg (hm, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH); + PEERSTORE_hash_key (sub_system, peer, key, &hm->keyhash); wc = GNUNET_new (struct GNUNET_PEERSTORE_WatchContext); wc->callback = callback; wc->callback_cls = callback_cls; wc->h = h; wc->keyhash = hm->keyhash; if (NULL == h->watches) - h->watches = GNUNET_CONTAINER_multihashmap_create (5, - GNUNET_NO); - GNUNET_assert (GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put (h->watches, - &wc->keyhash, - wc, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); + h->watches = GNUNET_CONTAINER_multihashmap_create (5, GNUNET_NO); + GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put ( + h->watches, + &wc->keyhash, + wc, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending a watch request for subsystem `%s', peer `%s', key `%s'.\n", sub_system, GNUNET_i2s (peer), key); - GNUNET_MQ_send (h->mq, - ev); + GNUNET_MQ_send (h->mq, ev); return wc; } diff --git a/src/regex/regex_internal.c b/src/regex/regex_internal.c index 3f667a11f..55d16129f 100644 --- a/src/regex/regex_internal.c +++ b/src/regex/regex_internal.c @@ -11,7 +11,7 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . @@ -66,7 +66,7 @@ struct REGEX_INTERNAL_StateSet_MDLL */ static void state_set_append (struct REGEX_INTERNAL_StateSet *set, - struct REGEX_INTERNAL_State *state) + struct REGEX_INTERNAL_State *state) { if (set->off == set->size) GNUNET_array_grow (set->states, set->size, set->size * 2 + 4); @@ -114,8 +114,7 @@ state_add_transition (struct REGEX_INTERNAL_Context *ctx, if (NULL == from_state) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Could not create Transition.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not create Transition.\n"); return; } @@ -147,7 +146,9 @@ state_add_transition (struct REGEX_INTERNAL_Context *ctx, /* Add outgoing transition to 'from_state' */ from_state->transition_count++; GNUNET_CONTAINER_DLL_insert_before (from_state->transitions_head, - from_state->transitions_tail, oth, t); + from_state->transitions_tail, + oth, + t); } @@ -170,7 +171,8 @@ state_remove_transition (struct REGEX_INTERNAL_State *state, GNUNET_free_non_null (transition->label); state->transition_count--; - GNUNET_CONTAINER_DLL_remove (state->transitions_head, state->transitions_tail, + GNUNET_CONTAINER_DLL_remove (state->transitions_head, + state->transitions_tail, transition); GNUNET_free (transition); @@ -207,8 +209,7 @@ state_compare (const void *a, const void *b) * @return number of edges. */ static unsigned int -state_get_edges (struct REGEX_INTERNAL_State *s, - struct REGEX_BLOCK_Edge *edges) +state_get_edges (struct REGEX_INTERNAL_State *s, struct REGEX_BLOCK_Edge *edges) { struct REGEX_INTERNAL_Transition *t; unsigned int count; @@ -463,10 +464,13 @@ automaton_add_state (struct REGEX_INTERNAL_Automaton *a, * @param action_cls closure for action. */ static void -automaton_state_traverse (struct REGEX_INTERNAL_State *s, int *marks, +automaton_state_traverse (struct REGEX_INTERNAL_State *s, + int *marks, unsigned int *count, - REGEX_INTERNAL_traverse_check check, void *check_cls, - REGEX_INTERNAL_traverse_action action, void *action_cls) + REGEX_INTERNAL_traverse_check check, + void *check_cls, + REGEX_INTERNAL_traverse_action action, + void *action_cls) { struct REGEX_INTERNAL_Transition *t; @@ -485,8 +489,13 @@ automaton_state_traverse (struct REGEX_INTERNAL_State *s, int *marks, if (NULL == check || (NULL != check && GNUNET_YES == check (check_cls, s, t))) { - automaton_state_traverse (t->to_state, marks, count, check, check_cls, - action, action_cls); + automaton_state_traverse (t->to_state, + marks, + count, + check, + check_cls, + action, + action_cls); } } } @@ -535,9 +544,13 @@ REGEX_INTERNAL_automaton_traverse (const struct REGEX_INTERNAL_Automaton *a, else s = start; - automaton_state_traverse (s, marks, &count, - check, check_cls, - action, action_cls); + automaton_state_traverse (s, + marks, + &count, + check, + check_cls, + action, + action_cls); } @@ -582,7 +595,6 @@ struct StringBuffer * most likely due to increased cache misses. */ int16_t synced; - }; @@ -595,14 +607,11 @@ struct StringBuffer * @return 0 if the strings are the same or both NULL, 1 or -1 if not. */ static int -sb_nullstrcmp (const struct StringBuffer *s1, - const struct StringBuffer *s2) +sb_nullstrcmp (const struct StringBuffer *s1, const struct StringBuffer *s2) { - if ( (GNUNET_YES == s1->null_flag) && - (GNUNET_YES == s2->null_flag) ) + if ((GNUNET_YES == s1->null_flag) && (GNUNET_YES == s2->null_flag)) return 0; - if ( (GNUNET_YES == s1->null_flag) || - (GNUNET_YES == s2->null_flag) ) + if ((GNUNET_YES == s1->null_flag) || (GNUNET_YES == s2->null_flag)) return -1; if (s1->slen != s2->slen) return -1; @@ -621,8 +630,7 @@ sb_nullstrcmp (const struct StringBuffer *s1, * @return 0 if the strings are the same, 1 or -1 if not. */ static int -sb_strcmp (const struct StringBuffer *s1, - const struct StringBuffer *s2) +sb_strcmp (const struct StringBuffer *s1, const struct StringBuffer *s2) { if (s1->slen != s2->slen) return -1; @@ -640,8 +648,7 @@ sb_strcmp (const struct StringBuffer *s1, * @param nlen target length for the buffer, must be at least ret->slen */ static void -sb_realloc (struct StringBuffer *ret, - size_t nlen) +sb_realloc (struct StringBuffer *ret, size_t nlen) { char *old; @@ -649,9 +656,7 @@ sb_realloc (struct StringBuffer *ret, old = ret->abuf; ret->abuf = GNUNET_malloc (nlen); ret->blen = nlen; - GNUNET_memcpy (ret->abuf, - ret->sbuf, - ret->slen); + GNUNET_memcpy (ret->abuf, ret->sbuf, ret->slen); ret->sbuf = ret->abuf; GNUNET_free_non_null (old); } @@ -664,17 +669,14 @@ sb_realloc (struct StringBuffer *ret, * @param sarg string to append */ static void -sb_append (struct StringBuffer *ret, - const struct StringBuffer *sarg) +sb_append (struct StringBuffer *ret, const struct StringBuffer *sarg) { if (GNUNET_YES == ret->null_flag) ret->slen = 0; ret->null_flag = GNUNET_NO; if (ret->blen < sarg->slen + ret->slen) sb_realloc (ret, ret->blen + sarg->slen + 128); - GNUNET_memcpy (&ret->sbuf[ret->slen], - sarg->sbuf, - sarg->slen); + GNUNET_memcpy (&ret->sbuf[ret->slen], sarg->sbuf, sarg->slen); ret->slen += sarg->slen; } @@ -686,8 +688,7 @@ sb_append (struct StringBuffer *ret, * @param cstr string to append */ static void -sb_append_cstr (struct StringBuffer *ret, - const char *cstr) +sb_append_cstr (struct StringBuffer *ret, const char *cstr) { size_t cstr_len = strlen (cstr); @@ -696,9 +697,7 @@ sb_append_cstr (struct StringBuffer *ret, ret->null_flag = GNUNET_NO; if (ret->blen < cstr_len + ret->slen) sb_realloc (ret, ret->blen + cstr_len + 128); - GNUNET_memcpy (&ret->sbuf[ret->slen], - cstr, - cstr_len); + GNUNET_memcpy (&ret->sbuf[ret->slen], cstr, cstr_len); ret->slen += cstr_len; } @@ -714,9 +713,7 @@ sb_append_cstr (struct StringBuffer *ret, * @param extra_chars how long will the result be, in addition to 'sarg' length */ static void -sb_wrap (struct StringBuffer *ret, - const char *format, - size_t extra_chars) +sb_wrap (struct StringBuffer *ret, const char *format, size_t extra_chars) { char *temp; @@ -725,10 +722,10 @@ sb_wrap (struct StringBuffer *ret, ret->null_flag = GNUNET_NO; temp = GNUNET_malloc (ret->slen + extra_chars + 1); GNUNET_snprintf (temp, - ret->slen + extra_chars + 1, - format, - (int) ret->slen, - ret->sbuf); + ret->slen + extra_chars + 1, + format, + (int) ret->slen, + ret->sbuf); GNUNET_free_non_null (ret->abuf); ret->abuf = temp; ret->sbuf = temp; @@ -748,21 +745,16 @@ sb_wrap (struct StringBuffer *ret, */ static void sb_printf1 (struct StringBuffer *ret, - const char *format, - size_t extra_chars, - const struct StringBuffer *sarg) + const char *format, + size_t extra_chars, + const struct StringBuffer *sarg) { if (ret->blen < sarg->slen + extra_chars + 1) - sb_realloc (ret, - sarg->slen + extra_chars + 1); + sb_realloc (ret, sarg->slen + extra_chars + 1); ret->null_flag = GNUNET_NO; ret->sbuf = ret->abuf; ret->slen = sarg->slen + extra_chars; - GNUNET_snprintf (ret->sbuf, - ret->blen, - format, - (int) sarg->slen, - sarg->sbuf); + GNUNET_snprintf (ret->sbuf, ret->blen, format, (int) sarg->slen, sarg->sbuf); } @@ -777,24 +769,23 @@ sb_printf1 (struct StringBuffer *ret, */ static void sb_printf2 (struct StringBuffer *ret, - const char *format, - size_t extra_chars, - const struct StringBuffer *sarg1, - const struct StringBuffer *sarg2) + const char *format, + size_t extra_chars, + const struct StringBuffer *sarg1, + const struct StringBuffer *sarg2) { if (ret->blen < sarg1->slen + sarg2->slen + extra_chars + 1) - sb_realloc (ret, - sarg1->slen + sarg2->slen + extra_chars + 1); + sb_realloc (ret, sarg1->slen + sarg2->slen + extra_chars + 1); ret->null_flag = GNUNET_NO; ret->slen = sarg1->slen + sarg2->slen + extra_chars; ret->sbuf = ret->abuf; GNUNET_snprintf (ret->sbuf, - ret->blen, - format, - (int) sarg1->slen, - sarg1->sbuf, - (int) sarg2->slen, - sarg2->sbuf); + ret->blen, + format, + (int) sarg1->slen, + sarg1->sbuf, + (int) sarg2->slen, + sarg2->sbuf); } @@ -811,27 +802,26 @@ sb_printf2 (struct StringBuffer *ret, */ static void sb_printf3 (struct StringBuffer *ret, - const char *format, - size_t extra_chars, - const struct StringBuffer *sarg1, - const struct StringBuffer *sarg2, - const struct StringBuffer *sarg3) + const char *format, + size_t extra_chars, + const struct StringBuffer *sarg1, + const struct StringBuffer *sarg2, + const struct StringBuffer *sarg3) { if (ret->blen < sarg1->slen + sarg2->slen + sarg3->slen + extra_chars + 1) - sb_realloc (ret, - sarg1->slen + sarg2->slen + sarg3->slen + extra_chars + 1); + sb_realloc (ret, sarg1->slen + sarg2->slen + sarg3->slen + extra_chars + 1); ret->null_flag = GNUNET_NO; ret->slen = sarg1->slen + sarg2->slen + sarg3->slen + extra_chars; ret->sbuf = ret->abuf; GNUNET_snprintf (ret->sbuf, - ret->blen, - format, - (int) sarg1->slen, - sarg1->sbuf, - (int) sarg2->slen, - sarg2->sbuf, - (int) sarg3->slen, - sarg3->sbuf); + ret->blen, + format, + (int) sarg1->slen, + sarg1->sbuf, + (int) sarg2->slen, + sarg2->sbuf, + (int) sarg3->slen, + sarg3->sbuf); } @@ -844,12 +834,10 @@ sb_printf3 (struct StringBuffer *ret, static void sb_free (struct StringBuffer *sb) { - GNUNET_array_grow (sb->abuf, - sb->blen, - 0); + GNUNET_array_grow (sb->abuf, sb->blen, 0); sb->slen = 0; sb->sbuf = NULL; - sb->null_flag= GNUNET_YES; + sb->null_flag = GNUNET_YES; } @@ -860,8 +848,7 @@ sb_free (struct StringBuffer *sb) * @param out output string */ static void -sb_strdup (struct StringBuffer *out, - const struct StringBuffer *in) +sb_strdup (struct StringBuffer *out, const struct StringBuffer *in) { out->null_flag = in->null_flag; @@ -869,9 +856,7 @@ sb_strdup (struct StringBuffer *out, return; if (out->blen < in->slen) { - GNUNET_array_grow (out->abuf, - out->blen, - in->slen); + GNUNET_array_grow (out->abuf, out->blen, in->slen); } out->sbuf = out->abuf; out->slen = in->slen; @@ -886,8 +871,7 @@ sb_strdup (struct StringBuffer *out, * @param out output string */ static void -sb_strdup_cstr (struct StringBuffer *out, - const char *cstr) +sb_strdup_cstr (struct StringBuffer *out, const char *cstr) { if (NULL == cstr) { @@ -898,9 +882,7 @@ sb_strdup_cstr (struct StringBuffer *out, out->slen = strlen (cstr); if (out->blen < out->slen) { - GNUNET_array_grow (out->abuf, - out->blen, - out->slen); + GNUNET_array_grow (out->abuf, out->blen, out->slen); } out->sbuf = out->abuf; GNUNET_memcpy (out->sbuf, cstr, out->slen); @@ -942,8 +924,7 @@ needs_parentheses (const struct StringBuffer *str) return GNUNET_YES; } /* while '(' before ')', count opening parens */ - while ( (NULL != (op = memchr (pos, '(', end - pos))) && - (op < cl) ) + while ((NULL != (op = memchr (pos, '(', end - pos))) && (op < cl)) { cnt++; pos = op + 1; @@ -979,10 +960,8 @@ remove_parentheses (struct StringBuffer *str) if (0) return; sbuf = str->sbuf; - if ( (GNUNET_YES == str->null_flag) || - (1 >= (slen = str->slen)) || - ('(' != str->sbuf[0]) || - (')' != str->sbuf[slen - 1]) ) + if ((GNUNET_YES == str->null_flag) || (1 >= (slen = str->slen)) || + ('(' != str->sbuf[0]) || (')' != str->sbuf[slen - 1])) return; cnt = 0; pos = &sbuf[1]; @@ -991,19 +970,16 @@ remove_parentheses (struct StringBuffer *str) cp = memchr (pos, ')', end - pos); while (NULL != cp) { - while ( (NULL != op) && - (op < cp) ) + while ((NULL != op) && (op < cp)) { cnt++; pos = op + 1; op = memchr (pos, '(', end - pos); } - while ( (NULL != cp) && - ( (NULL == op) || - (cp < op) ) ) + while ((NULL != cp) && ((NULL == op) || (cp < op))) { if (0 == cnt) - return; /* can't strip parens */ + return; /* can't strip parens */ cnt--; pos = cp + 1; cp = memchr (pos, ')', end - pos); @@ -1030,12 +1006,9 @@ remove_parentheses (struct StringBuffer *str) static int has_epsilon (const struct StringBuffer *str) { - return - (GNUNET_YES != str->null_flag) && - (0 < str->slen) && - ('(' == str->sbuf[0]) && - ('|' == str->sbuf[1]) && - (')' == str->sbuf[str->slen - 1]); + return (GNUNET_YES != str->null_flag) && (0 < str->slen) && + ('(' == str->sbuf[0]) && ('|' == str->sbuf[1]) && + (')' == str->sbuf[str->slen - 1]); } @@ -1049,25 +1022,20 @@ has_epsilon (const struct StringBuffer *str) * epsilon could be found, NULL if 'str' was NULL */ static void -remove_epsilon (const struct StringBuffer *str, - struct StringBuffer *ret) +remove_epsilon (const struct StringBuffer *str, struct StringBuffer *ret) { if (GNUNET_YES == str->null_flag) { ret->null_flag = GNUNET_YES; return; } - if ( (str->slen > 1) && - ('(' == str->sbuf[0]) && - ('|' == str->sbuf[1]) && - (')' == str->sbuf[str->slen - 1]) ) + if ((str->slen > 1) && ('(' == str->sbuf[0]) && ('|' == str->sbuf[1]) && + (')' == str->sbuf[str->slen - 1])) { /* remove epsilon */ if (ret->blen < str->slen - 3) { - GNUNET_array_grow (ret->abuf, - ret->blen, - str->slen - 3); + GNUNET_array_grow (ret->abuf, ret->blen, str->slen - 3); } ret->sbuf = ret->abuf; ret->slen = str->slen - 3; @@ -1089,13 +1057,12 @@ remove_epsilon (const struct StringBuffer *str, */ static int sb_strncmp (const struct StringBuffer *str1, - const struct StringBuffer *str2, size_t n) + const struct StringBuffer *str2, + size_t n) { size_t max; - if ( (str1->slen != str2->slen) && - ( (str1->slen < n) || - (str2->slen < n) ) ) + if ((str1->slen != str2->slen) && ((str1->slen < n) || (str2->slen < n))) return -1; max = GNUNET_MAX (str1->slen, str2->slen); if (max > n) @@ -1114,8 +1081,7 @@ sb_strncmp (const struct StringBuffer *str1, * @return -1 if any of the strings is NULL, 0 if equal, non 0 otherwise */ static int -sb_strncmp_cstr (const struct StringBuffer *str1, - const char *str2, size_t n) +sb_strncmp_cstr (const struct StringBuffer *str1, const char *str2, size_t n) { if (str1->slen < n) return -1; @@ -1131,8 +1097,7 @@ sb_strncmp_cstr (const struct StringBuffer *str1, * @param n desired target length */ static void -sb_init (struct StringBuffer *sb, - size_t n) +sb_init (struct StringBuffer *sb, size_t n) { sb->null_flag = GNUNET_NO; sb->abuf = sb->sbuf = (0 == n) ? NULL : GNUNET_malloc (n); @@ -1152,12 +1117,11 @@ sb_init (struct StringBuffer *sb, */ static int sb_strkcmp (const struct StringBuffer *str1, - const struct StringBuffer *str2, size_t k) + const struct StringBuffer *str2, + size_t k) { - if ( (GNUNET_YES == str1->null_flag) || - (GNUNET_YES == str2->null_flag) || - (k > str1->slen) || - (str1->slen - k != str2->slen) ) + if ((GNUNET_YES == str1->null_flag) || (GNUNET_YES == str2->null_flag) || + (k > str1->slen) || (str1->slen - k != str2->slen)) return -1; return memcmp (&str1->sbuf[k], str2->sbuf, str2->slen); } @@ -1172,7 +1136,8 @@ sb_strkcmp (const struct StringBuffer *str1, * @param s current state. */ static void -number_states (void *cls, const unsigned int count, +number_states (void *cls, + const unsigned int count, struct REGEX_INTERNAL_State *s) { struct REGEX_INTERNAL_State **states = cls; @@ -1183,10 +1148,9 @@ number_states (void *cls, const unsigned int count, } - -#define PRIS(a) \ +#define PRIS(a) \ ((GNUNET_YES == a.null_flag) ? 6 : (int) a.slen), \ - ((GNUNET_YES == a.null_flag) ? "(null)" : a.sbuf) + ((GNUNET_YES == a.null_flag) ? "(null)" : a.sbuf) /** @@ -1205,12 +1169,12 @@ number_states (void *cls, const unsigned int count, */ static void automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, - const struct StringBuffer *R_last_ik, + const struct StringBuffer *R_last_ik, const struct StringBuffer *R_last_kk, - const struct StringBuffer *R_last_kj, + const struct StringBuffer *R_last_kj, struct StringBuffer *R_cur_ij, - struct StringBuffer *R_cur_l, - struct StringBuffer *R_cur_r) + struct StringBuffer *R_cur_l, + struct StringBuffer *R_cur_r) { struct StringBuffer R_temp_ij; struct StringBuffer R_temp_ik; @@ -1235,9 +1199,9 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, * R_cur_r == R^{(k-1)}_{ik} ( R^{(k-1)}_{kk} )^* R^{(k-1)}_{kj} */ - if ( (GNUNET_YES == R_last_ij->null_flag) && - ( (GNUNET_YES == R_last_ik->null_flag) || - (GNUNET_YES == R_last_kj->null_flag))) + if ((GNUNET_YES == R_last_ij->null_flag) && + ((GNUNET_YES == R_last_ik->null_flag) || + (GNUNET_YES == R_last_kj->null_flag))) { /* R^{(k)}_{ij} = N | N */ R_cur_ij->null_flag = GNUNET_YES; @@ -1245,8 +1209,8 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, return; } - if ( (GNUNET_YES == R_last_ik->null_flag) || - (GNUNET_YES == R_last_kj->null_flag) ) + if ((GNUNET_YES == R_last_ik->null_flag) || + (GNUNET_YES == R_last_kj->null_flag)) { /* R^{(k)}_{ij} = R^{(k-1)}_{ij} | N */ if (GNUNET_YES == R_last_ij->synced) @@ -1299,9 +1263,9 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, remove_epsilon (R_last_ij, &R_temp_ij); remove_parentheses (&R_temp_ij); - if ( (0 == sb_strcmp (&R_temp_ij, &R_temp_ik)) && - (0 == sb_strcmp (&R_temp_ik, &R_temp_kk)) && - (0 == sb_strcmp (&R_temp_kk, &R_temp_kj)) ) + if ((0 == sb_strcmp (&R_temp_ij, &R_temp_ik)) && + (0 == sb_strcmp (&R_temp_ik, &R_temp_kk)) && + (0 == sb_strcmp (&R_temp_kk, &R_temp_kj))) { if (0 == R_temp_ij.slen) { @@ -1340,7 +1304,8 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, sb_printf1 (R_cur_r, "%.*s+", 1, &R_temp_ij); } } - else if ( (0 == ij_ik_cmp) && (0 == clean_kk_kj_cmp) && (0 != clean_ik_kk_cmp) ) + else if ((0 == ij_ik_cmp) && (0 == clean_kk_kj_cmp) && + (0 != clean_ik_kk_cmp)) { /* a|ab*b = ab* */ if (0 == R_last_kk->slen) @@ -1351,7 +1316,8 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, sb_printf2 (R_cur_r, "%.*s%.*s*", 1, R_last_ij, R_last_kk); R_cur_l->null_flag = GNUNET_YES; } - else if ( (0 == ij_kj_cmp) && (0 == clean_ik_kk_cmp) && (0 != clean_kk_kj_cmp)) + else if ((0 == ij_kj_cmp) && (0 == clean_ik_kk_cmp) && + (0 != clean_kk_kj_cmp)) { /* a|bb*a = b*a */ if (R_last_kk->slen < 1) @@ -1365,8 +1331,8 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, R_cur_l->null_flag = GNUNET_YES; } - else if ( (0 == ij_ik_cmp) && (0 == kk_kj_cmp) && (! has_epsilon (R_last_ij)) && - has_epsilon (R_last_kk)) + else if ((0 == ij_ik_cmp) && (0 == kk_kj_cmp) && + (! has_epsilon (R_last_ij)) && has_epsilon (R_last_kk)) { /* a|a(e|b)*(e|b) = a|ab* = a|a|ab|abb|abbb|... = ab* */ if (needs_parentheses (&R_temp_kk)) @@ -1375,8 +1341,8 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, sb_printf2 (R_cur_r, "%.*s%.*s*", 1, R_last_ij, &R_temp_kk); R_cur_l->null_flag = GNUNET_YES; } - else if ( (0 == ij_kj_cmp) && (0 == ik_kk_cmp) && (! has_epsilon (R_last_ij)) && - has_epsilon (R_last_kk)) + else if ((0 == ij_kj_cmp) && (0 == ik_kk_cmp) && + (! has_epsilon (R_last_ij)) && has_epsilon (R_last_kk)) { /* a|(e|b)(e|b)*a = a|b*a = a|a|ba|bba|bbba|... = b*a */ if (needs_parentheses (&R_temp_kk)) @@ -1403,15 +1369,12 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, length = R_temp_kk.slen - R_last_ik->slen; /* a(ba)*bx = (ab)+x */ - if ( (length > 0) && - (GNUNET_YES != R_last_kk->null_flag) && - (0 < R_last_kk->slen) && - (GNUNET_YES != R_last_kj->null_flag) && - (0 < R_last_kj->slen) && - (GNUNET_YES != R_last_ik->null_flag) && - (0 < R_last_ik->slen) && - (0 == sb_strkcmp (&R_temp_kk, R_last_ik, length)) && - (0 == sb_strncmp (&R_temp_kk, R_last_kj, length)) ) + if ((length > 0) && (GNUNET_YES != R_last_kk->null_flag) && + (0 < R_last_kk->slen) && (GNUNET_YES != R_last_kj->null_flag) && + (0 < R_last_kj->slen) && (GNUNET_YES != R_last_ik->null_flag) && + (0 < R_last_ik->slen) && + (0 == sb_strkcmp (&R_temp_kk, R_last_ik, length)) && + (0 == sb_strncmp (&R_temp_kk, R_last_kj, length))) { struct StringBuffer temp_a; struct StringBuffer temp_b; @@ -1430,9 +1393,8 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, temp_b.slen = length_r; /* e|(ab)+ = (ab)* */ - if ( (GNUNET_YES != R_cur_l->null_flag) && - (0 == R_cur_l->slen) && - (0 == temp_b.slen) ) + if ((GNUNET_YES != R_cur_l->null_flag) && (0 == R_cur_l->slen) && + (0 == temp_b.slen)) { sb_printf2 (R_cur_r, "(%.*s%.*s)*", 3, R_last_ik, &temp_a); sb_free (R_cur_l); @@ -1460,9 +1422,8 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, sb_printf1 (R_cur_r, "%.*s*", 1, &R_temp_kk); } /* aa*a = a+a */ - else if ( (0 == clean_ik_kk_cmp) && - (0 == clean_kk_kj_cmp) && - (! has_epsilon (R_last_ik)) ) + else if ((0 == clean_ik_kk_cmp) && (0 == clean_kk_kj_cmp) && + (! has_epsilon (R_last_ik))) { if (needs_parentheses (&R_temp_kk)) sb_printf2 (R_cur_r, "(%.*s)+%.*s", 3, &R_temp_kk, &R_temp_kk); @@ -1477,9 +1438,8 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, */ else { - eps_check = - (has_epsilon (R_last_ik) + has_epsilon (R_last_kk) + - has_epsilon (R_last_kj)); + eps_check = (has_epsilon (R_last_ik) + has_epsilon (R_last_kk) + + has_epsilon (R_last_kj)); if (1 == eps_check) { @@ -1538,18 +1498,26 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, { if (needs_parentheses (&R_temp_kk)) { - sb_printf3 (R_cur_r, "%.*s(%.*s)*%.*s", 3, R_last_ik, &R_temp_kk, - R_last_kj); + sb_printf3 (R_cur_r, + "%.*s(%.*s)*%.*s", + 3, + R_last_ik, + &R_temp_kk, + R_last_kj); } else { - sb_printf3 (R_cur_r, "%.*s%.*s*%.*s", 1, R_last_ik, &R_temp_kk, - R_last_kj); + sb_printf3 (R_cur_r, + "%.*s%.*s*%.*s", + 1, + R_last_ik, + &R_temp_kk, + R_last_kj); } } else { - sb_printf2 (R_cur_r, "%.*s%.*s", 0, R_last_ik, R_last_kj); + sb_printf2 (R_cur_r, "%.*s%.*s", 0, R_last_ik, R_last_kj); } } } @@ -1558,15 +1526,13 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, sb_free (&R_temp_kk); sb_free (&R_temp_kj); - if ( (GNUNET_YES == R_cur_l->null_flag) && - (GNUNET_YES == R_cur_r->null_flag) ) + if ((GNUNET_YES == R_cur_l->null_flag) && (GNUNET_YES == R_cur_r->null_flag)) { R_cur_ij->null_flag = GNUNET_YES; return; } - if ( (GNUNET_YES != R_cur_l->null_flag) && - (GNUNET_YES == R_cur_r->null_flag) ) + if ((GNUNET_YES != R_cur_l->null_flag) && (GNUNET_YES == R_cur_r->null_flag)) { struct StringBuffer tmp; @@ -1576,8 +1542,7 @@ automaton_create_proofs_simplify (const struct StringBuffer *R_last_ij, return; } - if ( (GNUNET_YES == R_cur_l->null_flag) && - (GNUNET_YES != R_cur_r->null_flag) ) + if ((GNUNET_YES == R_cur_l->null_flag) && (GNUNET_YES != R_cur_r->null_flag)) { struct StringBuffer tmp; @@ -1629,8 +1594,7 @@ automaton_create_proofs (struct REGEX_INTERNAL_Automaton *a) R_last = GNUNET_malloc_large (sizeof (struct StringBuffer) * n * n); R_cur = GNUNET_malloc_large (sizeof (struct StringBuffer) * n * n); - if ( (NULL == R_last) || - (NULL == R_cur) ) + if ((NULL == R_last) || (NULL == R_cur)) { GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "malloc"); GNUNET_free_non_null (R_cur); @@ -1639,14 +1603,18 @@ automaton_create_proofs (struct REGEX_INTERNAL_Automaton *a) } /* create depth-first numbering of the states, initializes 'state' */ - REGEX_INTERNAL_automaton_traverse (a, a->start, NULL, NULL, &number_states, - states); + REGEX_INTERNAL_automaton_traverse (a, + a->start, + NULL, + NULL, + &number_states, + states); for (i = 0; i < n; i++) GNUNET_assert (NULL != states[i]); for (i = 0; i < n; i++) for (j = 0; j < n; j++) - R_last[i *n + j].null_flag = GNUNET_YES; + R_last[i * n + j].null_flag = GNUNET_YES; /* Compute regular expressions of length "1" between each pair of states */ for (i = 0; i < n; i++) @@ -1660,8 +1628,8 @@ automaton_create_proofs (struct REGEX_INTERNAL_Automaton *a) } else { - sb_append_cstr (&R_last[i * n + j], "|"); - sb_append_cstr (&R_last[i * n + j], t->label); + sb_append_cstr (&R_last[i * n + j], "|"); + sb_append_cstr (&R_last[i * n + j], t->label); } } /* add self-loop: i is reachable from i via epsilon-transition */ @@ -1695,10 +1663,13 @@ automaton_create_proofs (struct REGEX_INTERNAL_Automaton *a) */ /* Create R_cur[i][j] and simplify the expression */ - automaton_create_proofs_simplify (&R_last[i * n + j], &R_last[i * n + k], - &R_last[k * n + k], &R_last[k * n + j], + automaton_create_proofs_simplify (&R_last[i * n + j], + &R_last[i * n + k], + &R_last[k * n + k], + &R_last[k * n + j], &R_cur[i * n + j], - &R_cur_l, &R_cur_r); + &R_cur_l, + &R_cur_r); } } /* set R_last = R_cur */ @@ -1718,8 +1689,9 @@ automaton_create_proofs (struct REGEX_INTERNAL_Automaton *a) if (GNUNET_YES != R_last[a->start->dfs_id * n + i].null_flag) { states[i]->proof = GNUNET_strndup (R_last[a->start->dfs_id * n + i].sbuf, - R_last[a->start->dfs_id * n + i].slen); - GNUNET_CRYPTO_hash (states[i]->proof, strlen (states[i]->proof), + R_last[a->start->dfs_id * n + i].slen); + GNUNET_CRYPTO_hash (states[i]->proof, + strlen (states[i]->proof), &states[i]->hash); } } @@ -1731,22 +1703,21 @@ automaton_create_proofs (struct REGEX_INTERNAL_Automaton *a) { if (states[i]->accepting) { - if ( (0 == complete_regex.slen) && - (0 < R_last[a->start->dfs_id * n + i].slen) ) + if ((0 == complete_regex.slen) && + (0 < R_last[a->start->dfs_id * n + i].slen)) { - sb_append (&complete_regex, - &R_last[a->start->dfs_id * n + i]); + sb_append (&complete_regex, &R_last[a->start->dfs_id * n + i]); } - else if ( (GNUNET_YES != R_last[a->start->dfs_id * n + i].null_flag) && - (0 < R_last[a->start->dfs_id * n + i].slen) ) + else if ((GNUNET_YES != R_last[a->start->dfs_id * n + i].null_flag) && + (0 < R_last[a->start->dfs_id * n + i].slen)) { - sb_append_cstr (&complete_regex, "|"); - sb_append (&complete_regex, - &R_last[a->start->dfs_id * n + i]); + sb_append_cstr (&complete_regex, "|"); + sb_append (&complete_regex, &R_last[a->start->dfs_id * n + i]); } } } - a->canonical_regex = GNUNET_strndup (complete_regex.sbuf, complete_regex.slen); + a->canonical_regex = + GNUNET_strndup (complete_regex.sbuf, complete_regex.slen); /* cleanup */ sb_free (&complete_regex); @@ -1807,10 +1778,7 @@ dfa_state_create (struct REGEX_INTERNAL_Context *ctx, for (i = 0; i < nfa_states->off; i++) { cstate = nfa_states->states[i]; - GNUNET_snprintf (pos, - pos - s->name + len, - "%i,", - cstate->id); + GNUNET_snprintf (pos, pos - s->name + len, "%i,", cstate->id); pos += strlen (pos); /* Add a transition for each distinct label to NULL state */ @@ -1911,7 +1879,12 @@ dfa_remove_unreachable_states (struct REGEX_INTERNAL_Automaton *a) s->marked = GNUNET_NO; /* 2. traverse dfa from start state and mark all visited states */ - REGEX_INTERNAL_automaton_traverse (a, a->start, NULL, NULL, &mark_states, NULL); + REGEX_INTERNAL_automaton_traverse (a, + a->start, + NULL, + NULL, + &mark_states, + NULL); /* 3. delete all states that were not visited */ for (s = a->states_head; NULL != s; s = s_next) @@ -1990,7 +1963,7 @@ dfa_merge_nondistinguishable_states (struct REGEX_INTERNAL_Context *ctx, unsigned long long idx; unsigned long long idx1; - if ( (NULL == a) || (0 == a->state_count) ) + if ((NULL == a) || (0 == a->state_count)) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not merge nondistinguishable states, automaton was NULL.\n"); @@ -1998,7 +1971,8 @@ dfa_merge_nondistinguishable_states (struct REGEX_INTERNAL_Context *ctx, } state_cnt = a->state_count; - table = GNUNET_malloc_large ((sizeof (uint32_t) * state_cnt * state_cnt / 32) + sizeof (uint32_t)); + table = GNUNET_malloc_large ( + (sizeof (uint32_t) * state_cnt * state_cnt / 32) + sizeof (uint32_t)); if (NULL == table) { GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "malloc"); @@ -2011,10 +1985,10 @@ dfa_merge_nondistinguishable_states (struct REGEX_INTERNAL_Context *ctx, /* Mark all pairs of accepting/!accepting states */ for (s1 = a->states_head; NULL != s1; s1 = s1->next) for (s2 = a->states_head; NULL != s2; s2 = s2->next) - if ( (s1->accepting && !s2->accepting) || - (!s1->accepting && s2->accepting) ) + if ((s1->accepting && ! s2->accepting) || + (! s1->accepting && s2->accepting)) { - idx = (unsigned long long) s1->marked * state_cnt + s2->marked; + idx = (unsigned long long) s1->marked * state_cnt + s2->marked; table[idx / 32] |= (1U << (idx % 32)); } @@ -2027,7 +2001,7 @@ dfa_merge_nondistinguishable_states (struct REGEX_INTERNAL_Context *ctx, { for (s2 = a->states_head; NULL != s2 && s1 != s2; s2 = s2->next) { - idx = (unsigned long long) s1->marked * state_cnt + s2->marked; + idx = (unsigned long long) s1->marked * state_cnt + s2->marked; if (0 != (table[idx / 32] & (1U << (idx % 32)))) continue; num_equal_edges = 0; @@ -2036,28 +2010,30 @@ dfa_merge_nondistinguishable_states (struct REGEX_INTERNAL_Context *ctx, for (t2 = s2->transitions_head; NULL != t2; t2 = t2->next) { if (0 == strcmp (t1->label, t2->label)) - { - num_equal_edges++; - /* same edge, but targets definitively different, so we're different + { + num_equal_edges++; + /* same edge, but targets definitively different, so we're different as well */ - if (t1->to_state->marked > t2->to_state->marked) - idx1 = (unsigned long long) t1->to_state->marked * state_cnt + t2->to_state->marked; - else - idx1 = (unsigned long long) t2->to_state->marked * state_cnt + t1->to_state->marked; - if (0 != (table[idx1 / 32] & (1U << (idx1 % 32)))) - { - table[idx / 32] |= (1U << (idx % 32)); - change = 1; /* changed a marker, need to run again */ - } - } - } + if (t1->to_state->marked > t2->to_state->marked) + idx1 = (unsigned long long) t1->to_state->marked * state_cnt + + t2->to_state->marked; + else + idx1 = (unsigned long long) t2->to_state->marked * state_cnt + + t1->to_state->marked; + if (0 != (table[idx1 / 32] & (1U << (idx1 % 32)))) + { + table[idx / 32] |= (1U << (idx % 32)); + change = 1; /* changed a marker, need to run again */ + } + } + } } - if ( (num_equal_edges != s1->transition_count) || - (num_equal_edges != s2->transition_count) ) + if ((num_equal_edges != s1->transition_count) || + (num_equal_edges != s2->transition_count)) { /* Make sure ALL edges of possible equal states are the same */ - table[idx / 32] |= (1U << (idx % 32)); - change = 1; /* changed a marker, need to run again */ + table[idx / 32] |= (1U << (idx % 32)); + change = 1; /* changed a marker, need to run again */ } } } @@ -2145,7 +2121,9 @@ struct REGEX_INTERNAL_Strided_Context * @param s current state in the depth-first traversal */ static void -dfa_add_multi_strides_helper (void *cls, const unsigned int depth, char *label, +dfa_add_multi_strides_helper (void *cls, + const unsigned int depth, + char *label, struct REGEX_INTERNAL_State *start, struct REGEX_INTERNAL_State *s) { @@ -2159,7 +2137,8 @@ dfa_add_multi_strides_helper (void *cls, const unsigned int depth, char *label, t->label = GNUNET_strdup (label); t->to_state = s; t->from_state = start; - GNUNET_CONTAINER_DLL_insert (ctx->transitions_head, ctx->transitions_tail, + GNUNET_CONTAINER_DLL_insert (ctx->transitions_head, + ctx->transitions_tail, t); } else @@ -2178,7 +2157,10 @@ dfa_add_multi_strides_helper (void *cls, const unsigned int depth, char *label, else new_label = GNUNET_strdup (t->label); - dfa_add_multi_strides_helper (cls, (depth + 1), new_label, start, + dfa_add_multi_strides_helper (cls, + (depth + 1), + new_label, + start, t->to_state); } } @@ -2195,7 +2177,8 @@ dfa_add_multi_strides_helper (void *cls, const unsigned int depth, char *label, * @param s current state. */ static void -dfa_add_multi_strides (void *cls, const unsigned int count, +dfa_add_multi_strides (void *cls, + const unsigned int count, struct REGEX_INTERNAL_State *s) { dfa_add_multi_strides_helper (cls, 0, NULL, s, s); @@ -2211,10 +2194,10 @@ dfa_add_multi_strides (void *cls, const unsigned int count, */ void REGEX_INTERNAL_dfa_add_multi_strides (struct REGEX_INTERNAL_Context *regex_ctx, - struct REGEX_INTERNAL_Automaton *dfa, - const unsigned int stride_len) + struct REGEX_INTERNAL_Automaton *dfa, + const unsigned int stride_len) { - struct REGEX_INTERNAL_Strided_Context ctx = { stride_len, NULL, NULL }; + struct REGEX_INTERNAL_Strided_Context ctx = {stride_len, NULL, NULL}; struct REGEX_INTERNAL_Transition *t; struct REGEX_INTERNAL_Transition *t_next; @@ -2222,8 +2205,12 @@ REGEX_INTERNAL_dfa_add_multi_strides (struct REGEX_INTERNAL_Context *regex_ctx, return; /* Compute the new transitions of given stride_len */ - REGEX_INTERNAL_automaton_traverse (dfa, dfa->start, NULL, NULL, - &dfa_add_multi_strides, &ctx); + REGEX_INTERNAL_automaton_traverse (dfa, + dfa->start, + NULL, + NULL, + &dfa_add_multi_strides, + &ctx); /* Add all the new transitions to the automaton. */ for (t = ctx.transitions_head; NULL != t; t = t_next) @@ -2255,7 +2242,8 @@ REGEX_INTERNAL_dfa_add_multi_strides (struct REGEX_INTERNAL_Context *regex_ctx, void dfa_compress_paths_helper (struct REGEX_INTERNAL_Automaton *dfa, struct REGEX_INTERNAL_State *start, - struct REGEX_INTERNAL_State *cur, char *label, + struct REGEX_INTERNAL_State *cur, + char *label, unsigned int max_len, struct REGEX_INTERNAL_Transition **transitions_head, struct REGEX_INTERNAL_Transition **transitions_tail) @@ -2266,8 +2254,8 @@ dfa_compress_paths_helper (struct REGEX_INTERNAL_Automaton *dfa, if (NULL != label && ((cur->incoming_transition_count > 1 || GNUNET_YES == cur->accepting || - GNUNET_YES == cur->marked) || (start != dfa->start && max_len > 0 && - max_len == strlen (label)) || + GNUNET_YES == cur->marked) || + (start != dfa->start && max_len > 0 && max_len == strlen (label)) || (start == dfa->start && GNUNET_REGEX_INITIAL_BYTES == strlen (label)))) { t = GNUNET_new (struct REGEX_INTERNAL_Transition); @@ -2278,7 +2266,12 @@ dfa_compress_paths_helper (struct REGEX_INTERNAL_Automaton *dfa, if (GNUNET_NO == cur->marked) { - dfa_compress_paths_helper (dfa, cur, cur, NULL, max_len, transitions_head, + dfa_compress_paths_helper (dfa, + cur, + cur, + NULL, + max_len, + transitions_head, transitions_tail); } return; @@ -2301,8 +2294,13 @@ dfa_compress_paths_helper (struct REGEX_INTERNAL_Automaton *dfa, if (t->to_state != cur) { - dfa_compress_paths_helper (dfa, start, t->to_state, new_label, max_len, - transitions_head, transitions_tail); + dfa_compress_paths_helper (dfa, + start, + t->to_state, + new_label, + max_len, + transitions_head, + transitions_tail); } GNUNET_free (new_label); } @@ -2319,7 +2317,8 @@ dfa_compress_paths_helper (struct REGEX_INTERNAL_Automaton *dfa, */ static void dfa_compress_paths (struct REGEX_INTERNAL_Context *regex_ctx, - struct REGEX_INTERNAL_Automaton *dfa, unsigned int max_len) + struct REGEX_INTERNAL_Automaton *dfa, + unsigned int max_len) { struct REGEX_INTERNAL_State *s; struct REGEX_INTERNAL_State *s_next; @@ -2349,8 +2348,13 @@ dfa_compress_paths (struct REGEX_INTERNAL_Context *regex_ctx, } /* Add strides and mark states that can be deleted. */ - dfa_compress_paths_helper (dfa, dfa->start, dfa->start, NULL, max_len, - &transitions_head, &transitions_tail); + dfa_compress_paths_helper (dfa, + dfa->start, + dfa->start, + NULL, + max_len, + &transitions_head, + &transitions_tail); /* Add all the new transitions to the automaton. */ for (t = transitions_head; NULL != t; t = t_next) @@ -2486,8 +2490,9 @@ nfa_state_create (struct REGEX_INTERNAL_Context *ctx, int accepting) */ static void nfa_closure_set_create (struct REGEX_INTERNAL_StateSet *ret, - struct REGEX_INTERNAL_Automaton *nfa, - struct REGEX_INTERNAL_StateSet *states, const char *label) + struct REGEX_INTERNAL_Automaton *nfa, + struct REGEX_INTERNAL_StateSet *states, + const char *label) { struct REGEX_INTERNAL_State *s; unsigned int i; @@ -2516,23 +2521,27 @@ nfa_closure_set_create (struct REGEX_INTERNAL_StateSet *ret, while (NULL != (currentstate = cls_stack.tail)) { - GNUNET_CONTAINER_MDLL_remove (ST, cls_stack.head, cls_stack.tail, - currentstate); + GNUNET_CONTAINER_MDLL_remove (ST, + cls_stack.head, + cls_stack.tail, + currentstate); cls_stack.len--; for (ctran = currentstate->transitions_head; NULL != ctran; - ctran = ctran->next) + ctran = ctran->next) { - if (NULL == (clsstate = ctran->to_state)) - continue; - if (0 != clsstate->contained) - continue; - if (0 != nullstrcmp (label, ctran->label)) - continue; - state_set_append (ret, clsstate); - GNUNET_CONTAINER_MDLL_insert_tail (ST, cls_stack.head, cls_stack.tail, - clsstate); - cls_stack.len++; - clsstate->contained = 1; + if (NULL == (clsstate = ctran->to_state)) + continue; + if (0 != clsstate->contained) + continue; + if (0 != nullstrcmp (label, ctran->label)) + continue; + state_set_append (ret, clsstate); + GNUNET_CONTAINER_MDLL_insert_tail (ST, + cls_stack.head, + cls_stack.tail, + clsstate); + cls_stack.len++; + clsstate->contained = 1; } } } @@ -2540,7 +2549,9 @@ nfa_closure_set_create (struct REGEX_INTERNAL_StateSet *ret, ret->states[i]->contained = 0; if (ret->off > 1) - qsort (ret->states, ret->off, sizeof (struct REGEX_INTERNAL_State *), + qsort (ret->states, + ret->off, + sizeof (struct REGEX_INTERNAL_State *), &state_compare); } @@ -2598,8 +2609,9 @@ nfa_add_star_op (struct REGEX_INTERNAL_Context *ctx) if (NULL == a) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "nfa_add_star_op failed, because there was no element on the stack"); + GNUNET_log ( + GNUNET_ERROR_TYPE_ERROR, + "nfa_add_star_op failed, because there was no element on the stack"); return; } @@ -2638,8 +2650,9 @@ nfa_add_plus_op (struct REGEX_INTERNAL_Context *ctx) if (NULL == a) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "nfa_add_plus_op failed, because there was no element on the stack"); + GNUNET_log ( + GNUNET_ERROR_TYPE_ERROR, + "nfa_add_plus_op failed, because there was no element on the stack"); return; } @@ -2667,8 +2680,9 @@ nfa_add_question_op (struct REGEX_INTERNAL_Context *ctx) a = ctx->stack_tail; if (NULL == a) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "nfa_add_question_op failed, because there was no element on the stack"); + GNUNET_log ( + GNUNET_ERROR_TYPE_ERROR, + "nfa_add_question_op failed, because there was no element on the stack"); return; } @@ -2803,7 +2817,7 @@ REGEX_INTERNAL_construct_nfa (const char *regex, const size_t len) { int altcount; int atomcount; - } *p; + } * p; if (NULL == regex || 0 == strlen (regex) || 0 == len) { @@ -2935,7 +2949,12 @@ REGEX_INTERNAL_construct_nfa (const char *regex, const size_t len) nfa->regex = GNUNET_strdup (regex); /* create depth-first numbering of the states for pretty printing */ - REGEX_INTERNAL_automaton_traverse (nfa, NULL, NULL, NULL, &number_states, NULL); + REGEX_INTERNAL_automaton_traverse (nfa, + NULL, + NULL, + NULL, + &number_states, + NULL); /* No multistriding added so far */ nfa->is_multistrided = GNUNET_NO; @@ -2997,7 +3016,7 @@ construct_dfa_states (struct REGEX_INTERNAL_Context *ctx, if (0 == state_set_compare (&state_iter->nfa_set, &nfa_set)) { state_contains = state_iter; - break; + break; } } if (NULL == state_contains) @@ -3034,7 +3053,8 @@ construct_dfa_states (struct REGEX_INTERNAL_Context *ctx, * @return DFA, needs to be freed using REGEX_INTERNAL_automaton_destroy. */ struct REGEX_INTERNAL_Automaton * -REGEX_INTERNAL_construct_dfa (const char *regex, const size_t len, +REGEX_INTERNAL_construct_dfa (const char *regex, + const size_t len, unsigned int max_path_len) { struct REGEX_INTERNAL_Context ctx; @@ -3130,8 +3150,7 @@ REGEX_INTERNAL_automaton_destroy (struct REGEX_INTERNAL_Automaton *a) * @return 0 if string matches, non-0 otherwise */ static int -evaluate_dfa (struct REGEX_INTERNAL_Automaton *a, - const char *string) +evaluate_dfa (struct REGEX_INTERNAL_Automaton *a, const char *string) { const char *strp; struct REGEX_INTERNAL_State *s; @@ -3173,8 +3192,7 @@ evaluate_dfa (struct REGEX_INTERNAL_Automaton *a, * @return 0 if string matches, non-0 otherwise */ static int -evaluate_nfa (struct REGEX_INTERNAL_Automaton *a, - const char *string) +evaluate_nfa (struct REGEX_INTERNAL_Automaton *a, const char *string) { const char *strp; char str[2]; @@ -3215,7 +3233,7 @@ evaluate_nfa (struct REGEX_INTERNAL_Automaton *a, for (i = 0; i < sset.off; i++) { s = sset.states[i]; - if ( (NULL != s) && (s->accepting) ) + if ((NULL != s) && (s->accepting)) { result = 0; break; @@ -3235,8 +3253,7 @@ evaluate_nfa (struct REGEX_INTERNAL_Automaton *a, * @return 0 if string matches, non-0 otherwise */ int -REGEX_INTERNAL_eval (struct REGEX_INTERNAL_Automaton *a, - const char *string) +REGEX_INTERNAL_eval (struct REGEX_INTERNAL_Automaton *a, const char *string) { int result; @@ -3321,12 +3338,11 @@ REGEX_INTERNAL_get_first_key (const char *input_string, { size_t size; - size = string_len < GNUNET_REGEX_INITIAL_BYTES ? string_len : - GNUNET_REGEX_INITIAL_BYTES; + size = string_len < GNUNET_REGEX_INITIAL_BYTES ? string_len + : GNUNET_REGEX_INITIAL_BYTES; if (NULL == input_string) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Given input string was NULL!\n"); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Given input string was NULL!\n"); return 0; } GNUNET_CRYPTO_hash (input_string, size, key); @@ -3367,21 +3383,16 @@ iterate_initial_edge (unsigned int min_len, else cur_len = 0; - if ( ( (cur_len >= min_len) || - (GNUNET_YES == state->accepting) ) && - (cur_len > 0) && - (NULL != consumed_string) ) + if (((cur_len >= min_len) || (GNUNET_YES == state->accepting)) && + (cur_len > 0) && (NULL != consumed_string)) { if (cur_len <= max_len) { - if ( (NULL != state->proof) && - (0 != strcmp (consumed_string, - state->proof)) ) + if ((NULL != state->proof) && + (0 != strcmp (consumed_string, state->proof))) { (void) state_get_edges (state, edges); - GNUNET_CRYPTO_hash (consumed_string, - strlen (consumed_string), - &hash); + GNUNET_CRYPTO_hash (consumed_string, strlen (consumed_string), &hash); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Start state for string `%s' is %s\n", consumed_string, @@ -3390,13 +3401,12 @@ iterate_initial_edge (unsigned int min_len, &hash, consumed_string, state->accepting, - num_edges, edges); + num_edges, + edges); } - if ( (GNUNET_YES == state->accepting) && - (cur_len > 1) && - (state->transition_count < 1) && - (cur_len < max_len) ) + if ((GNUNET_YES == state->accepting) && (cur_len > 1) && + (state->transition_count < 1) && (cur_len < max_len)) { /* Special case for regex consisting of just a string that is shorter than * max_len */ @@ -3404,18 +3414,12 @@ iterate_initial_edge (unsigned int min_len, edge[0].destination = state->hash; temp = GNUNET_strdup (consumed_string); temp[cur_len - 1] = '\0'; - GNUNET_CRYPTO_hash (temp, - cur_len - 1, - &hash_new); + GNUNET_CRYPTO_hash (temp, cur_len - 1, &hash_new); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Start state for short string `%s' is %s\n", temp, GNUNET_h2s (&hash_new)); - iterator (iterator_cls, - &hash_new, - temp, - GNUNET_NO, 1, - edge); + iterator (iterator_cls, &hash_new, temp, GNUNET_NO, 1, edge); GNUNET_free (temp); } } @@ -3432,12 +3436,7 @@ iterate_initial_edge (unsigned int min_len, temp, edge[0].label, GNUNET_h2s (&hash_new)); - iterator (iterator_cls, - &hash, - temp, - GNUNET_NO, - 1, - edge); + iterator (iterator_cls, &hash, temp, GNUNET_NO, 1, edge); GNUNET_free (temp); } } @@ -3446,22 +3445,16 @@ iterate_initial_edge (unsigned int min_len, { for (t = state->transitions_head; NULL != t; t = t->next) { - if (NULL != strchr (t->label, - (int) '.')) + if (NULL != strchr (t->label, (int) '.')) { /* Wildcards not allowed during starting states */ GNUNET_break (0); continue; } if (NULL != consumed_string) - GNUNET_asprintf (&temp, - "%s%s", - consumed_string, - t->label); + GNUNET_asprintf (&temp, "%s%s", consumed_string, t->label); else - GNUNET_asprintf (&temp, - "%s", - t->label); + GNUNET_asprintf (&temp, "%s", t->label); iterate_initial_edge (min_len, max_len, temp, @@ -3489,30 +3482,32 @@ REGEX_INTERNAL_iterate_all_edges (struct REGEX_INTERNAL_Automaton *a, { struct REGEX_INTERNAL_State *s; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Iterating over starting edges\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iterating over starting edges\n"); iterate_initial_edge (GNUNET_REGEX_INITIAL_BYTES, GNUNET_REGEX_INITIAL_BYTES, - NULL, a->start, - iterator, iterator_cls); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Iterating over DFA edges\n"); + NULL, + a->start, + iterator, + iterator_cls); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iterating over DFA edges\n"); for (s = a->states_head; NULL != s; s = s->next) { struct REGEX_BLOCK_Edge edges[s->transition_count]; unsigned int num_edges; num_edges = state_get_edges (s, edges); - if ( ( (NULL != s->proof) && - (0 < strlen (s->proof)) ) || s->accepting) + if (((NULL != s->proof) && (0 < strlen (s->proof))) || s->accepting) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating DFA edges at `%s' under key %s\n", s->proof, GNUNET_h2s (&s->hash)); - iterator (iterator_cls, &s->hash, s->proof, + iterator (iterator_cls, + &s->hash, + s->proof, s->accepting, - num_edges, edges); + num_edges, + edges); } s->marked = GNUNET_NO; } @@ -3525,7 +3520,8 @@ REGEX_INTERNAL_iterate_all_edges (struct REGEX_INTERNAL_Automaton *a, * Contains the same info as the Regex Iterator parametes except the key, * which comes directly from the HashMap iterator. */ -struct temporal_state_store { +struct temporal_state_store +{ int reachable; char *proof; int accepting; @@ -3537,7 +3533,8 @@ struct temporal_state_store { /** * Store regex iterator and cls in one place to pass to the hashmap iterator. */ -struct client_iterator { +struct client_iterator +{ REGEX_INTERNAL_KeyIterator iterator; void *iterator_cls; }; @@ -3573,9 +3570,13 @@ store_all_states (void *cls, tmp->num_edges = num_edges; edges_size = sizeof (struct REGEX_BLOCK_Edge) * num_edges; tmp->edges = GNUNET_malloc (edges_size); - GNUNET_memcpy(tmp->edges, edges, edges_size); - GNUNET_CONTAINER_multihashmap_put (hm, key, tmp, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST); + GNUNET_memcpy (tmp->edges, edges, edges_size); + GNUNET_assert (GNUNET_YES == + GNUNET_CONTAINER_multihashmap_put ( + hm, + key, + tmp, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); } @@ -3601,8 +3602,8 @@ mark_as_reachable (struct temporal_state_store *state, state->reachable = GNUNET_YES; for (i = 0; i < state->num_edges; i++) { - child = GNUNET_CONTAINER_multihashmap_get (hm, - &state->edges[i].destination); + child = + GNUNET_CONTAINER_multihashmap_get (hm, &state->edges[i].destination); if (NULL == child) { GNUNET_break (0); @@ -3655,24 +3656,24 @@ reachability_iterator (void *cls, * #GNUNET_NO if not. */ static int -iterate_reachables (void *cls, - const struct GNUNET_HashCode *key, - void *value) +iterate_reachables (void *cls, const struct GNUNET_HashCode *key, void *value) { struct client_iterator *ci = cls; struct temporal_state_store *state = value; if (GNUNET_YES == state->reachable) { - ci->iterator (ci->iterator_cls, key, - state->proof, state->accepting, - state->num_edges, state->edges); + ci->iterator (ci->iterator_cls, + key, + state->proof, + state->accepting, + state->num_edges, + state->edges); } GNUNET_free (state->edges); GNUNET_free (state->proof); GNUNET_free (state); return GNUNET_YES; - } /** diff --git a/src/statistics/gnunet-statistics.c b/src/statistics/gnunet-statistics.c index bf111ade2..bc30670e9 100644 --- a/src/statistics/gnunet-statistics.c +++ b/src/statistics/gnunet-statistics.c @@ -11,7 +11,7 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . @@ -93,7 +93,8 @@ static int set_value; /** * @brief Representation of all (testbed) nodes. */ -static struct Node { +static struct Node +{ /** * @brief Index of the node in this array. */ @@ -117,7 +118,7 @@ static struct Node { * @brief Identifier for shutdown task for this node. */ struct GNUNET_SCHEDULER_Task *shutdown_task; -} *nodes; +} * nodes; /** * @brief Number of configurations of all (testbed) nodes. @@ -204,11 +205,9 @@ new_value_set (const char *subsystem, * @return GNUNET_YES - continue iteration. */ static int -printer (void *cls, - const struct GNUNET_HashCode *key, - void *value) +printer (void *cls, const struct GNUNET_HashCode *key, void *value) { - struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get(); + struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get (); const char *now_str; struct ValueSet *value_set = value; @@ -218,38 +217,38 @@ printer (void *cls, { now_str = GNUNET_STRINGS_absolute_time_to_string (now); FPRINTF (stdout, - "%24s%s %s%s%12s%s %s%50s%s%s ", + "%24s%s %s%s%12s%s %s%50s%s%s ", now_str, csv_separator, value_set->is_persistent ? "!" : " ", csv_separator, value_set->subsystem, csv_separator, - (0 == strlen (csv_separator) ? "": "\""), /* quotes if csv */ - _(value_set->name), - (0 == strlen (csv_separator) ? "": "\""), /* quotes if csv */ - (0 == strlen (csv_separator) ? ":": csv_separator)); + (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ + _ (value_set->name), + (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ + (0 == strlen (csv_separator) ? ":" : csv_separator)); } else { FPRINTF (stdout, - "%s%s%12s%s %s%50s%s%s ", + "%s%s%12s%s %s%50s%s%s ", value_set->is_persistent ? "!" : " ", csv_separator, value_set->subsystem, csv_separator, - (0 == strlen (csv_separator) ? "": "\""), /* quotes if csv */ - _(value_set->name), - (0 == strlen (csv_separator) ? "": "\""), /* quotes if csv */ - (0 == strlen (csv_separator) ? ":": csv_separator)); + (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ + _ (value_set->name), + (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ + (0 == strlen (csv_separator) ? ":" : csv_separator)); } } for (unsigned i = 0; i < num_nodes; i++) { FPRINTF (stdout, - "%16llu%s", - (unsigned long long) value_set->values[i], - csv_separator); + "%16llu%s", + (unsigned long long) value_set->values[i], + csv_separator); } FPRINTF (stdout, "\n"); GNUNET_free (value_set->subsystem); @@ -276,7 +275,7 @@ printer_watch (void *cls, uint64_t value, int is_persistent) { - struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get(); + struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get (); const char *now_str; if (quiet == GNUNET_NO) @@ -292,10 +291,10 @@ printer_watch (void *cls, csv_separator, subsystem, csv_separator, - (0 == strlen (csv_separator) ? "": "\""), /* quotes if csv */ - _(name), - (0 == strlen (csv_separator) ? "": "\""), /* quotes if csv */ - (0 == strlen (csv_separator) ? ":": csv_separator), + (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ + _ (name), + (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ + (0 == strlen (csv_separator) ? ":" : csv_separator), (unsigned long long) value); } else @@ -306,17 +305,15 @@ printer_watch (void *cls, csv_separator, subsystem, csv_separator, - (0 == strlen (csv_separator) ? "": "\""), /* quotes if csv */ - _(name), - (0 == strlen (csv_separator) ? "": "\""), /* quotes if csv */ - (0 == strlen (csv_separator) ? ":": csv_separator), + (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ + _ (name), + (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ + (0 == strlen (csv_separator) ? ":" : csv_separator), (unsigned long long) value); } } else - FPRINTF (stdout, - "%llu\n", - (unsigned long long) value); + FPRINTF (stdout, "%llu\n", (unsigned long long) value); return GNUNET_OK; } @@ -335,8 +332,8 @@ clean_node (void *cls) struct GNUNET_STATISTICS_Handle *h; struct GNUNET_STATISTICS_GetHandle *gh; - if ( (NULL != path_testbed) && /* were issued with -t option */ - (NULL != nodes[index_node].conf) ) + if ((NULL != path_testbed) && /* were issued with -t option */ + (NULL != nodes[index_node].conf)) { GNUNET_CONFIGURATION_destroy (nodes[index_node].conf); nodes[index_node].conf = NULL; @@ -352,7 +349,8 @@ clean_node (void *cls) } if (GNUNET_YES == watch) { - GNUNET_assert (GNUNET_OK == + GNUNET_assert ( + GNUNET_OK == GNUNET_STATISTICS_watch_cancel (h, subsystem, name, @@ -383,7 +381,7 @@ static void print_finish (void *cls) { GNUNET_CONTAINER_multihashmap_iterate (values, printer, NULL); - GNUNET_SCHEDULER_shutdown(); + GNUNET_SCHEDULER_shutdown (); } /** @@ -395,8 +393,7 @@ print_finish (void *cls) * @param succes Whether statistics were obtained successfully. */ static void -continuation_print (void *cls, - int success) +continuation_print (void *cls, int success) { const unsigned index_node = *(unsigned *) cls; @@ -404,12 +401,10 @@ continuation_print (void *cls, if (GNUNET_OK != success) { if (NULL == remote_host) - FPRINTF (stderr, - "%s", - _("Failed to obtain statistics.\n")); + FPRINTF (stderr, "%s", _ ("Failed to obtain statistics.\n")); else FPRINTF (stderr, - _("Failed to obtain statistics from host `%s:%llu'\n"), + _ ("Failed to obtain statistics from host `%s:%llu'\n"), remote_host, remote_port); ret = 1; @@ -435,8 +430,7 @@ continuation_print (void *cls, * successfully obtained, #GNUNET_SYSERR if not. */ static void -cleanup (void *cls, - int success) +cleanup (void *cls, int success) { for (unsigned i = 0; i < num_nodes; i++) { @@ -445,12 +439,10 @@ cleanup (void *cls, if (GNUNET_OK != success) { if (NULL == remote_host) - FPRINTF (stderr, - "%s", - _("Failed to obtain statistics.\n")); + FPRINTF (stderr, "%s", _ ("Failed to obtain statistics.\n")); else FPRINTF (stderr, - _("Failed to obtain statistics from host `%s:%llu'\n"), + _ ("Failed to obtain statistics from host `%s:%llu'\n"), remote_host, remote_port); ret = 1; @@ -492,19 +484,19 @@ collector (void *cls, GNUNET_free (subsys_name); if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (values, key)) { - // get value_set = GNUNET_CONTAINER_multihashmap_get (values, key); } else { - // new value_set = new_value_set (subsystem, name, num_nodes, is_persistent); } - // write value_set->values[index_node] = value; - // put - GNUNET_CONTAINER_multihashmap_put (values, key, value_set, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); + GNUNET_assert (GNUNET_YES == + GNUNET_CONTAINER_multihashmap_put ( + values, + key, + value_set, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); return GNUNET_OK; } @@ -523,22 +515,17 @@ main_task (void *cls) { if (NULL == subsystem) { - FPRINTF (stderr, - "%s", - _("Missing argument: subsystem \n")); + FPRINTF (stderr, "%s", _ ("Missing argument: subsystem \n")); ret = 1; return; } if (NULL == name) { - FPRINTF (stderr, - "%s", - _("Missing argument: name\n")); + FPRINTF (stderr, "%s", _ ("Missing argument: name\n")); ret = 1; return; } - nodes[index_node].handle = GNUNET_STATISTICS_create (subsystem, - cfg); + nodes[index_node].handle = GNUNET_STATISTICS_create (subsystem, cfg); if (NULL == nodes[index_node].handle) { ret = 1; @@ -548,59 +535,51 @@ main_task (void *cls) name, (uint64_t) set_val, persistent); - GNUNET_STATISTICS_destroy (nodes[index_node].handle, - GNUNET_YES); + GNUNET_STATISTICS_destroy (nodes[index_node].handle, GNUNET_YES); nodes[index_node].handle = NULL; return; } - if (NULL == (nodes[index_node].handle = GNUNET_STATISTICS_create ("gnunet-statistics", - cfg))) + if (NULL == (nodes[index_node].handle = + GNUNET_STATISTICS_create ("gnunet-statistics", cfg))) { ret = 1; return; } if (GNUNET_NO == watch) { - if (NULL == - (nodes[index_node].gh = GNUNET_STATISTICS_get (nodes[index_node].handle, - subsystem, - name, - &continuation_print, - &collector, - &nodes[index_node].index_node)) ) - cleanup (nodes[index_node].handle, - GNUNET_SYSERR); + if (NULL == (nodes[index_node].gh = + GNUNET_STATISTICS_get (nodes[index_node].handle, + subsystem, + name, + &continuation_print, + &collector, + &nodes[index_node].index_node))) + cleanup (nodes[index_node].handle, GNUNET_SYSERR); } else { - if ( (NULL == subsystem) || - (NULL == name) ) + if ((NULL == subsystem) || (NULL == name)) { - printf (_("No subsystem or name given\n")); - GNUNET_STATISTICS_destroy (nodes[index_node].handle, - GNUNET_NO); + printf (_ ("No subsystem or name given\n")); + GNUNET_STATISTICS_destroy (nodes[index_node].handle, GNUNET_NO); nodes[index_node].handle = NULL; ret = 1; return; } - if (GNUNET_OK != - GNUNET_STATISTICS_watch (nodes[index_node].handle, - subsystem, - name, - &printer_watch, - &nodes[index_node].index_node)) + if (GNUNET_OK != GNUNET_STATISTICS_watch (nodes[index_node].handle, + subsystem, + name, + &printer_watch, + &nodes[index_node].index_node)) { - fprintf (stderr, - _("Failed to initialize watch routine\n")); + fprintf (stderr, _ ("Failed to initialize watch routine\n")); nodes[index_node].shutdown_task = - GNUNET_SCHEDULER_add_now (&clean_node, - &nodes[index_node].index_node); + GNUNET_SCHEDULER_add_now (&clean_node, &nodes[index_node].index_node); return; } } nodes[index_node].shutdown_task = - GNUNET_SCHEDULER_add_shutdown (&clean_node, - &nodes[index_node].index_node); + GNUNET_SCHEDULER_add_shutdown (&clean_node, &nodes[index_node].index_node); } /** @@ -615,16 +594,16 @@ main_task (void *cls) * @return to continue iteration or not to */ static int -iter_check_config (void *cls, - const char *filename) +iter_check_config (void *cls, const char *filename) { if (0 == strncmp (GNUNET_STRINGS_get_short_name (filename), "config", 6)) { /* Found the config - stop iteration successfully */ - GNUNET_array_grow (nodes, num_nodes, num_nodes+1); - nodes[num_nodes-1].conf = GNUNET_CONFIGURATION_create(); - nodes[num_nodes-1].index_node = num_nodes-1; - if (GNUNET_OK != GNUNET_CONFIGURATION_load (nodes[num_nodes-1].conf, filename)) + GNUNET_array_grow (nodes, num_nodes, num_nodes + 1); + nodes[num_nodes - 1].conf = GNUNET_CONFIGURATION_create (); + nodes[num_nodes - 1].index_node = num_nodes - 1; + if (GNUNET_OK != + GNUNET_CONFIGURATION_load (nodes[num_nodes - 1].conf, filename)) { FPRINTF (stderr, "Failed loading config `%s'\n", filename); return GNUNET_SYSERR; @@ -652,19 +631,14 @@ iter_check_config (void *cls, * @return status whether to continue iteration */ static int -iter_testbed_path (void *cls, - const char *filename) +iter_testbed_path (void *cls, const char *filename) { unsigned index_node; GNUNET_assert (NULL != filename); - if (1 == SSCANF (GNUNET_STRINGS_get_short_name (filename), - "%u", - &index_node)) + if (1 == SSCANF (GNUNET_STRINGS_get_short_name (filename), "%u", &index_node)) { - if (-1 == GNUNET_DISK_directory_scan (filename, - iter_check_config, - NULL)) + if (-1 == GNUNET_DISK_directory_scan (filename, iter_check_config, NULL)) { /* This is probably no directory for a testbed node * Go on with iteration */ @@ -687,14 +661,11 @@ discover_testbed_nodes (const char *path_testbed) { int num_dir_entries; - num_dir_entries = GNUNET_DISK_directory_scan (path_testbed, - iter_testbed_path, - NULL); + num_dir_entries = + GNUNET_DISK_directory_scan (path_testbed, iter_testbed_path, NULL); if (-1 == num_dir_entries) { - FPRINTF (stderr, - "Failure during scanning directory `%s'\n", - path_testbed); + FPRINTF (stderr, "Failure during scanning directory `%s'\n", path_testbed); return -1; } return 0; @@ -718,16 +689,13 @@ run (void *cls, c = (struct GNUNET_CONFIGURATION_Handle *) cfg; set_value = GNUNET_NO; - if (NULL == csv_separator) csv_separator = ""; + if (NULL == csv_separator) + csv_separator = ""; if (NULL != args[0]) { - if (1 != SSCANF (args[0], - "%llu", - &set_val)) + if (1 != SSCANF (args[0], "%llu", &set_val)) { - FPRINTF (stderr, - _("Invalid argument `%s'\n"), - args[0]); + FPRINTF (stderr, _ ("Invalid argument `%s'\n"), args[0]); ret = 1; return; } @@ -737,39 +705,36 @@ run (void *cls, { if (0 == remote_port) { - if (GNUNET_SYSERR == - GNUNET_CONFIGURATION_get_value_number (cfg, - "statistics", - "PORT", - &remote_port)) + if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, + "statistics", + "PORT", + &remote_port)) { - FPRINTF (stderr, - _("A port is required to connect to host `%s'\n"), - remote_host); - return; + FPRINTF (stderr, + _ ("A port is required to connect to host `%s'\n"), + remote_host); + return; } } else if (65535 <= remote_port) { FPRINTF (stderr, - _("A port has to be between 1 and 65535 to connect to host `%s'\n"), - remote_host); + _ ( + "A port has to be between 1 and 65535 to connect to host `%s'\n"), + remote_host); return; } /* Manipulate configuration */ + GNUNET_CONFIGURATION_set_value_string (c, "statistics", "UNIXPATH", ""); GNUNET_CONFIGURATION_set_value_string (c, - "statistics", - "UNIXPATH", - ""); - GNUNET_CONFIGURATION_set_value_string (c, - "statistics", - "HOSTNAME", - remote_host); + "statistics", + "HOSTNAME", + remote_host); GNUNET_CONFIGURATION_set_value_number (c, - "statistics", - "PORT", - remote_port); + "statistics", + "PORT", + remote_port); } if (NULL == path_testbed) { @@ -783,7 +748,8 @@ run (void *cls, { if (GNUNET_YES == watch) { - printf (_("Not able to watch testbed nodes (yet - feel free to implement)\n")); + printf ( + _ ("Not able to watch testbed nodes (yet - feel free to implement)\n")); ret = 1; return; } @@ -795,8 +761,7 @@ run (void *cls, /* For each config/node collect statistics */ for (unsigned i = 0; i < num_nodes; i++) { - GNUNET_SCHEDULER_add_now (&main_task, - &nodes[i].index_node); + GNUNET_SCHEDULER_add_now (&main_task, &nodes[i].index_node); } } } @@ -812,78 +777,82 @@ run (void *cls, int main (int argc, char *const *argv) { - struct GNUNET_GETOPT_CommandLineOption options[] = { - GNUNET_GETOPT_option_string ('n', - "name", - "NAME", - gettext_noop ("limit output to statistics for the given NAME"), - &name), - - GNUNET_GETOPT_option_flag ('p', - "persistent", - gettext_noop ("make the value being set persistent"), - &persistent), - - GNUNET_GETOPT_option_string ('s', - "subsystem", - "SUBSYSTEM", - gettext_noop ("limit output to the given SUBSYSTEM"), - &subsystem), - - GNUNET_GETOPT_option_string ('S', - "csv-separator", - "CSV_SEPARATOR", - gettext_noop ("use as csv separator"), - &csv_separator), - - GNUNET_GETOPT_option_filename ('t', - "testbed", - "TESTBED", - gettext_noop ("path to the folder containing the testbed data"), - &path_testbed), - - GNUNET_GETOPT_option_flag ('q', - "quiet", - gettext_noop ("just print the statistics value"), - &quiet), - - GNUNET_GETOPT_option_flag ('w', - "watch", - gettext_noop ("watch value continuously"), - &watch), - - GNUNET_GETOPT_option_string ('r', - "remote", - "REMOTE", - gettext_noop ("connect to remote host"), - &remote_host), - - GNUNET_GETOPT_option_ulong ('o', - "port", - "PORT", - gettext_noop ("port for remote host"), - &remote_port), - - GNUNET_GETOPT_OPTION_END - }; + struct GNUNET_GETOPT_CommandLineOption options[] = + {GNUNET_GETOPT_option_string ( + 'n', + "name", + "NAME", + gettext_noop ("limit output to statistics for the given NAME"), + &name), + + GNUNET_GETOPT_option_flag ('p', + "persistent", + gettext_noop ( + "make the value being set persistent"), + &persistent), + + GNUNET_GETOPT_option_string ('s', + "subsystem", + "SUBSYSTEM", + gettext_noop ( + "limit output to the given SUBSYSTEM"), + &subsystem), + + GNUNET_GETOPT_option_string ('S', + "csv-separator", + "CSV_SEPARATOR", + gettext_noop ("use as csv separator"), + &csv_separator), + + GNUNET_GETOPT_option_filename ( + 't', + "testbed", + "TESTBED", + gettext_noop ("path to the folder containing the testbed data"), + &path_testbed), + + GNUNET_GETOPT_option_flag ('q', + "quiet", + gettext_noop ( + "just print the statistics value"), + &quiet), + + GNUNET_GETOPT_option_flag ('w', + "watch", + gettext_noop ("watch value continuously"), + &watch), + + GNUNET_GETOPT_option_string ('r', + "remote", + "REMOTE", + gettext_noop ("connect to remote host"), + &remote_host), + + GNUNET_GETOPT_option_ulong ('o', + "port", + "PORT", + gettext_noop ("port for remote host"), + &remote_port), + + GNUNET_GETOPT_OPTION_END}; remote_port = 0; remote_host = NULL; - 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; ret = (GNUNET_OK == - GNUNET_PROGRAM_run (argc, - argv, - "gnunet-statistics [options [value]]", - gettext_noop - ("Print statistics about GNUnet operations."), - options, - &run, - NULL)) ? ret : 1; + GNUNET_PROGRAM_run (argc, + argv, + "gnunet-statistics [options [value]]", + gettext_noop ( + "Print statistics about GNUnet operations."), + options, + &run, + NULL)) + ? ret + : 1; GNUNET_free_non_null (remote_host); - GNUNET_free ((void*) argv); + GNUNET_free ((void *) argv); return ret; } -- 2.25.1