diff options
author | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
---|---|---|
committer | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
commit | d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch) | |
tree | 9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/statistics | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/statistics')
-rw-r--r-- | src/statistics/gnunet-service-statistics.c | 853 | ||||
-rw-r--r-- | src/statistics/gnunet-statistics.c | 815 | ||||
-rw-r--r-- | src/statistics/statistics.h | 18 | ||||
-rw-r--r-- | src/statistics/statistics_api.c | 1146 | ||||
-rw-r--r-- | src/statistics/test_statistics_api.c | 297 | ||||
-rw-r--r-- | src/statistics/test_statistics_api_loop.c | 101 | ||||
-rw-r--r-- | src/statistics/test_statistics_api_watch.c | 139 | ||||
-rw-r--r-- | src/statistics/test_statistics_api_watch_zero_value.c | 187 |
8 files changed, 1767 insertions, 1789 deletions
diff --git a/src/statistics/gnunet-service-statistics.c b/src/statistics/gnunet-service-statistics.c index 18905f458..7d84f421e 100644 --- a/src/statistics/gnunet-service-statistics.c +++ b/src/statistics/gnunet-service-statistics.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file statistics/gnunet-service-statistics.c | 22 | * @file statistics/gnunet-service-statistics.c |
@@ -38,9 +38,7 @@ | |||
38 | /** | 38 | /** |
39 | * Watch entry. | 39 | * Watch entry. |
40 | */ | 40 | */ |
41 | struct WatchEntry | 41 | struct WatchEntry { |
42 | { | ||
43 | |||
44 | /** | 42 | /** |
45 | * Watch entries are kept in a linked list. | 43 | * Watch entries are kept in a linked list. |
46 | */ | 44 | */ |
@@ -84,8 +82,7 @@ struct SubsystemEntry; | |||
84 | /** | 82 | /** |
85 | * Entry in the statistics list. | 83 | * Entry in the statistics list. |
86 | */ | 84 | */ |
87 | struct StatsEntry | 85 | struct StatsEntry { |
88 | { | ||
89 | /** | 86 | /** |
90 | * This is a linked list. | 87 | * This is a linked list. |
91 | */ | 88 | */ |
@@ -144,8 +141,7 @@ struct StatsEntry | |||
144 | * We keep the statistics organized by subsystem for faster | 141 | * We keep the statistics organized by subsystem for faster |
145 | * lookup during SET operations. | 142 | * lookup during SET operations. |
146 | */ | 143 | */ |
147 | struct SubsystemEntry | 144 | struct SubsystemEntry { |
148 | { | ||
149 | /** | 145 | /** |
150 | * Subsystems are kept in a DLL. | 146 | * Subsystems are kept in a DLL. |
151 | */ | 147 | */ |
@@ -177,8 +173,7 @@ struct SubsystemEntry | |||
177 | /** | 173 | /** |
178 | * Client entry. | 174 | * Client entry. |
179 | */ | 175 | */ |
180 | struct ClientEntry | 176 | struct ClientEntry { |
181 | { | ||
182 | /** | 177 | /** |
183 | * Corresponding server handle. | 178 | * Corresponding server handle. |
184 | */ | 179 | */ |
@@ -241,7 +236,7 @@ static int in_shutdown; | |||
241 | * Write persistent statistics to disk. | 236 | * Write persistent statistics to disk. |
242 | */ | 237 | */ |
243 | static void | 238 | static void |
244 | save () | 239 | save() |
245 | { | 240 | { |
246 | struct SubsystemEntry *se; | 241 | struct SubsystemEntry *se; |
247 | struct StatsEntry *pos; | 242 | struct StatsEntry *pos; |
@@ -253,74 +248,74 @@ save () | |||
253 | size_t slen; | 248 | size_t slen; |
254 | struct GNUNET_STATISTICS_SetMessage *msg; | 249 | struct GNUNET_STATISTICS_SetMessage *msg; |
255 | 250 | ||
256 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, | 251 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg, |
257 | "STATISTICS", | 252 | "STATISTICS", |
258 | "DATABASE", | 253 | "DATABASE", |
259 | &fn)) | 254 | &fn)) |
260 | { | 255 | { |
261 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, | 256 | GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, |
262 | "STATISTICS", | 257 | "STATISTICS", |
263 | "DATABASE"); | 258 | "DATABASE"); |
264 | return; | 259 | return; |
265 | } | 260 | } |
266 | (void) GNUNET_DISK_directory_create_for_file (fn); | 261 | (void)GNUNET_DISK_directory_create_for_file(fn); |
267 | wh = GNUNET_BIO_write_open (fn); | 262 | wh = GNUNET_BIO_write_open(fn); |
268 | total = 0; | 263 | total = 0; |
269 | while (NULL != (se = sub_head)) | 264 | while (NULL != (se = sub_head)) |
270 | { | ||
271 | GNUNET_CONTAINER_DLL_remove (sub_head, sub_tail, se); | ||
272 | slen = strlen (se->service) + 1; | ||
273 | while (NULL != (pos = se->stat_head)) | ||
274 | { | 265 | { |
275 | GNUNET_CONTAINER_DLL_remove (se->stat_head, se->stat_tail, pos); | 266 | GNUNET_CONTAINER_DLL_remove(sub_head, sub_tail, se); |
276 | if ((pos->persistent) && (NULL != wh)) | 267 | slen = strlen(se->service) + 1; |
277 | { | 268 | while (NULL != (pos = se->stat_head)) |
278 | nlen = strlen (pos->name) + 1; | ||
279 | size = sizeof (struct GNUNET_STATISTICS_SetMessage) + nlen + slen; | ||
280 | GNUNET_assert (size < UINT16_MAX); | ||
281 | msg = GNUNET_malloc (size); | ||
282 | |||
283 | msg->header.size = htons ((uint16_t) size); | ||
284 | msg->header.type = htons (GNUNET_MESSAGE_TYPE_STATISTICS_SET); | ||
285 | GNUNET_assert (nlen + slen == | ||
286 | GNUNET_STRINGS_buffer_fill ((char *) &msg[1], | ||
287 | nlen + slen, | ||
288 | 2, | ||
289 | se->service, | ||
290 | pos->name)); | ||
291 | msg->flags = | ||
292 | htonl (pos->persistent ? GNUNET_STATISTICS_SETFLAG_PERSISTENT : 0); | ||
293 | msg->value = GNUNET_htonll (pos->value); | ||
294 | if (GNUNET_OK != GNUNET_BIO_write (wh, msg, size)) | ||
295 | { | 269 | { |
296 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", fn); | 270 | GNUNET_CONTAINER_DLL_remove(se->stat_head, se->stat_tail, pos); |
297 | if (GNUNET_OK != GNUNET_BIO_write_close (wh)) | 271 | if ((pos->persistent) && (NULL != wh)) |
298 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", fn); | 272 | { |
299 | wh = NULL; | 273 | nlen = strlen(pos->name) + 1; |
274 | size = sizeof(struct GNUNET_STATISTICS_SetMessage) + nlen + slen; | ||
275 | GNUNET_assert(size < UINT16_MAX); | ||
276 | msg = GNUNET_malloc(size); | ||
277 | |||
278 | msg->header.size = htons((uint16_t)size); | ||
279 | msg->header.type = htons(GNUNET_MESSAGE_TYPE_STATISTICS_SET); | ||
280 | GNUNET_assert(nlen + slen == | ||
281 | GNUNET_STRINGS_buffer_fill((char *)&msg[1], | ||
282 | nlen + slen, | ||
283 | 2, | ||
284 | se->service, | ||
285 | pos->name)); | ||
286 | msg->flags = | ||
287 | htonl(pos->persistent ? GNUNET_STATISTICS_SETFLAG_PERSISTENT : 0); | ||
288 | msg->value = GNUNET_htonll(pos->value); | ||
289 | if (GNUNET_OK != GNUNET_BIO_write(wh, msg, size)) | ||
290 | { | ||
291 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "write", fn); | ||
292 | if (GNUNET_OK != GNUNET_BIO_write_close(wh)) | ||
293 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "close", fn); | ||
294 | wh = NULL; | ||
295 | } | ||
296 | else | ||
297 | { | ||
298 | total += size; | ||
299 | } | ||
300 | GNUNET_free(msg); | ||
301 | } | ||
302 | GNUNET_free(pos); | ||
300 | } | 303 | } |
301 | else | 304 | GNUNET_free(se); |
302 | { | ||
303 | total += size; | ||
304 | } | ||
305 | GNUNET_free (msg); | ||
306 | } | ||
307 | GNUNET_free (pos); | ||
308 | } | 305 | } |
309 | GNUNET_free (se); | ||
310 | } | ||
311 | if (NULL != wh) | 306 | if (NULL != wh) |
312 | { | 307 | { |
313 | if (GNUNET_OK != GNUNET_BIO_write_close (wh)) | 308 | if (GNUNET_OK != GNUNET_BIO_write_close(wh)) |
314 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", fn); | 309 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "close", fn); |
315 | if (0 == total) | 310 | if (0 == total) |
316 | GNUNET_break (0 == unlink (fn)); | 311 | GNUNET_break(0 == unlink(fn)); |
317 | else | 312 | else |
318 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 313 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
319 | _ ("Wrote %llu bytes of statistics to `%s'\n"), | 314 | _("Wrote %llu bytes of statistics to `%s'\n"), |
320 | total, | 315 | total, |
321 | fn); | 316 | fn); |
322 | } | 317 | } |
323 | GNUNET_free_non_null (fn); | 318 | GNUNET_free_non_null(fn); |
324 | } | 319 | } |
325 | 320 | ||
326 | 321 | ||
@@ -331,31 +326,31 @@ save () | |||
331 | * @param e value to transmit | 326 | * @param e value to transmit |
332 | */ | 327 | */ |
333 | static void | 328 | static void |
334 | transmit (struct ClientEntry *ce, const struct StatsEntry *e) | 329 | transmit(struct ClientEntry *ce, const struct StatsEntry *e) |
335 | { | 330 | { |
336 | struct GNUNET_MQ_Envelope *env; | 331 | struct GNUNET_MQ_Envelope *env; |
337 | struct GNUNET_STATISTICS_ReplyMessage *m; | 332 | struct GNUNET_STATISTICS_ReplyMessage *m; |
338 | size_t size; | 333 | size_t size; |
339 | 334 | ||
340 | size = strlen (e->subsystem->service) + 1 + strlen (e->name) + 1; | 335 | size = strlen(e->subsystem->service) + 1 + strlen(e->name) + 1; |
341 | GNUNET_assert (size < GNUNET_MAX_MESSAGE_SIZE); | 336 | GNUNET_assert(size < GNUNET_MAX_MESSAGE_SIZE); |
342 | env = GNUNET_MQ_msg_extra (m, size, GNUNET_MESSAGE_TYPE_STATISTICS_VALUE); | 337 | env = GNUNET_MQ_msg_extra(m, size, GNUNET_MESSAGE_TYPE_STATISTICS_VALUE); |
343 | m->uid = htonl (e->uid); | 338 | m->uid = htonl(e->uid); |
344 | if (e->persistent) | 339 | if (e->persistent) |
345 | m->uid |= htonl (GNUNET_STATISTICS_PERSIST_BIT); | 340 | m->uid |= htonl(GNUNET_STATISTICS_PERSIST_BIT); |
346 | m->value = GNUNET_htonll (e->value); | 341 | m->value = GNUNET_htonll(e->value); |
347 | GNUNET_assert (size == GNUNET_STRINGS_buffer_fill ((char *) &m[1], | 342 | GNUNET_assert(size == GNUNET_STRINGS_buffer_fill((char *)&m[1], |
348 | size, | 343 | size, |
349 | 2, | 344 | 2, |
350 | e->subsystem->service, | 345 | e->subsystem->service, |
351 | e->name)); | 346 | e->name)); |
352 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 347 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
353 | "Transmitting value for `%s:%s' (%d): %llu\n", | 348 | "Transmitting value for `%s:%s' (%d): %llu\n", |
354 | e->subsystem->service, | 349 | e->subsystem->service, |
355 | e->name, | 350 | e->name, |
356 | e->persistent, | 351 | e->persistent, |
357 | (unsigned long long) e->value); | 352 | (unsigned long long)e->value); |
358 | GNUNET_MQ_send (ce->mq, env); | 353 | GNUNET_MQ_send(ce->mq, env); |
359 | } | 354 | } |
360 | 355 | ||
361 | 356 | ||
@@ -368,17 +363,17 @@ transmit (struct ClientEntry *ce, const struct StatsEntry *e) | |||
368 | * @return @a c | 363 | * @return @a c |
369 | */ | 364 | */ |
370 | static void * | 365 | static void * |
371 | client_connect_cb (void *cls, | 366 | client_connect_cb(void *cls, |
372 | struct GNUNET_SERVICE_Client *c, | 367 | struct GNUNET_SERVICE_Client *c, |
373 | struct GNUNET_MQ_Handle *mq) | 368 | struct GNUNET_MQ_Handle *mq) |
374 | { | 369 | { |
375 | struct ClientEntry *ce; | 370 | struct ClientEntry *ce; |
376 | 371 | ||
377 | ce = GNUNET_new (struct ClientEntry); | 372 | ce = GNUNET_new(struct ClientEntry); |
378 | ce->client = c; | 373 | ce->client = c; |
379 | ce->mq = mq; | 374 | ce->mq = mq; |
380 | client_count++; | 375 | client_count++; |
381 | GNUNET_notification_context_add (nc, mq); | 376 | GNUNET_notification_context_add(nc, mq); |
382 | return ce; | 377 | return ce; |
383 | } | 378 | } |
384 | 379 | ||
@@ -391,22 +386,22 @@ client_connect_cb (void *cls, | |||
391 | * @return #GNUNET_OK if @a message is well-formed | 386 | * @return #GNUNET_OK if @a message is well-formed |
392 | */ | 387 | */ |
393 | static int | 388 | static int |
394 | check_get (void *cls, const struct GNUNET_MessageHeader *message) | 389 | check_get(void *cls, const struct GNUNET_MessageHeader *message) |
395 | { | 390 | { |
396 | const char *service; | 391 | const char *service; |
397 | const char *name; | 392 | const char *name; |
398 | size_t size; | 393 | size_t size; |
399 | 394 | ||
400 | size = ntohs (message->size) - sizeof (struct GNUNET_MessageHeader); | 395 | size = ntohs(message->size) - sizeof(struct GNUNET_MessageHeader); |
401 | if (size != GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1], | 396 | if (size != GNUNET_STRINGS_buffer_tokenize((const char *)&message[1], |
402 | size, | 397 | size, |
403 | 2, | 398 | 2, |
404 | &service, | 399 | &service, |
405 | &name)) | 400 | &name)) |
406 | { | 401 | { |
407 | GNUNET_break (0); | 402 | GNUNET_break(0); |
408 | return GNUNET_SYSERR; | 403 | return GNUNET_SYSERR; |
409 | } | 404 | } |
410 | return GNUNET_OK; | 405 | return GNUNET_OK; |
411 | } | 406 | } |
412 | 407 | ||
@@ -418,7 +413,7 @@ check_get (void *cls, const struct GNUNET_MessageHeader *message) | |||
418 | * @param message the actual message | 413 | * @param message the actual message |
419 | */ | 414 | */ |
420 | static void | 415 | static void |
421 | handle_get (void *cls, const struct GNUNET_MessageHeader *message) | 416 | handle_get(void *cls, const struct GNUNET_MessageHeader *message) |
422 | { | 417 | { |
423 | struct ClientEntry *ce = cls; | 418 | struct ClientEntry *ce = cls; |
424 | struct GNUNET_MQ_Envelope *env; | 419 | struct GNUNET_MQ_Envelope *env; |
@@ -431,33 +426,33 @@ handle_get (void *cls, const struct GNUNET_MessageHeader *message) | |||
431 | struct StatsEntry *pos; | 426 | struct StatsEntry *pos; |
432 | size_t size; | 427 | size_t size; |
433 | 428 | ||
434 | size = ntohs (message->size) - sizeof (struct GNUNET_MessageHeader); | 429 | size = ntohs(message->size) - sizeof(struct GNUNET_MessageHeader); |
435 | GNUNET_assert (size == | 430 | GNUNET_assert(size == |
436 | GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1], | 431 | GNUNET_STRINGS_buffer_tokenize((const char *)&message[1], |
437 | size, | 432 | size, |
438 | 2, | 433 | 2, |
439 | &service, | 434 | &service, |
440 | &name)); | 435 | &name)); |
441 | slen = strlen (service); | 436 | slen = strlen(service); |
442 | nlen = strlen (name); | 437 | nlen = strlen(name); |
443 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 438 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
444 | "Received request for statistics on `%s:%s'\n", | 439 | "Received request for statistics on `%s:%s'\n", |
445 | slen ? service : "*", | 440 | slen ? service : "*", |
446 | nlen ? name : "*"); | 441 | nlen ? name : "*"); |
447 | for (se = sub_head; NULL != se; se = se->next) | 442 | for (se = sub_head; NULL != se; se = se->next) |
448 | { | ||
449 | if (! ((0 == slen) || (0 == strcmp (service, se->service)))) | ||
450 | continue; | ||
451 | for (pos = se->stat_head; NULL != pos; pos = pos->next) | ||
452 | { | 443 | { |
453 | if (! ((0 == nlen) || (0 == strcmp (name, pos->name)))) | 444 | if (!((0 == slen) || (0 == strcmp(service, se->service)))) |
454 | continue; | 445 | continue; |
455 | transmit (ce, pos); | 446 | for (pos = se->stat_head; NULL != pos; pos = pos->next) |
447 | { | ||
448 | if (!((0 == nlen) || (0 == strcmp(name, pos->name)))) | ||
449 | continue; | ||
450 | transmit(ce, pos); | ||
451 | } | ||
456 | } | 452 | } |
457 | } | 453 | env = GNUNET_MQ_msg(end, GNUNET_MESSAGE_TYPE_STATISTICS_END); |
458 | env = GNUNET_MQ_msg (end, GNUNET_MESSAGE_TYPE_STATISTICS_END); | 454 | GNUNET_MQ_send(ce->mq, env); |
459 | GNUNET_MQ_send (ce->mq, env); | 455 | GNUNET_SERVICE_client_continue(ce->client); |
460 | GNUNET_SERVICE_client_continue (ce->client); | ||
461 | } | 456 | } |
462 | 457 | ||
463 | 458 | ||
@@ -467,32 +462,32 @@ handle_get (void *cls, const struct GNUNET_MessageHeader *message) | |||
467 | * @param se value that changed | 462 | * @param se value that changed |
468 | */ | 463 | */ |
469 | static void | 464 | static void |
470 | notify_change (struct StatsEntry *se) | 465 | notify_change(struct StatsEntry *se) |
471 | { | 466 | { |
472 | struct GNUNET_MQ_Envelope *env; | 467 | struct GNUNET_MQ_Envelope *env; |
473 | struct GNUNET_STATISTICS_WatchValueMessage *wvm; | 468 | struct GNUNET_STATISTICS_WatchValueMessage *wvm; |
474 | struct WatchEntry *pos; | 469 | struct WatchEntry *pos; |
475 | 470 | ||
476 | for (pos = se->we_head; NULL != pos; pos = pos->next) | 471 | for (pos = se->we_head; NULL != pos; pos = pos->next) |
477 | { | ||
478 | if (GNUNET_YES == pos->last_value_set) | ||
479 | { | ||
480 | if (pos->last_value == se->value) | ||
481 | continue; | ||
482 | } | ||
483 | else | ||
484 | { | 472 | { |
485 | pos->last_value_set = GNUNET_YES; | 473 | if (GNUNET_YES == pos->last_value_set) |
474 | { | ||
475 | if (pos->last_value == se->value) | ||
476 | continue; | ||
477 | } | ||
478 | else | ||
479 | { | ||
480 | pos->last_value_set = GNUNET_YES; | ||
481 | } | ||
482 | env = GNUNET_MQ_msg(wvm, GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE); | ||
483 | wvm->flags = | ||
484 | htonl(se->persistent ? GNUNET_STATISTICS_SETFLAG_PERSISTENT : 0); | ||
485 | wvm->wid = htonl(pos->wid); | ||
486 | wvm->reserved = htonl(0); | ||
487 | wvm->value = GNUNET_htonll(se->value); | ||
488 | GNUNET_MQ_send(pos->ce->mq, env); | ||
489 | pos->last_value = se->value; | ||
486 | } | 490 | } |
487 | env = GNUNET_MQ_msg (wvm, GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE); | ||
488 | wvm->flags = | ||
489 | htonl (se->persistent ? GNUNET_STATISTICS_SETFLAG_PERSISTENT : 0); | ||
490 | wvm->wid = htonl (pos->wid); | ||
491 | wvm->reserved = htonl (0); | ||
492 | wvm->value = GNUNET_htonll (se->value); | ||
493 | GNUNET_MQ_send (pos->ce->mq, env); | ||
494 | pos->last_value = se->value; | ||
495 | } | ||
496 | } | 491 | } |
497 | 492 | ||
498 | 493 | ||
@@ -505,7 +500,7 @@ notify_change (struct StatsEntry *se) | |||
505 | * @return subsystem entry, never NULL (subsystem entry is created if necessary) | 500 | * @return subsystem entry, never NULL (subsystem entry is created if necessary) |
506 | */ | 501 | */ |
507 | static struct SubsystemEntry * | 502 | static struct SubsystemEntry * |
508 | find_subsystem_entry (struct ClientEntry *ce, const char *service) | 503 | find_subsystem_entry(struct ClientEntry *ce, const char *service) |
509 | { | 504 | { |
510 | size_t slen; | 505 | size_t slen; |
511 | struct SubsystemEntry *se; | 506 | struct SubsystemEntry *se; |
@@ -514,24 +509,24 @@ find_subsystem_entry (struct ClientEntry *ce, const char *service) | |||
514 | se = ce->subsystem; | 509 | se = ce->subsystem; |
515 | else | 510 | else |
516 | se = NULL; | 511 | se = NULL; |
517 | if ((NULL == se) || (0 != strcmp (service, se->service))) | 512 | if ((NULL == se) || (0 != strcmp(service, se->service))) |
518 | { | 513 | { |
519 | for (se = sub_head; NULL != se; se = se->next) | 514 | for (se = sub_head; NULL != se; se = se->next) |
520 | if (0 == strcmp (service, se->service)) | 515 | if (0 == strcmp(service, se->service)) |
521 | break; | 516 | break; |
522 | if (NULL != ce) | 517 | if (NULL != ce) |
523 | ce->subsystem = se; | 518 | ce->subsystem = se; |
524 | } | 519 | } |
525 | if (NULL != se) | 520 | if (NULL != se) |
526 | return se; | 521 | return se; |
527 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 522 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
528 | "Allocating new subsystem entry `%s'\n", | 523 | "Allocating new subsystem entry `%s'\n", |
529 | service); | 524 | service); |
530 | slen = strlen (service) + 1; | 525 | slen = strlen(service) + 1; |
531 | se = GNUNET_malloc (sizeof (struct SubsystemEntry) + slen); | 526 | se = GNUNET_malloc(sizeof(struct SubsystemEntry) + slen); |
532 | GNUNET_memcpy (&se[1], service, slen); | 527 | GNUNET_memcpy(&se[1], service, slen); |
533 | se->service = (const char *) &se[1]; | 528 | se->service = (const char *)&se[1]; |
534 | GNUNET_CONTAINER_DLL_insert (sub_head, sub_tail, se); | 529 | GNUNET_CONTAINER_DLL_insert(sub_head, sub_tail, se); |
535 | if (NULL != ce) | 530 | if (NULL != ce) |
536 | ce->subsystem = se; | 531 | ce->subsystem = se; |
537 | return se; | 532 | return se; |
@@ -546,12 +541,12 @@ find_subsystem_entry (struct ClientEntry *ce, const char *service) | |||
546 | * @return statistis entry, or NULL if not found | 541 | * @return statistis entry, or NULL if not found |
547 | */ | 542 | */ |
548 | static struct StatsEntry * | 543 | static struct StatsEntry * |
549 | find_stat_entry (struct SubsystemEntry *se, const char *name) | 544 | find_stat_entry(struct SubsystemEntry *se, const char *name) |
550 | { | 545 | { |
551 | struct StatsEntry *pos; | 546 | struct StatsEntry *pos; |
552 | 547 | ||
553 | for (pos = se->stat_head; NULL != pos; pos = pos->next) | 548 | for (pos = se->stat_head; NULL != pos; pos = pos->next) |
554 | if (0 == strcmp (name, pos->name)) | 549 | if (0 == strcmp(name, pos->name)) |
555 | return pos; | 550 | return pos; |
556 | return NULL; | 551 | return NULL; |
557 | } | 552 | } |
@@ -565,22 +560,22 @@ find_stat_entry (struct SubsystemEntry *se, const char *name) | |||
565 | * @return #GNUNET_OK if message is well-formed | 560 | * @return #GNUNET_OK if message is well-formed |
566 | */ | 561 | */ |
567 | static int | 562 | static int |
568 | check_set (void *cls, const struct GNUNET_STATISTICS_SetMessage *msg) | 563 | check_set(void *cls, const struct GNUNET_STATISTICS_SetMessage *msg) |
569 | { | 564 | { |
570 | const char *service; | 565 | const char *service; |
571 | const char *name; | 566 | const char *name; |
572 | size_t msize; | 567 | size_t msize; |
573 | 568 | ||
574 | msize = ntohs (msg->header.size) - sizeof (*msg); | 569 | msize = ntohs(msg->header.size) - sizeof(*msg); |
575 | if (msize != GNUNET_STRINGS_buffer_tokenize ((const char *) &msg[1], | 570 | if (msize != GNUNET_STRINGS_buffer_tokenize((const char *)&msg[1], |
576 | msize, | 571 | msize, |
577 | 2, | 572 | 2, |
578 | &service, | 573 | &service, |
579 | &name)) | 574 | &name)) |
580 | { | 575 | { |
581 | GNUNET_break (0); | 576 | GNUNET_break(0); |
582 | return GNUNET_SYSERR; | 577 | return GNUNET_SYSERR; |
583 | } | 578 | } |
584 | return GNUNET_OK; | 579 | return GNUNET_OK; |
585 | } | 580 | } |
586 | 581 | ||
@@ -592,7 +587,7 @@ check_set (void *cls, const struct GNUNET_STATISTICS_SetMessage *msg) | |||
592 | * @param message the actual message | 587 | * @param message the actual message |
593 | */ | 588 | */ |
594 | static void | 589 | static void |
595 | handle_set (void *cls, const struct GNUNET_STATISTICS_SetMessage *msg) | 590 | handle_set(void *cls, const struct GNUNET_STATISTICS_SetMessage *msg) |
596 | { | 591 | { |
597 | struct ClientEntry *ce = cls; | 592 | struct ClientEntry *ce = cls; |
598 | const char *service; | 593 | const char *service; |
@@ -608,95 +603,95 @@ handle_set (void *cls, const struct GNUNET_STATISTICS_SetMessage *msg) | |||
608 | int changed; | 603 | int changed; |
609 | int initial_set; | 604 | int initial_set; |
610 | 605 | ||
611 | msize = ntohs (msg->header.size); | 606 | msize = ntohs(msg->header.size); |
612 | size = msize - sizeof (struct GNUNET_STATISTICS_SetMessage); | 607 | size = msize - sizeof(struct GNUNET_STATISTICS_SetMessage); |
613 | GNUNET_assert (size == GNUNET_STRINGS_buffer_tokenize ((const char *) &msg[1], | 608 | GNUNET_assert(size == GNUNET_STRINGS_buffer_tokenize((const char *)&msg[1], |
614 | size, | 609 | size, |
615 | 2, | 610 | 2, |
616 | &service, | 611 | &service, |
617 | &name)); | 612 | &name)); |
618 | se = find_subsystem_entry (ce, service); | 613 | se = find_subsystem_entry(ce, service); |
619 | flags = ntohl (msg->flags); | 614 | flags = ntohl(msg->flags); |
620 | value = GNUNET_ntohll (msg->value); | 615 | value = GNUNET_ntohll(msg->value); |
621 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 616 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
622 | "Received request to update statistic on `%s:%s' (%u) to/by %llu\n", | 617 | "Received request to update statistic on `%s:%s' (%u) to/by %llu\n", |
623 | service, | 618 | service, |
624 | name, | 619 | name, |
625 | (unsigned int) flags, | 620 | (unsigned int)flags, |
626 | (unsigned long long) value); | 621 | (unsigned long long)value); |
627 | pos = find_stat_entry (se, name); | 622 | pos = find_stat_entry(se, name); |
628 | if (NULL != pos) | 623 | if (NULL != pos) |
629 | { | ||
630 | initial_set = 0; | ||
631 | if (0 == (flags & GNUNET_STATISTICS_SETFLAG_RELATIVE)) | ||
632 | { | 624 | { |
633 | changed = (pos->value != value); | 625 | initial_set = 0; |
634 | pos->value = value; | 626 | if (0 == (flags & GNUNET_STATISTICS_SETFLAG_RELATIVE)) |
635 | } | 627 | { |
636 | else | 628 | changed = (pos->value != value); |
637 | { | 629 | pos->value = value; |
638 | delta = (int64_t) value; | 630 | } |
639 | if ((delta < 0) && (pos->value < -delta)) | ||
640 | { | ||
641 | changed = (0 != pos->value); | ||
642 | pos->value = 0; | ||
643 | } | ||
644 | else | 631 | else |
645 | { | 632 | { |
646 | changed = (0 != delta); | 633 | delta = (int64_t)value; |
647 | GNUNET_break ((delta <= 0) || (pos->value + delta > pos->value)); | 634 | if ((delta < 0) && (pos->value < -delta)) |
648 | pos->value += delta; | 635 | { |
649 | } | 636 | changed = (0 != pos->value); |
637 | pos->value = 0; | ||
638 | } | ||
639 | else | ||
640 | { | ||
641 | changed = (0 != delta); | ||
642 | GNUNET_break((delta <= 0) || (pos->value + delta > pos->value)); | ||
643 | pos->value += delta; | ||
644 | } | ||
645 | } | ||
646 | if (GNUNET_NO == pos->set) | ||
647 | { | ||
648 | pos->set = GNUNET_YES; | ||
649 | initial_set = 1; | ||
650 | } | ||
651 | pos->persistent = (0 != (flags & GNUNET_STATISTICS_SETFLAG_PERSISTENT)); | ||
652 | if (pos != se->stat_head) | ||
653 | { | ||
654 | /* move to front for faster setting next time! */ | ||
655 | GNUNET_CONTAINER_DLL_remove(se->stat_head, se->stat_tail, pos); | ||
656 | GNUNET_CONTAINER_DLL_insert(se->stat_head, se->stat_tail, pos); | ||
657 | } | ||
658 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
659 | "Statistic `%s:%s' updated to value %llu (%d).\n", | ||
660 | service, | ||
661 | name, | ||
662 | (unsigned long long)pos->value, | ||
663 | pos->persistent); | ||
664 | if ((changed) || (1 == initial_set)) | ||
665 | notify_change(pos); | ||
666 | GNUNET_SERVICE_client_continue(ce->client); | ||
667 | return; | ||
650 | } | 668 | } |
651 | if (GNUNET_NO == pos->set) | 669 | /* not found, create a new entry */ |
670 | nlen = strlen(name) + 1; | ||
671 | pos = GNUNET_malloc(sizeof(struct StatsEntry) + nlen); | ||
672 | GNUNET_memcpy(&pos[1], name, nlen); | ||
673 | pos->name = (const char *)&pos[1]; | ||
674 | pos->subsystem = se; | ||
675 | if ((0 == (flags & GNUNET_STATISTICS_SETFLAG_RELATIVE)) || | ||
676 | (0 < (int64_t)GNUNET_ntohll(msg->value))) | ||
652 | { | 677 | { |
678 | pos->value = GNUNET_ntohll(msg->value); | ||
653 | pos->set = GNUNET_YES; | 679 | pos->set = GNUNET_YES; |
654 | initial_set = 1; | ||
655 | } | 680 | } |
656 | pos->persistent = (0 != (flags & GNUNET_STATISTICS_SETFLAG_PERSISTENT)); | 681 | else |
657 | if (pos != se->stat_head) | ||
658 | { | 682 | { |
659 | /* move to front for faster setting next time! */ | 683 | pos->set = GNUNET_NO; |
660 | GNUNET_CONTAINER_DLL_remove (se->stat_head, se->stat_tail, pos); | ||
661 | GNUNET_CONTAINER_DLL_insert (se->stat_head, se->stat_tail, pos); | ||
662 | } | 684 | } |
663 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
664 | "Statistic `%s:%s' updated to value %llu (%d).\n", | ||
665 | service, | ||
666 | name, | ||
667 | (unsigned long long) pos->value, | ||
668 | pos->persistent); | ||
669 | if ((changed) || (1 == initial_set)) | ||
670 | notify_change (pos); | ||
671 | GNUNET_SERVICE_client_continue (ce->client); | ||
672 | return; | ||
673 | } | ||
674 | /* not found, create a new entry */ | ||
675 | nlen = strlen (name) + 1; | ||
676 | pos = GNUNET_malloc (sizeof (struct StatsEntry) + nlen); | ||
677 | GNUNET_memcpy (&pos[1], name, nlen); | ||
678 | pos->name = (const char *) &pos[1]; | ||
679 | pos->subsystem = se; | ||
680 | if ((0 == (flags & GNUNET_STATISTICS_SETFLAG_RELATIVE)) || | ||
681 | (0 < (int64_t) GNUNET_ntohll (msg->value))) | ||
682 | { | ||
683 | pos->value = GNUNET_ntohll (msg->value); | ||
684 | pos->set = GNUNET_YES; | ||
685 | } | ||
686 | else | ||
687 | { | ||
688 | pos->set = GNUNET_NO; | ||
689 | } | ||
690 | pos->uid = uidgen++; | 685 | pos->uid = uidgen++; |
691 | pos->persistent = (0 != (flags & GNUNET_STATISTICS_SETFLAG_PERSISTENT)); | 686 | pos->persistent = (0 != (flags & GNUNET_STATISTICS_SETFLAG_PERSISTENT)); |
692 | GNUNET_CONTAINER_DLL_insert (se->stat_head, se->stat_tail, pos); | 687 | GNUNET_CONTAINER_DLL_insert(se->stat_head, se->stat_tail, pos); |
693 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 688 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
694 | "New statistic on `%s:%s' with value %llu created.\n", | 689 | "New statistic on `%s:%s' with value %llu created.\n", |
695 | service, | 690 | service, |
696 | name, | 691 | name, |
697 | (unsigned long long) pos->value); | 692 | (unsigned long long)pos->value); |
698 | if (NULL != ce) | 693 | if (NULL != ce) |
699 | GNUNET_SERVICE_client_continue (ce->client); | 694 | GNUNET_SERVICE_client_continue(ce->client); |
700 | } | 695 | } |
701 | 696 | ||
702 | 697 | ||
@@ -708,22 +703,22 @@ handle_set (void *cls, const struct GNUNET_STATISTICS_SetMessage *msg) | |||
708 | * @return #GNUNET_OK if message is well-formed | 703 | * @return #GNUNET_OK if message is well-formed |
709 | */ | 704 | */ |
710 | static int | 705 | static int |
711 | check_watch (void *cls, const struct GNUNET_MessageHeader *message) | 706 | check_watch(void *cls, const struct GNUNET_MessageHeader *message) |
712 | { | 707 | { |
713 | size_t size; | 708 | size_t size; |
714 | const char *service; | 709 | const char *service; |
715 | const char *name; | 710 | const char *name; |
716 | 711 | ||
717 | size = ntohs (message->size) - sizeof (struct GNUNET_MessageHeader); | 712 | size = ntohs(message->size) - sizeof(struct GNUNET_MessageHeader); |
718 | if (size != GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1], | 713 | if (size != GNUNET_STRINGS_buffer_tokenize((const char *)&message[1], |
719 | size, | 714 | size, |
720 | 2, | 715 | 2, |
721 | &service, | 716 | &service, |
722 | &name)) | 717 | &name)) |
723 | { | 718 | { |
724 | GNUNET_break (0); | 719 | GNUNET_break(0); |
725 | return GNUNET_SYSERR; | 720 | return GNUNET_SYSERR; |
726 | } | 721 | } |
727 | return GNUNET_OK; | 722 | return GNUNET_OK; |
728 | } | 723 | } |
729 | 724 | ||
@@ -735,7 +730,7 @@ check_watch (void *cls, const struct GNUNET_MessageHeader *message) | |||
735 | * @param message the actual message | 730 | * @param message the actual message |
736 | */ | 731 | */ |
737 | static void | 732 | static void |
738 | handle_watch (void *cls, const struct GNUNET_MessageHeader *message) | 733 | handle_watch(void *cls, const struct GNUNET_MessageHeader *message) |
739 | { | 734 | { |
740 | struct ClientEntry *ce = cls; | 735 | struct ClientEntry *ce = cls; |
741 | const char *service; | 736 | const char *service; |
@@ -748,49 +743,49 @@ handle_watch (void *cls, const struct GNUNET_MessageHeader *message) | |||
748 | size_t nlen; | 743 | size_t nlen; |
749 | 744 | ||
750 | if (NULL == nc) | 745 | if (NULL == nc) |
751 | { | 746 | { |
752 | GNUNET_SERVICE_client_drop (ce->client); | 747 | GNUNET_SERVICE_client_drop(ce->client); |
753 | return; | 748 | return; |
754 | } | 749 | } |
755 | GNUNET_SERVICE_client_mark_monitor (ce->client); | 750 | GNUNET_SERVICE_client_mark_monitor(ce->client); |
756 | msize = ntohs (message->size); | 751 | msize = ntohs(message->size); |
757 | size = msize - sizeof (struct GNUNET_MessageHeader); | 752 | size = msize - sizeof(struct GNUNET_MessageHeader); |
758 | GNUNET_assert (size == | 753 | GNUNET_assert(size == |
759 | GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1], | 754 | GNUNET_STRINGS_buffer_tokenize((const char *)&message[1], |
760 | size, | 755 | size, |
761 | 2, | 756 | 2, |
762 | &service, | 757 | &service, |
763 | &name)); | 758 | &name)); |
764 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 759 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
765 | "Received request to watch statistic on `%s:%s'\n", | 760 | "Received request to watch statistic on `%s:%s'\n", |
766 | service, | 761 | service, |
767 | name); | 762 | name); |
768 | se = find_subsystem_entry (ce, service); | 763 | se = find_subsystem_entry(ce, service); |
769 | pos = find_stat_entry (se, name); | 764 | pos = find_stat_entry(se, name); |
770 | if (NULL == pos) | 765 | if (NULL == pos) |
771 | { | 766 | { |
772 | nlen = strlen (name) + 1; | 767 | nlen = strlen(name) + 1; |
773 | pos = GNUNET_malloc (sizeof (struct StatsEntry) + nlen); | 768 | pos = GNUNET_malloc(sizeof(struct StatsEntry) + nlen); |
774 | GNUNET_memcpy (&pos[1], name, nlen); | 769 | GNUNET_memcpy(&pos[1], name, nlen); |
775 | pos->name = (const char *) &pos[1]; | 770 | pos->name = (const char *)&pos[1]; |
776 | pos->subsystem = se; | 771 | pos->subsystem = se; |
777 | GNUNET_CONTAINER_DLL_insert (se->stat_head, se->stat_tail, pos); | 772 | GNUNET_CONTAINER_DLL_insert(se->stat_head, se->stat_tail, pos); |
778 | pos->uid = uidgen++; | 773 | pos->uid = uidgen++; |
779 | pos->set = GNUNET_NO; | 774 | pos->set = GNUNET_NO; |
780 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 775 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
781 | "New statistic on `%s:%s' with value %llu created.\n", | 776 | "New statistic on `%s:%s' with value %llu created.\n", |
782 | service, | 777 | service, |
783 | name, | 778 | name, |
784 | (unsigned long long) pos->value); | 779 | (unsigned long long)pos->value); |
785 | } | 780 | } |
786 | we = GNUNET_new (struct WatchEntry); | 781 | we = GNUNET_new(struct WatchEntry); |
787 | we->ce = ce; | 782 | we->ce = ce; |
788 | we->last_value_set = GNUNET_NO; | 783 | we->last_value_set = GNUNET_NO; |
789 | we->wid = ce->max_wid++; | 784 | we->wid = ce->max_wid++; |
790 | GNUNET_CONTAINER_DLL_insert (pos->we_head, pos->we_tail, we); | 785 | GNUNET_CONTAINER_DLL_insert(pos->we_head, pos->we_tail, we); |
791 | if (0 != pos->value) | 786 | if (0 != pos->value) |
792 | notify_change (pos); | 787 | notify_change(pos); |
793 | GNUNET_SERVICE_client_continue (ce->client); | 788 | GNUNET_SERVICE_client_continue(ce->client); |
794 | } | 789 | } |
795 | 790 | ||
796 | 791 | ||
@@ -803,15 +798,15 @@ handle_watch (void *cls, const struct GNUNET_MessageHeader *message) | |||
803 | * @param message the actual message | 798 | * @param message the actual message |
804 | */ | 799 | */ |
805 | static void | 800 | static void |
806 | handle_disconnect (void *cls, const struct GNUNET_MessageHeader *message) | 801 | handle_disconnect(void *cls, const struct GNUNET_MessageHeader *message) |
807 | { | 802 | { |
808 | struct ClientEntry *ce = cls; | 803 | struct ClientEntry *ce = cls; |
809 | struct GNUNET_MQ_Envelope *env; | 804 | struct GNUNET_MQ_Envelope *env; |
810 | struct GNUNET_MessageHeader *msg; | 805 | struct GNUNET_MessageHeader *msg; |
811 | 806 | ||
812 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM); | 807 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM); |
813 | GNUNET_MQ_send (ce->mq, env); | 808 | GNUNET_MQ_send(ce->mq, env); |
814 | GNUNET_SERVICE_client_continue (ce->client); | 809 | GNUNET_SERVICE_client_continue(ce->client); |
815 | } | 810 | } |
816 | 811 | ||
817 | 812 | ||
@@ -819,7 +814,7 @@ handle_disconnect (void *cls, const struct GNUNET_MessageHeader *message) | |||
819 | * Actually perform the shutdown. | 814 | * Actually perform the shutdown. |
820 | */ | 815 | */ |
821 | static void | 816 | static void |
822 | do_shutdown () | 817 | do_shutdown() |
823 | { | 818 | { |
824 | struct WatchEntry *we; | 819 | struct WatchEntry *we; |
825 | struct StatsEntry *pos; | 820 | struct StatsEntry *pos; |
@@ -827,26 +822,26 @@ do_shutdown () | |||
827 | 822 | ||
828 | if (NULL == nc) | 823 | if (NULL == nc) |
829 | return; | 824 | return; |
830 | save (); | 825 | save(); |
831 | GNUNET_notification_context_destroy (nc); | 826 | GNUNET_notification_context_destroy(nc); |
832 | nc = NULL; | 827 | nc = NULL; |
833 | GNUNET_assert (0 == client_count); | 828 | GNUNET_assert(0 == client_count); |
834 | while (NULL != (se = sub_head)) | 829 | while (NULL != (se = sub_head)) |
835 | { | ||
836 | GNUNET_CONTAINER_DLL_remove (sub_head, sub_tail, se); | ||
837 | while (NULL != (pos = se->stat_head)) | ||
838 | { | 830 | { |
839 | GNUNET_CONTAINER_DLL_remove (se->stat_head, se->stat_tail, pos); | 831 | GNUNET_CONTAINER_DLL_remove(sub_head, sub_tail, se); |
840 | while (NULL != (we = pos->we_head)) | 832 | while (NULL != (pos = se->stat_head)) |
841 | { | 833 | { |
842 | GNUNET_break (0); | 834 | GNUNET_CONTAINER_DLL_remove(se->stat_head, se->stat_tail, pos); |
843 | GNUNET_CONTAINER_DLL_remove (pos->we_head, pos->we_tail, we); | 835 | while (NULL != (we = pos->we_head)) |
844 | GNUNET_free (we); | 836 | { |
845 | } | 837 | GNUNET_break(0); |
846 | GNUNET_free (pos); | 838 | GNUNET_CONTAINER_DLL_remove(pos->we_head, pos->we_tail, we); |
839 | GNUNET_free(we); | ||
840 | } | ||
841 | GNUNET_free(pos); | ||
842 | } | ||
843 | GNUNET_free(se); | ||
847 | } | 844 | } |
848 | GNUNET_free (se); | ||
849 | } | ||
850 | } | 845 | } |
851 | 846 | ||
852 | 847 | ||
@@ -856,12 +851,12 @@ do_shutdown () | |||
856 | * @param cls unused | 851 | * @param cls unused |
857 | */ | 852 | */ |
858 | static void | 853 | static void |
859 | shutdown_task (void *cls) | 854 | shutdown_task(void *cls) |
860 | { | 855 | { |
861 | in_shutdown = GNUNET_YES; | 856 | in_shutdown = GNUNET_YES; |
862 | if (0 != client_count) | 857 | if (0 != client_count) |
863 | return; | 858 | return; |
864 | do_shutdown (); | 859 | do_shutdown(); |
865 | } | 860 | } |
866 | 861 | ||
867 | 862 | ||
@@ -873,9 +868,9 @@ shutdown_task (void *cls) | |||
873 | * @param app_cls the `struct ClientEntry *` | 868 | * @param app_cls the `struct ClientEntry *` |
874 | */ | 869 | */ |
875 | static void | 870 | static void |
876 | client_disconnect_cb (void *cls, | 871 | client_disconnect_cb(void *cls, |
877 | struct GNUNET_SERVICE_Client *client, | 872 | struct GNUNET_SERVICE_Client *client, |
878 | void *app_cls) | 873 | void *app_cls) |
879 | { | 874 | { |
880 | struct ClientEntry *ce = app_cls; | 875 | struct ClientEntry *ce = app_cls; |
881 | struct WatchEntry *we; | 876 | struct WatchEntry *we; |
@@ -885,23 +880,23 @@ client_disconnect_cb (void *cls, | |||
885 | 880 | ||
886 | client_count--; | 881 | client_count--; |
887 | for (se = sub_head; NULL != se; se = se->next) | 882 | for (se = sub_head; NULL != se; se = se->next) |
888 | { | ||
889 | for (pos = se->stat_head; NULL != pos; pos = pos->next) | ||
890 | { | 883 | { |
891 | wen = pos->we_head; | 884 | for (pos = se->stat_head; NULL != pos; pos = pos->next) |
892 | while (NULL != (we = wen)) | 885 | { |
893 | { | 886 | wen = pos->we_head; |
894 | wen = we->next; | 887 | while (NULL != (we = wen)) |
895 | if (we->ce != ce) | 888 | { |
896 | continue; | 889 | wen = we->next; |
897 | GNUNET_CONTAINER_DLL_remove (pos->we_head, pos->we_tail, we); | 890 | if (we->ce != ce) |
898 | GNUNET_free (we); | 891 | continue; |
899 | } | 892 | GNUNET_CONTAINER_DLL_remove(pos->we_head, pos->we_tail, we); |
893 | GNUNET_free(we); | ||
894 | } | ||
895 | } | ||
900 | } | 896 | } |
901 | } | 897 | GNUNET_free(ce); |
902 | GNUNET_free (ce); | ||
903 | if ((0 == client_count) && (GNUNET_YES == in_shutdown)) | 898 | if ((0 == client_count) && (GNUNET_YES == in_shutdown)) |
904 | do_shutdown (); | 899 | do_shutdown(); |
905 | } | 900 | } |
906 | 901 | ||
907 | 902 | ||
@@ -917,19 +912,19 @@ client_disconnect_cb (void *cls, | |||
917 | * #GNUNET_SYSERR to stop further processing with error | 912 | * #GNUNET_SYSERR to stop further processing with error |
918 | */ | 913 | */ |
919 | static int | 914 | static int |
920 | inject_message (void *cls, const struct GNUNET_MessageHeader *message) | 915 | inject_message(void *cls, const struct GNUNET_MessageHeader *message) |
921 | { | 916 | { |
922 | uint16_t msize = ntohs (message->size); | 917 | uint16_t msize = ntohs(message->size); |
923 | const struct GNUNET_STATISTICS_SetMessage *sm; | 918 | const struct GNUNET_STATISTICS_SetMessage *sm; |
924 | 919 | ||
925 | sm = (const struct GNUNET_STATISTICS_SetMessage *) message; | 920 | sm = (const struct GNUNET_STATISTICS_SetMessage *)message; |
926 | if ((sizeof (struct GNUNET_STATISTICS_SetMessage) > msize) || | 921 | if ((sizeof(struct GNUNET_STATISTICS_SetMessage) > msize) || |
927 | (GNUNET_OK != check_set (NULL, sm))) | 922 | (GNUNET_OK != check_set(NULL, sm))) |
928 | { | 923 | { |
929 | GNUNET_break (0); | 924 | GNUNET_break(0); |
930 | return GNUNET_SYSERR; | 925 | return GNUNET_SYSERR; |
931 | } | 926 | } |
932 | handle_set (NULL, sm); | 927 | handle_set(NULL, sm); |
933 | return GNUNET_OK; | 928 | return GNUNET_OK; |
934 | } | 929 | } |
935 | 930 | ||
@@ -939,7 +934,7 @@ inject_message (void *cls, const struct GNUNET_MessageHeader *message) | |||
939 | * format that we also use for setting the values over the network. | 934 | * format that we also use for setting the values over the network. |
940 | */ | 935 | */ |
941 | static void | 936 | static void |
942 | load () | 937 | load() |
943 | { | 938 | { |
944 | char *fn; | 939 | char *fn; |
945 | struct GNUNET_BIO_ReadHandle *rh; | 940 | struct GNUNET_BIO_ReadHandle *rh; |
@@ -947,51 +942,51 @@ load () | |||
947 | char *buf; | 942 | char *buf; |
948 | struct GNUNET_MessageStreamTokenizer *mst; | 943 | struct GNUNET_MessageStreamTokenizer *mst; |
949 | 944 | ||
950 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, | 945 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg, |
951 | "STATISTICS", | 946 | "STATISTICS", |
952 | "DATABASE", | 947 | "DATABASE", |
953 | &fn)) | 948 | &fn)) |
954 | { | 949 | { |
955 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, | 950 | GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, |
956 | "STATISTICS", | 951 | "STATISTICS", |
957 | "DATABASE"); | 952 | "DATABASE"); |
958 | return; | 953 | return; |
959 | } | 954 | } |
960 | if ((GNUNET_OK != | 955 | if ((GNUNET_OK != |
961 | GNUNET_DISK_file_size (fn, &fsize, GNUNET_NO, GNUNET_YES)) || | 956 | GNUNET_DISK_file_size(fn, &fsize, GNUNET_NO, GNUNET_YES)) || |
962 | (0 == fsize)) | 957 | (0 == fsize)) |
963 | { | 958 | { |
964 | GNUNET_free (fn); | 959 | GNUNET_free(fn); |
965 | return; | 960 | return; |
966 | } | 961 | } |
967 | buf = GNUNET_malloc (fsize); | 962 | buf = GNUNET_malloc(fsize); |
968 | rh = GNUNET_BIO_read_open (fn); | 963 | rh = GNUNET_BIO_read_open(fn); |
969 | if (! rh) | 964 | if (!rh) |
970 | { | 965 | { |
971 | GNUNET_free (buf); | 966 | GNUNET_free(buf); |
972 | GNUNET_free (fn); | 967 | GNUNET_free(fn); |
973 | return; | 968 | return; |
974 | } | 969 | } |
975 | if (GNUNET_OK != GNUNET_BIO_read (rh, fn, buf, fsize)) | 970 | if (GNUNET_OK != GNUNET_BIO_read(rh, fn, buf, fsize)) |
976 | { | 971 | { |
977 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "read", fn); | 972 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "read", fn); |
978 | GNUNET_break (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL)); | 973 | GNUNET_break(GNUNET_OK == GNUNET_BIO_read_close(rh, NULL)); |
979 | GNUNET_free (buf); | 974 | GNUNET_free(buf); |
980 | GNUNET_free (fn); | 975 | GNUNET_free(fn); |
981 | return; | 976 | return; |
982 | } | 977 | } |
983 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 978 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
984 | _ ("Loading %llu bytes of statistics from `%s'\n"), | 979 | _("Loading %llu bytes of statistics from `%s'\n"), |
985 | (unsigned long long) fsize, | 980 | (unsigned long long)fsize, |
986 | fn); | 981 | fn); |
987 | mst = GNUNET_MST_create (&inject_message, NULL); | 982 | mst = GNUNET_MST_create(&inject_message, NULL); |
988 | GNUNET_break ( | 983 | GNUNET_break( |
989 | GNUNET_OK == | 984 | GNUNET_OK == |
990 | GNUNET_MST_from_buffer (mst, buf, (size_t) fsize, GNUNET_YES, GNUNET_NO)); | 985 | GNUNET_MST_from_buffer(mst, buf, (size_t)fsize, GNUNET_YES, GNUNET_NO)); |
991 | GNUNET_MST_destroy (mst); | 986 | GNUNET_MST_destroy(mst); |
992 | GNUNET_free (buf); | 987 | GNUNET_free(buf); |
993 | GNUNET_break (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL)); | 988 | GNUNET_break(GNUNET_OK == GNUNET_BIO_read_close(rh, NULL)); |
994 | GNUNET_free (fn); | 989 | GNUNET_free(fn); |
995 | } | 990 | } |
996 | 991 | ||
997 | 992 | ||
@@ -1003,44 +998,44 @@ load () | |||
1003 | * @param service the initialized service | 998 | * @param service the initialized service |
1004 | */ | 999 | */ |
1005 | static void | 1000 | static void |
1006 | run (void *cls, | 1001 | run(void *cls, |
1007 | const struct GNUNET_CONFIGURATION_Handle *c, | 1002 | const struct GNUNET_CONFIGURATION_Handle *c, |
1008 | struct GNUNET_SERVICE_Handle *service) | 1003 | struct GNUNET_SERVICE_Handle *service) |
1009 | { | 1004 | { |
1010 | cfg = c; | 1005 | cfg = c; |
1011 | nc = GNUNET_notification_context_create (16); | 1006 | nc = GNUNET_notification_context_create(16); |
1012 | load (); | 1007 | load(); |
1013 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); | 1008 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); |
1014 | } | 1009 | } |
1015 | 1010 | ||
1016 | 1011 | ||
1017 | /** | 1012 | /** |
1018 | * Define "main" method using service macro. | 1013 | * Define "main" method using service macro. |
1019 | */ | 1014 | */ |
1020 | GNUNET_SERVICE_MAIN ( | 1015 | GNUNET_SERVICE_MAIN( |
1021 | "statistics", | 1016 | "statistics", |
1022 | GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, | 1017 | GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, |
1023 | &run, | 1018 | &run, |
1024 | &client_connect_cb, | 1019 | &client_connect_cb, |
1025 | &client_disconnect_cb, | 1020 | &client_disconnect_cb, |
1026 | NULL, | 1021 | NULL, |
1027 | GNUNET_MQ_hd_var_size (set, | 1022 | GNUNET_MQ_hd_var_size(set, |
1028 | GNUNET_MESSAGE_TYPE_STATISTICS_SET, | 1023 | GNUNET_MESSAGE_TYPE_STATISTICS_SET, |
1029 | struct GNUNET_STATISTICS_SetMessage, | 1024 | struct GNUNET_STATISTICS_SetMessage, |
1030 | NULL), | 1025 | NULL), |
1031 | GNUNET_MQ_hd_var_size (get, | 1026 | GNUNET_MQ_hd_var_size(get, |
1032 | GNUNET_MESSAGE_TYPE_STATISTICS_GET, | 1027 | GNUNET_MESSAGE_TYPE_STATISTICS_GET, |
1033 | struct GNUNET_MessageHeader, | 1028 | struct GNUNET_MessageHeader, |
1034 | NULL), | 1029 | NULL), |
1035 | GNUNET_MQ_hd_var_size (watch, | 1030 | GNUNET_MQ_hd_var_size(watch, |
1036 | GNUNET_MESSAGE_TYPE_STATISTICS_WATCH, | 1031 | GNUNET_MESSAGE_TYPE_STATISTICS_WATCH, |
1037 | struct GNUNET_MessageHeader, | 1032 | struct GNUNET_MessageHeader, |
1038 | NULL), | 1033 | NULL), |
1039 | GNUNET_MQ_hd_fixed_size (disconnect, | 1034 | GNUNET_MQ_hd_fixed_size(disconnect, |
1040 | GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT, | 1035 | GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT, |
1041 | struct GNUNET_MessageHeader, | 1036 | struct GNUNET_MessageHeader, |
1042 | NULL), | 1037 | NULL), |
1043 | GNUNET_MQ_handler_end ()); | 1038 | GNUNET_MQ_handler_end()); |
1044 | 1039 | ||
1045 | 1040 | ||
1046 | #if defined(LINUX) && defined(__GLIBC__) | 1041 | #if defined(LINUX) && defined(__GLIBC__) |
@@ -1049,11 +1044,11 @@ GNUNET_SERVICE_MAIN ( | |||
1049 | /** | 1044 | /** |
1050 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. | 1045 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. |
1051 | */ | 1046 | */ |
1052 | void __attribute__ ((constructor)) GNUNET_STATISTICS_memory_init () | 1047 | void __attribute__ ((constructor)) GNUNET_STATISTICS_memory_init() |
1053 | { | 1048 | { |
1054 | mallopt (M_TRIM_THRESHOLD, 4 * 1024); | 1049 | mallopt(M_TRIM_THRESHOLD, 4 * 1024); |
1055 | mallopt (M_TOP_PAD, 1 * 1024); | 1050 | mallopt(M_TOP_PAD, 1 * 1024); |
1056 | malloc_trim (0); | 1051 | malloc_trim(0); |
1057 | } | 1052 | } |
1058 | #endif | 1053 | #endif |
1059 | 1054 | ||
diff --git a/src/statistics/gnunet-statistics.c b/src/statistics/gnunet-statistics.c index f1ea8cb19..470bb2ed8 100644 --- a/src/statistics/gnunet-statistics.c +++ b/src/statistics/gnunet-statistics.c | |||
@@ -16,7 +16,7 @@ | |||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file statistics/gnunet-statistics.c | 22 | * @file statistics/gnunet-statistics.c |
@@ -93,8 +93,7 @@ static int set_value; | |||
93 | /** | 93 | /** |
94 | * @brief Representation of all (testbed) nodes. | 94 | * @brief Representation of all (testbed) nodes. |
95 | */ | 95 | */ |
96 | static struct Node | 96 | static struct Node { |
97 | { | ||
98 | /** | 97 | /** |
99 | * @brief Index of the node in this array. | 98 | * @brief Index of the node in this array. |
100 | */ | 99 | */ |
@@ -128,8 +127,7 @@ static unsigned num_nodes; | |||
128 | /** | 127 | /** |
129 | * @brief Set of values for a combination of subsystem and name. | 128 | * @brief Set of values for a combination of subsystem and name. |
130 | */ | 129 | */ |
131 | struct ValueSet | 130 | struct ValueSet { |
132 | { | ||
133 | /** | 131 | /** |
134 | * @brief Subsystem of the valueset. | 132 | * @brief Subsystem of the valueset. |
135 | */ | 133 | */ |
@@ -177,17 +175,17 @@ static int num_nodes_ready_shutdown; | |||
177 | * @return Newly allocated #ValueSet. | 175 | * @return Newly allocated #ValueSet. |
178 | */ | 176 | */ |
179 | static struct ValueSet * | 177 | static struct ValueSet * |
180 | new_value_set (const char *subsystem, | 178 | new_value_set(const char *subsystem, |
181 | const char *name, | 179 | const char *name, |
182 | unsigned num_values, | 180 | unsigned num_values, |
183 | int is_persistent) | 181 | int is_persistent) |
184 | { | 182 | { |
185 | struct ValueSet *value_set; | 183 | struct ValueSet *value_set; |
186 | 184 | ||
187 | value_set = GNUNET_new (struct ValueSet); | 185 | value_set = GNUNET_new(struct ValueSet); |
188 | value_set->subsystem = GNUNET_strdup (subsystem); | 186 | value_set->subsystem = GNUNET_strdup(subsystem); |
189 | value_set->name = GNUNET_strdup (name); | 187 | value_set->name = GNUNET_strdup(name); |
190 | value_set->values = GNUNET_new_array (num_values, uint64_t); | 188 | value_set->values = GNUNET_new_array(num_values, uint64_t); |
191 | value_set->is_persistent = persistent; | 189 | value_set->is_persistent = persistent; |
192 | return value_set; | 190 | return value_set; |
193 | } | 191 | } |
@@ -205,56 +203,56 @@ new_value_set (const char *subsystem, | |||
205 | * @return GNUNET_YES - continue iteration. | 203 | * @return GNUNET_YES - continue iteration. |
206 | */ | 204 | */ |
207 | static int | 205 | static int |
208 | printer (void *cls, const struct GNUNET_HashCode *key, void *value) | 206 | printer(void *cls, const struct GNUNET_HashCode *key, void *value) |
209 | { | 207 | { |
210 | struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get (); | 208 | struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get(); |
211 | const char *now_str; | 209 | const char *now_str; |
212 | struct ValueSet *value_set = value; | 210 | struct ValueSet *value_set = value; |
213 | 211 | ||
214 | if (quiet == GNUNET_NO) | 212 | if (quiet == GNUNET_NO) |
215 | { | ||
216 | if (GNUNET_YES == watch) | ||
217 | { | 213 | { |
218 | now_str = GNUNET_STRINGS_absolute_time_to_string (now); | 214 | if (GNUNET_YES == watch) |
219 | fprintf (stdout, | 215 | { |
220 | "%24s%s %s%s%12s%s %s%50s%s%s ", | 216 | now_str = GNUNET_STRINGS_absolute_time_to_string(now); |
221 | now_str, | 217 | fprintf(stdout, |
222 | csv_separator, | 218 | "%24s%s %s%s%12s%s %s%50s%s%s ", |
223 | value_set->is_persistent ? "!" : " ", | 219 | now_str, |
224 | csv_separator, | 220 | csv_separator, |
225 | value_set->subsystem, | 221 | value_set->is_persistent ? "!" : " ", |
226 | csv_separator, | 222 | csv_separator, |
227 | (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ | 223 | value_set->subsystem, |
228 | _ (value_set->name), | 224 | csv_separator, |
229 | (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ | 225 | (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */ |
230 | (0 == strlen (csv_separator) ? ":" : csv_separator)); | 226 | _(value_set->name), |
227 | (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */ | ||
228 | (0 == strlen(csv_separator) ? ":" : csv_separator)); | ||
229 | } | ||
230 | else | ||
231 | { | ||
232 | fprintf(stdout, | ||
233 | "%s%s%12s%s %s%50s%s%s ", | ||
234 | value_set->is_persistent ? "!" : " ", | ||
235 | csv_separator, | ||
236 | value_set->subsystem, | ||
237 | csv_separator, | ||
238 | (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */ | ||
239 | _(value_set->name), | ||
240 | (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */ | ||
241 | (0 == strlen(csv_separator) ? ":" : csv_separator)); | ||
242 | } | ||
231 | } | 243 | } |
232 | else | 244 | for (unsigned i = 0; i < num_nodes; i++) |
233 | { | 245 | { |
234 | fprintf (stdout, | 246 | fprintf(stdout, |
235 | "%s%s%12s%s %s%50s%s%s ", | 247 | "%16llu%s", |
236 | value_set->is_persistent ? "!" : " ", | 248 | (unsigned long long)value_set->values[i], |
237 | csv_separator, | 249 | csv_separator); |
238 | value_set->subsystem, | ||
239 | csv_separator, | ||
240 | (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ | ||
241 | _ (value_set->name), | ||
242 | (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ | ||
243 | (0 == strlen (csv_separator) ? ":" : csv_separator)); | ||
244 | } | 250 | } |
245 | } | 251 | fprintf(stdout, "\n"); |
246 | for (unsigned i = 0; i < num_nodes; i++) | 252 | GNUNET_free(value_set->subsystem); |
247 | { | 253 | GNUNET_free(value_set->name); |
248 | fprintf (stdout, | 254 | GNUNET_free(value_set->values); |
249 | "%16llu%s", | 255 | GNUNET_free(value_set); |
250 | (unsigned long long) value_set->values[i], | ||
251 | csv_separator); | ||
252 | } | ||
253 | fprintf (stdout, "\n"); | ||
254 | GNUNET_free (value_set->subsystem); | ||
255 | GNUNET_free (value_set->name); | ||
256 | GNUNET_free (value_set->values); | ||
257 | GNUNET_free (value_set); | ||
258 | return GNUNET_YES; | 256 | return GNUNET_YES; |
259 | } | 257 | } |
260 | 258 | ||
@@ -269,51 +267,51 @@ printer (void *cls, const struct GNUNET_HashCode *key, void *value) | |||
269 | * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration | 267 | * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration |
270 | */ | 268 | */ |
271 | static int | 269 | static int |
272 | printer_watch (void *cls, | 270 | printer_watch(void *cls, |
273 | const char *subsystem, | 271 | const char *subsystem, |
274 | const char *name, | 272 | const char *name, |
275 | uint64_t value, | 273 | uint64_t value, |
276 | int is_persistent) | 274 | int is_persistent) |
277 | { | 275 | { |
278 | struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get (); | 276 | struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get(); |
279 | const char *now_str; | 277 | const char *now_str; |
280 | 278 | ||
281 | if (quiet == GNUNET_NO) | 279 | if (quiet == GNUNET_NO) |
282 | { | ||
283 | if (GNUNET_YES == watch) | ||
284 | { | 280 | { |
285 | now_str = GNUNET_STRINGS_absolute_time_to_string (now); | 281 | if (GNUNET_YES == watch) |
286 | fprintf (stdout, | 282 | { |
287 | "%24s%s %s%s%12s%s %s%50s%s%s %16llu\n", | 283 | now_str = GNUNET_STRINGS_absolute_time_to_string(now); |
288 | now_str, | 284 | fprintf(stdout, |
289 | csv_separator, | 285 | "%24s%s %s%s%12s%s %s%50s%s%s %16llu\n", |
290 | is_persistent ? "!" : " ", | 286 | now_str, |
291 | csv_separator, | 287 | csv_separator, |
292 | subsystem, | 288 | is_persistent ? "!" : " ", |
293 | csv_separator, | 289 | csv_separator, |
294 | (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ | 290 | subsystem, |
295 | _ (name), | 291 | csv_separator, |
296 | (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ | 292 | (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */ |
297 | (0 == strlen (csv_separator) ? ":" : csv_separator), | 293 | _(name), |
298 | (unsigned long long) value); | 294 | (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */ |
295 | (0 == strlen(csv_separator) ? ":" : csv_separator), | ||
296 | (unsigned long long)value); | ||
297 | } | ||
298 | else | ||
299 | { | ||
300 | fprintf(stdout, | ||
301 | "%s%s%12s%s %s%50s%s%s %16llu\n", | ||
302 | is_persistent ? "!" : " ", | ||
303 | csv_separator, | ||
304 | subsystem, | ||
305 | csv_separator, | ||
306 | (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */ | ||
307 | _(name), | ||
308 | (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */ | ||
309 | (0 == strlen(csv_separator) ? ":" : csv_separator), | ||
310 | (unsigned long long)value); | ||
311 | } | ||
299 | } | 312 | } |
300 | else | ||
301 | { | ||
302 | fprintf (stdout, | ||
303 | "%s%s%12s%s %s%50s%s%s %16llu\n", | ||
304 | is_persistent ? "!" : " ", | ||
305 | csv_separator, | ||
306 | subsystem, | ||
307 | csv_separator, | ||
308 | (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ | ||
309 | _ (name), | ||
310 | (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */ | ||
311 | (0 == strlen (csv_separator) ? ":" : csv_separator), | ||
312 | (unsigned long long) value); | ||
313 | } | ||
314 | } | ||
315 | else | 313 | else |
316 | fprintf (stdout, "%llu\n", (unsigned long long) value); | 314 | fprintf(stdout, "%llu\n", (unsigned long long)value); |
317 | 315 | ||
318 | return GNUNET_OK; | 316 | return GNUNET_OK; |
319 | } | 317 | } |
@@ -326,50 +324,50 @@ printer_watch (void *cls, | |||
326 | * @param cls the index of the node | 324 | * @param cls the index of the node |
327 | */ | 325 | */ |
328 | static void | 326 | static void |
329 | clean_node (void *cls) | 327 | clean_node(void *cls) |
330 | { | 328 | { |
331 | const unsigned index_node = *(unsigned *) cls; | 329 | const unsigned index_node = *(unsigned *)cls; |
332 | struct GNUNET_STATISTICS_Handle *h; | 330 | struct GNUNET_STATISTICS_Handle *h; |
333 | struct GNUNET_STATISTICS_GetHandle *gh; | 331 | struct GNUNET_STATISTICS_GetHandle *gh; |
334 | 332 | ||
335 | if ((NULL != path_testbed) && /* were issued with -t <testbed-path> option */ | 333 | if ((NULL != path_testbed) && /* were issued with -t <testbed-path> option */ |
336 | (NULL != nodes[index_node].conf)) | 334 | (NULL != nodes[index_node].conf)) |
337 | { | 335 | { |
338 | GNUNET_CONFIGURATION_destroy (nodes[index_node].conf); | 336 | GNUNET_CONFIGURATION_destroy(nodes[index_node].conf); |
339 | nodes[index_node].conf = NULL; | 337 | nodes[index_node].conf = NULL; |
340 | } | 338 | } |
341 | 339 | ||
342 | h = nodes[index_node].handle; | 340 | h = nodes[index_node].handle; |
343 | gh = nodes[index_node].gh; | 341 | gh = nodes[index_node].gh; |
344 | 342 | ||
345 | if (NULL != gh) | 343 | if (NULL != gh) |
346 | { | 344 | { |
347 | GNUNET_STATISTICS_get_cancel (gh); | 345 | GNUNET_STATISTICS_get_cancel(gh); |
348 | gh = NULL; | 346 | gh = NULL; |
349 | } | 347 | } |
350 | if (GNUNET_YES == watch) | 348 | if (GNUNET_YES == watch) |
351 | { | 349 | { |
352 | GNUNET_assert ( | 350 | GNUNET_assert( |
353 | GNUNET_OK == | 351 | GNUNET_OK == |
354 | GNUNET_STATISTICS_watch_cancel (h, | 352 | GNUNET_STATISTICS_watch_cancel(h, |
355 | subsystem, | 353 | subsystem, |
356 | name, | 354 | name, |
357 | &printer_watch, | 355 | &printer_watch, |
358 | &nodes[index_node].index_node)); | 356 | &nodes[index_node].index_node)); |
359 | } | 357 | } |
360 | 358 | ||
361 | if (NULL != h) | 359 | if (NULL != h) |
362 | { | 360 | { |
363 | GNUNET_STATISTICS_destroy (h, GNUNET_NO); | 361 | GNUNET_STATISTICS_destroy(h, GNUNET_NO); |
364 | h = NULL; | 362 | h = NULL; |
365 | } | 363 | } |
366 | 364 | ||
367 | num_nodes_ready_shutdown++; | 365 | num_nodes_ready_shutdown++; |
368 | if (num_nodes == num_nodes_ready_shutdown) | 366 | if (num_nodes == num_nodes_ready_shutdown) |
369 | { | 367 | { |
370 | GNUNET_array_grow (nodes, num_nodes, 0); | 368 | GNUNET_array_grow(nodes, num_nodes, 0); |
371 | GNUNET_CONTAINER_multihashmap_destroy (values); | 369 | GNUNET_CONTAINER_multihashmap_destroy(values); |
372 | } | 370 | } |
373 | } | 371 | } |
374 | 372 | ||
375 | /** | 373 | /** |
@@ -378,10 +376,10 @@ clean_node (void *cls) | |||
378 | * @param cls unused | 376 | * @param cls unused |
379 | */ | 377 | */ |
380 | static void | 378 | static void |
381 | print_finish (void *cls) | 379 | print_finish(void *cls) |
382 | { | 380 | { |
383 | GNUNET_CONTAINER_multihashmap_iterate (values, printer, NULL); | 381 | GNUNET_CONTAINER_multihashmap_iterate(values, printer, NULL); |
384 | GNUNET_SCHEDULER_shutdown (); | 382 | GNUNET_SCHEDULER_shutdown(); |
385 | } | 383 | } |
386 | 384 | ||
387 | /** | 385 | /** |
@@ -393,33 +391,33 @@ print_finish (void *cls) | |||
393 | * @param succes Whether statistics were obtained successfully. | 391 | * @param succes Whether statistics were obtained successfully. |
394 | */ | 392 | */ |
395 | static void | 393 | static void |
396 | continuation_print (void *cls, int success) | 394 | continuation_print(void *cls, int success) |
397 | { | 395 | { |
398 | const unsigned index_node = *(unsigned *) cls; | 396 | const unsigned index_node = *(unsigned *)cls; |
399 | 397 | ||
400 | nodes[index_node].gh = NULL; | 398 | nodes[index_node].gh = NULL; |
401 | if (GNUNET_OK != success) | 399 | if (GNUNET_OK != success) |
402 | { | 400 | { |
403 | if (NULL == remote_host) | 401 | if (NULL == remote_host) |
404 | fprintf (stderr, "%s", _ ("Failed to obtain statistics.\n")); | 402 | fprintf(stderr, "%s", _("Failed to obtain statistics.\n")); |
405 | else | 403 | else |
406 | fprintf (stderr, | 404 | fprintf(stderr, |
407 | _ ("Failed to obtain statistics from host `%s:%llu'\n"), | 405 | _("Failed to obtain statistics from host `%s:%llu'\n"), |
408 | remote_host, | 406 | remote_host, |
409 | remote_port); | 407 | remote_port); |
410 | ret = 1; | 408 | ret = 1; |
411 | } | 409 | } |
412 | if (NULL != nodes[index_node].shutdown_task) | 410 | if (NULL != nodes[index_node].shutdown_task) |
413 | { | 411 | { |
414 | GNUNET_SCHEDULER_cancel (nodes[index_node].shutdown_task); | 412 | GNUNET_SCHEDULER_cancel(nodes[index_node].shutdown_task); |
415 | nodes[index_node].shutdown_task = NULL; | 413 | nodes[index_node].shutdown_task = NULL; |
416 | } | 414 | } |
417 | GNUNET_SCHEDULER_add_now (clean_node, &nodes[index_node].index_node); | 415 | GNUNET_SCHEDULER_add_now(clean_node, &nodes[index_node].index_node); |
418 | num_nodes_ready++; | 416 | num_nodes_ready++; |
419 | if (num_nodes_ready == num_nodes) | 417 | if (num_nodes_ready == num_nodes) |
420 | { | 418 | { |
421 | GNUNET_SCHEDULER_add_now (print_finish, NULL); | 419 | GNUNET_SCHEDULER_add_now(print_finish, NULL); |
422 | } | 420 | } |
423 | } | 421 | } |
424 | 422 | ||
425 | /** | 423 | /** |
@@ -430,24 +428,24 @@ continuation_print (void *cls, int success) | |||
430 | * successfully obtained, #GNUNET_SYSERR if not. | 428 | * successfully obtained, #GNUNET_SYSERR if not. |
431 | */ | 429 | */ |
432 | static void | 430 | static void |
433 | cleanup (void *cls, int success) | 431 | cleanup(void *cls, int success) |
434 | { | 432 | { |
435 | for (unsigned i = 0; i < num_nodes; i++) | 433 | for (unsigned i = 0; i < num_nodes; i++) |
436 | { | 434 | { |
437 | nodes[i].gh = NULL; | 435 | nodes[i].gh = NULL; |
438 | } | 436 | } |
439 | if (GNUNET_OK != success) | 437 | if (GNUNET_OK != success) |
440 | { | 438 | { |
441 | if (NULL == remote_host) | 439 | if (NULL == remote_host) |
442 | fprintf (stderr, "%s", _ ("Failed to obtain statistics.\n")); | 440 | fprintf(stderr, "%s", _("Failed to obtain statistics.\n")); |
443 | else | 441 | else |
444 | fprintf (stderr, | 442 | fprintf(stderr, |
445 | _ ("Failed to obtain statistics from host `%s:%llu'\n"), | 443 | _("Failed to obtain statistics from host `%s:%llu'\n"), |
446 | remote_host, | 444 | remote_host, |
447 | remote_port); | 445 | remote_port); |
448 | ret = 1; | 446 | ret = 1; |
449 | } | 447 | } |
450 | GNUNET_SCHEDULER_shutdown (); | 448 | GNUNET_SCHEDULER_shutdown(); |
451 | } | 449 | } |
452 | 450 | ||
453 | /** | 451 | /** |
@@ -463,40 +461,40 @@ cleanup (void *cls, int success) | |||
463 | * @return GNUNET_OK - continue. | 461 | * @return GNUNET_OK - continue. |
464 | */ | 462 | */ |
465 | static int | 463 | static int |
466 | collector (void *cls, | 464 | collector(void *cls, |
467 | const char *subsystem, | 465 | const char *subsystem, |
468 | const char *name, | 466 | const char *name, |
469 | uint64_t value, | 467 | uint64_t value, |
470 | int is_persistent) | 468 | int is_persistent) |
471 | { | 469 | { |
472 | const unsigned index_node = *(unsigned *) cls; | 470 | const unsigned index_node = *(unsigned *)cls; |
473 | struct GNUNET_HashCode *key; | 471 | struct GNUNET_HashCode *key; |
474 | struct GNUNET_HashCode hc; | 472 | struct GNUNET_HashCode hc; |
475 | char *subsys_name; | 473 | char *subsys_name; |
476 | unsigned len_subsys_name; | 474 | unsigned len_subsys_name; |
477 | struct ValueSet *value_set; | 475 | struct ValueSet *value_set; |
478 | 476 | ||
479 | len_subsys_name = strlen (subsystem) + 3 + strlen (name) + 1; | 477 | len_subsys_name = strlen(subsystem) + 3 + strlen(name) + 1; |
480 | subsys_name = GNUNET_malloc (len_subsys_name); | 478 | subsys_name = GNUNET_malloc(len_subsys_name); |
481 | sprintf (subsys_name, "%s---%s", subsystem, name); | 479 | sprintf(subsys_name, "%s---%s", subsystem, name); |
482 | key = &hc; | 480 | key = &hc; |
483 | GNUNET_CRYPTO_hash (subsys_name, len_subsys_name, key); | 481 | GNUNET_CRYPTO_hash(subsys_name, len_subsys_name, key); |
484 | GNUNET_free (subsys_name); | 482 | GNUNET_free(subsys_name); |
485 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (values, key)) | 483 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(values, key)) |
486 | { | 484 | { |
487 | value_set = GNUNET_CONTAINER_multihashmap_get (values, key); | 485 | value_set = GNUNET_CONTAINER_multihashmap_get(values, key); |
488 | } | 486 | } |
489 | else | 487 | else |
490 | { | 488 | { |
491 | value_set = new_value_set (subsystem, name, num_nodes, is_persistent); | 489 | value_set = new_value_set(subsystem, name, num_nodes, is_persistent); |
492 | } | 490 | } |
493 | value_set->values[index_node] = value; | 491 | value_set->values[index_node] = value; |
494 | GNUNET_assert (GNUNET_YES == | 492 | GNUNET_assert(GNUNET_YES == |
495 | GNUNET_CONTAINER_multihashmap_put ( | 493 | GNUNET_CONTAINER_multihashmap_put( |
496 | values, | 494 | values, |
497 | key, | 495 | key, |
498 | value_set, | 496 | value_set, |
499 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 497 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
500 | return GNUNET_OK; | 498 | return GNUNET_OK; |
501 | } | 499 | } |
502 | 500 | ||
@@ -506,80 +504,80 @@ collector (void *cls, | |||
506 | * @param cls closure with our configuration | 504 | * @param cls closure with our configuration |
507 | */ | 505 | */ |
508 | static void | 506 | static void |
509 | main_task (void *cls) | 507 | main_task(void *cls) |
510 | { | 508 | { |
511 | unsigned index_node = *(unsigned *) cls; | 509 | unsigned index_node = *(unsigned *)cls; |
512 | const struct GNUNET_CONFIGURATION_Handle *cfg = nodes[index_node].conf; | 510 | const struct GNUNET_CONFIGURATION_Handle *cfg = nodes[index_node].conf; |
513 | 511 | ||
514 | if (set_value) | 512 | if (set_value) |
515 | { | ||
516 | if (NULL == subsystem) | ||
517 | { | 513 | { |
518 | fprintf (stderr, "%s", _ ("Missing argument: subsystem \n")); | 514 | if (NULL == subsystem) |
519 | ret = 1; | 515 | { |
520 | return; | 516 | fprintf(stderr, "%s", _("Missing argument: subsystem \n")); |
521 | } | 517 | ret = 1; |
522 | if (NULL == name) | 518 | return; |
523 | { | 519 | } |
524 | fprintf (stderr, "%s", _ ("Missing argument: name\n")); | 520 | if (NULL == name) |
525 | ret = 1; | 521 | { |
522 | fprintf(stderr, "%s", _("Missing argument: name\n")); | ||
523 | ret = 1; | ||
524 | return; | ||
525 | } | ||
526 | nodes[index_node].handle = GNUNET_STATISTICS_create(subsystem, cfg); | ||
527 | if (NULL == nodes[index_node].handle) | ||
528 | { | ||
529 | ret = 1; | ||
530 | return; | ||
531 | } | ||
532 | GNUNET_STATISTICS_set(nodes[index_node].handle, | ||
533 | name, | ||
534 | (uint64_t)set_val, | ||
535 | persistent); | ||
536 | GNUNET_STATISTICS_destroy(nodes[index_node].handle, GNUNET_YES); | ||
537 | nodes[index_node].handle = NULL; | ||
526 | return; | 538 | return; |
527 | } | 539 | } |
528 | nodes[index_node].handle = GNUNET_STATISTICS_create (subsystem, cfg); | 540 | if (NULL == (nodes[index_node].handle = |
529 | if (NULL == nodes[index_node].handle) | 541 | GNUNET_STATISTICS_create("gnunet-statistics", cfg))) |
530 | { | 542 | { |
531 | ret = 1; | 543 | ret = 1; |
532 | return; | 544 | return; |
533 | } | 545 | } |
534 | GNUNET_STATISTICS_set (nodes[index_node].handle, | ||
535 | name, | ||
536 | (uint64_t) set_val, | ||
537 | persistent); | ||
538 | GNUNET_STATISTICS_destroy (nodes[index_node].handle, GNUNET_YES); | ||
539 | nodes[index_node].handle = NULL; | ||
540 | return; | ||
541 | } | ||
542 | if (NULL == (nodes[index_node].handle = | ||
543 | GNUNET_STATISTICS_create ("gnunet-statistics", cfg))) | ||
544 | { | ||
545 | ret = 1; | ||
546 | return; | ||
547 | } | ||
548 | if (GNUNET_NO == watch) | 546 | if (GNUNET_NO == watch) |
549 | { | ||
550 | if (NULL == (nodes[index_node].gh = | ||
551 | GNUNET_STATISTICS_get (nodes[index_node].handle, | ||
552 | subsystem, | ||
553 | name, | ||
554 | &continuation_print, | ||
555 | &collector, | ||
556 | &nodes[index_node].index_node))) | ||
557 | cleanup (nodes[index_node].handle, GNUNET_SYSERR); | ||
558 | } | ||
559 | else | ||
560 | { | ||
561 | if ((NULL == subsystem) || (NULL == name)) | ||
562 | { | 547 | { |
563 | printf (_ ("No subsystem or name given\n")); | 548 | if (NULL == (nodes[index_node].gh = |
564 | GNUNET_STATISTICS_destroy (nodes[index_node].handle, GNUNET_NO); | 549 | GNUNET_STATISTICS_get(nodes[index_node].handle, |
565 | nodes[index_node].handle = NULL; | 550 | subsystem, |
566 | ret = 1; | 551 | name, |
567 | return; | 552 | &continuation_print, |
553 | &collector, | ||
554 | &nodes[index_node].index_node))) | ||
555 | cleanup(nodes[index_node].handle, GNUNET_SYSERR); | ||
568 | } | 556 | } |
569 | if (GNUNET_OK != GNUNET_STATISTICS_watch (nodes[index_node].handle, | 557 | else |
570 | subsystem, | ||
571 | name, | ||
572 | &printer_watch, | ||
573 | &nodes[index_node].index_node)) | ||
574 | { | 558 | { |
575 | fprintf (stderr, _ ("Failed to initialize watch routine\n")); | 559 | if ((NULL == subsystem) || (NULL == name)) |
576 | nodes[index_node].shutdown_task = | 560 | { |
577 | GNUNET_SCHEDULER_add_now (&clean_node, &nodes[index_node].index_node); | 561 | printf(_("No subsystem or name given\n")); |
578 | return; | 562 | GNUNET_STATISTICS_destroy(nodes[index_node].handle, GNUNET_NO); |
563 | nodes[index_node].handle = NULL; | ||
564 | ret = 1; | ||
565 | return; | ||
566 | } | ||
567 | if (GNUNET_OK != GNUNET_STATISTICS_watch(nodes[index_node].handle, | ||
568 | subsystem, | ||
569 | name, | ||
570 | &printer_watch, | ||
571 | &nodes[index_node].index_node)) | ||
572 | { | ||
573 | fprintf(stderr, _("Failed to initialize watch routine\n")); | ||
574 | nodes[index_node].shutdown_task = | ||
575 | GNUNET_SCHEDULER_add_now(&clean_node, &nodes[index_node].index_node); | ||
576 | return; | ||
577 | } | ||
579 | } | 578 | } |
580 | } | ||
581 | nodes[index_node].shutdown_task = | 579 | nodes[index_node].shutdown_task = |
582 | GNUNET_SCHEDULER_add_shutdown (&clean_node, &nodes[index_node].index_node); | 580 | GNUNET_SCHEDULER_add_shutdown(&clean_node, &nodes[index_node].index_node); |
583 | } | 581 | } |
584 | 582 | ||
585 | /** | 583 | /** |
@@ -594,27 +592,27 @@ main_task (void *cls) | |||
594 | * @return to continue iteration or not to | 592 | * @return to continue iteration or not to |
595 | */ | 593 | */ |
596 | static int | 594 | static int |
597 | iter_check_config (void *cls, const char *filename) | 595 | iter_check_config(void *cls, const char *filename) |
598 | { | 596 | { |
599 | if (0 == strncmp (GNUNET_STRINGS_get_short_name (filename), "config", 6)) | 597 | if (0 == strncmp(GNUNET_STRINGS_get_short_name(filename), "config", 6)) |
600 | { | ||
601 | /* Found the config - stop iteration successfully */ | ||
602 | GNUNET_array_grow (nodes, num_nodes, num_nodes + 1); | ||
603 | nodes[num_nodes - 1].conf = GNUNET_CONFIGURATION_create (); | ||
604 | nodes[num_nodes - 1].index_node = num_nodes - 1; | ||
605 | if (GNUNET_OK != | ||
606 | GNUNET_CONFIGURATION_load (nodes[num_nodes - 1].conf, filename)) | ||
607 | { | 598 | { |
608 | fprintf (stderr, "Failed loading config `%s'\n", filename); | 599 | /* Found the config - stop iteration successfully */ |
609 | return GNUNET_SYSERR; | 600 | GNUNET_array_grow(nodes, num_nodes, num_nodes + 1); |
601 | nodes[num_nodes - 1].conf = GNUNET_CONFIGURATION_create(); | ||
602 | nodes[num_nodes - 1].index_node = num_nodes - 1; | ||
603 | if (GNUNET_OK != | ||
604 | GNUNET_CONFIGURATION_load(nodes[num_nodes - 1].conf, filename)) | ||
605 | { | ||
606 | fprintf(stderr, "Failed loading config `%s'\n", filename); | ||
607 | return GNUNET_SYSERR; | ||
608 | } | ||
609 | return GNUNET_NO; | ||
610 | } | 610 | } |
611 | return GNUNET_NO; | ||
612 | } | ||
613 | else | 611 | else |
614 | { | 612 | { |
615 | /* Continue iteration */ | 613 | /* Continue iteration */ |
616 | return GNUNET_OK; | 614 | return GNUNET_OK; |
617 | } | 615 | } |
618 | } | 616 | } |
619 | 617 | ||
620 | /** | 618 | /** |
@@ -631,21 +629,21 @@ iter_check_config (void *cls, const char *filename) | |||
631 | * @return status whether to continue iteration | 629 | * @return status whether to continue iteration |
632 | */ | 630 | */ |
633 | static int | 631 | static int |
634 | iter_testbed_path (void *cls, const char *filename) | 632 | iter_testbed_path(void *cls, const char *filename) |
635 | { | 633 | { |
636 | unsigned index_node; | 634 | unsigned index_node; |
637 | 635 | ||
638 | GNUNET_assert (NULL != filename); | 636 | GNUNET_assert(NULL != filename); |
639 | if (1 == sscanf (GNUNET_STRINGS_get_short_name (filename), "%u", &index_node)) | 637 | if (1 == sscanf(GNUNET_STRINGS_get_short_name(filename), "%u", &index_node)) |
640 | { | ||
641 | if (-1 == GNUNET_DISK_directory_scan (filename, iter_check_config, NULL)) | ||
642 | { | 638 | { |
643 | /* This is probably no directory for a testbed node | 639 | if (-1 == GNUNET_DISK_directory_scan(filename, iter_check_config, NULL)) |
644 | * Go on with iteration */ | 640 | { |
641 | /* This is probably no directory for a testbed node | ||
642 | * Go on with iteration */ | ||
643 | return GNUNET_OK; | ||
644 | } | ||
645 | return GNUNET_OK; | 645 | return GNUNET_OK; |
646 | } | 646 | } |
647 | return GNUNET_OK; | ||
648 | } | ||
649 | return GNUNET_OK; | 647 | return GNUNET_OK; |
650 | } | 648 | } |
651 | 649 | ||
@@ -657,17 +655,17 @@ iter_testbed_path (void *cls, const char *filename) | |||
657 | * @return number of running nodes | 655 | * @return number of running nodes |
658 | */ | 656 | */ |
659 | static int | 657 | static int |
660 | discover_testbed_nodes (const char *path_testbed) | 658 | discover_testbed_nodes(const char *path_testbed) |
661 | { | 659 | { |
662 | int num_dir_entries; | 660 | int num_dir_entries; |
663 | 661 | ||
664 | num_dir_entries = | 662 | num_dir_entries = |
665 | GNUNET_DISK_directory_scan (path_testbed, iter_testbed_path, NULL); | 663 | GNUNET_DISK_directory_scan(path_testbed, iter_testbed_path, NULL); |
666 | if (-1 == num_dir_entries) | 664 | if (-1 == num_dir_entries) |
667 | { | 665 | { |
668 | fprintf (stderr, "Failure during scanning directory `%s'\n", path_testbed); | 666 | fprintf(stderr, "Failure during scanning directory `%s'\n", path_testbed); |
669 | return -1; | 667 | return -1; |
670 | } | 668 | } |
671 | return 0; | 669 | return 0; |
672 | } | 670 | } |
673 | 671 | ||
@@ -680,90 +678,90 @@ discover_testbed_nodes (const char *path_testbed) | |||
680 | * @param cfg configuration | 678 | * @param cfg configuration |
681 | */ | 679 | */ |
682 | static void | 680 | static void |
683 | run (void *cls, | 681 | run(void *cls, |
684 | char *const *args, | 682 | char *const *args, |
685 | const char *cfgfile, | 683 | const char *cfgfile, |
686 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 684 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
687 | { | 685 | { |
688 | struct GNUNET_CONFIGURATION_Handle *c; | 686 | struct GNUNET_CONFIGURATION_Handle *c; |
689 | 687 | ||
690 | c = (struct GNUNET_CONFIGURATION_Handle *) cfg; | 688 | c = (struct GNUNET_CONFIGURATION_Handle *)cfg; |
691 | set_value = GNUNET_NO; | 689 | set_value = GNUNET_NO; |
692 | if (NULL == csv_separator) | 690 | if (NULL == csv_separator) |
693 | csv_separator = ""; | 691 | csv_separator = ""; |
694 | if (NULL != args[0]) | 692 | if (NULL != args[0]) |
695 | { | ||
696 | if (1 != sscanf (args[0], "%llu", &set_val)) | ||
697 | { | 693 | { |
698 | fprintf (stderr, _ ("Invalid argument `%s'\n"), args[0]); | 694 | if (1 != sscanf(args[0], "%llu", &set_val)) |
699 | ret = 1; | 695 | { |
700 | return; | 696 | fprintf(stderr, _("Invalid argument `%s'\n"), args[0]); |
697 | ret = 1; | ||
698 | return; | ||
699 | } | ||
700 | set_value = GNUNET_YES; | ||
701 | } | 701 | } |
702 | set_value = GNUNET_YES; | ||
703 | } | ||
704 | if (NULL != remote_host) | 702 | if (NULL != remote_host) |
705 | { | ||
706 | if (0 == remote_port) | ||
707 | { | 703 | { |
708 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, | 704 | if (0 == remote_port) |
709 | "statistics", | 705 | { |
710 | "PORT", | 706 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, |
711 | &remote_port)) | 707 | "statistics", |
712 | { | 708 | "PORT", |
713 | fprintf (stderr, | 709 | &remote_port)) |
714 | _ ("A port is required to connect to host `%s'\n"), | 710 | { |
715 | remote_host); | 711 | fprintf(stderr, |
716 | return; | 712 | _("A port is required to connect to host `%s'\n"), |
717 | } | 713 | remote_host); |
714 | return; | ||
715 | } | ||
716 | } | ||
717 | else if (65535 <= remote_port) | ||
718 | { | ||
719 | fprintf(stderr, | ||
720 | _( | ||
721 | "A port has to be between 1 and 65535 to connect to host `%s'\n"), | ||
722 | remote_host); | ||
723 | return; | ||
724 | } | ||
725 | |||
726 | /* Manipulate configuration */ | ||
727 | GNUNET_CONFIGURATION_set_value_string(c, "statistics", "UNIXPATH", ""); | ||
728 | GNUNET_CONFIGURATION_set_value_string(c, | ||
729 | "statistics", | ||
730 | "HOSTNAME", | ||
731 | remote_host); | ||
732 | GNUNET_CONFIGURATION_set_value_number(c, | ||
733 | "statistics", | ||
734 | "PORT", | ||
735 | remote_port); | ||
718 | } | 736 | } |
719 | else if (65535 <= remote_port) | ||
720 | { | ||
721 | fprintf (stderr, | ||
722 | _ ( | ||
723 | "A port has to be between 1 and 65535 to connect to host `%s'\n"), | ||
724 | remote_host); | ||
725 | return; | ||
726 | } | ||
727 | |||
728 | /* Manipulate configuration */ | ||
729 | GNUNET_CONFIGURATION_set_value_string (c, "statistics", "UNIXPATH", ""); | ||
730 | GNUNET_CONFIGURATION_set_value_string (c, | ||
731 | "statistics", | ||
732 | "HOSTNAME", | ||
733 | remote_host); | ||
734 | GNUNET_CONFIGURATION_set_value_number (c, | ||
735 | "statistics", | ||
736 | "PORT", | ||
737 | remote_port); | ||
738 | } | ||
739 | if (NULL == path_testbed) | 737 | if (NULL == path_testbed) |
740 | { | ||
741 | values = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO); | ||
742 | GNUNET_array_grow (nodes, num_nodes, 1); | ||
743 | nodes[0].index_node = 0; | ||
744 | nodes[0].conf = c; | ||
745 | GNUNET_SCHEDULER_add_now (&main_task, &nodes[0].index_node); | ||
746 | } | ||
747 | else | ||
748 | { | ||
749 | if (GNUNET_YES == watch) | ||
750 | { | ||
751 | printf ( | ||
752 | _ ("Not able to watch testbed nodes (yet - feel free to implement)\n")); | ||
753 | ret = 1; | ||
754 | return; | ||
755 | } | ||
756 | values = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO); | ||
757 | if (-1 == discover_testbed_nodes (path_testbed)) | ||
758 | { | 738 | { |
759 | return; | 739 | values = GNUNET_CONTAINER_multihashmap_create(1, GNUNET_NO); |
740 | GNUNET_array_grow(nodes, num_nodes, 1); | ||
741 | nodes[0].index_node = 0; | ||
742 | nodes[0].conf = c; | ||
743 | GNUNET_SCHEDULER_add_now(&main_task, &nodes[0].index_node); | ||
760 | } | 744 | } |
761 | /* For each config/node collect statistics */ | 745 | else |
762 | for (unsigned i = 0; i < num_nodes; i++) | ||
763 | { | 746 | { |
764 | GNUNET_SCHEDULER_add_now (&main_task, &nodes[i].index_node); | 747 | if (GNUNET_YES == watch) |
748 | { | ||
749 | printf( | ||
750 | _("Not able to watch testbed nodes (yet - feel free to implement)\n")); | ||
751 | ret = 1; | ||
752 | return; | ||
753 | } | ||
754 | values = GNUNET_CONTAINER_multihashmap_create(4, GNUNET_NO); | ||
755 | if (-1 == discover_testbed_nodes(path_testbed)) | ||
756 | { | ||
757 | return; | ||
758 | } | ||
759 | /* For each config/node collect statistics */ | ||
760 | for (unsigned i = 0; i < num_nodes; i++) | ||
761 | { | ||
762 | GNUNET_SCHEDULER_add_now(&main_task, &nodes[i].index_node); | ||
763 | } | ||
765 | } | 764 | } |
766 | } | ||
767 | } | 765 | } |
768 | 766 | ||
769 | 767 | ||
@@ -775,84 +773,85 @@ run (void *cls, | |||
775 | * @return 0 ok, 1 on error | 773 | * @return 0 ok, 1 on error |
776 | */ | 774 | */ |
777 | int | 775 | int |
778 | main (int argc, char *const *argv) | 776 | main(int argc, char *const *argv) |
779 | { | 777 | { |
780 | struct GNUNET_GETOPT_CommandLineOption options[] = | 778 | struct GNUNET_GETOPT_CommandLineOption options[] = |
781 | {GNUNET_GETOPT_option_string ( | 779 | { GNUNET_GETOPT_option_string( |
782 | 'n', | 780 | 'n', |
783 | "name", | 781 | "name", |
784 | "NAME", | 782 | "NAME", |
785 | gettext_noop ("limit output to statistics for the given NAME"), | 783 | gettext_noop("limit output to statistics for the given NAME"), |
786 | &name), | 784 | &name), |
787 | 785 | ||
788 | GNUNET_GETOPT_option_flag ('p', | 786 | GNUNET_GETOPT_option_flag('p', |
789 | "persistent", | 787 | "persistent", |
790 | gettext_noop ( | 788 | gettext_noop( |
791 | "make the value being set persistent"), | 789 | "make the value being set persistent"), |
792 | &persistent), | 790 | &persistent), |
793 | 791 | ||
794 | GNUNET_GETOPT_option_string ('s', | 792 | GNUNET_GETOPT_option_string('s', |
795 | "subsystem", | 793 | "subsystem", |
796 | "SUBSYSTEM", | 794 | "SUBSYSTEM", |
797 | gettext_noop ( | 795 | gettext_noop( |
798 | "limit output to the given SUBSYSTEM"), | 796 | "limit output to the given SUBSYSTEM"), |
799 | &subsystem), | 797 | &subsystem), |
800 | 798 | ||
801 | GNUNET_GETOPT_option_string ('S', | 799 | GNUNET_GETOPT_option_string('S', |
802 | "csv-separator", | 800 | "csv-separator", |
803 | "CSV_SEPARATOR", | 801 | "CSV_SEPARATOR", |
804 | gettext_noop ("use as csv separator"), | 802 | gettext_noop("use as csv separator"), |
805 | &csv_separator), | 803 | &csv_separator), |
806 | 804 | ||
807 | GNUNET_GETOPT_option_filename ( | 805 | GNUNET_GETOPT_option_filename( |
808 | 't', | 806 | 't', |
809 | "testbed", | 807 | "testbed", |
810 | "TESTBED", | 808 | "TESTBED", |
811 | gettext_noop ("path to the folder containing the testbed data"), | 809 | gettext_noop("path to the folder containing the testbed data"), |
812 | &path_testbed), | 810 | &path_testbed), |
813 | 811 | ||
814 | GNUNET_GETOPT_option_flag ('q', | 812 | GNUNET_GETOPT_option_flag('q', |
815 | "quiet", | 813 | "quiet", |
816 | gettext_noop ( | 814 | gettext_noop( |
817 | "just print the statistics value"), | 815 | "just print the statistics value"), |
818 | &quiet), | 816 | &quiet), |
819 | 817 | ||
820 | GNUNET_GETOPT_option_flag ('w', | 818 | GNUNET_GETOPT_option_flag('w', |
821 | "watch", | 819 | "watch", |
822 | gettext_noop ("watch value continuously"), | 820 | gettext_noop("watch value continuously"), |
823 | &watch), | 821 | &watch), |
824 | 822 | ||
825 | GNUNET_GETOPT_option_string ('r', | 823 | GNUNET_GETOPT_option_string('r', |
826 | "remote", | 824 | "remote", |
827 | "REMOTE", | 825 | "REMOTE", |
828 | gettext_noop ("connect to remote host"), | 826 | gettext_noop("connect to remote host"), |
829 | &remote_host), | 827 | &remote_host), |
830 | 828 | ||
831 | GNUNET_GETOPT_option_ulong ('o', | 829 | GNUNET_GETOPT_option_ulong('o', |
832 | "port", | 830 | "port", |
833 | "PORT", | 831 | "PORT", |
834 | gettext_noop ("port for remote host"), | 832 | gettext_noop("port for remote host"), |
835 | &remote_port), | 833 | &remote_port), |
836 | 834 | ||
837 | GNUNET_GETOPT_OPTION_END}; | 835 | GNUNET_GETOPT_OPTION_END }; |
836 | |||
838 | remote_port = 0; | 837 | remote_port = 0; |
839 | remote_host = NULL; | 838 | remote_host = NULL; |
840 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) | 839 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) |
841 | return 2; | 840 | return 2; |
842 | 841 | ||
843 | ret = (GNUNET_OK == | 842 | ret = (GNUNET_OK == |
844 | GNUNET_PROGRAM_run (argc, | 843 | GNUNET_PROGRAM_run(argc, |
845 | argv, | 844 | argv, |
846 | "gnunet-statistics [options [value]]", | 845 | "gnunet-statistics [options [value]]", |
847 | gettext_noop ( | 846 | gettext_noop( |
848 | "Print statistics about GNUnet operations."), | 847 | "Print statistics about GNUnet operations."), |
849 | options, | 848 | options, |
850 | &run, | 849 | &run, |
851 | NULL)) | 850 | NULL)) |
852 | ? ret | 851 | ? ret |
853 | : 1; | 852 | : 1; |
854 | GNUNET_free_non_null (remote_host); | 853 | GNUNET_free_non_null(remote_host); |
855 | GNUNET_free ((void *) argv); | 854 | GNUNET_free((void *)argv); |
856 | return ret; | 855 | return ret; |
857 | } | 856 | } |
858 | 857 | ||
diff --git a/src/statistics/statistics.h b/src/statistics/statistics.h index f5fa48580..c01dca15a 100644 --- a/src/statistics/statistics.h +++ b/src/statistics/statistics.h | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @author Christian Grothoff | 22 | * @author Christian Grothoff |
@@ -37,8 +37,7 @@ GNUNET_NETWORK_STRUCT_BEGIN | |||
37 | * The struct is be followed by the service name and | 37 | * The struct is be followed by the service name and |
38 | * name of the statistic, both 0-terminated. | 38 | * name of the statistic, both 0-terminated. |
39 | */ | 39 | */ |
40 | struct GNUNET_STATISTICS_ReplyMessage | 40 | struct GNUNET_STATISTICS_ReplyMessage { |
41 | { | ||
42 | /** | 41 | /** |
43 | * Type: GNUNET_MESSAGE_TYPE_STATISTICS_VALUE | 42 | * Type: GNUNET_MESSAGE_TYPE_STATISTICS_VALUE |
44 | */ | 43 | */ |
@@ -56,14 +55,13 @@ struct GNUNET_STATISTICS_ReplyMessage | |||
56 | * The value. | 55 | * The value. |
57 | */ | 56 | */ |
58 | uint64_t value GNUNET_PACKED; | 57 | uint64_t value GNUNET_PACKED; |
59 | |||
60 | }; | 58 | }; |
61 | 59 | ||
62 | /** | 60 | /** |
63 | * Flag for the `struct GNUNET_STATISTICS_ReplyMessage` UID only. | 61 | * Flag for the `struct GNUNET_STATISTICS_ReplyMessage` UID only. |
64 | * Note that other messages use #GNUNET_STATISTICS_SETFLAG_PERSISTENT. | 62 | * Note that other messages use #GNUNET_STATISTICS_SETFLAG_PERSISTENT. |
65 | */ | 63 | */ |
66 | #define GNUNET_STATISTICS_PERSIST_BIT ((uint32_t) (1LLU<<31)) | 64 | #define GNUNET_STATISTICS_PERSIST_BIT ((uint32_t)(1LLU << 31)) |
67 | 65 | ||
68 | /** | 66 | /** |
69 | * The value being set is an absolute change. | 67 | * The value being set is an absolute change. |
@@ -89,8 +87,7 @@ struct GNUNET_STATISTICS_ReplyMessage | |||
89 | * by the subsystem name and the name of | 87 | * by the subsystem name and the name of |
90 | * the statistic (each 0-terminated). | 88 | * the statistic (each 0-terminated). |
91 | */ | 89 | */ |
92 | struct GNUNET_STATISTICS_SetMessage | 90 | struct GNUNET_STATISTICS_SetMessage { |
93 | { | ||
94 | /** | 91 | /** |
95 | * Type: #GNUNET_MESSAGE_TYPE_STATISTICS_SET | 92 | * Type: #GNUNET_MESSAGE_TYPE_STATISTICS_SET |
96 | */ | 93 | */ |
@@ -107,15 +104,13 @@ struct GNUNET_STATISTICS_SetMessage | |||
107 | * be signed even though the type given here is unsigned. | 104 | * be signed even though the type given here is unsigned. |
108 | */ | 105 | */ |
109 | uint64_t value GNUNET_PACKED; | 106 | uint64_t value GNUNET_PACKED; |
110 | |||
111 | }; | 107 | }; |
112 | 108 | ||
113 | 109 | ||
114 | /** | 110 | /** |
115 | * Message transmitted if a watched value changes. | 111 | * Message transmitted if a watched value changes. |
116 | */ | 112 | */ |
117 | struct GNUNET_STATISTICS_WatchValueMessage | 113 | struct GNUNET_STATISTICS_WatchValueMessage { |
118 | { | ||
119 | /** | 114 | /** |
120 | * Type: #GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE | 115 | * Type: #GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE |
121 | */ | 116 | */ |
@@ -145,7 +140,6 @@ struct GNUNET_STATISTICS_WatchValueMessage | |||
145 | * be signed even though the type given here is unsigned. | 140 | * be signed even though the type given here is unsigned. |
146 | */ | 141 | */ |
147 | uint64_t value GNUNET_PACKED; | 142 | uint64_t value GNUNET_PACKED; |
148 | |||
149 | }; | 143 | }; |
150 | GNUNET_NETWORK_STRUCT_END | 144 | GNUNET_NETWORK_STRUCT_END |
151 | 145 | ||
diff --git a/src/statistics/statistics_api.c b/src/statistics/statistics_api.c index da307c887..487f2569c 100644 --- a/src/statistics/statistics_api.c +++ b/src/statistics/statistics_api.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file statistics/statistics_api.c | 22 | * @file statistics/statistics_api.c |
@@ -35,15 +35,14 @@ | |||
35 | * a value times out? (The update will be lost if the | 35 | * a value times out? (The update will be lost if the |
36 | * service does not react within this timeframe). | 36 | * service does not react within this timeframe). |
37 | */ | 37 | */ |
38 | #define SET_TRANSMIT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2) | 38 | #define SET_TRANSMIT_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2) |
39 | 39 | ||
40 | #define LOG(kind,...) GNUNET_log_from (kind, "statistics-api",__VA_ARGS__) | 40 | #define LOG(kind, ...) GNUNET_log_from(kind, "statistics-api", __VA_ARGS__) |
41 | 41 | ||
42 | /** | 42 | /** |
43 | * Types of actions. | 43 | * Types of actions. |
44 | */ | 44 | */ |
45 | enum ActionType | 45 | enum ActionType { |
46 | { | ||
47 | /** | 46 | /** |
48 | * Get a value. | 47 | * Get a value. |
49 | */ | 48 | */ |
@@ -69,9 +68,7 @@ enum ActionType | |||
69 | /** | 68 | /** |
70 | * Entry kept for each value we are watching. | 69 | * Entry kept for each value we are watching. |
71 | */ | 70 | */ |
72 | struct GNUNET_STATISTICS_WatchEntry | 71 | struct GNUNET_STATISTICS_WatchEntry { |
73 | { | ||
74 | |||
75 | /** | 72 | /** |
76 | * What subsystem is this action about? (never NULL) | 73 | * What subsystem is this action about? (never NULL) |
77 | */ | 74 | */ |
@@ -91,16 +88,13 @@ struct GNUNET_STATISTICS_WatchEntry | |||
91 | * Closure for @e proc | 88 | * Closure for @e proc |
92 | */ | 89 | */ |
93 | void *proc_cls; | 90 | void *proc_cls; |
94 | |||
95 | }; | 91 | }; |
96 | 92 | ||
97 | 93 | ||
98 | /** | 94 | /** |
99 | * Linked list of things we still need to do. | 95 | * Linked list of things we still need to do. |
100 | */ | 96 | */ |
101 | struct GNUNET_STATISTICS_GetHandle | 97 | struct GNUNET_STATISTICS_GetHandle { |
102 | { | ||
103 | |||
104 | /** | 98 | /** |
105 | * This is a doubly linked list. | 99 | * This is a doubly linked list. |
106 | */ | 100 | */ |
@@ -170,15 +164,13 @@ struct GNUNET_STATISTICS_GetHandle | |||
170 | * Size of the message that we will be transmitting. | 164 | * Size of the message that we will be transmitting. |
171 | */ | 165 | */ |
172 | uint16_t msize; | 166 | uint16_t msize; |
173 | |||
174 | }; | 167 | }; |
175 | 168 | ||
176 | 169 | ||
177 | /** | 170 | /** |
178 | * Handle for the service. | 171 | * Handle for the service. |
179 | */ | 172 | */ |
180 | struct GNUNET_STATISTICS_Handle | 173 | struct GNUNET_STATISTICS_Handle { |
181 | { | ||
182 | /** | 174 | /** |
183 | * Name of our subsystem. | 175 | * Name of our subsystem. |
184 | */ | 176 | */ |
@@ -257,7 +249,6 @@ struct GNUNET_STATISTICS_Handle | |||
257 | * Are we currently receiving from the service? | 249 | * Are we currently receiving from the service? |
258 | */ | 250 | */ |
259 | int receiving; | 251 | int receiving; |
260 | |||
261 | }; | 252 | }; |
262 | 253 | ||
263 | 254 | ||
@@ -266,7 +257,7 @@ struct GNUNET_STATISTICS_Handle | |||
266 | * report those as well (if they changed). | 257 | * report those as well (if they changed). |
267 | */ | 258 | */ |
268 | static void | 259 | static void |
269 | update_memory_statistics (struct GNUNET_STATISTICS_Handle *h) | 260 | update_memory_statistics(struct GNUNET_STATISTICS_Handle *h) |
270 | { | 261 | { |
271 | #if ENABLE_HEAP_STATISTICS | 262 | #if ENABLE_HEAP_STATISTICS |
272 | uint64_t current_heap_size = 0; | 263 | uint64_t current_heap_size = 0; |
@@ -286,28 +277,28 @@ update_memory_statistics (struct GNUNET_STATISTICS_Handle *h) | |||
286 | { | 277 | { |
287 | struct rusage ru; | 278 | struct rusage ru; |
288 | 279 | ||
289 | if (0 == getrusage (RUSAGE_SELF, &ru)) | 280 | if (0 == getrusage(RUSAGE_SELF, &ru)) |
290 | { | 281 | { |
291 | current_rss = 1024LL * ru.ru_maxrss; | 282 | current_rss = 1024LL * ru.ru_maxrss; |
292 | } | 283 | } |
293 | } | 284 | } |
294 | #endif | 285 | #endif |
295 | if (current_heap_size > h->peak_heap_size) | 286 | if (current_heap_size > h->peak_heap_size) |
296 | { | 287 | { |
297 | h->peak_heap_size = current_heap_size; | 288 | h->peak_heap_size = current_heap_size; |
298 | GNUNET_STATISTICS_set (h, | 289 | GNUNET_STATISTICS_set(h, |
299 | "# peak heap size", | 290 | "# peak heap size", |
300 | current_heap_size, | 291 | current_heap_size, |
301 | GNUNET_NO); | 292 | GNUNET_NO); |
302 | } | 293 | } |
303 | if (current_rss > h->peak_rss) | 294 | if (current_rss > h->peak_rss) |
304 | { | 295 | { |
305 | h->peak_rss = current_rss; | 296 | h->peak_rss = current_rss; |
306 | GNUNET_STATISTICS_set (h, | 297 | GNUNET_STATISTICS_set(h, |
307 | "# peak resident set size", | 298 | "# peak resident set size", |
308 | current_rss, | 299 | current_rss, |
309 | GNUNET_NO); | 300 | GNUNET_NO); |
310 | } | 301 | } |
311 | #endif | 302 | #endif |
312 | } | 303 | } |
313 | 304 | ||
@@ -318,7 +309,7 @@ update_memory_statistics (struct GNUNET_STATISTICS_Handle *h) | |||
318 | * @param h statistics handle | 309 | * @param h statistics handle |
319 | */ | 310 | */ |
320 | static void | 311 | static void |
321 | reconnect_later (struct GNUNET_STATISTICS_Handle *h); | 312 | reconnect_later(struct GNUNET_STATISTICS_Handle *h); |
322 | 313 | ||
323 | 314 | ||
324 | /** | 315 | /** |
@@ -327,7 +318,7 @@ reconnect_later (struct GNUNET_STATISTICS_Handle *h); | |||
327 | * @param cls statistics handle to reconnect | 318 | * @param cls statistics handle to reconnect |
328 | */ | 319 | */ |
329 | static void | 320 | static void |
330 | schedule_action (void *cls); | 321 | schedule_action(void *cls); |
331 | 322 | ||
332 | 323 | ||
333 | /** | 324 | /** |
@@ -338,35 +329,35 @@ schedule_action (void *cls); | |||
338 | * @param watch watch entry of the value to watch | 329 | * @param watch watch entry of the value to watch |
339 | */ | 330 | */ |
340 | static void | 331 | static void |
341 | schedule_watch_request (struct GNUNET_STATISTICS_Handle *h, | 332 | schedule_watch_request(struct GNUNET_STATISTICS_Handle *h, |
342 | struct GNUNET_STATISTICS_WatchEntry *watch) | 333 | struct GNUNET_STATISTICS_WatchEntry *watch) |
343 | { | 334 | { |
344 | struct GNUNET_STATISTICS_GetHandle *ai; | 335 | struct GNUNET_STATISTICS_GetHandle *ai; |
345 | size_t slen; | 336 | size_t slen; |
346 | size_t nlen; | 337 | size_t nlen; |
347 | size_t nsize; | 338 | size_t nsize; |
348 | 339 | ||
349 | slen = strlen (watch->subsystem) + 1; | 340 | slen = strlen(watch->subsystem) + 1; |
350 | nlen = strlen (watch->name) + 1; | 341 | nlen = strlen(watch->name) + 1; |
351 | nsize = sizeof (struct GNUNET_MessageHeader) + slen + nlen; | 342 | nsize = sizeof(struct GNUNET_MessageHeader) + slen + nlen; |
352 | if (nsize >= GNUNET_MAX_MESSAGE_SIZE) | 343 | if (nsize >= GNUNET_MAX_MESSAGE_SIZE) |
353 | { | 344 | { |
354 | GNUNET_break (0); | 345 | GNUNET_break(0); |
355 | return; | 346 | return; |
356 | } | 347 | } |
357 | ai = GNUNET_new (struct GNUNET_STATISTICS_GetHandle); | 348 | ai = GNUNET_new(struct GNUNET_STATISTICS_GetHandle); |
358 | ai->sh = h; | 349 | ai->sh = h; |
359 | ai->subsystem = GNUNET_strdup (watch->subsystem); | 350 | ai->subsystem = GNUNET_strdup(watch->subsystem); |
360 | ai->name = GNUNET_strdup (watch->name); | 351 | ai->name = GNUNET_strdup(watch->name); |
361 | ai->timeout = GNUNET_TIME_UNIT_FOREVER_ABS; | 352 | ai->timeout = GNUNET_TIME_UNIT_FOREVER_ABS; |
362 | ai->msize = nsize; | 353 | ai->msize = nsize; |
363 | ai->type = ACTION_WATCH; | 354 | ai->type = ACTION_WATCH; |
364 | ai->proc = watch->proc; | 355 | ai->proc = watch->proc; |
365 | ai->cls = watch->proc_cls; | 356 | ai->cls = watch->proc_cls; |
366 | GNUNET_CONTAINER_DLL_insert_tail (h->action_head, | 357 | GNUNET_CONTAINER_DLL_insert_tail(h->action_head, |
367 | h->action_tail, | 358 | h->action_tail, |
368 | ai); | 359 | ai); |
369 | schedule_action (h); | 360 | schedule_action(h); |
370 | } | 361 | } |
371 | 362 | ||
372 | 363 | ||
@@ -376,11 +367,11 @@ schedule_watch_request (struct GNUNET_STATISTICS_Handle *h, | |||
376 | * @param gh action item to free | 367 | * @param gh action item to free |
377 | */ | 368 | */ |
378 | static void | 369 | static void |
379 | free_action_item (struct GNUNET_STATISTICS_GetHandle *gh) | 370 | free_action_item(struct GNUNET_STATISTICS_GetHandle *gh) |
380 | { | 371 | { |
381 | GNUNET_free_non_null (gh->subsystem); | 372 | GNUNET_free_non_null(gh->subsystem); |
382 | GNUNET_free_non_null (gh->name); | 373 | GNUNET_free_non_null(gh->name); |
383 | GNUNET_free (gh); | 374 | GNUNET_free(gh); |
384 | } | 375 | } |
385 | 376 | ||
386 | 377 | ||
@@ -390,28 +381,28 @@ free_action_item (struct GNUNET_STATISTICS_GetHandle *gh) | |||
390 | * @param h statistics handle to disconnect from | 381 | * @param h statistics handle to disconnect from |
391 | */ | 382 | */ |
392 | static void | 383 | static void |
393 | do_disconnect (struct GNUNET_STATISTICS_Handle *h) | 384 | do_disconnect(struct GNUNET_STATISTICS_Handle *h) |
394 | { | 385 | { |
395 | struct GNUNET_STATISTICS_GetHandle *c; | 386 | struct GNUNET_STATISTICS_GetHandle *c; |
396 | 387 | ||
397 | h->receiving = GNUNET_NO; | 388 | h->receiving = GNUNET_NO; |
398 | if (NULL != (c = h->current)) | 389 | if (NULL != (c = h->current)) |
399 | { | ||
400 | h->current = NULL; | ||
401 | if ( (NULL != c->cont) && | ||
402 | (GNUNET_YES != c->aborted) ) | ||
403 | { | 390 | { |
404 | c->cont (c->cls, | 391 | h->current = NULL; |
405 | GNUNET_SYSERR); | 392 | if ((NULL != c->cont) && |
406 | c->cont = NULL; | 393 | (GNUNET_YES != c->aborted)) |
394 | { | ||
395 | c->cont(c->cls, | ||
396 | GNUNET_SYSERR); | ||
397 | c->cont = NULL; | ||
398 | } | ||
399 | free_action_item(c); | ||
407 | } | 400 | } |
408 | free_action_item (c); | ||
409 | } | ||
410 | if (NULL != h->mq) | 401 | if (NULL != h->mq) |
411 | { | 402 | { |
412 | GNUNET_MQ_destroy (h->mq); | 403 | GNUNET_MQ_destroy(h->mq); |
413 | h->mq = NULL; | 404 | h->mq = NULL; |
414 | } | 405 | } |
415 | } | 406 | } |
416 | 407 | ||
417 | 408 | ||
@@ -423,25 +414,25 @@ do_disconnect (struct GNUNET_STATISTICS_Handle *h) | |||
423 | * @return #GNUNET_OK if the message was well-formed | 414 | * @return #GNUNET_OK if the message was well-formed |
424 | */ | 415 | */ |
425 | static int | 416 | static int |
426 | check_statistics_value (void *cls, | 417 | check_statistics_value(void *cls, |
427 | const struct GNUNET_STATISTICS_ReplyMessage *smsg) | 418 | const struct GNUNET_STATISTICS_ReplyMessage *smsg) |
428 | { | 419 | { |
429 | const char *service; | 420 | const char *service; |
430 | const char *name; | 421 | const char *name; |
431 | uint16_t size; | 422 | uint16_t size; |
432 | 423 | ||
433 | size = ntohs (smsg->header.size); | 424 | size = ntohs(smsg->header.size); |
434 | size -= sizeof (struct GNUNET_STATISTICS_ReplyMessage); | 425 | size -= sizeof(struct GNUNET_STATISTICS_ReplyMessage); |
435 | if (size != | 426 | if (size != |
436 | GNUNET_STRINGS_buffer_tokenize ((const char *) &smsg[1], | 427 | GNUNET_STRINGS_buffer_tokenize((const char *)&smsg[1], |
437 | size, | 428 | size, |
438 | 2, | 429 | 2, |
439 | &service, | 430 | &service, |
440 | &name)) | 431 | &name)) |
441 | { | 432 | { |
442 | GNUNET_break (0); | 433 | GNUNET_break(0); |
443 | return GNUNET_SYSERR; | 434 | return GNUNET_SYSERR; |
444 | } | 435 | } |
445 | return GNUNET_OK; | 436 | return GNUNET_OK; |
446 | } | 437 | } |
447 | 438 | ||
@@ -454,8 +445,8 @@ check_statistics_value (void *cls, | |||
454 | * @return #GNUNET_OK if the message was well-formed | 445 | * @return #GNUNET_OK if the message was well-formed |
455 | */ | 446 | */ |
456 | static void | 447 | static void |
457 | handle_statistics_value (void *cls, | 448 | handle_statistics_value(void *cls, |
458 | const struct GNUNET_STATISTICS_ReplyMessage *smsg) | 449 | const struct GNUNET_STATISTICS_ReplyMessage *smsg) |
459 | { | 450 | { |
460 | struct GNUNET_STATISTICS_Handle *h = cls; | 451 | struct GNUNET_STATISTICS_Handle *h = cls; |
461 | const char *service; | 452 | const char *service; |
@@ -465,30 +456,30 @@ handle_statistics_value (void *cls, | |||
465 | if (h->current->aborted) | 456 | if (h->current->aborted) |
466 | return; /* iteration aborted, don't bother */ | 457 | return; /* iteration aborted, don't bother */ |
467 | 458 | ||
468 | size = ntohs (smsg->header.size); | 459 | size = ntohs(smsg->header.size); |
469 | size -= sizeof (struct GNUNET_STATISTICS_ReplyMessage); | 460 | size -= sizeof(struct GNUNET_STATISTICS_ReplyMessage); |
470 | GNUNET_assert (size == | 461 | GNUNET_assert(size == |
471 | GNUNET_STRINGS_buffer_tokenize ((const char *) &smsg[1], | 462 | GNUNET_STRINGS_buffer_tokenize((const char *)&smsg[1], |
472 | size, | 463 | size, |
473 | 2, | 464 | 2, |
474 | &service, | 465 | &service, |
475 | &name)); | 466 | &name)); |
476 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 467 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
477 | "Received valid statistic on `%s:%s': %llu\n", | 468 | "Received valid statistic on `%s:%s': %llu\n", |
478 | service, name, | 469 | service, name, |
479 | GNUNET_ntohll (smsg->value)); | 470 | GNUNET_ntohll(smsg->value)); |
480 | if (GNUNET_OK != | 471 | if (GNUNET_OK != |
481 | h->current->proc (h->current->cls, | 472 | h->current->proc(h->current->cls, |
482 | service, | 473 | service, |
483 | name, | 474 | name, |
484 | GNUNET_ntohll (smsg->value), | 475 | GNUNET_ntohll(smsg->value), |
485 | 0 != | 476 | 0 != |
486 | (ntohl (smsg->uid) & GNUNET_STATISTICS_PERSIST_BIT))) | 477 | (ntohl(smsg->uid) & GNUNET_STATISTICS_PERSIST_BIT))) |
487 | { | 478 | { |
488 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 479 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
489 | "Processing of remaining statistics aborted by client.\n"); | 480 | "Processing of remaining statistics aborted by client.\n"); |
490 | h->current->aborted = GNUNET_YES; | 481 | h->current->aborted = GNUNET_YES; |
491 | } | 482 | } |
492 | } | 483 | } |
493 | 484 | ||
494 | 485 | ||
@@ -499,29 +490,29 @@ handle_statistics_value (void *cls, | |||
499 | * @param msg the watch value message | 490 | * @param msg the watch value message |
500 | */ | 491 | */ |
501 | static void | 492 | static void |
502 | handle_statistics_watch_value (void *cls, | 493 | handle_statistics_watch_value(void *cls, |
503 | const struct GNUNET_STATISTICS_WatchValueMessage *wvm) | 494 | const struct GNUNET_STATISTICS_WatchValueMessage *wvm) |
504 | { | 495 | { |
505 | struct GNUNET_STATISTICS_Handle *h = cls; | 496 | struct GNUNET_STATISTICS_Handle *h = cls; |
506 | struct GNUNET_STATISTICS_WatchEntry *w; | 497 | struct GNUNET_STATISTICS_WatchEntry *w; |
507 | uint32_t wid; | 498 | uint32_t wid; |
508 | 499 | ||
509 | GNUNET_break (0 == ntohl (wvm->reserved)); | 500 | GNUNET_break(0 == ntohl(wvm->reserved)); |
510 | wid = ntohl (wvm->wid); | 501 | wid = ntohl(wvm->wid); |
511 | if (wid >= h->watches_size) | 502 | if (wid >= h->watches_size) |
512 | { | 503 | { |
513 | do_disconnect (h); | 504 | do_disconnect(h); |
514 | reconnect_later (h); | 505 | reconnect_later(h); |
515 | return; | 506 | return; |
516 | } | 507 | } |
517 | w = h->watches[wid]; | 508 | w = h->watches[wid]; |
518 | if (NULL == w) | 509 | if (NULL == w) |
519 | return; | 510 | return; |
520 | (void) w->proc (w->proc_cls, | 511 | (void)w->proc(w->proc_cls, |
521 | w->subsystem, | 512 | w->subsystem, |
522 | w->name, | 513 | w->name, |
523 | GNUNET_ntohll (wvm->value), | 514 | GNUNET_ntohll(wvm->value), |
524 | 0 != (ntohl (wvm->flags) & GNUNET_STATISTICS_PERSIST_BIT)); | 515 | 0 != (ntohl(wvm->flags) & GNUNET_STATISTICS_PERSIST_BIT)); |
525 | } | 516 | } |
526 | 517 | ||
527 | 518 | ||
@@ -534,25 +525,25 @@ handle_statistics_watch_value (void *cls, | |||
534 | * @param error error code | 525 | * @param error error code |
535 | */ | 526 | */ |
536 | static void | 527 | static void |
537 | mq_error_handler (void *cls, | 528 | mq_error_handler(void *cls, |
538 | enum GNUNET_MQ_Error error) | 529 | enum GNUNET_MQ_Error error) |
539 | { | 530 | { |
540 | struct GNUNET_STATISTICS_Handle *h = cls; | 531 | struct GNUNET_STATISTICS_Handle *h = cls; |
541 | 532 | ||
542 | if (GNUNET_NO != h->do_destroy) | 533 | if (GNUNET_NO != h->do_destroy) |
543 | { | ||
544 | h->do_destroy = GNUNET_NO; | ||
545 | if (NULL != h->destroy_task) | ||
546 | { | 534 | { |
547 | GNUNET_SCHEDULER_cancel (h->destroy_task); | 535 | h->do_destroy = GNUNET_NO; |
548 | h->destroy_task = NULL; | 536 | if (NULL != h->destroy_task) |
537 | { | ||
538 | GNUNET_SCHEDULER_cancel(h->destroy_task); | ||
539 | h->destroy_task = NULL; | ||
540 | } | ||
541 | GNUNET_STATISTICS_destroy(h, | ||
542 | GNUNET_NO); | ||
543 | return; | ||
549 | } | 544 | } |
550 | GNUNET_STATISTICS_destroy (h, | 545 | do_disconnect(h); |
551 | GNUNET_NO); | 546 | reconnect_later(h); |
552 | return; | ||
553 | } | ||
554 | do_disconnect (h); | ||
555 | reconnect_later (h); | ||
556 | } | 547 | } |
557 | 548 | ||
558 | 549 | ||
@@ -562,16 +553,16 @@ mq_error_handler (void *cls, | |||
562 | * @param cls the `struct GNUNET_STATISTICS_Handle` | 553 | * @param cls the `struct GNUNET_STATISTICS_Handle` |
563 | */ | 554 | */ |
564 | static void | 555 | static void |
565 | do_destroy (void *cls) | 556 | do_destroy(void *cls) |
566 | { | 557 | { |
567 | struct GNUNET_STATISTICS_Handle *h = cls; | 558 | struct GNUNET_STATISTICS_Handle *h = cls; |
568 | 559 | ||
569 | h->destroy_task = NULL; | 560 | h->destroy_task = NULL; |
570 | h->do_destroy = GNUNET_NO; | 561 | h->do_destroy = GNUNET_NO; |
571 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 562 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
572 | "Running final destruction\n"); | 563 | "Running final destruction\n"); |
573 | GNUNET_STATISTICS_destroy (h, | 564 | GNUNET_STATISTICS_destroy(h, |
574 | GNUNET_NO); | 565 | GNUNET_NO); |
575 | } | 566 | } |
576 | 567 | ||
577 | 568 | ||
@@ -584,25 +575,25 @@ do_destroy (void *cls) | |||
584 | * @param msg the message | 575 | * @param msg the message |
585 | */ | 576 | */ |
586 | static void | 577 | static void |
587 | handle_disconnect_confirm (void *cls, | 578 | handle_disconnect_confirm(void *cls, |
588 | const struct GNUNET_MessageHeader *msg) | 579 | const struct GNUNET_MessageHeader *msg) |
589 | { | 580 | { |
590 | struct GNUNET_STATISTICS_Handle *h = cls; | 581 | struct GNUNET_STATISTICS_Handle *h = cls; |
591 | 582 | ||
592 | if (GNUNET_SYSERR != h->do_destroy) | 583 | if (GNUNET_SYSERR != h->do_destroy) |
593 | { | 584 | { |
594 | /* not in shutdown, why do we get 'TEST'? */ | 585 | /* not in shutdown, why do we get 'TEST'? */ |
595 | GNUNET_break (0); | 586 | GNUNET_break(0); |
596 | do_disconnect (h); | 587 | do_disconnect(h); |
597 | reconnect_later (h); | 588 | reconnect_later(h); |
598 | return; | 589 | return; |
599 | } | 590 | } |
600 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 591 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
601 | "Received DISCONNNECT_CONFIRM message from statistics, can complete disconnect\n"); | 592 | "Received DISCONNNECT_CONFIRM message from statistics, can complete disconnect\n"); |
602 | if (NULL != h->destroy_task) | 593 | if (NULL != h->destroy_task) |
603 | GNUNET_SCHEDULER_cancel (h->destroy_task); | 594 | GNUNET_SCHEDULER_cancel(h->destroy_task); |
604 | h->destroy_task = GNUNET_SCHEDULER_add_now (&do_destroy, | 595 | h->destroy_task = GNUNET_SCHEDULER_add_now(&do_destroy, |
605 | h); | 596 | h); |
606 | } | 597 | } |
607 | 598 | ||
608 | 599 | ||
@@ -615,31 +606,31 @@ handle_disconnect_confirm (void *cls, | |||
615 | * @param msg the message | 606 | * @param msg the message |
616 | */ | 607 | */ |
617 | static void | 608 | static void |
618 | handle_statistics_end (void *cls, | 609 | handle_statistics_end(void *cls, |
619 | const struct GNUNET_MessageHeader *msg) | 610 | const struct GNUNET_MessageHeader *msg) |
620 | { | 611 | { |
621 | struct GNUNET_STATISTICS_Handle *h = cls; | 612 | struct GNUNET_STATISTICS_Handle *h = cls; |
622 | struct GNUNET_STATISTICS_GetHandle *c; | 613 | struct GNUNET_STATISTICS_GetHandle *c; |
623 | 614 | ||
624 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 615 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
625 | "Received end of statistics marker\n"); | 616 | "Received end of statistics marker\n"); |
626 | if (NULL == (c = h->current)) | 617 | if (NULL == (c = h->current)) |
627 | { | 618 | { |
628 | GNUNET_break (0); | 619 | GNUNET_break(0); |
629 | do_disconnect (h); | 620 | do_disconnect(h); |
630 | reconnect_later (h); | 621 | reconnect_later(h); |
631 | return; | 622 | return; |
632 | } | 623 | } |
633 | h->backoff = GNUNET_TIME_UNIT_MILLISECONDS; | 624 | h->backoff = GNUNET_TIME_UNIT_MILLISECONDS; |
634 | h->current = NULL; | 625 | h->current = NULL; |
635 | schedule_action (h); | 626 | schedule_action(h); |
636 | if (NULL != c->cont) | 627 | if (NULL != c->cont) |
637 | { | 628 | { |
638 | c->cont (c->cls, | 629 | c->cont(c->cls, |
639 | GNUNET_OK); | 630 | GNUNET_OK); |
640 | c->cont = NULL; | 631 | c->cont = NULL; |
641 | } | 632 | } |
642 | free_action_item (c); | 633 | free_action_item(c); |
643 | } | 634 | } |
644 | 635 | ||
645 | 636 | ||
@@ -650,26 +641,26 @@ handle_statistics_end (void *cls, | |||
650 | * @return #GNUNET_YES on success, #GNUNET_NO on failure. | 641 | * @return #GNUNET_YES on success, #GNUNET_NO on failure. |
651 | */ | 642 | */ |
652 | static int | 643 | static int |
653 | try_connect (struct GNUNET_STATISTICS_Handle *h) | 644 | try_connect(struct GNUNET_STATISTICS_Handle *h) |
654 | { | 645 | { |
655 | struct GNUNET_MQ_MessageHandler handlers[] = { | 646 | struct GNUNET_MQ_MessageHandler handlers[] = { |
656 | GNUNET_MQ_hd_fixed_size (disconnect_confirm, | 647 | GNUNET_MQ_hd_fixed_size(disconnect_confirm, |
657 | GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM, | 648 | GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM, |
658 | struct GNUNET_MessageHeader, | 649 | struct GNUNET_MessageHeader, |
659 | h), | 650 | h), |
660 | GNUNET_MQ_hd_fixed_size (statistics_end, | 651 | GNUNET_MQ_hd_fixed_size(statistics_end, |
661 | GNUNET_MESSAGE_TYPE_STATISTICS_END, | 652 | GNUNET_MESSAGE_TYPE_STATISTICS_END, |
662 | struct GNUNET_MessageHeader, | 653 | struct GNUNET_MessageHeader, |
663 | h), | 654 | h), |
664 | GNUNET_MQ_hd_var_size (statistics_value, | 655 | GNUNET_MQ_hd_var_size(statistics_value, |
665 | GNUNET_MESSAGE_TYPE_STATISTICS_VALUE, | 656 | GNUNET_MESSAGE_TYPE_STATISTICS_VALUE, |
666 | struct GNUNET_STATISTICS_ReplyMessage, | 657 | struct GNUNET_STATISTICS_ReplyMessage, |
667 | h), | 658 | h), |
668 | GNUNET_MQ_hd_fixed_size (statistics_watch_value, | 659 | GNUNET_MQ_hd_fixed_size(statistics_watch_value, |
669 | GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE, | 660 | GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE, |
670 | struct GNUNET_STATISTICS_WatchValueMessage, | 661 | struct GNUNET_STATISTICS_WatchValueMessage, |
671 | h), | 662 | h), |
672 | GNUNET_MQ_handler_end () | 663 | GNUNET_MQ_handler_end() |
673 | }; | 664 | }; |
674 | struct GNUNET_STATISTICS_GetHandle *gh; | 665 | struct GNUNET_STATISTICS_GetHandle *gh; |
675 | struct GNUNET_STATISTICS_GetHandle *gn; | 666 | struct GNUNET_STATISTICS_GetHandle *gn; |
@@ -678,33 +669,33 @@ try_connect (struct GNUNET_STATISTICS_Handle *h) | |||
678 | return GNUNET_NO; | 669 | return GNUNET_NO; |
679 | if (NULL != h->mq) | 670 | if (NULL != h->mq) |
680 | return GNUNET_YES; | 671 | return GNUNET_YES; |
681 | h->mq = GNUNET_CLIENT_connect (h->cfg, | 672 | h->mq = GNUNET_CLIENT_connect(h->cfg, |
682 | "statistics", | 673 | "statistics", |
683 | handlers, | 674 | handlers, |
684 | &mq_error_handler, | 675 | &mq_error_handler, |
685 | h); | 676 | h); |
686 | if (NULL == h->mq) | 677 | if (NULL == h->mq) |
687 | { | 678 | { |
688 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 679 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
689 | "Failed to connect to statistics service!\n"); | 680 | "Failed to connect to statistics service!\n"); |
690 | return GNUNET_NO; | 681 | return GNUNET_NO; |
691 | } | 682 | } |
692 | gn = h->action_head; | 683 | gn = h->action_head; |
693 | while (NULL != (gh = gn)) | 684 | while (NULL != (gh = gn)) |
694 | { | ||
695 | gn = gh->next; | ||
696 | if (gh->type == ACTION_WATCH) | ||
697 | { | 685 | { |
698 | GNUNET_CONTAINER_DLL_remove (h->action_head, | 686 | gn = gh->next; |
699 | h->action_tail, | 687 | if (gh->type == ACTION_WATCH) |
700 | gh); | 688 | { |
701 | free_action_item (gh); | 689 | GNUNET_CONTAINER_DLL_remove(h->action_head, |
690 | h->action_tail, | ||
691 | gh); | ||
692 | free_action_item(gh); | ||
693 | } | ||
702 | } | 694 | } |
703 | } | ||
704 | for (unsigned int i = 0; i < h->watches_size; i++) | 695 | for (unsigned int i = 0; i < h->watches_size; i++) |
705 | if (NULL != h->watches[i]) | 696 | if (NULL != h->watches[i]) |
706 | schedule_watch_request (h, | 697 | schedule_watch_request(h, |
707 | h->watches[i]); | 698 | h->watches[i]); |
708 | return GNUNET_YES; | 699 | return GNUNET_YES; |
709 | } | 700 | } |
710 | 701 | ||
@@ -715,12 +706,12 @@ try_connect (struct GNUNET_STATISTICS_Handle *h) | |||
715 | * @param cls the `struct GNUNET_STATISTICS_Handle` to reconnect | 706 | * @param cls the `struct GNUNET_STATISTICS_Handle` to reconnect |
716 | */ | 707 | */ |
717 | static void | 708 | static void |
718 | reconnect_task (void *cls) | 709 | reconnect_task(void *cls) |
719 | { | 710 | { |
720 | struct GNUNET_STATISTICS_Handle *h = cls; | 711 | struct GNUNET_STATISTICS_Handle *h = cls; |
721 | 712 | ||
722 | h->backoff_task = NULL; | 713 | h->backoff_task = NULL; |
723 | schedule_action (h); | 714 | schedule_action(h); |
724 | } | 715 | } |
725 | 716 | ||
726 | 717 | ||
@@ -730,38 +721,38 @@ reconnect_task (void *cls) | |||
730 | * @param h statistics handle | 721 | * @param h statistics handle |
731 | */ | 722 | */ |
732 | static void | 723 | static void |
733 | reconnect_later (struct GNUNET_STATISTICS_Handle *h) | 724 | reconnect_later(struct GNUNET_STATISTICS_Handle *h) |
734 | { | 725 | { |
735 | int loss; | 726 | int loss; |
736 | struct GNUNET_STATISTICS_GetHandle *gh; | 727 | struct GNUNET_STATISTICS_GetHandle *gh; |
737 | 728 | ||
738 | GNUNET_assert (NULL == h->backoff_task); | 729 | GNUNET_assert(NULL == h->backoff_task); |
739 | if (GNUNET_YES == h->do_destroy) | 730 | if (GNUNET_YES == h->do_destroy) |
740 | { | 731 | { |
741 | /* So we are shutting down and the service is not reachable. | 732 | /* So we are shutting down and the service is not reachable. |
742 | * Chances are that it's down for good and we are not going to connect to | 733 | * Chances are that it's down for good and we are not going to connect to |
743 | * it anymore. | 734 | * it anymore. |
744 | * Give up and don't sync the rest of the data. | 735 | * Give up and don't sync the rest of the data. |
745 | */ | 736 | */ |
746 | loss = GNUNET_NO; | 737 | loss = GNUNET_NO; |
747 | for (gh = h->action_head; NULL != gh; gh = gh->next) | 738 | for (gh = h->action_head; NULL != gh; gh = gh->next) |
748 | if ( (gh->make_persistent) && | 739 | if ((gh->make_persistent) && |
749 | (ACTION_SET == gh->type) ) | 740 | (ACTION_SET == gh->type)) |
750 | loss = GNUNET_YES; | 741 | loss = GNUNET_YES; |
751 | if (GNUNET_YES == loss) | 742 | if (GNUNET_YES == loss) |
752 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 743 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
753 | _("Could not save some persistent statistics\n")); | 744 | _("Could not save some persistent statistics\n")); |
754 | if (NULL != h->destroy_task) | 745 | if (NULL != h->destroy_task) |
755 | GNUNET_SCHEDULER_cancel (h->destroy_task); | 746 | GNUNET_SCHEDULER_cancel(h->destroy_task); |
756 | h->destroy_task = GNUNET_SCHEDULER_add_now (&do_destroy, | 747 | h->destroy_task = GNUNET_SCHEDULER_add_now(&do_destroy, |
757 | h); | 748 | h); |
758 | return; | 749 | return; |
759 | } | 750 | } |
760 | h->backoff_task | 751 | h->backoff_task |
761 | = GNUNET_SCHEDULER_add_delayed (h->backoff, | 752 | = GNUNET_SCHEDULER_add_delayed(h->backoff, |
762 | &reconnect_task, | 753 | &reconnect_task, |
763 | h); | 754 | h); |
764 | h->backoff = GNUNET_TIME_STD_BACKOFF (h->backoff); | 755 | h->backoff = GNUNET_TIME_STD_BACKOFF(h->backoff); |
765 | } | 756 | } |
766 | 757 | ||
767 | 758 | ||
@@ -773,7 +764,7 @@ reconnect_later (struct GNUNET_STATISTICS_Handle *h) | |||
773 | * @param handle statistics handle | 764 | * @param handle statistics handle |
774 | */ | 765 | */ |
775 | static void | 766 | static void |
776 | transmit_get (struct GNUNET_STATISTICS_Handle *handle) | 767 | transmit_get(struct GNUNET_STATISTICS_Handle *handle) |
777 | { | 768 | { |
778 | struct GNUNET_STATISTICS_GetHandle *c; | 769 | struct GNUNET_STATISTICS_GetHandle *c; |
779 | struct GNUNET_MessageHeader *hdr; | 770 | struct GNUNET_MessageHeader *hdr; |
@@ -781,23 +772,23 @@ transmit_get (struct GNUNET_STATISTICS_Handle *handle) | |||
781 | size_t slen1; | 772 | size_t slen1; |
782 | size_t slen2; | 773 | size_t slen2; |
783 | 774 | ||
784 | GNUNET_assert (NULL != (c = handle->current)); | 775 | GNUNET_assert(NULL != (c = handle->current)); |
785 | slen1 = strlen (c->subsystem) + 1; | 776 | slen1 = strlen(c->subsystem) + 1; |
786 | slen2 = strlen (c->name) + 1; | 777 | slen2 = strlen(c->name) + 1; |
787 | env = GNUNET_MQ_msg_extra (hdr, | 778 | env = GNUNET_MQ_msg_extra(hdr, |
788 | slen1 + slen2, | 779 | slen1 + slen2, |
789 | GNUNET_MESSAGE_TYPE_STATISTICS_GET); | 780 | GNUNET_MESSAGE_TYPE_STATISTICS_GET); |
790 | GNUNET_assert (slen1 + slen2 == | 781 | GNUNET_assert(slen1 + slen2 == |
791 | GNUNET_STRINGS_buffer_fill ((char *) &hdr[1], | 782 | GNUNET_STRINGS_buffer_fill((char *)&hdr[1], |
792 | slen1 + slen2, | 783 | slen1 + slen2, |
793 | 2, | 784 | 2, |
794 | c->subsystem, | 785 | c->subsystem, |
795 | c->name)); | 786 | c->name)); |
796 | GNUNET_MQ_notify_sent (env, | 787 | GNUNET_MQ_notify_sent(env, |
797 | &schedule_action, | 788 | &schedule_action, |
798 | handle); | 789 | handle); |
799 | GNUNET_MQ_send (handle->mq, | 790 | GNUNET_MQ_send(handle->mq, |
800 | env); | 791 | env); |
801 | } | 792 | } |
802 | 793 | ||
803 | 794 | ||
@@ -808,36 +799,36 @@ transmit_get (struct GNUNET_STATISTICS_Handle *handle) | |||
808 | * @param handle statistics handle | 799 | * @param handle statistics handle |
809 | */ | 800 | */ |
810 | static void | 801 | static void |
811 | transmit_watch (struct GNUNET_STATISTICS_Handle *handle) | 802 | transmit_watch(struct GNUNET_STATISTICS_Handle *handle) |
812 | { | 803 | { |
813 | struct GNUNET_MessageHeader *hdr; | 804 | struct GNUNET_MessageHeader *hdr; |
814 | struct GNUNET_MQ_Envelope *env; | 805 | struct GNUNET_MQ_Envelope *env; |
815 | size_t slen1; | 806 | size_t slen1; |
816 | size_t slen2; | 807 | size_t slen2; |
817 | 808 | ||
818 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 809 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
819 | "Transmitting watch request for `%s'\n", | 810 | "Transmitting watch request for `%s'\n", |
820 | handle->current->name); | 811 | handle->current->name); |
821 | slen1 = strlen (handle->current->subsystem) + 1; | 812 | slen1 = strlen(handle->current->subsystem) + 1; |
822 | slen2 = strlen (handle->current->name) + 1; | 813 | slen2 = strlen(handle->current->name) + 1; |
823 | env = GNUNET_MQ_msg_extra (hdr, | 814 | env = GNUNET_MQ_msg_extra(hdr, |
824 | slen1 + slen2, | 815 | slen1 + slen2, |
825 | GNUNET_MESSAGE_TYPE_STATISTICS_WATCH); | 816 | GNUNET_MESSAGE_TYPE_STATISTICS_WATCH); |
826 | GNUNET_assert (slen1 + slen2 == | 817 | GNUNET_assert(slen1 + slen2 == |
827 | GNUNET_STRINGS_buffer_fill ((char *) &hdr[1], | 818 | GNUNET_STRINGS_buffer_fill((char *)&hdr[1], |
828 | slen1 + slen2, | 819 | slen1 + slen2, |
829 | 2, | 820 | 2, |
830 | handle->current->subsystem, | 821 | handle->current->subsystem, |
831 | handle->current->name)); | 822 | handle->current->name)); |
832 | GNUNET_MQ_notify_sent (env, | 823 | GNUNET_MQ_notify_sent(env, |
833 | &schedule_action, | 824 | &schedule_action, |
834 | handle); | 825 | handle); |
835 | GNUNET_MQ_send (handle->mq, | 826 | GNUNET_MQ_send(handle->mq, |
836 | env); | 827 | env); |
837 | GNUNET_assert (NULL == handle->current->cont); | 828 | GNUNET_assert(NULL == handle->current->cont); |
838 | free_action_item (handle->current); | 829 | free_action_item(handle->current); |
839 | handle->current = NULL; | 830 | handle->current = NULL; |
840 | schedule_action (handle); | 831 | schedule_action(handle); |
841 | } | 832 | } |
842 | 833 | ||
843 | 834 | ||
@@ -847,39 +838,39 @@ transmit_watch (struct GNUNET_STATISTICS_Handle *handle) | |||
847 | * @param handle statistics handle | 838 | * @param handle statistics handle |
848 | */ | 839 | */ |
849 | static void | 840 | static void |
850 | transmit_set (struct GNUNET_STATISTICS_Handle *handle) | 841 | transmit_set(struct GNUNET_STATISTICS_Handle *handle) |
851 | { | 842 | { |
852 | struct GNUNET_STATISTICS_SetMessage *r; | 843 | struct GNUNET_STATISTICS_SetMessage *r; |
853 | struct GNUNET_MQ_Envelope *env; | 844 | struct GNUNET_MQ_Envelope *env; |
854 | size_t slen; | 845 | size_t slen; |
855 | size_t nlen; | 846 | size_t nlen; |
856 | 847 | ||
857 | slen = strlen (handle->current->subsystem) + 1; | 848 | slen = strlen(handle->current->subsystem) + 1; |
858 | nlen = strlen (handle->current->name) + 1; | 849 | nlen = strlen(handle->current->name) + 1; |
859 | env = GNUNET_MQ_msg_extra (r, | 850 | env = GNUNET_MQ_msg_extra(r, |
860 | slen + nlen, | 851 | slen + nlen, |
861 | GNUNET_MESSAGE_TYPE_STATISTICS_SET); | 852 | GNUNET_MESSAGE_TYPE_STATISTICS_SET); |
862 | r->flags = 0; | 853 | r->flags = 0; |
863 | r->value = GNUNET_htonll (handle->current->value); | 854 | r->value = GNUNET_htonll(handle->current->value); |
864 | if (handle->current->make_persistent) | 855 | if (handle->current->make_persistent) |
865 | r->flags |= htonl (GNUNET_STATISTICS_SETFLAG_PERSISTENT); | 856 | r->flags |= htonl(GNUNET_STATISTICS_SETFLAG_PERSISTENT); |
866 | if (handle->current->type == ACTION_UPDATE) | 857 | if (handle->current->type == ACTION_UPDATE) |
867 | r->flags |= htonl (GNUNET_STATISTICS_SETFLAG_RELATIVE); | 858 | r->flags |= htonl(GNUNET_STATISTICS_SETFLAG_RELATIVE); |
868 | GNUNET_assert (slen + nlen == | 859 | GNUNET_assert(slen + nlen == |
869 | GNUNET_STRINGS_buffer_fill ((char *) &r[1], | 860 | GNUNET_STRINGS_buffer_fill((char *)&r[1], |
870 | slen + nlen, | 861 | slen + nlen, |
871 | 2, | 862 | 2, |
872 | handle->current->subsystem, | 863 | handle->current->subsystem, |
873 | handle->current->name)); | 864 | handle->current->name)); |
874 | GNUNET_assert (NULL == handle->current->cont); | 865 | GNUNET_assert(NULL == handle->current->cont); |
875 | free_action_item (handle->current); | 866 | free_action_item(handle->current); |
876 | handle->current = NULL; | 867 | handle->current = NULL; |
877 | update_memory_statistics (handle); | 868 | update_memory_statistics(handle); |
878 | GNUNET_MQ_notify_sent (env, | 869 | GNUNET_MQ_notify_sent(env, |
879 | &schedule_action, | 870 | &schedule_action, |
880 | handle); | 871 | handle); |
881 | GNUNET_MQ_send (handle->mq, | 872 | GNUNET_MQ_send(handle->mq, |
882 | env); | 873 | env); |
883 | } | 874 | } |
884 | 875 | ||
885 | 876 | ||
@@ -891,19 +882,19 @@ transmit_set (struct GNUNET_STATISTICS_Handle *handle) | |||
891 | * @return handle to use | 882 | * @return handle to use |
892 | */ | 883 | */ |
893 | struct GNUNET_STATISTICS_Handle * | 884 | struct GNUNET_STATISTICS_Handle * |
894 | GNUNET_STATISTICS_create (const char *subsystem, | 885 | GNUNET_STATISTICS_create(const char *subsystem, |
895 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 886 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
896 | { | 887 | { |
897 | struct GNUNET_STATISTICS_Handle *h; | 888 | struct GNUNET_STATISTICS_Handle *h; |
898 | 889 | ||
899 | if (GNUNET_YES == | 890 | if (GNUNET_YES == |
900 | GNUNET_CONFIGURATION_get_value_yesno (cfg, | 891 | GNUNET_CONFIGURATION_get_value_yesno(cfg, |
901 | "statistics", | 892 | "statistics", |
902 | "DISABLE")) | 893 | "DISABLE")) |
903 | return NULL; | 894 | return NULL; |
904 | h = GNUNET_new (struct GNUNET_STATISTICS_Handle); | 895 | h = GNUNET_new(struct GNUNET_STATISTICS_Handle); |
905 | h->cfg = cfg; | 896 | h->cfg = cfg; |
906 | h->subsystem = GNUNET_strdup (subsystem); | 897 | h->subsystem = GNUNET_strdup(subsystem); |
907 | h->backoff = GNUNET_TIME_UNIT_MILLISECONDS; | 898 | h->backoff = GNUNET_TIME_UNIT_MILLISECONDS; |
908 | return h; | 899 | return h; |
909 | } | 900 | } |
@@ -918,82 +909,82 @@ GNUNET_STATISTICS_create (const char *subsystem, | |||
918 | * be completed | 909 | * be completed |
919 | */ | 910 | */ |
920 | void | 911 | void |
921 | GNUNET_STATISTICS_destroy (struct GNUNET_STATISTICS_Handle *h, | 912 | GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, |
922 | int sync_first) | 913 | int sync_first) |
923 | { | 914 | { |
924 | struct GNUNET_STATISTICS_GetHandle *pos; | 915 | struct GNUNET_STATISTICS_GetHandle *pos; |
925 | struct GNUNET_STATISTICS_GetHandle *next; | 916 | struct GNUNET_STATISTICS_GetHandle *next; |
926 | 917 | ||
927 | if (NULL == h) | 918 | if (NULL == h) |
928 | return; | 919 | return; |
929 | GNUNET_assert (GNUNET_NO == h->do_destroy); /* Don't call twice. */ | 920 | GNUNET_assert(GNUNET_NO == h->do_destroy); /* Don't call twice. */ |
930 | if ( (sync_first) && | 921 | if ((sync_first) && |
931 | (NULL != h->mq) && | 922 | (NULL != h->mq) && |
932 | (0 != GNUNET_MQ_get_length (h->mq)) ) | 923 | (0 != GNUNET_MQ_get_length(h->mq))) |
933 | { | ||
934 | if ( (NULL != h->current) && | ||
935 | (ACTION_GET == h->current->type) ) | ||
936 | h->current->aborted = GNUNET_YES; | ||
937 | next = h->action_head; | ||
938 | while (NULL != (pos = next)) | ||
939 | { | 924 | { |
940 | next = pos->next; | 925 | if ((NULL != h->current) && |
941 | if ( (ACTION_GET == pos->type) || | 926 | (ACTION_GET == h->current->type)) |
942 | (ACTION_WATCH == pos->type) ) | 927 | h->current->aborted = GNUNET_YES; |
943 | { | 928 | next = h->action_head; |
944 | GNUNET_CONTAINER_DLL_remove (h->action_head, | 929 | while (NULL != (pos = next)) |
945 | h->action_tail, | 930 | { |
946 | pos); | 931 | next = pos->next; |
947 | free_action_item (pos); | 932 | if ((ACTION_GET == pos->type) || |
948 | } | 933 | (ACTION_WATCH == pos->type)) |
949 | } | 934 | { |
950 | h->do_destroy = GNUNET_YES; | 935 | GNUNET_CONTAINER_DLL_remove(h->action_head, |
951 | schedule_action (h); | 936 | h->action_tail, |
952 | GNUNET_assert (NULL == h->destroy_task); | 937 | pos); |
953 | h->destroy_task | 938 | free_action_item(pos); |
954 | = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (h->backoff, | 939 | } |
940 | } | ||
941 | h->do_destroy = GNUNET_YES; | ||
942 | schedule_action(h); | ||
943 | GNUNET_assert(NULL == h->destroy_task); | ||
944 | h->destroy_task | ||
945 | = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(h->backoff, | ||
955 | 5), | 946 | 5), |
956 | &do_destroy, | 947 | &do_destroy, |
957 | h); | 948 | h); |
958 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 949 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
959 | "Deferring destruction\n"); | 950 | "Deferring destruction\n"); |
960 | return; /* do not finish destruction just yet */ | 951 | return; /* do not finish destruction just yet */ |
961 | } | 952 | } |
962 | /* do clean up all */ | 953 | /* do clean up all */ |
963 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 954 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
964 | "Cleaning all up\n"); | 955 | "Cleaning all up\n"); |
965 | while (NULL != (pos = h->action_head)) | 956 | while (NULL != (pos = h->action_head)) |
966 | { | 957 | { |
967 | GNUNET_CONTAINER_DLL_remove (h->action_head, | 958 | GNUNET_CONTAINER_DLL_remove(h->action_head, |
968 | h->action_tail, | 959 | h->action_tail, |
969 | pos); | 960 | pos); |
970 | free_action_item (pos); | 961 | free_action_item(pos); |
971 | } | 962 | } |
972 | do_disconnect (h); | 963 | do_disconnect(h); |
973 | if (NULL != h->backoff_task) | 964 | if (NULL != h->backoff_task) |
974 | { | 965 | { |
975 | GNUNET_SCHEDULER_cancel (h->backoff_task); | 966 | GNUNET_SCHEDULER_cancel(h->backoff_task); |
976 | h->backoff_task = NULL; | 967 | h->backoff_task = NULL; |
977 | } | 968 | } |
978 | if (NULL != h->destroy_task) | 969 | if (NULL != h->destroy_task) |
979 | { | 970 | { |
980 | GNUNET_break (0); | 971 | GNUNET_break(0); |
981 | GNUNET_SCHEDULER_cancel (h->destroy_task); | 972 | GNUNET_SCHEDULER_cancel(h->destroy_task); |
982 | h->destroy_task = NULL; | 973 | h->destroy_task = NULL; |
983 | } | 974 | } |
984 | for (unsigned int i = 0; i < h->watches_size; i++) | 975 | for (unsigned int i = 0; i < h->watches_size; i++) |
985 | { | 976 | { |
986 | if (NULL == h->watches[i]) | 977 | if (NULL == h->watches[i]) |
987 | continue; | 978 | continue; |
988 | GNUNET_free (h->watches[i]->subsystem); | 979 | GNUNET_free(h->watches[i]->subsystem); |
989 | GNUNET_free (h->watches[i]->name); | 980 | GNUNET_free(h->watches[i]->name); |
990 | GNUNET_free (h->watches[i]); | 981 | GNUNET_free(h->watches[i]); |
991 | } | 982 | } |
992 | GNUNET_array_grow (h->watches, | 983 | GNUNET_array_grow(h->watches, |
993 | h->watches_size, | 984 | h->watches_size, |
994 | 0); | 985 | 0); |
995 | GNUNET_free (h->subsystem); | 986 | GNUNET_free(h->subsystem); |
996 | GNUNET_free (h); | 987 | GNUNET_free(h); |
997 | } | 988 | } |
998 | 989 | ||
999 | 990 | ||
@@ -1003,63 +994,66 @@ GNUNET_STATISTICS_destroy (struct GNUNET_STATISTICS_Handle *h, | |||
1003 | * @param cls statistics handle | 994 | * @param cls statistics handle |
1004 | */ | 995 | */ |
1005 | static void | 996 | static void |
1006 | schedule_action (void *cls) | 997 | schedule_action(void *cls) |
1007 | { | 998 | { |
1008 | struct GNUNET_STATISTICS_Handle *h = cls; | 999 | struct GNUNET_STATISTICS_Handle *h = cls; |
1009 | 1000 | ||
1010 | if (NULL != h->backoff_task) | 1001 | if (NULL != h->backoff_task) |
1011 | return; /* action already pending */ | 1002 | return; /* action already pending */ |
1012 | if (GNUNET_YES != try_connect (h)) | 1003 | if (GNUNET_YES != try_connect(h)) |
1013 | { | ||
1014 | reconnect_later (h); | ||
1015 | return; | ||
1016 | } | ||
1017 | if (0 < GNUNET_MQ_get_length (h->mq)) | ||
1018 | return; /* Wait for queue to be reduced more */ | ||
1019 | /* schedule next action */ | ||
1020 | while (NULL == h->current) | ||
1021 | { | ||
1022 | h->current = h->action_head; | ||
1023 | if (NULL == h->current) | ||
1024 | { | 1004 | { |
1025 | struct GNUNET_MessageHeader *hdr; | 1005 | reconnect_later(h); |
1026 | struct GNUNET_MQ_Envelope *env; | ||
1027 | |||
1028 | if (GNUNET_YES != h->do_destroy) | ||
1029 | return; /* nothing to do */ | ||
1030 | /* let service know that we're done */ | ||
1031 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1032 | "Notifying service that we are done\n"); | ||
1033 | h->do_destroy = GNUNET_SYSERR; /* in 'TEST' mode */ | ||
1034 | env = GNUNET_MQ_msg (hdr, | ||
1035 | GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT); | ||
1036 | GNUNET_MQ_notify_sent (env, | ||
1037 | &schedule_action, | ||
1038 | h); | ||
1039 | GNUNET_MQ_send (h->mq, | ||
1040 | env); | ||
1041 | return; | 1006 | return; |
1042 | } | 1007 | } |
1043 | GNUNET_CONTAINER_DLL_remove (h->action_head, | 1008 | if (0 < GNUNET_MQ_get_length(h->mq)) |
1044 | h->action_tail, | 1009 | return; /* Wait for queue to be reduced more */ |
1045 | h->current); | 1010 | /* schedule next action */ |
1046 | switch (h->current->type) | 1011 | while (NULL == h->current) |
1047 | { | 1012 | { |
1048 | case ACTION_GET: | 1013 | h->current = h->action_head; |
1049 | transmit_get (h); | 1014 | if (NULL == h->current) |
1050 | break; | 1015 | { |
1051 | case ACTION_SET: | 1016 | struct GNUNET_MessageHeader *hdr; |
1052 | case ACTION_UPDATE: | 1017 | struct GNUNET_MQ_Envelope *env; |
1053 | transmit_set (h); | 1018 | |
1054 | break; | 1019 | if (GNUNET_YES != h->do_destroy) |
1055 | case ACTION_WATCH: | 1020 | return; /* nothing to do */ |
1056 | transmit_watch (h); | 1021 | /* let service know that we're done */ |
1057 | break; | 1022 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
1058 | default: | 1023 | "Notifying service that we are done\n"); |
1059 | GNUNET_assert (0); | 1024 | h->do_destroy = GNUNET_SYSERR; /* in 'TEST' mode */ |
1060 | break; | 1025 | env = GNUNET_MQ_msg(hdr, |
1026 | GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT); | ||
1027 | GNUNET_MQ_notify_sent(env, | ||
1028 | &schedule_action, | ||
1029 | h); | ||
1030 | GNUNET_MQ_send(h->mq, | ||
1031 | env); | ||
1032 | return; | ||
1033 | } | ||
1034 | GNUNET_CONTAINER_DLL_remove(h->action_head, | ||
1035 | h->action_tail, | ||
1036 | h->current); | ||
1037 | switch (h->current->type) | ||
1038 | { | ||
1039 | case ACTION_GET: | ||
1040 | transmit_get(h); | ||
1041 | break; | ||
1042 | |||
1043 | case ACTION_SET: | ||
1044 | case ACTION_UPDATE: | ||
1045 | transmit_set(h); | ||
1046 | break; | ||
1047 | |||
1048 | case ACTION_WATCH: | ||
1049 | transmit_watch(h); | ||
1050 | break; | ||
1051 | |||
1052 | default: | ||
1053 | GNUNET_assert(0); | ||
1054 | break; | ||
1055 | } | ||
1061 | } | 1056 | } |
1062 | } | ||
1063 | } | 1057 | } |
1064 | 1058 | ||
1065 | 1059 | ||
@@ -1076,12 +1070,12 @@ schedule_action (void *cls) | |||
1076 | * @return NULL on error | 1070 | * @return NULL on error |
1077 | */ | 1071 | */ |
1078 | struct GNUNET_STATISTICS_GetHandle * | 1072 | struct GNUNET_STATISTICS_GetHandle * |
1079 | GNUNET_STATISTICS_get (struct GNUNET_STATISTICS_Handle *handle, | 1073 | GNUNET_STATISTICS_get(struct GNUNET_STATISTICS_Handle *handle, |
1080 | const char *subsystem, | 1074 | const char *subsystem, |
1081 | const char *name, | 1075 | const char *name, |
1082 | GNUNET_STATISTICS_Callback cont, | 1076 | GNUNET_STATISTICS_Callback cont, |
1083 | GNUNET_STATISTICS_Iterator proc, | 1077 | GNUNET_STATISTICS_Iterator proc, |
1084 | void *cls) | 1078 | void *cls) |
1085 | { | 1079 | { |
1086 | size_t slen1; | 1080 | size_t slen1; |
1087 | size_t slen2; | 1081 | size_t slen2; |
@@ -1089,29 +1083,29 @@ GNUNET_STATISTICS_get (struct GNUNET_STATISTICS_Handle *handle, | |||
1089 | 1083 | ||
1090 | if (NULL == handle) | 1084 | if (NULL == handle) |
1091 | return NULL; | 1085 | return NULL; |
1092 | GNUNET_assert (NULL != proc); | 1086 | GNUNET_assert(NULL != proc); |
1093 | GNUNET_assert (GNUNET_NO == handle->do_destroy); | 1087 | GNUNET_assert(GNUNET_NO == handle->do_destroy); |
1094 | if (NULL == subsystem) | 1088 | if (NULL == subsystem) |
1095 | subsystem = ""; | 1089 | subsystem = ""; |
1096 | if (NULL == name) | 1090 | if (NULL == name) |
1097 | name = ""; | 1091 | name = ""; |
1098 | slen1 = strlen (subsystem) + 1; | 1092 | slen1 = strlen(subsystem) + 1; |
1099 | slen2 = strlen (name) + 1; | 1093 | slen2 = strlen(name) + 1; |
1100 | GNUNET_assert (slen1 + slen2 + sizeof (struct GNUNET_MessageHeader) < | 1094 | GNUNET_assert(slen1 + slen2 + sizeof(struct GNUNET_MessageHeader) < |
1101 | GNUNET_MAX_MESSAGE_SIZE); | 1095 | GNUNET_MAX_MESSAGE_SIZE); |
1102 | ai = GNUNET_new (struct GNUNET_STATISTICS_GetHandle); | 1096 | ai = GNUNET_new(struct GNUNET_STATISTICS_GetHandle); |
1103 | ai->sh = handle; | 1097 | ai->sh = handle; |
1104 | ai->subsystem = GNUNET_strdup (subsystem); | 1098 | ai->subsystem = GNUNET_strdup(subsystem); |
1105 | ai->name = GNUNET_strdup (name); | 1099 | ai->name = GNUNET_strdup(name); |
1106 | ai->cont = cont; | 1100 | ai->cont = cont; |
1107 | ai->proc = proc; | 1101 | ai->proc = proc; |
1108 | ai->cls = cls; | 1102 | ai->cls = cls; |
1109 | ai->type = ACTION_GET; | 1103 | ai->type = ACTION_GET; |
1110 | ai->msize = slen1 + slen2 + sizeof (struct GNUNET_MessageHeader); | 1104 | ai->msize = slen1 + slen2 + sizeof(struct GNUNET_MessageHeader); |
1111 | GNUNET_CONTAINER_DLL_insert_tail (handle->action_head, | 1105 | GNUNET_CONTAINER_DLL_insert_tail(handle->action_head, |
1112 | handle->action_tail, | 1106 | handle->action_tail, |
1113 | ai); | 1107 | ai); |
1114 | schedule_action (handle); | 1108 | schedule_action(handle); |
1115 | return ai; | 1109 | return ai; |
1116 | } | 1110 | } |
1117 | 1111 | ||
@@ -1123,22 +1117,22 @@ GNUNET_STATISTICS_get (struct GNUNET_STATISTICS_Handle *handle, | |||
1123 | * @param gh handle of the request to cancel | 1117 | * @param gh handle of the request to cancel |
1124 | */ | 1118 | */ |
1125 | void | 1119 | void |
1126 | GNUNET_STATISTICS_get_cancel (struct GNUNET_STATISTICS_GetHandle *gh) | 1120 | GNUNET_STATISTICS_get_cancel(struct GNUNET_STATISTICS_GetHandle *gh) |
1127 | { | 1121 | { |
1128 | if (NULL == gh) | 1122 | if (NULL == gh) |
1129 | return; | 1123 | return; |
1130 | gh->cont = NULL; | 1124 | gh->cont = NULL; |
1131 | if (gh->sh->current == gh) | 1125 | if (gh->sh->current == gh) |
1132 | { | 1126 | { |
1133 | gh->aborted = GNUNET_YES; | 1127 | gh->aborted = GNUNET_YES; |
1134 | return; | 1128 | return; |
1135 | } | 1129 | } |
1136 | GNUNET_CONTAINER_DLL_remove (gh->sh->action_head, | 1130 | GNUNET_CONTAINER_DLL_remove(gh->sh->action_head, |
1137 | gh->sh->action_tail, | 1131 | gh->sh->action_tail, |
1138 | gh); | 1132 | gh); |
1139 | GNUNET_free (gh->name); | 1133 | GNUNET_free(gh->name); |
1140 | GNUNET_free (gh->subsystem); | 1134 | GNUNET_free(gh->subsystem); |
1141 | GNUNET_free (gh); | 1135 | GNUNET_free(gh); |
1142 | } | 1136 | } |
1143 | 1137 | ||
1144 | 1138 | ||
@@ -1153,26 +1147,26 @@ GNUNET_STATISTICS_get_cancel (struct GNUNET_STATISTICS_GetHandle *gh) | |||
1153 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 1147 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
1154 | */ | 1148 | */ |
1155 | int | 1149 | int |
1156 | GNUNET_STATISTICS_watch (struct GNUNET_STATISTICS_Handle *handle, | 1150 | GNUNET_STATISTICS_watch(struct GNUNET_STATISTICS_Handle *handle, |
1157 | const char *subsystem, | 1151 | const char *subsystem, |
1158 | const char *name, | 1152 | const char *name, |
1159 | GNUNET_STATISTICS_Iterator proc, | 1153 | GNUNET_STATISTICS_Iterator proc, |
1160 | void *proc_cls) | 1154 | void *proc_cls) |
1161 | { | 1155 | { |
1162 | struct GNUNET_STATISTICS_WatchEntry *w; | 1156 | struct GNUNET_STATISTICS_WatchEntry *w; |
1163 | 1157 | ||
1164 | if (NULL == handle) | 1158 | if (NULL == handle) |
1165 | return GNUNET_SYSERR; | 1159 | return GNUNET_SYSERR; |
1166 | w = GNUNET_new (struct GNUNET_STATISTICS_WatchEntry); | 1160 | w = GNUNET_new(struct GNUNET_STATISTICS_WatchEntry); |
1167 | w->subsystem = GNUNET_strdup (subsystem); | 1161 | w->subsystem = GNUNET_strdup(subsystem); |
1168 | w->name = GNUNET_strdup (name); | 1162 | w->name = GNUNET_strdup(name); |
1169 | w->proc = proc; | 1163 | w->proc = proc; |
1170 | w->proc_cls = proc_cls; | 1164 | w->proc_cls = proc_cls; |
1171 | GNUNET_array_append (handle->watches, | 1165 | GNUNET_array_append(handle->watches, |
1172 | handle->watches_size, | 1166 | handle->watches_size, |
1173 | w); | 1167 | w); |
1174 | schedule_watch_request (handle, | 1168 | schedule_watch_request(handle, |
1175 | w); | 1169 | w); |
1176 | return GNUNET_OK; | 1170 | return GNUNET_OK; |
1177 | } | 1171 | } |
1178 | 1172 | ||
@@ -1188,35 +1182,35 @@ GNUNET_STATISTICS_watch (struct GNUNET_STATISTICS_Handle *handle, | |||
1188 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error (no such watch) | 1182 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error (no such watch) |
1189 | */ | 1183 | */ |
1190 | int | 1184 | int |
1191 | GNUNET_STATISTICS_watch_cancel (struct GNUNET_STATISTICS_Handle *handle, | 1185 | GNUNET_STATISTICS_watch_cancel(struct GNUNET_STATISTICS_Handle *handle, |
1192 | const char *subsystem, | 1186 | const char *subsystem, |
1193 | const char *name, | 1187 | const char *name, |
1194 | GNUNET_STATISTICS_Iterator proc, | 1188 | GNUNET_STATISTICS_Iterator proc, |
1195 | void *proc_cls) | 1189 | void *proc_cls) |
1196 | { | 1190 | { |
1197 | struct GNUNET_STATISTICS_WatchEntry *w; | 1191 | struct GNUNET_STATISTICS_WatchEntry *w; |
1198 | 1192 | ||
1199 | if (NULL == handle) | 1193 | if (NULL == handle) |
1200 | return GNUNET_SYSERR; | 1194 | return GNUNET_SYSERR; |
1201 | for (unsigned int i=0;i<handle->watches_size;i++) | 1195 | for (unsigned int i = 0; i < handle->watches_size; i++) |
1202 | { | ||
1203 | w = handle->watches[i]; | ||
1204 | if (NULL == w) | ||
1205 | continue; | ||
1206 | if ( (w->proc == proc) && | ||
1207 | (w->proc_cls == proc_cls) && | ||
1208 | (0 == strcmp (w->name, | ||
1209 | name)) && | ||
1210 | (0 == strcmp (w->subsystem, | ||
1211 | subsystem)) ) | ||
1212 | { | 1196 | { |
1213 | GNUNET_free (w->name); | 1197 | w = handle->watches[i]; |
1214 | GNUNET_free (w->subsystem); | 1198 | if (NULL == w) |
1215 | GNUNET_free (w); | 1199 | continue; |
1216 | handle->watches[i] = NULL; | 1200 | if ((w->proc == proc) && |
1217 | return GNUNET_OK; | 1201 | (w->proc_cls == proc_cls) && |
1202 | (0 == strcmp(w->name, | ||
1203 | name)) && | ||
1204 | (0 == strcmp(w->subsystem, | ||
1205 | subsystem))) | ||
1206 | { | ||
1207 | GNUNET_free(w->name); | ||
1208 | GNUNET_free(w->subsystem); | ||
1209 | GNUNET_free(w); | ||
1210 | handle->watches[i] = NULL; | ||
1211 | return GNUNET_OK; | ||
1212 | } | ||
1218 | } | 1213 | } |
1219 | } | ||
1220 | return GNUNET_SYSERR; | 1214 | return GNUNET_SYSERR; |
1221 | } | 1215 | } |
1222 | 1216 | ||
@@ -1231,11 +1225,11 @@ GNUNET_STATISTICS_watch_cancel (struct GNUNET_STATISTICS_Handle *handle, | |||
1231 | * @param type type of the action (#ACTION_SET or #ACTION_UPDATE) | 1225 | * @param type type of the action (#ACTION_SET or #ACTION_UPDATE) |
1232 | */ | 1226 | */ |
1233 | static void | 1227 | static void |
1234 | add_setter_action (struct GNUNET_STATISTICS_Handle *h, | 1228 | add_setter_action(struct GNUNET_STATISTICS_Handle *h, |
1235 | const char *name, | 1229 | const char *name, |
1236 | int make_persistent, | 1230 | int make_persistent, |
1237 | uint64_t value, | 1231 | uint64_t value, |
1238 | enum ActionType type) | 1232 | enum ActionType type) |
1239 | { | 1233 | { |
1240 | struct GNUNET_STATISTICS_GetHandle *ai; | 1234 | struct GNUNET_STATISTICS_GetHandle *ai; |
1241 | size_t slen; | 1235 | size_t slen; |
@@ -1243,83 +1237,83 @@ add_setter_action (struct GNUNET_STATISTICS_Handle *h, | |||
1243 | size_t nsize; | 1237 | size_t nsize; |
1244 | int64_t delta; | 1238 | int64_t delta; |
1245 | 1239 | ||
1246 | slen = strlen (h->subsystem) + 1; | 1240 | slen = strlen(h->subsystem) + 1; |
1247 | nlen = strlen (name) + 1; | 1241 | nlen = strlen(name) + 1; |
1248 | nsize = sizeof (struct GNUNET_STATISTICS_SetMessage) + slen + nlen; | 1242 | nsize = sizeof(struct GNUNET_STATISTICS_SetMessage) + slen + nlen; |
1249 | if (nsize >= GNUNET_MAX_MESSAGE_SIZE) | 1243 | if (nsize >= GNUNET_MAX_MESSAGE_SIZE) |
1250 | { | ||
1251 | GNUNET_break (0); | ||
1252 | return; | ||
1253 | } | ||
1254 | for (ai = h->action_head; NULL != ai; ai = ai->next) | ||
1255 | { | ||
1256 | if (! ( (0 == strcmp (ai->subsystem, | ||
1257 | h->subsystem)) && | ||
1258 | (0 == strcmp (ai->name, | ||
1259 | name)) && | ||
1260 | ( (ACTION_UPDATE == ai->type) || | ||
1261 | (ACTION_SET == ai->type) ) ) ) | ||
1262 | continue; | ||
1263 | if (ACTION_SET == ai->type) | ||
1264 | { | 1244 | { |
1265 | if (ACTION_UPDATE == type) | 1245 | GNUNET_break(0); |
1266 | { | 1246 | return; |
1267 | delta = (int64_t) value; | ||
1268 | if (delta > 0) | ||
1269 | { | ||
1270 | /* update old set by new delta */ | ||
1271 | ai->value += delta; | ||
1272 | } | ||
1273 | else | ||
1274 | { | ||
1275 | /* update old set by new delta, but never go negative */ | ||
1276 | if (ai->value < -delta) | ||
1277 | ai->value = 0; | ||
1278 | else | ||
1279 | ai->value += delta; | ||
1280 | } | ||
1281 | } | ||
1282 | else | ||
1283 | { | ||
1284 | /* new set overrides old set */ | ||
1285 | ai->value = value; | ||
1286 | } | ||
1287 | } | 1247 | } |
1288 | else | 1248 | for (ai = h->action_head; NULL != ai; ai = ai->next) |
1289 | { | 1249 | { |
1290 | if (ACTION_UPDATE == type) | 1250 | if (!((0 == strcmp(ai->subsystem, |
1291 | { | 1251 | h->subsystem)) && |
1292 | /* make delta cummulative */ | 1252 | (0 == strcmp(ai->name, |
1293 | delta = (int64_t) value; | 1253 | name)) && |
1294 | ai->value += delta; | 1254 | ((ACTION_UPDATE == ai->type) || |
1295 | } | 1255 | (ACTION_SET == ai->type)))) |
1256 | continue; | ||
1257 | if (ACTION_SET == ai->type) | ||
1258 | { | ||
1259 | if (ACTION_UPDATE == type) | ||
1260 | { | ||
1261 | delta = (int64_t)value; | ||
1262 | if (delta > 0) | ||
1263 | { | ||
1264 | /* update old set by new delta */ | ||
1265 | ai->value += delta; | ||
1266 | } | ||
1267 | else | ||
1268 | { | ||
1269 | /* update old set by new delta, but never go negative */ | ||
1270 | if (ai->value < -delta) | ||
1271 | ai->value = 0; | ||
1272 | else | ||
1273 | ai->value += delta; | ||
1274 | } | ||
1275 | } | ||
1276 | else | ||
1277 | { | ||
1278 | /* new set overrides old set */ | ||
1279 | ai->value = value; | ||
1280 | } | ||
1281 | } | ||
1296 | else | 1282 | else |
1297 | { | 1283 | { |
1298 | /* drop old 'update', use new 'set' instead */ | 1284 | if (ACTION_UPDATE == type) |
1299 | ai->value = value; | 1285 | { |
1300 | ai->type = type; | 1286 | /* make delta cummulative */ |
1301 | } | 1287 | delta = (int64_t)value; |
1288 | ai->value += delta; | ||
1289 | } | ||
1290 | else | ||
1291 | { | ||
1292 | /* drop old 'update', use new 'set' instead */ | ||
1293 | ai->value = value; | ||
1294 | ai->type = type; | ||
1295 | } | ||
1296 | } | ||
1297 | ai->timeout | ||
1298 | = GNUNET_TIME_relative_to_absolute(SET_TRANSMIT_TIMEOUT); | ||
1299 | ai->make_persistent | ||
1300 | = make_persistent; | ||
1301 | return; | ||
1302 | } | 1302 | } |
1303 | ai->timeout | ||
1304 | = GNUNET_TIME_relative_to_absolute (SET_TRANSMIT_TIMEOUT); | ||
1305 | ai->make_persistent | ||
1306 | = make_persistent; | ||
1307 | return; | ||
1308 | } | ||
1309 | /* no existing entry matches, create a fresh one */ | 1303 | /* no existing entry matches, create a fresh one */ |
1310 | ai = GNUNET_new (struct GNUNET_STATISTICS_GetHandle); | 1304 | ai = GNUNET_new(struct GNUNET_STATISTICS_GetHandle); |
1311 | ai->sh = h; | 1305 | ai->sh = h; |
1312 | ai->subsystem = GNUNET_strdup (h->subsystem); | 1306 | ai->subsystem = GNUNET_strdup(h->subsystem); |
1313 | ai->name = GNUNET_strdup (name); | 1307 | ai->name = GNUNET_strdup(name); |
1314 | ai->timeout = GNUNET_TIME_relative_to_absolute (SET_TRANSMIT_TIMEOUT); | 1308 | ai->timeout = GNUNET_TIME_relative_to_absolute(SET_TRANSMIT_TIMEOUT); |
1315 | ai->make_persistent = make_persistent; | 1309 | ai->make_persistent = make_persistent; |
1316 | ai->msize = nsize; | 1310 | ai->msize = nsize; |
1317 | ai->value = value; | 1311 | ai->value = value; |
1318 | ai->type = type; | 1312 | ai->type = type; |
1319 | GNUNET_CONTAINER_DLL_insert_tail (h->action_head, | 1313 | GNUNET_CONTAINER_DLL_insert_tail(h->action_head, |
1320 | h->action_tail, | 1314 | h->action_tail, |
1321 | ai); | 1315 | ai); |
1322 | schedule_action (h); | 1316 | schedule_action(h); |
1323 | } | 1317 | } |
1324 | 1318 | ||
1325 | 1319 | ||
@@ -1333,19 +1327,19 @@ add_setter_action (struct GNUNET_STATISTICS_Handle *h, | |||
1333 | * @param make_persistent should the value be kept across restarts? | 1327 | * @param make_persistent should the value be kept across restarts? |
1334 | */ | 1328 | */ |
1335 | void | 1329 | void |
1336 | GNUNET_STATISTICS_set (struct GNUNET_STATISTICS_Handle *handle, | 1330 | GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, |
1337 | const char *name, | 1331 | const char *name, |
1338 | uint64_t value, | 1332 | uint64_t value, |
1339 | int make_persistent) | 1333 | int make_persistent) |
1340 | { | 1334 | { |
1341 | if (NULL == handle) | 1335 | if (NULL == handle) |
1342 | return; | 1336 | return; |
1343 | GNUNET_assert (GNUNET_NO == handle->do_destroy); | 1337 | GNUNET_assert(GNUNET_NO == handle->do_destroy); |
1344 | add_setter_action (handle, | 1338 | add_setter_action(handle, |
1345 | name, | 1339 | name, |
1346 | make_persistent, | 1340 | make_persistent, |
1347 | value, | 1341 | value, |
1348 | ACTION_SET); | 1342 | ACTION_SET); |
1349 | } | 1343 | } |
1350 | 1344 | ||
1351 | 1345 | ||
@@ -1359,21 +1353,21 @@ GNUNET_STATISTICS_set (struct GNUNET_STATISTICS_Handle *handle, | |||
1359 | * @param make_persistent should the value be kept across restarts? | 1353 | * @param make_persistent should the value be kept across restarts? |
1360 | */ | 1354 | */ |
1361 | void | 1355 | void |
1362 | GNUNET_STATISTICS_update (struct GNUNET_STATISTICS_Handle *handle, | 1356 | GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, |
1363 | const char *name, | 1357 | const char *name, |
1364 | int64_t delta, | 1358 | int64_t delta, |
1365 | int make_persistent) | 1359 | int make_persistent) |
1366 | { | 1360 | { |
1367 | if (NULL == handle) | 1361 | if (NULL == handle) |
1368 | return; | 1362 | return; |
1369 | if (0 == delta) | 1363 | if (0 == delta) |
1370 | return; | 1364 | return; |
1371 | GNUNET_assert (GNUNET_NO == handle->do_destroy); | 1365 | GNUNET_assert(GNUNET_NO == handle->do_destroy); |
1372 | add_setter_action (handle, | 1366 | add_setter_action(handle, |
1373 | name, | 1367 | name, |
1374 | make_persistent, | 1368 | make_persistent, |
1375 | (uint64_t) delta, | 1369 | (uint64_t)delta, |
1376 | ACTION_UPDATE); | 1370 | ACTION_UPDATE); |
1377 | } | 1371 | } |
1378 | 1372 | ||
1379 | 1373 | ||
diff --git a/src/statistics/test_statistics_api.c b/src/statistics/test_statistics_api.c index 7a0756cda..b21fa5ef1 100644 --- a/src/statistics/test_statistics_api.c +++ b/src/statistics/test_statistics_api.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | /** | 20 | /** |
21 | * @file statistics/test_statistics_api.c | 21 | * @file statistics/test_statistics_api.c |
22 | * @brief testcase for statistics_api.c | 22 | * @brief testcase for statistics_api.c |
@@ -33,220 +33,219 @@ static struct GNUNET_STATISTICS_GetHandle *g; | |||
33 | 33 | ||
34 | 34 | ||
35 | static void | 35 | static void |
36 | do_shutdown () | 36 | do_shutdown() |
37 | { | 37 | { |
38 | if (NULL != g) | 38 | if (NULL != g) |
39 | { | 39 | { |
40 | GNUNET_STATISTICS_get_cancel (g); | 40 | GNUNET_STATISTICS_get_cancel(g); |
41 | g = NULL; | 41 | g = NULL; |
42 | } | 42 | } |
43 | GNUNET_STATISTICS_destroy (h, GNUNET_NO); | 43 | GNUNET_STATISTICS_destroy(h, GNUNET_NO); |
44 | h = NULL; | 44 | h = NULL; |
45 | } | 45 | } |
46 | 46 | ||
47 | 47 | ||
48 | static int | 48 | static int |
49 | check_1 (void *cls, | 49 | check_1(void *cls, |
50 | const char *subsystem, | 50 | const char *subsystem, |
51 | const char *name, | 51 | const char *name, |
52 | uint64_t value, | 52 | uint64_t value, |
53 | int is_persistent) | 53 | int is_persistent) |
54 | { | 54 | { |
55 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 55 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
56 | "Received value %llu for `%s:%s\n", | 56 | "Received value %llu for `%s:%s\n", |
57 | (unsigned long long) value, | 57 | (unsigned long long)value, |
58 | subsystem, | 58 | subsystem, |
59 | name); | 59 | name); |
60 | GNUNET_assert (0 == strcmp (name, "test-1")); | 60 | GNUNET_assert(0 == strcmp(name, "test-1")); |
61 | GNUNET_assert (0 == strcmp (subsystem, "test-statistics-api")); | 61 | GNUNET_assert(0 == strcmp(subsystem, "test-statistics-api")); |
62 | GNUNET_assert (value == 1); | 62 | GNUNET_assert(value == 1); |
63 | GNUNET_assert (is_persistent == GNUNET_NO); | 63 | GNUNET_assert(is_persistent == GNUNET_NO); |
64 | return GNUNET_OK; | 64 | return GNUNET_OK; |
65 | } | 65 | } |
66 | 66 | ||
67 | 67 | ||
68 | static int | 68 | static int |
69 | check_2 (void *cls, | 69 | check_2(void *cls, |
70 | const char *subsystem, | 70 | const char *subsystem, |
71 | const char *name, | 71 | const char *name, |
72 | uint64_t value, | 72 | uint64_t value, |
73 | int is_persistent) | 73 | int is_persistent) |
74 | { | 74 | { |
75 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 75 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
76 | "Received value %llu for `%s:%s\n", | 76 | "Received value %llu for `%s:%s\n", |
77 | (unsigned long long) value, | 77 | (unsigned long long)value, |
78 | subsystem, | 78 | subsystem, |
79 | name); | 79 | name); |
80 | GNUNET_assert (0 == strcmp (name, "test-2")); | 80 | GNUNET_assert(0 == strcmp(name, "test-2")); |
81 | GNUNET_assert (0 == strcmp (subsystem, "test-statistics-api")); | 81 | GNUNET_assert(0 == strcmp(subsystem, "test-statistics-api")); |
82 | GNUNET_assert (value == 2); | 82 | GNUNET_assert(value == 2); |
83 | GNUNET_assert (is_persistent == GNUNET_NO); | 83 | GNUNET_assert(is_persistent == GNUNET_NO); |
84 | return GNUNET_OK; | 84 | return GNUNET_OK; |
85 | } | 85 | } |
86 | 86 | ||
87 | 87 | ||
88 | static int | 88 | static int |
89 | check_3 (void *cls, | 89 | check_3(void *cls, |
90 | const char *subsystem, | 90 | const char *subsystem, |
91 | const char *name, | 91 | const char *name, |
92 | uint64_t value, | 92 | uint64_t value, |
93 | int is_persistent) | 93 | int is_persistent) |
94 | { | 94 | { |
95 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 95 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
96 | "Received value %llu for `%s:%s\n", | 96 | "Received value %llu for `%s:%s\n", |
97 | (unsigned long long) value, | 97 | (unsigned long long)value, |
98 | subsystem, | 98 | subsystem, |
99 | name); | 99 | name); |
100 | GNUNET_assert (0 == strcmp (name, "test-3")); | 100 | GNUNET_assert(0 == strcmp(name, "test-3")); |
101 | GNUNET_assert (0 == strcmp (subsystem, "test-statistics-api")); | 101 | GNUNET_assert(0 == strcmp(subsystem, "test-statistics-api")); |
102 | GNUNET_assert (value == 3); | 102 | GNUNET_assert(value == 3); |
103 | GNUNET_assert (is_persistent == GNUNET_YES); | 103 | GNUNET_assert(is_persistent == GNUNET_YES); |
104 | return GNUNET_OK; | 104 | return GNUNET_OK; |
105 | } | 105 | } |
106 | 106 | ||
107 | 107 | ||
108 | static void | 108 | static void |
109 | next_fin (void *cls, | 109 | next_fin(void *cls, |
110 | int success) | 110 | int success) |
111 | { | 111 | { |
112 | int *ok = cls; | 112 | int *ok = cls; |
113 | 113 | ||
114 | g = NULL; | 114 | g = NULL; |
115 | GNUNET_SCHEDULER_shutdown (); | 115 | GNUNET_SCHEDULER_shutdown(); |
116 | GNUNET_assert (success == GNUNET_OK); | 116 | GNUNET_assert(success == GNUNET_OK); |
117 | *ok = 0; | 117 | *ok = 0; |
118 | } | 118 | } |
119 | 119 | ||
120 | 120 | ||
121 | static void | 121 | static void |
122 | next (void *cls, int success) | 122 | next(void *cls, int success) |
123 | { | 123 | { |
124 | g = NULL; | 124 | g = NULL; |
125 | GNUNET_assert (success == GNUNET_OK); | 125 | GNUNET_assert(success == GNUNET_OK); |
126 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 126 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
127 | "Issuing GET request\n"); | 127 | "Issuing GET request\n"); |
128 | GNUNET_break (NULL != | 128 | GNUNET_break(NULL != |
129 | GNUNET_STATISTICS_get (h, NULL, "test-2", | 129 | GNUNET_STATISTICS_get(h, NULL, "test-2", |
130 | &next_fin, | 130 | &next_fin, |
131 | &check_2, cls)); | 131 | &check_2, cls)); |
132 | } | 132 | } |
133 | 133 | ||
134 | 134 | ||
135 | static void | 135 | static void |
136 | run (void *cls, | 136 | run(void *cls, |
137 | char *const *args, | 137 | char *const *args, |
138 | const char *cfgfile, | 138 | const char *cfgfile, |
139 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 139 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
140 | { | 140 | { |
141 | h = GNUNET_STATISTICS_create ("test-statistics-api", cfg); | 141 | h = GNUNET_STATISTICS_create("test-statistics-api", cfg); |
142 | if (NULL == h) | 142 | if (NULL == h) |
143 | { | 143 | { |
144 | GNUNET_break (0); | 144 | GNUNET_break(0); |
145 | return; | 145 | return; |
146 | } | 146 | } |
147 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, | 147 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, |
148 | NULL); | 148 | NULL); |
149 | GNUNET_STATISTICS_set (h, "test-1", 1, GNUNET_NO); | 149 | GNUNET_STATISTICS_set(h, "test-1", 1, GNUNET_NO); |
150 | GNUNET_STATISTICS_set (h, "test-2", 2, GNUNET_NO); | 150 | GNUNET_STATISTICS_set(h, "test-2", 2, GNUNET_NO); |
151 | GNUNET_STATISTICS_set (h, "test-3", 2, GNUNET_NO); | 151 | GNUNET_STATISTICS_set(h, "test-3", 2, GNUNET_NO); |
152 | GNUNET_STATISTICS_update (h, "test-3", 1, GNUNET_YES); | 152 | GNUNET_STATISTICS_update(h, "test-3", 1, GNUNET_YES); |
153 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 153 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
154 | "Issuing GET request\n"); | 154 | "Issuing GET request\n"); |
155 | GNUNET_break (NULL != | 155 | GNUNET_break(NULL != |
156 | (g = GNUNET_STATISTICS_get (h, NULL, "test-1", | 156 | (g = GNUNET_STATISTICS_get(h, NULL, "test-1", |
157 | &next, | 157 | &next, |
158 | &check_1, cls))); | 158 | &check_1, cls))); |
159 | } | 159 | } |
160 | 160 | ||
161 | 161 | ||
162 | static void | 162 | static void |
163 | run_more (void *cls, | 163 | run_more(void *cls, |
164 | char *const *args, | 164 | char *const *args, |
165 | const char *cfgfile, | 165 | const char *cfgfile, |
166 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 166 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
167 | { | 167 | { |
168 | h = GNUNET_STATISTICS_create ("test-statistics-api", | 168 | h = GNUNET_STATISTICS_create("test-statistics-api", |
169 | cfg); | 169 | cfg); |
170 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, | 170 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, |
171 | NULL); | 171 | NULL); |
172 | GNUNET_break (NULL != | 172 | GNUNET_break(NULL != |
173 | (g = GNUNET_STATISTICS_get (h, NULL, | 173 | (g = GNUNET_STATISTICS_get(h, NULL, |
174 | "test-3", | 174 | "test-3", |
175 | &next_fin, | 175 | &next_fin, |
176 | &check_3, cls))); | 176 | &check_3, cls))); |
177 | } | 177 | } |
178 | 178 | ||
179 | 179 | ||
180 | int | 180 | int |
181 | main (int argc, char *argv_ign[]) | 181 | main(int argc, char *argv_ign[]) |
182 | { | 182 | { |
183 | int ok = 1; | 183 | int ok = 1; |
184 | char *const argv[] = { "test-statistics-api", | 184 | char *const argv[] = { "test-statistics-api", |
185 | "-c", | 185 | "-c", |
186 | "test_statistics_api_data.conf", | 186 | "test_statistics_api_data.conf", |
187 | "-L", "WARNING", | 187 | "-L", "WARNING", |
188 | NULL | 188 | NULL }; |
189 | }; | ||
190 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 189 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
191 | GNUNET_GETOPT_OPTION_END | 190 | GNUNET_GETOPT_OPTION_END |
192 | }; | 191 | }; |
193 | struct GNUNET_OS_Process *proc; | 192 | struct GNUNET_OS_Process *proc; |
194 | char *binary; | 193 | char *binary; |
195 | 194 | ||
196 | GNUNET_log_setup ("test_statistics_api", | 195 | GNUNET_log_setup("test_statistics_api", |
197 | "WARNING", | 196 | "WARNING", |
198 | NULL); | 197 | NULL); |
199 | binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-statistics"); | 198 | binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-statistics"); |
200 | proc = | 199 | proc = |
201 | GNUNET_OS_start_process (GNUNET_YES, | 200 | GNUNET_OS_start_process(GNUNET_YES, |
202 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 201 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
203 | NULL, NULL, NULL, | 202 | NULL, NULL, NULL, |
204 | binary, | 203 | binary, |
205 | "gnunet-service-statistics", | 204 | "gnunet-service-statistics", |
206 | "-c", "test_statistics_api_data.conf", NULL); | 205 | "-c", "test_statistics_api_data.conf", NULL); |
207 | GNUNET_assert (NULL != proc); | 206 | GNUNET_assert(NULL != proc); |
208 | GNUNET_PROGRAM_run (5, argv, | 207 | GNUNET_PROGRAM_run(5, argv, |
209 | "test-statistics-api", "nohelp", | 208 | "test-statistics-api", "nohelp", |
210 | options, &run, | 209 | options, &run, |
211 | &ok); | 210 | &ok); |
212 | if (0 != GNUNET_OS_process_kill (proc, | 211 | if (0 != GNUNET_OS_process_kill(proc, |
213 | GNUNET_TERM_SIG)) | 212 | GNUNET_TERM_SIG)) |
214 | { | 213 | { |
215 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | 214 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); |
216 | ok = 1; | 215 | ok = 1; |
217 | } | 216 | } |
218 | GNUNET_OS_process_wait (proc); | 217 | GNUNET_OS_process_wait(proc); |
219 | GNUNET_OS_process_destroy (proc); | 218 | GNUNET_OS_process_destroy(proc); |
220 | proc = NULL; | 219 | proc = NULL; |
221 | if (ok != 0) | 220 | if (ok != 0) |
222 | { | 221 | { |
223 | GNUNET_free (binary); | 222 | GNUNET_free(binary); |
224 | return ok; | 223 | return ok; |
225 | } | 224 | } |
226 | ok = 1; | 225 | ok = 1; |
227 | /* restart to check persistence! */ | 226 | /* restart to check persistence! */ |
228 | proc = | 227 | proc = |
229 | GNUNET_OS_start_process (GNUNET_YES, | 228 | GNUNET_OS_start_process(GNUNET_YES, |
230 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 229 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
231 | NULL, NULL, NULL, | 230 | NULL, NULL, NULL, |
232 | binary, | 231 | binary, |
233 | "gnunet-service-statistics", | 232 | "gnunet-service-statistics", |
234 | "-c", "test_statistics_api_data.conf", | 233 | "-c", "test_statistics_api_data.conf", |
235 | NULL); | 234 | NULL); |
236 | GNUNET_PROGRAM_run (5, argv, | 235 | GNUNET_PROGRAM_run(5, argv, |
237 | "test-statistics-api", "nohelp", | 236 | "test-statistics-api", "nohelp", |
238 | options, | 237 | options, |
239 | &run_more, &ok); | 238 | &run_more, &ok); |
240 | if (0 != GNUNET_OS_process_kill (proc, | 239 | if (0 != GNUNET_OS_process_kill(proc, |
241 | GNUNET_TERM_SIG)) | 240 | GNUNET_TERM_SIG)) |
242 | { | 241 | { |
243 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | 242 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); |
244 | ok = 1; | 243 | ok = 1; |
245 | } | 244 | } |
246 | GNUNET_OS_process_wait (proc); | 245 | GNUNET_OS_process_wait(proc); |
247 | GNUNET_OS_process_destroy (proc); | 246 | GNUNET_OS_process_destroy(proc); |
248 | proc = NULL; | 247 | proc = NULL; |
249 | GNUNET_free (binary); | 248 | GNUNET_free(binary); |
250 | return ok; | 249 | return ok; |
251 | } | 250 | } |
252 | 251 | ||
diff --git a/src/statistics/test_statistics_api_loop.c b/src/statistics/test_statistics_api_loop.c index 2438fd95a..61cf1130a 100644 --- a/src/statistics/test_statistics_api_loop.c +++ b/src/statistics/test_statistics_api_loop.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | /** | 20 | /** |
21 | * @file statistics/test_statistics_api_loop.c | 21 | * @file statistics/test_statistics_api_loop.c |
22 | * @brief testcase for statistics_api.c | 22 | * @brief testcase for statistics_api.c |
@@ -31,91 +31,90 @@ static struct GNUNET_STATISTICS_Handle *h; | |||
31 | 31 | ||
32 | 32 | ||
33 | static int | 33 | static int |
34 | check_1 (void *cls, | 34 | check_1(void *cls, |
35 | const char *subsystem, | 35 | const char *subsystem, |
36 | const char *name, | 36 | const char *name, |
37 | uint64_t value, | 37 | uint64_t value, |
38 | int is_persistent) | 38 | int is_persistent) |
39 | { | 39 | { |
40 | GNUNET_assert (0 == strcmp (name, "test-0")); | 40 | GNUNET_assert(0 == strcmp(name, "test-0")); |
41 | GNUNET_assert (0 == strcmp (subsystem, "test-statistics-api-loop")); | 41 | GNUNET_assert(0 == strcmp(subsystem, "test-statistics-api-loop")); |
42 | GNUNET_assert (is_persistent == GNUNET_NO); | 42 | GNUNET_assert(is_persistent == GNUNET_NO); |
43 | return GNUNET_OK; | 43 | return GNUNET_OK; |
44 | } | 44 | } |
45 | 45 | ||
46 | 46 | ||
47 | static void | 47 | static void |
48 | next (void *cls, | 48 | next(void *cls, |
49 | int success) | 49 | int success) |
50 | { | 50 | { |
51 | int *ok = cls; | 51 | int *ok = cls; |
52 | 52 | ||
53 | GNUNET_STATISTICS_destroy (h, GNUNET_NO); | 53 | GNUNET_STATISTICS_destroy(h, GNUNET_NO); |
54 | GNUNET_assert (success == GNUNET_OK); | 54 | GNUNET_assert(success == GNUNET_OK); |
55 | *ok = 0; | 55 | *ok = 0; |
56 | } | 56 | } |
57 | 57 | ||
58 | 58 | ||
59 | static void | 59 | static void |
60 | run (void *cls, | 60 | run(void *cls, |
61 | char *const *args, | 61 | char *const *args, |
62 | const char *cfgfile, | 62 | const char *cfgfile, |
63 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 63 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
64 | { | 64 | { |
65 | unsigned int i; | 65 | unsigned int i; |
66 | char name[128]; | 66 | char name[128]; |
67 | 67 | ||
68 | h = GNUNET_STATISTICS_create ("test-statistics-api-loop", cfg); | 68 | h = GNUNET_STATISTICS_create("test-statistics-api-loop", cfg); |
69 | for (i = 0; i < ROUNDS; i++) | 69 | for (i = 0; i < ROUNDS; i++) |
70 | { | 70 | { |
71 | GNUNET_snprintf (name, sizeof (name), "test-%d", i % 32); | 71 | GNUNET_snprintf(name, sizeof(name), "test-%d", i % 32); |
72 | GNUNET_STATISTICS_set (h, name, i, GNUNET_NO); | 72 | GNUNET_STATISTICS_set(h, name, i, GNUNET_NO); |
73 | GNUNET_snprintf (name, sizeof (name), "test-%d", i % 16); | 73 | GNUNET_snprintf(name, sizeof(name), "test-%d", i % 16); |
74 | GNUNET_STATISTICS_update (h, name, 1, GNUNET_NO); | 74 | GNUNET_STATISTICS_update(h, name, 1, GNUNET_NO); |
75 | } | 75 | } |
76 | i = 0; | 76 | i = 0; |
77 | GNUNET_break (NULL != | 77 | GNUNET_break(NULL != |
78 | GNUNET_STATISTICS_get (h, NULL, "test-0", | 78 | GNUNET_STATISTICS_get(h, NULL, "test-0", |
79 | &next, | 79 | &next, |
80 | &check_1, cls)); | 80 | &check_1, cls)); |
81 | } | 81 | } |
82 | 82 | ||
83 | 83 | ||
84 | int | 84 | int |
85 | main (int argc, char *argv_ign[]) | 85 | main(int argc, char *argv_ign[]) |
86 | { | 86 | { |
87 | int ok = 1; | 87 | int ok = 1; |
88 | 88 | ||
89 | char *const argv[] = { "test-statistics-api", | 89 | char *const argv[] = { "test-statistics-api", |
90 | "-c", | 90 | "-c", |
91 | "test_statistics_api_data.conf", | 91 | "test_statistics_api_data.conf", |
92 | NULL | 92 | NULL }; |
93 | }; | ||
94 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 93 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
95 | GNUNET_GETOPT_OPTION_END | 94 | GNUNET_GETOPT_OPTION_END |
96 | }; | 95 | }; |
97 | struct GNUNET_OS_Process *proc; | 96 | struct GNUNET_OS_Process *proc; |
98 | char *binary; | 97 | char *binary; |
99 | 98 | ||
100 | binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-statistics"); | 99 | binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-statistics"); |
101 | proc = | 100 | proc = |
102 | GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 101 | GNUNET_OS_start_process(GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
103 | NULL, NULL, NULL, | 102 | NULL, NULL, NULL, |
104 | binary, | 103 | binary, |
105 | "gnunet-service-statistics", | 104 | "gnunet-service-statistics", |
106 | "-c", "test_statistics_api_data.conf", NULL); | 105 | "-c", "test_statistics_api_data.conf", NULL); |
107 | GNUNET_assert (NULL != proc); | 106 | GNUNET_assert(NULL != proc); |
108 | GNUNET_PROGRAM_run (3, argv, "test-statistics-api", "nohelp", options, &run, | 107 | GNUNET_PROGRAM_run(3, argv, "test-statistics-api", "nohelp", options, &run, |
109 | &ok); | 108 | &ok); |
110 | if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG)) | 109 | if (0 != GNUNET_OS_process_kill(proc, GNUNET_TERM_SIG)) |
111 | { | 110 | { |
112 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | 111 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); |
113 | ok = 1; | 112 | ok = 1; |
114 | } | 113 | } |
115 | GNUNET_OS_process_wait (proc); | 114 | GNUNET_OS_process_wait(proc); |
116 | GNUNET_OS_process_destroy (proc); | 115 | GNUNET_OS_process_destroy(proc); |
117 | proc = NULL; | 116 | proc = NULL; |
118 | GNUNET_free (binary); | 117 | GNUNET_free(binary); |
119 | return ok; | 118 | return ok; |
120 | } | 119 | } |
121 | 120 | ||
diff --git a/src/statistics/test_statistics_api_watch.c b/src/statistics/test_statistics_api_watch.c index 38ba0e84e..e8cd15047 100644 --- a/src/statistics/test_statistics_api_watch.c +++ b/src/statistics/test_statistics_api_watch.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | /** | 20 | /** |
21 | * @file statistics/test_statistics_api_watch.c | 21 | * @file statistics/test_statistics_api_watch.c |
22 | * @brief testcase for statistics_api.c watch functions | 22 | * @brief testcase for statistics_api.c watch functions |
@@ -37,118 +37,117 @@ static struct GNUNET_SCHEDULER_Task *shutdown_task; | |||
37 | 37 | ||
38 | 38 | ||
39 | static void | 39 | static void |
40 | force_shutdown (void *cls) | 40 | force_shutdown(void *cls) |
41 | { | 41 | { |
42 | fprintf (stderr, "Timeout, failed to receive notifications: %d\n", ok); | 42 | fprintf(stderr, "Timeout, failed to receive notifications: %d\n", ok); |
43 | GNUNET_STATISTICS_destroy (h, GNUNET_NO); | 43 | GNUNET_STATISTICS_destroy(h, GNUNET_NO); |
44 | GNUNET_STATISTICS_destroy (h2, GNUNET_NO); | 44 | GNUNET_STATISTICS_destroy(h2, GNUNET_NO); |
45 | ok = 7; | 45 | ok = 7; |
46 | } | 46 | } |
47 | 47 | ||
48 | 48 | ||
49 | static void | 49 | static void |
50 | normal_shutdown (void *cls) | 50 | normal_shutdown(void *cls) |
51 | { | 51 | { |
52 | GNUNET_STATISTICS_destroy (h, GNUNET_NO); | 52 | GNUNET_STATISTICS_destroy(h, GNUNET_NO); |
53 | GNUNET_STATISTICS_destroy (h2, GNUNET_NO); | 53 | GNUNET_STATISTICS_destroy(h2, GNUNET_NO); |
54 | } | 54 | } |
55 | 55 | ||
56 | 56 | ||
57 | static int | 57 | static int |
58 | watch_1 (void *cls, | 58 | watch_1(void *cls, |
59 | const char *subsystem, | 59 | const char *subsystem, |
60 | const char *name, | 60 | const char *name, |
61 | uint64_t value, | 61 | uint64_t value, |
62 | int is_persistent) | 62 | int is_persistent) |
63 | { | 63 | { |
64 | GNUNET_assert (value == 42); | 64 | GNUNET_assert(value == 42); |
65 | GNUNET_assert (0 == strcmp (name, "test-1")); | 65 | GNUNET_assert(0 == strcmp(name, "test-1")); |
66 | ok &= ~1; | 66 | ok &= ~1; |
67 | if (0 == ok) | 67 | if (0 == ok) |
68 | { | 68 | { |
69 | GNUNET_SCHEDULER_cancel (shutdown_task); | 69 | GNUNET_SCHEDULER_cancel(shutdown_task); |
70 | GNUNET_SCHEDULER_add_now (&normal_shutdown, NULL); | 70 | GNUNET_SCHEDULER_add_now(&normal_shutdown, NULL); |
71 | } | 71 | } |
72 | return GNUNET_OK; | 72 | return GNUNET_OK; |
73 | } | 73 | } |
74 | 74 | ||
75 | 75 | ||
76 | static int | 76 | static int |
77 | watch_2 (void *cls, | 77 | watch_2(void *cls, |
78 | const char *subsystem, | 78 | const char *subsystem, |
79 | const char *name, | 79 | const char *name, |
80 | uint64_t value, | 80 | uint64_t value, |
81 | int is_persistent) | 81 | int is_persistent) |
82 | { | 82 | { |
83 | GNUNET_assert (value == 43); | 83 | GNUNET_assert(value == 43); |
84 | GNUNET_assert (0 == strcmp (name, "test-2")); | 84 | GNUNET_assert(0 == strcmp(name, "test-2")); |
85 | ok &= ~2; | 85 | ok &= ~2; |
86 | if (0 == ok) | 86 | if (0 == ok) |
87 | { | 87 | { |
88 | GNUNET_SCHEDULER_cancel (shutdown_task); | 88 | GNUNET_SCHEDULER_cancel(shutdown_task); |
89 | GNUNET_SCHEDULER_add_now (&normal_shutdown, NULL); | 89 | GNUNET_SCHEDULER_add_now(&normal_shutdown, NULL); |
90 | } | 90 | } |
91 | return GNUNET_OK; | 91 | return GNUNET_OK; |
92 | } | 92 | } |
93 | 93 | ||
94 | 94 | ||
95 | static void | 95 | static void |
96 | run (void *cls, | 96 | run(void *cls, |
97 | char *const *args, | 97 | char *const *args, |
98 | const char *cfgfile, | 98 | const char *cfgfile, |
99 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 99 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
100 | { | 100 | { |
101 | h = GNUNET_STATISTICS_create ("dummy", cfg); | 101 | h = GNUNET_STATISTICS_create("dummy", cfg); |
102 | GNUNET_assert (GNUNET_OK == | 102 | GNUNET_assert(GNUNET_OK == |
103 | GNUNET_STATISTICS_watch (h, "test-statistics-api-watch", | 103 | GNUNET_STATISTICS_watch(h, "test-statistics-api-watch", |
104 | "test-1", &watch_1, NULL)); | 104 | "test-1", &watch_1, NULL)); |
105 | GNUNET_assert (GNUNET_OK == | 105 | GNUNET_assert(GNUNET_OK == |
106 | GNUNET_STATISTICS_watch (h, "test-statistics-api-watch", | 106 | GNUNET_STATISTICS_watch(h, "test-statistics-api-watch", |
107 | "test-2", &watch_2, NULL)); | 107 | "test-2", &watch_2, NULL)); |
108 | h2 = GNUNET_STATISTICS_create ("test-statistics-api-watch", cfg); | 108 | h2 = GNUNET_STATISTICS_create("test-statistics-api-watch", cfg); |
109 | GNUNET_STATISTICS_set (h2, "test-1", 42, GNUNET_NO); | 109 | GNUNET_STATISTICS_set(h2, "test-1", 42, GNUNET_NO); |
110 | GNUNET_STATISTICS_set (h2, "test-2", 43, GNUNET_NO); | 110 | GNUNET_STATISTICS_set(h2, "test-2", 43, GNUNET_NO); |
111 | shutdown_task = | 111 | shutdown_task = |
112 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, | 112 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, |
113 | &force_shutdown, | 113 | &force_shutdown, |
114 | NULL); | 114 | NULL); |
115 | } | 115 | } |
116 | 116 | ||
117 | 117 | ||
118 | int | 118 | int |
119 | main (int argc, char *argv_ign[]) | 119 | main(int argc, char *argv_ign[]) |
120 | { | 120 | { |
121 | char *const argv[] = { "test-statistics-api", | 121 | char *const argv[] = { "test-statistics-api", |
122 | "-c", | 122 | "-c", |
123 | "test_statistics_api_data.conf", | 123 | "test_statistics_api_data.conf", |
124 | NULL | 124 | NULL }; |
125 | }; | ||
126 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 125 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
127 | GNUNET_GETOPT_OPTION_END | 126 | GNUNET_GETOPT_OPTION_END |
128 | }; | 127 | }; |
129 | struct GNUNET_OS_Process *proc; | 128 | struct GNUNET_OS_Process *proc; |
130 | char *binary; | 129 | char *binary; |
131 | 130 | ||
132 | binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-statistics"); | 131 | binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-statistics"); |
133 | proc = | 132 | proc = |
134 | GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 133 | GNUNET_OS_start_process(GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
135 | NULL, NULL, NULL, | 134 | NULL, NULL, NULL, |
136 | binary, | 135 | binary, |
137 | "gnunet-service-statistics", | 136 | "gnunet-service-statistics", |
138 | "-c", "test_statistics_api_data.conf", NULL); | 137 | "-c", "test_statistics_api_data.conf", NULL); |
139 | GNUNET_assert (NULL != proc); | 138 | GNUNET_assert(NULL != proc); |
140 | ok = 3; | 139 | ok = 3; |
141 | GNUNET_PROGRAM_run (3, argv, "test-statistics-api", "nohelp", options, &run, | 140 | GNUNET_PROGRAM_run(3, argv, "test-statistics-api", "nohelp", options, &run, |
142 | NULL); | 141 | NULL); |
143 | if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG)) | 142 | if (0 != GNUNET_OS_process_kill(proc, GNUNET_TERM_SIG)) |
144 | { | 143 | { |
145 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | 144 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); |
146 | ok = 1; | 145 | ok = 1; |
147 | } | 146 | } |
148 | GNUNET_OS_process_wait (proc); | 147 | GNUNET_OS_process_wait(proc); |
149 | GNUNET_OS_process_destroy (proc); | 148 | GNUNET_OS_process_destroy(proc); |
150 | proc = NULL; | 149 | proc = NULL; |
151 | GNUNET_free (binary); | 150 | GNUNET_free(binary); |
152 | return ok; | 151 | return ok; |
153 | } | 152 | } |
154 | 153 | ||
diff --git a/src/statistics/test_statistics_api_watch_zero_value.c b/src/statistics/test_statistics_api_watch_zero_value.c index 05dc75366..1dc093658 100644 --- a/src/statistics/test_statistics_api_watch_zero_value.c +++ b/src/statistics/test_statistics_api_watch_zero_value.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | /** | 20 | /** |
21 | * @file statistics/test_statistics_api_watch_zero_value.c | 21 | * @file statistics/test_statistics_api_watch_zero_value.c |
22 | * @brief testcase for statistics_api.c watch functions with initial 0 value | 22 | * @brief testcase for statistics_api.c watch functions with initial 0 value |
@@ -37,157 +37,156 @@ static struct GNUNET_SCHEDULER_Task *shutdown_task; | |||
37 | 37 | ||
38 | 38 | ||
39 | static void | 39 | static void |
40 | force_shutdown (void *cls) | 40 | force_shutdown(void *cls) |
41 | { | 41 | { |
42 | fprintf (stderr, "Timeout, failed to receive notifications: %d\n", ok); | 42 | fprintf(stderr, "Timeout, failed to receive notifications: %d\n", ok); |
43 | GNUNET_STATISTICS_destroy (h, GNUNET_NO); | 43 | GNUNET_STATISTICS_destroy(h, GNUNET_NO); |
44 | GNUNET_STATISTICS_destroy (h2, GNUNET_NO); | 44 | GNUNET_STATISTICS_destroy(h2, GNUNET_NO); |
45 | ok = 7; | 45 | ok = 7; |
46 | } | 46 | } |
47 | 47 | ||
48 | 48 | ||
49 | static void | 49 | static void |
50 | normal_shutdown (void *cls) | 50 | normal_shutdown(void *cls) |
51 | { | 51 | { |
52 | GNUNET_STATISTICS_destroy (h, GNUNET_NO); | 52 | GNUNET_STATISTICS_destroy(h, GNUNET_NO); |
53 | GNUNET_STATISTICS_destroy (h2, GNUNET_NO); | 53 | GNUNET_STATISTICS_destroy(h2, GNUNET_NO); |
54 | } | 54 | } |
55 | 55 | ||
56 | 56 | ||
57 | static int | 57 | static int |
58 | watch_1 (void *cls, const char *subsystem, const char *name, uint64_t value, | 58 | watch_1(void *cls, const char *subsystem, const char *name, uint64_t value, |
59 | int is_persistent) | 59 | int is_persistent) |
60 | { | 60 | { |
61 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 61 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
62 | "Received value `%s' `%s' %llu\n", | 62 | "Received value `%s' `%s' %llu\n", |
63 | subsystem, | 63 | subsystem, |
64 | name, | 64 | name, |
65 | (unsigned long long) value); | 65 | (unsigned long long)value); |
66 | GNUNET_assert (0 == strcmp (name, "test-1")); | 66 | GNUNET_assert(0 == strcmp(name, "test-1")); |
67 | if ((0 == value) && (3 == ok)) | 67 | if ((0 == value) && (3 == ok)) |
68 | { | 68 | { |
69 | ok--; | 69 | ok--; |
70 | GNUNET_STATISTICS_set (h, "test-1", 42, GNUNET_NO); | 70 | GNUNET_STATISTICS_set(h, "test-1", 42, GNUNET_NO); |
71 | } | 71 | } |
72 | 72 | ||
73 | if ((42 == value) && (2 == ok)) | 73 | if ((42 == value) && (2 == ok)) |
74 | { | 74 | { |
75 | ok--; | 75 | ok--; |
76 | GNUNET_STATISTICS_set (h, "test-1", 0, GNUNET_NO); | 76 | GNUNET_STATISTICS_set(h, "test-1", 0, GNUNET_NO); |
77 | } | 77 | } |
78 | 78 | ||
79 | if ((0 == value) && (1 == ok)) | 79 | if ((0 == value) && (1 == ok)) |
80 | { | 80 | { |
81 | ok--; | 81 | ok--; |
82 | } | 82 | } |
83 | if ((0 == ok) && (0 == ok2)) | 83 | if ((0 == ok) && (0 == ok2)) |
84 | { | 84 | { |
85 | GNUNET_SCHEDULER_cancel (shutdown_task); | 85 | GNUNET_SCHEDULER_cancel(shutdown_task); |
86 | GNUNET_SCHEDULER_add_now (&normal_shutdown, NULL); | 86 | GNUNET_SCHEDULER_add_now(&normal_shutdown, NULL); |
87 | } | 87 | } |
88 | 88 | ||
89 | return GNUNET_OK; | 89 | return GNUNET_OK; |
90 | } | 90 | } |
91 | 91 | ||
92 | 92 | ||
93 | static int | 93 | static int |
94 | watch_2 (void *cls, | 94 | watch_2(void *cls, |
95 | const char *subsystem, | 95 | const char *subsystem, |
96 | const char *name, | 96 | const char *name, |
97 | uint64_t value, | 97 | uint64_t value, |
98 | int is_persistent) | 98 | int is_persistent) |
99 | { | 99 | { |
100 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 100 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
101 | "Received value `%s' `%s' %llu\n", | 101 | "Received value `%s' `%s' %llu\n", |
102 | subsystem, | 102 | subsystem, |
103 | name, | 103 | name, |
104 | (unsigned long long) value); | 104 | (unsigned long long)value); |
105 | 105 | ||
106 | GNUNET_assert (0 == strcmp (name, "test-2")); | 106 | GNUNET_assert(0 == strcmp(name, "test-2")); |
107 | if ((42 == value) && (1 == ok2)) | 107 | if ((42 == value) && (1 == ok2)) |
108 | { | ||
109 | ok2 = 0; | ||
110 | if (0 == ok) | ||
111 | { | 108 | { |
112 | GNUNET_SCHEDULER_cancel (shutdown_task); | 109 | ok2 = 0; |
113 | GNUNET_SCHEDULER_add_now (&normal_shutdown, NULL); | 110 | if (0 == ok) |
111 | { | ||
112 | GNUNET_SCHEDULER_cancel(shutdown_task); | ||
113 | GNUNET_SCHEDULER_add_now(&normal_shutdown, NULL); | ||
114 | } | ||
114 | } | 115 | } |
115 | } | ||
116 | else | 116 | else |
117 | { | 117 | { |
118 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 118 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
119 | "Received unexpected value %llu\n", | 119 | "Received unexpected value %llu\n", |
120 | (unsigned long long) value); | 120 | (unsigned long long)value); |
121 | 121 | ||
122 | GNUNET_break (0); | 122 | GNUNET_break(0); |
123 | GNUNET_SCHEDULER_cancel (shutdown_task); | 123 | GNUNET_SCHEDULER_cancel(shutdown_task); |
124 | GNUNET_SCHEDULER_add_now (&normal_shutdown, NULL); | 124 | GNUNET_SCHEDULER_add_now(&normal_shutdown, NULL); |
125 | } | 125 | } |
126 | 126 | ||
127 | return GNUNET_OK; | 127 | return GNUNET_OK; |
128 | } | 128 | } |
129 | 129 | ||
130 | 130 | ||
131 | static void | 131 | static void |
132 | run (void *cls, char *const *args, const char *cfgfile, | 132 | run(void *cls, char *const *args, const char *cfgfile, |
133 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 133 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
134 | { | 134 | { |
135 | h = GNUNET_STATISTICS_create ("dummy", cfg); | 135 | h = GNUNET_STATISTICS_create("dummy", cfg); |
136 | h2 = GNUNET_STATISTICS_create ("dummy-2", cfg); | 136 | h2 = GNUNET_STATISTICS_create("dummy-2", cfg); |
137 | GNUNET_assert (GNUNET_OK == | 137 | GNUNET_assert(GNUNET_OK == |
138 | GNUNET_STATISTICS_watch (h, "dummy", | 138 | GNUNET_STATISTICS_watch(h, "dummy", |
139 | "test-1", &watch_1, NULL)); | 139 | "test-1", &watch_1, NULL)); |
140 | 140 | ||
141 | GNUNET_assert (GNUNET_OK == | 141 | GNUNET_assert(GNUNET_OK == |
142 | GNUNET_STATISTICS_watch (h2, "dummy-2", | 142 | GNUNET_STATISTICS_watch(h2, "dummy-2", |
143 | "test-2", &watch_2, NULL)); | 143 | "test-2", &watch_2, NULL)); |
144 | 144 | ||
145 | /* Set initial value to 0 */ | 145 | /* Set initial value to 0 */ |
146 | GNUNET_STATISTICS_set (h, "test-1", 0, GNUNET_NO); | 146 | GNUNET_STATISTICS_set(h, "test-1", 0, GNUNET_NO); |
147 | GNUNET_STATISTICS_set (h2, "test-2", 42, GNUNET_NO); | 147 | GNUNET_STATISTICS_set(h2, "test-2", 42, GNUNET_NO); |
148 | 148 | ||
149 | shutdown_task = | 149 | shutdown_task = |
150 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, | 150 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, |
151 | &force_shutdown, | 151 | &force_shutdown, |
152 | NULL); | 152 | NULL); |
153 | } | 153 | } |
154 | 154 | ||
155 | 155 | ||
156 | int | 156 | int |
157 | main (int argc, char *argv_ign[]) | 157 | main(int argc, char *argv_ign[]) |
158 | { | 158 | { |
159 | char *const argv[] = { "test-statistics-api", | 159 | char *const argv[] = { "test-statistics-api", |
160 | "-c", | 160 | "-c", |
161 | "test_statistics_api_data.conf", | 161 | "test_statistics_api_data.conf", |
162 | NULL | 162 | NULL }; |
163 | }; | ||
164 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 163 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
165 | GNUNET_GETOPT_OPTION_END | 164 | GNUNET_GETOPT_OPTION_END |
166 | }; | 165 | }; |
167 | struct GNUNET_OS_Process *proc; | 166 | struct GNUNET_OS_Process *proc; |
168 | char *binary; | 167 | char *binary; |
169 | 168 | ||
170 | binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-statistics"); | 169 | binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-statistics"); |
171 | proc = | 170 | proc = |
172 | GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 171 | GNUNET_OS_start_process(GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
173 | NULL, NULL, NULL, | 172 | NULL, NULL, NULL, |
174 | binary, | 173 | binary, |
175 | "gnunet-service-statistics", | 174 | "gnunet-service-statistics", |
176 | "-c", "test_statistics_api_data.conf", NULL); | 175 | "-c", "test_statistics_api_data.conf", NULL); |
177 | GNUNET_assert (NULL != proc); | 176 | GNUNET_assert(NULL != proc); |
178 | ok = 3; | 177 | ok = 3; |
179 | ok2 = 1; | 178 | ok2 = 1; |
180 | GNUNET_PROGRAM_run (3, argv, "test-statistics-api", "nohelp", options, &run, | 179 | GNUNET_PROGRAM_run(3, argv, "test-statistics-api", "nohelp", options, &run, |
181 | NULL); | 180 | NULL); |
182 | if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG)) | 181 | if (0 != GNUNET_OS_process_kill(proc, GNUNET_TERM_SIG)) |
183 | { | 182 | { |
184 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | 183 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); |
185 | ok = 1; | 184 | ok = 1; |
186 | } | 185 | } |
187 | GNUNET_OS_process_wait (proc); | 186 | GNUNET_OS_process_wait(proc); |
188 | GNUNET_OS_process_destroy (proc); | 187 | GNUNET_OS_process_destroy(proc); |
189 | proc = NULL; | 188 | proc = NULL; |
190 | GNUNET_free (binary); | 189 | GNUNET_free(binary); |
191 | if ((0 == ok) && (0 == ok2)) | 190 | if ((0 == ok) && (0 == ok2)) |
192 | return 0; | 191 | return 0; |
193 | return 1; | 192 | return 1; |