src/statistics/statistics_api.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 2, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file statistics/statistics_api.c
  23  * @brief API of the statistics service
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_client_lib.h"
  28 #include "gnunet_protocols.h"
  29 #include "gnunet_server_lib.h"
  30 #include "gnunet_statistics_service.h"
  31 #include "gnunet_strings_lib.h"
  32 #include "statistics.h"
  33
  34 #define SET_TRANSMIT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
  35
  36
  37 /**
  38  * Types of actions.
  39  */
  40 enum ActionType
  41 {
  42   ACTION_GET,
  43   ACTION_SET,
  44   ACTION_UPDATE
  45 };
  46
  47
  48 /**
  49  * Linked list of things we still need to do.
  50  */
  51 struct ActionItem
  52 {
  53   /**
  54    * This is a linked list.
  55    */
  56   struct ActionItem *next;
  57
  58   /**
  59    * What subsystem is this action about? (can be NULL)
  60    */
  61   char *subsystem;
  62
  63   /**
  64    * What value is this action about? (can be NULL)
  65    */
  66   char *name;
  67
  68   /**
  69    * Continuation to call once action is complete.
  70    */
  71   GNUNET_STATISTICS_Callback cont;
  72
  73   /**
  74    * Function to call (for GET actions only).
  75    */
  76   GNUNET_STATISTICS_Iterator proc;
  77
  78   /**
  79    * Closure for proc and cont.
  80    */
  81   void *cls;
  82
  83   /**
  84    * Timeout for this action.
  85    */
  86   struct GNUNET_TIME_Absolute timeout;
  87
  88   /**
  89    * Associated value.
  90    */
  91   uint64_t value;
  92
  93   /**
  94    * Flag for SET/UPDATE actions.
  95    */
  96   int make_persistent;
  97
  98   /**
  99    * Has the current iteration been aborted; for GET actions.
 100    */
 101   int aborted;
 102
 103   /**
 104    * Is this a GET, SET or UPDATE?
 105    */
 106   enum ActionType type;
 107
 108   /**
 109    * Size of the message that we will be transmitting.
 110    */
 111   uint16_t msize;
 112
 113 };
 114
 115
 116 /**
 117  * Handle for the service.
 118  */
 119 struct GNUNET_STATISTICS_Handle
 120 {
 121   /**
 122    * Our scheduler.
 123    */
 124   struct GNUNET_SCHEDULER_Handle *sched;
 125
 126   /**
 127    * Name of our subsystem.
 128    */
 129   char *subsystem;
 130
 131   /**
 132    * Configuration to use.
 133    */
 134   const struct GNUNET_CONFIGURATION_Handle *cfg;
 135
 136   /**
 137    * Socket (if available).
 138    */
 139   struct GNUNET_CLIENT_Connection *client;
 140
 141   /**
 142    * Currently pending transmission request.
 143    */
 144   struct GNUNET_CLIENT_TransmitHandle *th;
 145
 146   /**
 147    * Head of the linked list of pending actions (first action
 148    * to be performed).
 149    */
 150   struct ActionItem *action_head;
 151
 152   /**
 153    * Tail of the linked list of actions (for fast append).
 154    */
 155   struct ActionItem *action_tail;
 156
 157   /**
 158    * Action we are currently busy with (action request has been
 159    * transmitted, we're now receiving the response from the
 160    * service).
 161    */
 162   struct ActionItem *current;
 163
 164   /**
 165    * Should this handle auto-destruct once all actions have
 166    * been processed?
 167    */
 168   int do_destroy;
 169
 170 };
 171
 172
 173 /**
 174  * Try to (re)connect to the statistics service.
 175  *
 176  * @return GNUNET_YES on success, GNUNET_NO on failure.
 177  */
 178 static int
 179 try_connect (struct GNUNET_STATISTICS_Handle *ret)
 180 {
 181   if (ret->client != NULL)
 182     return GNUNET_OK;
 183   ret->client = GNUNET_CLIENT_connect (ret->sched, "statistics", ret->cfg);
 184   if (ret->client != NULL)
 185     return GNUNET_YES;
 186 #if DEBUG_STATISTICS
 187   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 188               _("Failed to connect to statistics service!\n"));
 189 #endif
 190   return GNUNET_NO;
 191 }
 192
 193
 194 /**
 195  * Free memory associated with the given action item.
 196  */
 197 static void
 198 free_action_item (struct ActionItem *ai)
 199 {
 200   GNUNET_free_non_null (ai->subsystem);
 201   GNUNET_free_non_null (ai->name);
 202   GNUNET_free (ai);
 203 }
 204
 205
 206
 207
 208
 209 /**
 210  * Schedule the next action to be performed.
 211  */
 212 static void schedule_action (struct GNUNET_STATISTICS_Handle *h);
 213
 214
 215 /**
 216  * GET processing is complete, tell client about it.
 217  */
 218 static void
 219 finish (struct GNUNET_STATISTICS_Handle *h, int code)
 220 {
 221   struct ActionItem *pos = h->current;
 222   h->current = NULL;
 223   schedule_action (h);
 224   if (pos->cont != NULL)
 225     pos->cont (pos->cls, code);
 226   free_action_item (pos);
 227 }
 228
 229
 230 /**
 231  * Process the message.
 232  *
 233  * @return GNUNET_OK if the message was well-formed
 234  */
 235 static int
 236 process_message (struct GNUNET_STATISTICS_Handle *h,
 237                  const struct GNUNET_MessageHeader *msg)
 238 {
 239   char *service;
 240   char *name;
 241   const struct GNUNET_STATISTICS_ReplyMessage *smsg;
 242   uint16_t size;
 243
 244   if (h->current->aborted)
 245     return GNUNET_OK;           /* don't bother */
 246   size = ntohs (msg->size);
 247   if (size < sizeof (struct GNUNET_STATISTICS_ReplyMessage))
 248     {
 249       GNUNET_break (0);
 250       return GNUNET_SYSERR;
 251     }
 252   smsg = (const struct GNUNET_STATISTICS_ReplyMessage *) msg;
 253   size -= sizeof (struct GNUNET_STATISTICS_ReplyMessage);
 254   if (size != GNUNET_STRINGS_buffer_tokenize ((const char *) &smsg[1],
 255                                               size, 2, &service, &name))
 256     {
 257       GNUNET_break (0);
 258       return GNUNET_SYSERR;
 259     }
 260 #if DEBUG_STATISTICS
 261   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 262               "Received valid statistic on `%s:%s': %llu\n",
 263               service, name, GNUNET_ntohll (smsg->value));
 264 #endif
 265   if (GNUNET_OK !=
 266       h->current->proc (h->current->cls,
 267                         service,
 268                         name,
 269                         GNUNET_ntohll (smsg->value),
 270                         0 !=
 271                         (ntohl (smsg->uid) & GNUNET_STATISTICS_PERSIST_BIT)))
 272     {
 273 #if DEBUG_STATISTICS
 274       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 275                   "Processing of remaining statistics aborted by client.\n");
 276 #endif
 277       h->current->aborted = GNUNET_YES;
 278     }
 279   return GNUNET_OK;
 280 }
 281
 282
 283 /**
 284  * Function called with messages from stats service.
 285  *
 286  * @param cls closure
 287  * @param msg message received, NULL on timeout or fatal error
 288  */
 289 static void
 290 receive_stats (void *cls, const struct GNUNET_MessageHeader *msg)
 291 {
 292   struct GNUNET_STATISTICS_Handle *h = cls;
 293
 294   if (msg == NULL)
 295     {
 296       if (NULL != h->client)
 297         {
 298           GNUNET_CLIENT_disconnect (h->client);
 299           h->client = NULL;
 300         }
 301 #if DEBUG_STATISTICS
 302       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
 303                   "Error receiving statistics from service, is the service running?\n" );
 304 #endif
 305       finish (h, GNUNET_SYSERR);
 306       return;
 307     }
 308   switch (ntohs (msg->type))
 309     {
 310     case GNUNET_MESSAGE_TYPE_STATISTICS_END:
 311 #if DEBUG_STATISTICS
 312       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 313                   "Received end of statistics marker\n");
 314 #endif
 315       finish (h, GNUNET_OK);
 316       return;
 317     case GNUNET_MESSAGE_TYPE_STATISTICS_VALUE:
 318       if (GNUNET_OK == process_message (h, msg))
 319         {
 320           /* finally, look for more! */
 321           GNUNET_CLIENT_receive (h->client,
 322                                  &receive_stats,
 323                                  h,
 324                                  GNUNET_TIME_absolute_get_remaining
 325                                  (h->current->timeout));
 326           return;
 327         }
 328       GNUNET_break (0);
 329       break;
 330     default:
 331       GNUNET_break (0);
 332       break;
 333     }
 334   if (NULL != h->client)
 335     {
 336       GNUNET_CLIENT_disconnect (h->client);
 337       h->client = NULL;
 338     }
 339   finish (h, GNUNET_SYSERR);
 340 }
 341
 342
 343 /**
 344  * Transmit a GET request (and if successful, start to receive
 345  * the response).
 346  */
 347 static size_t
 348 transmit_get (struct GNUNET_STATISTICS_Handle *handle, size_t size, void *buf)
 349 {
 350   struct GNUNET_MessageHeader *hdr;
 351   size_t slen1;
 352   size_t slen2;
 353   uint16_t msize;
 354
 355   if (buf == NULL)
 356     {
 357       /* timeout / error */
 358 #if DEBUG_STATISTICS
 359       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 360                   "Transmission of request for statistics failed!\n");
 361 #endif
 362       finish (handle, GNUNET_SYSERR);
 363       return 0;
 364     }
 365   slen1 = strlen (handle->current->subsystem) + 1;
 366   slen2 = strlen (handle->current->name) + 1;
 367   msize = slen1 + slen2 + sizeof (struct GNUNET_MessageHeader);
 368   GNUNET_assert (msize <= size);
 369   hdr = (struct GNUNET_MessageHeader *) buf;
 370   hdr->size = htons (msize);
 371   hdr->type = htons (GNUNET_MESSAGE_TYPE_STATISTICS_GET);
 372   GNUNET_assert (slen1 + slen2 ==
 373                  GNUNET_STRINGS_buffer_fill ((char *) &hdr[1],
 374                                              slen1 + slen2,
 375                                              2,
 376                                              handle->current->subsystem,
 377                                              handle->current->name));
 378   GNUNET_CLIENT_receive (handle->client,
 379                          &receive_stats,
 380                          handle,
 381                          GNUNET_TIME_absolute_get_remaining (handle->
 382                                                              current->timeout));
 383   return msize;
 384 }
 385
 386
 387
 388 /**
 389  * Transmit a SET/UPDATE request.
 390  */
 391 static size_t
 392 transmit_set (struct GNUNET_STATISTICS_Handle *handle, size_t size, void *buf)
 393 {
 394   struct GNUNET_STATISTICS_SetMessage *r;
 395   size_t slen;
 396   size_t nlen;
 397   size_t nsize;
 398
 399   if (NULL == buf)
 400     {
 401       finish (handle, GNUNET_SYSERR);
 402       return 0;
 403     }
 404
 405   slen = strlen (handle->current->subsystem) + 1;
 406   nlen = strlen (handle->current->name) + 1;
 407   nsize = sizeof (struct GNUNET_STATISTICS_SetMessage) + slen + nlen;
 408   if (size < nsize)
 409     {
 410       GNUNET_break (0);
 411       finish (handle, GNUNET_SYSERR);
 412       return 0;
 413     }
 414   r = buf;
 415   r->header.size = htons (nsize);
 416   r->header.type = htons (GNUNET_MESSAGE_TYPE_STATISTICS_SET);
 417   r->flags = 0;
 418   r->value = GNUNET_htonll (handle->current->value);
 419   if (handle->current->make_persistent)
 420     r->flags |= htonl (GNUNET_STATISTICS_SETFLAG_PERSISTENT);
 421   if (handle->current->type == ACTION_UPDATE)
 422     r->flags |= htonl (GNUNET_STATISTICS_SETFLAG_RELATIVE);
 423   GNUNET_assert (slen + nlen ==
 424                  GNUNET_STRINGS_buffer_fill ((char *) &r[1],
 425                                              slen + nlen,
 426                                              2,
 427                                              handle->current->subsystem,
 428                                              handle->current->name));
 429   finish (handle, GNUNET_OK);
 430   return nsize;
 431 }
 432
 433
 434 static size_t
 435 transmit_action (void *cls, size_t size, void *buf)
 436 {
 437   struct GNUNET_STATISTICS_Handle *handle = cls;
 438   size_t ret;
 439
 440   handle->th = NULL;
 441   switch (handle->current->type)
 442     {
 443     case ACTION_GET:
 444       ret = transmit_get (handle, size, buf);
 445       break;
 446     case ACTION_SET:
 447     case ACTION_UPDATE:
 448       ret = transmit_set (handle, size, buf);
 449       break;
 450     default:
 451       ret = 0;
 452       GNUNET_break (0);
 453       break;
 454     }
 455   return ret;
 456 }
 457
 458
 459 /**
 460  * Get handle for the statistics service.
 461  *
 462  * @param sched scheduler to use
 463  * @param subsystem name of subsystem using the service
 464  * @param cfg services configuration in use
 465  * @return handle to use
 466  */
 467 struct GNUNET_STATISTICS_Handle *
 468 GNUNET_STATISTICS_create (struct GNUNET_SCHEDULER_Handle *sched,
 469                           const char *subsystem,
 470                           const struct GNUNET_CONFIGURATION_Handle *cfg)
 471 {
 472   struct GNUNET_STATISTICS_Handle *ret;
 473
 474   GNUNET_assert (subsystem != NULL);
 475   GNUNET_assert (sched != NULL);
 476   GNUNET_assert (cfg != NULL);
 477   ret = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_Handle));
 478   ret->sched = sched;
 479   ret->cfg = cfg;
 480   ret->subsystem = GNUNET_strdup (subsystem);
 481   try_connect (ret);
 482   return ret;
 483 }
 484
 485
 486 /**
 487  * Destroy a handle (free all state associated with
 488  * it).
 489  *
 490  * @param h statistics handle to destroy
 491  * @param sync_first set to GNUNET_YES if pending SET requests should
 492  *        be completed
 493  */
 494 void
 495 GNUNET_STATISTICS_destroy (struct GNUNET_STATISTICS_Handle *h,
 496                            int sync_first)
 497 {
 498   struct ActionItem *pos;
 499   struct ActionItem *next;
 500   struct ActionItem *prev;
 501   struct GNUNET_TIME_Relative timeout;
 502
 503   if (sync_first)
 504     {
 505       if (h->current != NULL)
 506         {
 507           if (h->current->type == ACTION_GET)
 508             {
 509               GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
 510               h->th = NULL;
 511               free_action_item (h->current);
 512               h->current = NULL;
 513             }
 514         }
 515       pos = h->action_head;
 516       prev = NULL;
 517       while (pos != NULL)
 518         {
 519           next = pos->next;
 520           if (pos->type == ACTION_GET)
 521             {
 522               if (prev == NULL)
 523                 h->action_head = next;
 524               else
 525                 prev->next = next;
 526               free_action_item (pos);
 527             }
 528           else
 529             {
 530               prev = pos;
 531             }
 532           pos = next;
 533         }
 534       h->action_tail = prev;
 535       if (h->current == NULL)
 536         {
 537           h->current = h->action_head;
 538           if (h->action_head != NULL)
 539             {
 540               h->action_head = h->action_head->next;
 541               if (h->action_head == NULL)
 542                 h->action_tail = NULL;
 543             }
 544         }
 545       if ( (h->current != NULL) &&
 546            (h->th == NULL) )
 547         {
 548           timeout = GNUNET_TIME_absolute_get_remaining (h->current->timeout);
 549           h->th = GNUNET_CLIENT_notify_transmit_ready (h->client,
 550                                                        h->current->msize,
 551                                                        timeout,
 552                                                        GNUNET_YES,
 553                                                        &transmit_action, h);
 554           GNUNET_assert (NULL != h->th);
 555         }
 556       h->do_destroy = GNUNET_YES;
 557       return;
 558     }
 559   if (NULL != h->th)
 560     {
 561       GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
 562       h->th = NULL;
 563     }
 564   if (h->current != NULL)
 565     free_action_item (h->current);
 566   while (NULL != (pos = h->action_head))
 567     {
 568       h->action_head = pos->next;
 569       free_action_item (pos);
 570     }
 571   if (h->client != NULL)
 572     {
 573       GNUNET_CLIENT_disconnect (h->client);
 574       h->client = NULL;
 575     }
 576   GNUNET_free (h->subsystem);
 577   GNUNET_free (h);
 578 }
 579
 580
 581
 582 /**
 583  * Schedule the next action to be performed.
 584  */
 585 static void
 586 schedule_action (struct GNUNET_STATISTICS_Handle *h)
 587 {
 588   struct GNUNET_TIME_Relative timeout;
 589
 590   if (h->current != NULL)
 591     return;                     /* action already pending */
 592   if (GNUNET_YES != try_connect (h))
 593     {
 594       finish (h, GNUNET_SYSERR);
 595       return;
 596     }
 597
 598   /* schedule next action */
 599   h->current = h->action_head;
 600   if (NULL == h->current)
 601     {
 602       if (h->do_destroy)
 603         {
 604           h->do_destroy = GNUNET_NO;
 605           GNUNET_STATISTICS_destroy (h, GNUNET_YES);
 606         }
 607       return;
 608     }
 609   h->action_head = h->action_head->next;
 610   if (NULL == h->action_head)
 611     h->action_tail = NULL;
 612   h->current->next = NULL;
 613   timeout = GNUNET_TIME_absolute_get_remaining (h->current->timeout);
 614   if (NULL ==
 615       (h->th = GNUNET_CLIENT_notify_transmit_ready (h->client,
 616                                                     h->current->msize,
 617                                                     timeout,
 618                                                     GNUNET_YES,
 619                                                     &transmit_action, h)))
 620     {
 621 #if DEBUG_STATISTICS
 622       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 623                   "Failed to transmit request to statistics service.\n");
 624 #endif
 625       finish (h, GNUNET_SYSERR);
 626     }
 627 }
 628
 629
 630 static void
 631 insert_ai (struct GNUNET_STATISTICS_Handle *h, struct ActionItem *ai)
 632 {
 633   if (h->action_tail == NULL)
 634     {
 635       h->action_head = ai;
 636       h->action_tail = ai;
 637       schedule_action (h);
 638     }
 639   else
 640     {
 641       h->action_tail->next = ai;
 642       h->action_tail = ai;
 643     }
 644 }
 645
 646
 647 /**
 648  * Get statistic from the peer.
 649  *
 650  * @param handle identification of the statistics service
 651  * @param subsystem limit to the specified subsystem, NULL for our subsystem
 652  * @param name name of the statistic value, NULL for all values
 653  * @param timeout after how long should we give up (and call
 654  *        cont with an error code)?
 655  * @param cont continuation to call when done (can be NULL)
 656  * @param proc function to call on each value
 657  * @param cls closure for cont and proc
 658  */
 659 void
 660 GNUNET_STATISTICS_get (struct GNUNET_STATISTICS_Handle *handle,
 661                        const char *subsystem,
 662                        const char *name,
 663                        struct GNUNET_TIME_Relative timeout,
 664                        GNUNET_STATISTICS_Callback cont,
 665                        GNUNET_STATISTICS_Iterator proc, void *cls)
 666 {
 667   size_t slen1;
 668   size_t slen2;
 669   struct ActionItem *ai;
 670
 671   GNUNET_assert (handle != NULL);
 672   GNUNET_assert (proc != NULL);
 673   GNUNET_assert (GNUNET_NO == handle->do_destroy);
 674   if (GNUNET_YES != try_connect (handle))
 675     {
 676 #if DEBUG_STATISTICS
 677       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 678                   "Failed to connect to statistics service, can not get value `%s:%s'.\n",
 679                   strlen (subsystem) ? subsystem : "*",
 680                   strlen (name) ? name : "*");
 681 #endif
 682       if (cont != NULL)
 683         cont (cls, GNUNET_SYSERR);
 684       return;
 685     }
 686   if (subsystem == NULL)
 687     subsystem = "";
 688   if (name == NULL)
 689     name = "";
 690   slen1 = strlen (subsystem);
 691   slen2 = strlen (name);
 692   GNUNET_assert (slen1 + slen2 + sizeof (struct GNUNET_MessageHeader) <
 693                  GNUNET_SERVER_MAX_MESSAGE_SIZE);
 694   ai = GNUNET_malloc (sizeof (struct ActionItem));
 695   ai->subsystem = GNUNET_strdup (subsystem);
 696   ai->name = GNUNET_strdup (name);
 697   ai->cont = cont;
 698   ai->proc = proc;
 699   ai->cls = cls;
 700   ai->timeout = GNUNET_TIME_relative_to_absolute (timeout);
 701   ai->type = ACTION_GET;
 702   ai->msize = slen1 + slen2 + sizeof (struct GNUNET_MessageHeader);
 703   insert_ai (handle, ai);
 704 }
 705
 706
 707 static void
 708 add_setter_action (struct GNUNET_STATISTICS_Handle *h,
 709                    const char *name,
 710                    int make_persistent,
 711                    uint64_t value, enum ActionType type)
 712 {
 713   struct ActionItem *ai;
 714   size_t slen;
 715   size_t nlen;
 716   size_t nsize;
 717
 718   GNUNET_assert (h != NULL);
 719   GNUNET_assert (name != NULL);
 720   if (GNUNET_YES != try_connect (h))
 721     return;
 722   slen = strlen (h->subsystem) + 1;
 723   nlen = strlen (name) + 1;
 724   nsize = sizeof (struct GNUNET_STATISTICS_SetMessage) + slen + nlen;
 725   if (nsize >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
 726     {
 727       GNUNET_break (0);
 728       return;
 729     }
 730   ai = GNUNET_malloc (sizeof (struct ActionItem));
 731   ai->subsystem = GNUNET_strdup (h->subsystem);
 732   ai->name = GNUNET_strdup (name);
 733   ai->timeout = GNUNET_TIME_relative_to_absolute (SET_TRANSMIT_TIMEOUT);
 734   ai->make_persistent = make_persistent;
 735   ai->msize = nsize;
 736   ai->value = value;
 737   ai->type = type;
 738   insert_ai (h, ai);
 739   schedule_action (h);
 740 }
 741
 742
 743 /**
 744  * Set statistic value for the peer.  Will always use our
 745  * subsystem (the argument used when "handle" was created).
 746  *
 747  * @param handle identification of the statistics service
 748  * @param name name of the statistic value
 749  * @param value new value to set
 750  * @param make_persistent should the value be kept across restarts?
 751  */
 752 void
 753 GNUNET_STATISTICS_set (struct GNUNET_STATISTICS_Handle *handle,
 754                        const char *name,
 755                        uint64_t value, int make_persistent)
 756 {
 757   GNUNET_assert (GNUNET_NO == handle->do_destroy);
 758   add_setter_action (handle, name, make_persistent, value, ACTION_SET);
 759 }
 760
 761
 762 /**
 763  * Set statistic value for the peer.  Will always use our
 764  * subsystem (the argument used when "handle" was created).
 765  *
 766  * @param handle identification of the statistics service
 767  * @param name name of the statistic value
 768  * @param delta change in value (added to existing value)
 769  * @param make_persistent should the value be kept across restarts?
 770  */
 771 void
 772 GNUNET_STATISTICS_update (struct GNUNET_STATISTICS_Handle *handle,
 773                           const char *name,
 774                           int64_t delta, int make_persistent)
 775 {
 776   GNUNET_assert (GNUNET_NO == handle->do_destroy);
 777   add_setter_action (handle, name, make_persistent,
 778                      (unsigned long long) delta, ACTION_UPDATE);
 779 }
 780
 781
 782 /* end of statistics_api.c */