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