Imported Upstream version 0.9.2upstream/0.9.2

1 files changed, 1277 insertions, 0 deletions

diff --git a/src/statistics/statistics_api.c b/src/statistics/statistics_api.c
new file mode 100644
index 0000000..2838b70
--- /dev/null
+++ b/src/statistics/statistics_api.c
@@ -0,0 +1,1277 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file statistics/statistics_api.c
+ * @brief API of the statistics service
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_client_lib.h"
+#include "gnunet_constants.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_server_lib.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet_strings_lib.h"
+#include "statistics.h"
+
+/**
+ * How long do we wait until a statistics request for setting
+ * a value times out?  (The update will be lost if the
+ * service does not react within this timeframe).
+ */
+#define SET_TRANSMIT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2)
+
+#define LOG(kind,...) GNUNET_log_from (kind, "statistics-api",__VA_ARGS__)
+
+/**
+ * Types of actions.
+ */
+enum ActionType
+{
+  /**
+   * Get a value.
+   */
+  ACTION_GET,
+
+  /**
+   * Set a value.
+   */
+  ACTION_SET,
+
+  /**
+   * Update a value.
+   */
+  ACTION_UPDATE,
+
+  /**
+   * Watch a value.
+   */
+  ACTION_WATCH
+};
+
+
+/**
+ * Entry kept for each value we are watching.
+ */
+struct GNUNET_STATISTICS_WatchEntry
+{
+
+  /**
+   * What subsystem is this action about? (never NULL)
+   */
+  char *subsystem;
+
+  /**
+   * What value is this action about? (never NULL)
+   */
+  char *name;
+
+  /**
+   * Function to call
+   */
+  GNUNET_STATISTICS_Iterator proc;
+
+  /**
+   * Closure for proc
+   */
+  void *proc_cls;
+
+};
+
+
+/**
+ * Linked list of things we still need to do.
+ */
+struct GNUNET_STATISTICS_GetHandle
+{
+
+  /**
+   * This is a doubly linked list.
+   */
+  struct GNUNET_STATISTICS_GetHandle *next;
+
+  /**
+   * This is a doubly linked list.
+   */
+  struct GNUNET_STATISTICS_GetHandle *prev;
+
+  /**
+   * Main statistics handle.
+   */
+  struct GNUNET_STATISTICS_Handle *sh;
+
+  /**
+   * What subsystem is this action about? (can be NULL)
+   */
+  char *subsystem;
+
+  /**
+   * What value is this action about? (can be NULL)
+   */
+  char *name;
+
+  /**
+   * Continuation to call once action is complete.
+   */
+  GNUNET_STATISTICS_Callback cont;
+
+  /**
+   * Function to call (for GET actions only).
+   */
+  GNUNET_STATISTICS_Iterator proc;
+
+  /**
+   * Closure for proc and cont.
+   */
+  void *cls;
+
+  /**
+   * Timeout for this action.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * Associated value.
+   */
+  uint64_t value;
+
+  /**
+   * Flag for SET/UPDATE actions.
+   */
+  int make_persistent;
+
+  /**
+   * Has the current iteration been aborted; for GET actions.
+   */
+  int aborted;
+
+  /**
+   * Is this a GET, SET, UPDATE or WATCH?
+   */
+  enum ActionType type;
+
+  /**
+   * Size of the message that we will be transmitting.
+   */
+  uint16_t msize;
+
+};
+
+
+/**
+ * Handle for the service.
+ */
+struct GNUNET_STATISTICS_Handle
+{
+  /**
+   * Name of our subsystem.
+   */
+  char *subsystem;
+
+  /**
+   * Configuration to use.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Socket (if available).
+   */
+  struct GNUNET_CLIENT_Connection *client;
+
+  /**
+   * Currently pending transmission request.
+   */
+  struct GNUNET_CLIENT_TransmitHandle *th;
+
+  /**
+   * Head of the linked list of pending actions (first action
+   * to be performed).
+   */
+  struct GNUNET_STATISTICS_GetHandle *action_head;
+
+  /**
+   * Tail of the linked list of actions (for fast append).
+   */
+  struct GNUNET_STATISTICS_GetHandle *action_tail;
+
+  /**
+   * Action we are currently busy with (action request has been
+   * transmitted, we're now receiving the response from the
+   * service).
+   */
+  struct GNUNET_STATISTICS_GetHandle *current;
+
+  /**
+   * Array of watch entries.
+   */
+  struct GNUNET_STATISTICS_WatchEntry **watches;
+
+  /**
+   * Task doing exponential back-off trying to reconnect.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier backoff_task;
+
+  /**
+   * Time for next connect retry.
+   */
+  struct GNUNET_TIME_Relative backoff;
+
+  /**
+   * Size of the 'watches' array.
+   */
+  unsigned int watches_size;
+
+  /**
+   * Should this handle auto-destruct once all actions have
+   * been processed?
+   */
+  int do_destroy;
+
+  /**
+   * Are we currently receiving from the service?
+   */
+  int receiving;
+
+};
+
+
+/**
+ * Schedule the next action to be performed.
+ *
+ * @param h statistics handle to reconnect
+ */
+static void
+schedule_action (struct GNUNET_STATISTICS_Handle *h);
+
+
+/**
+ * Transmit request to service that we want to watch
+ * the development of a particular value.
+ *
+ * @param h statistics handle
+ * @param watch watch entry of the value to watch
+ */
+static void
+schedule_watch_request (struct GNUNET_STATISTICS_Handle *h,
+                        struct GNUNET_STATISTICS_WatchEntry *watch)
+{
+
+  struct GNUNET_STATISTICS_GetHandle *ai;
+  size_t slen;
+  size_t nlen;
+  size_t nsize;
+
+  GNUNET_assert (h != NULL);
+  slen = strlen (watch->subsystem) + 1;
+  nlen = strlen (watch->name) + 1;
+  nsize = sizeof (struct GNUNET_MessageHeader) + slen + nlen;
+  if (nsize >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  ai = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_GetHandle));
+  ai->sh = h;
+  ai->subsystem = GNUNET_strdup (watch->subsystem);
+  ai->name = GNUNET_strdup (watch->name);
+  ai->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
+  ai->msize = nsize;
+  ai->type = ACTION_WATCH;
+  ai->proc = watch->proc;
+  ai->cls = watch->proc_cls;
+  GNUNET_CONTAINER_DLL_insert_tail (h->action_head, h->action_tail,
+				    ai);
+  schedule_action (h);
+}
+
+
+/**
+ * Free memory associated with the given action item.
+ *
+ * @param gh action item to free
+ */
+static void
+free_action_item (struct GNUNET_STATISTICS_GetHandle *gh)
+{
+  GNUNET_free_non_null (gh->subsystem);
+  GNUNET_free_non_null (gh->name);
+  GNUNET_free (gh);
+}
+
+
+/**
+ * Disconnect from the statistics service.
+ *
+ * @param h statistics handle to disconnect from
+ */
+static void
+do_disconnect (struct GNUNET_STATISTICS_Handle *h)
+{
+  struct GNUNET_STATISTICS_GetHandle *c;
+  
+  if (NULL != h->th)
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
+    h->th = NULL;
+  } 
+  if (NULL != h->client)
+  {
+    GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
+    h->client = NULL;
+  }
+  h->receiving = GNUNET_NO;
+  if (NULL != (c = h->current))
+  {
+    h->current = NULL;
+    if (c->cont != NULL)
+      c->cont (c->cls, GNUNET_SYSERR);
+    free_action_item (c);
+  }
+}
+
+
+/**
+ * Try to (re)connect to the statistics service.
+ *
+ * @param h statistics handle to reconnect
+ * @return GNUNET_YES on success, GNUNET_NO on failure.
+ */
+static int
+try_connect (struct GNUNET_STATISTICS_Handle *h)
+{
+  struct GNUNET_STATISTICS_GetHandle *gh;
+  struct GNUNET_STATISTICS_GetHandle *gn;
+  unsigned int i;
+
+  if (h->backoff_task != GNUNET_SCHEDULER_NO_TASK)
+    return GNUNET_NO;
+  if (h->client != NULL)
+    return GNUNET_YES;
+  h->client = GNUNET_CLIENT_connect ("statistics", h->cfg);  
+  if (h->client != NULL)
+  {
+    gn = h->action_head; 
+    while (NULL != (gh = gn))
+    {
+      gn = gh->next;
+      if (gh->type == ACTION_WATCH)
+      {
+	GNUNET_CONTAINER_DLL_remove (h->action_head,
+				     h->action_tail,
+				     gh);
+	free_action_item (gh);	
+      }
+    }
+    for (i = 0; i < h->watches_size; i++)
+      schedule_watch_request (h, h->watches[i]);
+    return GNUNET_YES;
+  }
+#if DEBUG_STATISTICS
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       _("Failed to connect to statistics service!\n"));
+#endif
+  return GNUNET_NO;
+}
+
+
+/**
+ * We've waited long enough, reconnect now.
+ *
+ * @param cls the 'struct GNUNET_STATISTICS_Handle' to reconnect
+ * @param tc scheduler context (unused)
+ */
+static void
+reconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_STATISTICS_Handle *h = cls;
+
+  h->backoff_task = GNUNET_SCHEDULER_NO_TASK;
+  schedule_action (h);
+}
+
+
+/**
+ * Reconnect at a later time, respecting back-off.
+ *
+ * @param h statistics handle
+ */
+static void
+reconnect_later (struct GNUNET_STATISTICS_Handle *h)
+{
+  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->backoff_task);
+  h->backoff_task =
+    GNUNET_SCHEDULER_add_delayed (h->backoff, &reconnect_task, h);
+  h->backoff = GNUNET_TIME_relative_multiply (h->backoff, 2);
+  h->backoff =
+    GNUNET_TIME_relative_min (h->backoff, GNUNET_CONSTANTS_SERVICE_TIMEOUT);
+}
+
+
+/**
+ * Process a 'GNUNET_MESSAGE_TYPE_STATISTICS_VALUE' message.
+ *
+ * @param h statistics handle
+ * @param msg message received from the service, never NULL
+ * @return GNUNET_OK if the message was well-formed
+ */
+static int
+process_statistics_value_message (struct GNUNET_STATISTICS_Handle *h,
+				  const struct GNUNET_MessageHeader *msg)
+{
+  char *service;
+  char *name;
+  const struct GNUNET_STATISTICS_ReplyMessage *smsg;
+  uint16_t size;
+
+  if (h->current->aborted)
+  {
+#if DEBUG_STATISTICS
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Iteration was aborted, ignoring VALUE\n");
+#endif
+    return GNUNET_OK;           /* don't bother */
+  }
+  size = ntohs (msg->size);
+  if (size < sizeof (struct GNUNET_STATISTICS_ReplyMessage))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  smsg = (const struct GNUNET_STATISTICS_ReplyMessage *) msg;
+  size -= sizeof (struct GNUNET_STATISTICS_ReplyMessage);
+  if (size !=
+      GNUNET_STRINGS_buffer_tokenize ((const char *) &smsg[1], size, 2,
+                                      &service, &name))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+#if DEBUG_STATISTICS
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received valid statistic on `%s:%s': %llu\n",
+       service, name, GNUNET_ntohll (smsg->value));
+#endif
+  if (GNUNET_OK !=
+      h->current->proc (h->current->cls, service, name,
+                        GNUNET_ntohll (smsg->value),
+                        0 !=
+                        (ntohl (smsg->uid) & GNUNET_STATISTICS_PERSIST_BIT)))
+  {
+#if DEBUG_STATISTICS
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Processing of remaining statistics aborted by client.\n");
+#endif
+    h->current->aborted = GNUNET_YES;
+  }
+#if DEBUG_STATISTICS
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "VALUE processed successfully\n");
+#endif
+  return GNUNET_OK;
+}
+
+
+/**
+ * We have received a watch value from the service.  Process it.
+ *
+ * @param h statistics handle
+ * @param msg the watch value message
+ * @return GNUNET_OK if the message was well-formed, GNUNET_SYSERR if not,
+ *         GNUNET_NO if this watch has been cancelled
+ */
+static int
+process_watch_value (struct GNUNET_STATISTICS_Handle *h,
+                     const struct GNUNET_MessageHeader *msg)
+{
+  const struct GNUNET_STATISTICS_WatchValueMessage *wvm;
+  struct GNUNET_STATISTICS_WatchEntry *w;
+  uint32_t wid;
+
+  if (sizeof (struct GNUNET_STATISTICS_WatchValueMessage) != ntohs (msg->size))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  wvm = (const struct GNUNET_STATISTICS_WatchValueMessage *) msg;
+  GNUNET_break (0 == ntohl (wvm->reserved));
+  wid = ntohl (wvm->wid);
+  if (wid >= h->watches_size)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  w = h->watches[wid];
+  if (NULL == w)  
+    return GNUNET_NO;  
+  (void) w->proc (w->proc_cls, w->subsystem, w->name,
+                  GNUNET_ntohll (wvm->value),
+                  0 != (ntohl (wvm->flags) & GNUNET_STATISTICS_PERSIST_BIT));
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called with messages from stats service.
+ *
+ * @param cls closure
+ * @param msg message received, NULL on timeout or fatal error
+ */
+static void
+receive_stats (void *cls, const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_STATISTICS_Handle *h = cls;
+  struct GNUNET_STATISTICS_GetHandle *c;
+  int ret;
+
+  if (msg == NULL)
+  {
+#if DEBUG_STATISTICS
+    LOG (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+         "Error receiving statistics from service, is the service running?\n");
+#endif
+    do_disconnect (h);
+    reconnect_later (h);
+    return;
+  }
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_STATISTICS_END:
+#if DEBUG_STATISTICS
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Received end of statistics marker\n");
+#endif
+    if (NULL == (c = h->current))
+    {
+      GNUNET_break (0);
+      do_disconnect (h);
+      reconnect_later (h);
+      return;
+    }
+    h->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
+    if (h->watches_size > 0)
+    {
+      GNUNET_CLIENT_receive (h->client, &receive_stats, h,
+                             GNUNET_TIME_UNIT_FOREVER_REL);
+    }
+    else
+    {
+      h->receiving = GNUNET_NO;
+    }    
+    h->current = NULL;
+    schedule_action (h);
+    if (c->cont != NULL)
+      c->cont (c->cls, GNUNET_OK);
+    free_action_item (c);
+    return;
+  case GNUNET_MESSAGE_TYPE_STATISTICS_VALUE:
+    if (GNUNET_OK != process_statistics_value_message (h, msg))
+    {
+      do_disconnect (h);
+      reconnect_later (h);
+      return;     
+    }
+    /* finally, look for more! */
+#if DEBUG_STATISTICS
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+	 "Processing VALUE done, now reading more\n");
+#endif
+    GNUNET_CLIENT_receive (h->client, &receive_stats, h,
+			   GNUNET_TIME_absolute_get_remaining (h->
+							       current->timeout));
+    h->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
+    return;
+  case GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE:
+    if (GNUNET_OK != 
+	(ret = process_watch_value (h, msg)))
+    {
+      do_disconnect (h);
+      if (GNUNET_NO == ret)
+	h->backoff = GNUNET_TIME_UNIT_MILLISECONDS; 
+      reconnect_later (h);
+      return;
+    }
+    h->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
+    GNUNET_assert (h->watches_size > 0);
+    GNUNET_CLIENT_receive (h->client, &receive_stats, h,
+			   GNUNET_TIME_UNIT_FOREVER_REL);
+    return;    
+  default:
+    GNUNET_break (0);
+    do_disconnect (h);
+    reconnect_later (h);
+    return;
+  }
+}
+
+
+/**
+ * Transmit a GET request (and if successful, start to receive
+ * the response).
+ *
+ * @param handle statistics handle
+ * @param size how many bytes can we write to buf
+ * @param buf where to write requests to the service
+ * @return number of bytes written to buf
+ */
+static size_t
+transmit_get (struct GNUNET_STATISTICS_Handle *handle, size_t size, void *buf)
+{
+  struct GNUNET_STATISTICS_GetHandle *c;
+  struct GNUNET_MessageHeader *hdr;
+  size_t slen1;
+  size_t slen2;
+  uint16_t msize;
+
+  GNUNET_assert (NULL != (c = handle->current));
+  if (buf == NULL)
+  {
+    /* timeout / error */
+#if DEBUG_STATISTICS
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Transmission of request for statistics failed!\n");
+#endif  
+    do_disconnect (handle);
+    reconnect_later (handle);
+    return 0;
+  }
+  slen1 = strlen (c->subsystem) + 1;
+  slen2 = strlen (c->name) + 1;
+  msize = slen1 + slen2 + sizeof (struct GNUNET_MessageHeader);
+  GNUNET_assert (msize <= size);
+  hdr = (struct GNUNET_MessageHeader *) buf;
+  hdr->size = htons (msize);
+  hdr->type = htons (GNUNET_MESSAGE_TYPE_STATISTICS_GET);
+  GNUNET_assert (slen1 + slen2 ==
+                 GNUNET_STRINGS_buffer_fill ((char *) &hdr[1], slen1 + slen2, 2,
+                                             c->subsystem,
+                                             c->name));
+  if (GNUNET_YES != handle->receiving)
+  {
+#if DEBUG_STATISTICS
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Transmission of GET done, now reading response\n");
+#endif
+    handle->receiving = GNUNET_YES;
+    GNUNET_CLIENT_receive (handle->client, &receive_stats, handle,
+                           GNUNET_TIME_absolute_get_remaining (c->timeout));
+  }
+  return msize;
+}
+
+
+/**
+ * Transmit a WATCH request (and if successful, start to receive
+ * the response).
+ *
+ * @param handle statistics handle
+ * @param size how many bytes can we write to buf
+ * @param buf where to write requests to the service
+ * @return number of bytes written to buf
+ */
+static size_t
+transmit_watch (struct GNUNET_STATISTICS_Handle *handle, size_t size, void *buf)
+{
+  struct GNUNET_MessageHeader *hdr;
+  size_t slen1;
+  size_t slen2;
+  uint16_t msize;
+
+  if (buf == NULL)
+  {
+    /* timeout / error */
+#if DEBUG_STATISTICS
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Transmission of request for statistics failed!\n");
+#endif
+    do_disconnect (handle);
+    reconnect_later (handle);
+    return 0;
+  }
+#if DEBUG_STATISTICS
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Transmitting watch request for `%s'\n",
+       handle->current->name);
+#endif
+  slen1 = strlen (handle->current->subsystem) + 1;
+  slen2 = strlen (handle->current->name) + 1;
+  msize = slen1 + slen2 + sizeof (struct GNUNET_MessageHeader);
+  GNUNET_assert (msize <= size);
+  hdr = (struct GNUNET_MessageHeader *) buf;
+  hdr->size = htons (msize);
+  hdr->type = htons (GNUNET_MESSAGE_TYPE_STATISTICS_WATCH);
+  GNUNET_assert (slen1 + slen2 ==
+                 GNUNET_STRINGS_buffer_fill ((char *) &hdr[1], slen1 + slen2, 2,
+                                             handle->current->subsystem,
+                                             handle->current->name));
+  if (GNUNET_YES != handle->receiving)
+  {
+    handle->receiving = GNUNET_YES;
+    GNUNET_CLIENT_receive (handle->client, &receive_stats, handle,
+                           GNUNET_TIME_UNIT_FOREVER_REL);
+  }
+  GNUNET_assert (NULL == handle->current->cont);
+  free_action_item (handle->current);
+  handle->current = NULL;
+  return msize;
+}
+
+
+/**
+ * Transmit a SET/UPDATE request.
+ *
+ * @param handle statistics handle
+ * @param size how many bytes can we write to buf
+ * @param buf where to write requests to the service
+ * @return number of bytes written to buf
+ */
+static size_t
+transmit_set (struct GNUNET_STATISTICS_Handle *handle, size_t size, void *buf)
+{
+  struct GNUNET_STATISTICS_SetMessage *r;
+  size_t slen;
+  size_t nlen;
+  size_t nsize;
+
+  if (NULL == buf)
+  {
+    do_disconnect (handle);
+    reconnect_later (handle);
+    return 0;
+  }
+  slen = strlen (handle->current->subsystem) + 1;
+  nlen = strlen (handle->current->name) + 1;
+  nsize = sizeof (struct GNUNET_STATISTICS_SetMessage) + slen + nlen;
+  if (size < nsize)
+  {
+    GNUNET_break (0);
+    do_disconnect (handle);
+    reconnect_later (handle);
+    return 0;
+  }
+  r = buf;
+  r->header.size = htons (nsize);
+  r->header.type = htons (GNUNET_MESSAGE_TYPE_STATISTICS_SET);
+  r->flags = 0;
+  r->value = GNUNET_htonll (handle->current->value);
+  if (handle->current->make_persistent)
+    r->flags |= htonl (GNUNET_STATISTICS_SETFLAG_PERSISTENT);
+  if (handle->current->type == ACTION_UPDATE)
+    r->flags |= htonl (GNUNET_STATISTICS_SETFLAG_RELATIVE);
+  GNUNET_assert (slen + nlen ==
+                 GNUNET_STRINGS_buffer_fill ((char *) &r[1], slen + nlen, 2,
+                                             handle->current->subsystem,
+                                             handle->current->name));
+  GNUNET_assert (NULL == handle->current->cont);
+  free_action_item (handle->current);
+  handle->current = NULL;
+  return nsize;
+}
+
+
+/**
+ * Function called when we are ready to transmit a request to the service.
+ *
+ * @param cls the 'struct GNUNET_STATISTICS_Handle'
+ * @param size how many bytes can we write to buf
+ * @param buf where to write requests to the service
+ * @return number of bytes written to buf
+ */
+static size_t
+transmit_action (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_STATISTICS_Handle *h = cls;
+  size_t ret;
+
+  h->th = NULL;
+  ret = 0;
+  if (NULL != h->current)
+    switch (h->current->type)
+    {
+    case ACTION_GET:
+      ret = transmit_get (h, size, buf);
+      break;
+    case ACTION_SET:
+    case ACTION_UPDATE:
+      ret = transmit_set (h, size, buf);
+      break;
+    case ACTION_WATCH:
+      ret = transmit_watch (h, size, buf);
+      break;
+    default:
+      GNUNET_assert (0);
+      break;
+    }
+  schedule_action (h);
+  return ret;
+}
+
+
+/**
+ * Get handle for the statistics service.
+ *
+ * @param subsystem name of subsystem using the service
+ * @param cfg services configuration in use
+ * @return handle to use
+ */
+struct GNUNET_STATISTICS_Handle *
+GNUNET_STATISTICS_create (const char *subsystem,
+                          const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_STATISTICS_Handle *ret;
+
+  GNUNET_assert (subsystem != NULL);
+  GNUNET_assert (cfg != NULL);
+  ret = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_Handle));
+  ret->cfg = cfg;
+  ret->subsystem = GNUNET_strdup (subsystem);
+  ret->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
+  return ret;
+}
+
+
+/**
+ * Destroy a handle (free all state associated with
+ * it).
+ *
+ * @param h statistics handle to destroy
+ * @param sync_first set to GNUNET_YES if pending SET requests should
+ *        be completed
+ */
+void
+GNUNET_STATISTICS_destroy (struct GNUNET_STATISTICS_Handle *h, int sync_first)
+{
+  struct GNUNET_STATISTICS_GetHandle *pos;
+  struct GNUNET_STATISTICS_GetHandle *next;
+  struct GNUNET_TIME_Relative timeout;
+  int i;
+
+  if (h == NULL)
+    return;
+  if (GNUNET_SCHEDULER_NO_TASK != h->backoff_task)
+  {
+    GNUNET_SCHEDULER_cancel (h->backoff_task);
+    h->backoff_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if (sync_first)
+  {
+    if (h->current != NULL)
+    {
+      if (h->current->type == ACTION_GET)
+      {
+        GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
+        h->th = NULL;
+        free_action_item (h->current);
+        h->current = NULL;
+      }
+    }
+    next = h->action_head; 
+    while (NULL != (pos = next))
+    {
+      next = pos->next;
+      if (pos->type == ACTION_GET)
+      {
+	GNUNET_CONTAINER_DLL_remove (h->action_head,
+				     h->action_tail,
+				     pos);
+        free_action_item (pos);
+      }
+    }
+    if ( (NULL == h->current) &&
+	 (NULL != (h->current = h->action_head)) )
+      GNUNET_CONTAINER_DLL_remove (h->action_head,
+				   h->action_tail,
+				   h->current);
+    h->do_destroy = GNUNET_YES;
+    if ((h->current != NULL) && (h->th == NULL))
+    {
+      if (NULL == h->client)
+      {
+	/* instant-connect (regardless of back-off) to submit final value */
+	h->client = GNUNET_CLIENT_connect ("statistics", h->cfg);
+      }
+      if (NULL != h->client)
+      {
+	timeout = GNUNET_TIME_absolute_get_remaining (h->current->timeout);
+	h->th =
+          GNUNET_CLIENT_notify_transmit_ready (h->client, h->current->msize,
+                                               timeout, GNUNET_YES,
+                                               &transmit_action, h);
+	GNUNET_assert (NULL != h->th);
+      }
+    }
+    if (h->th != NULL)
+      return; /* do not finish destruction just yet */
+  }
+  while (NULL != (pos = h->action_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (h->action_head,
+				 h->action_tail,
+				 pos);
+    free_action_item (pos);
+  }
+  do_disconnect (h);
+  for (i = 0; i < h->watches_size; i++)
+  {
+    if (NULL == h->watches[i])
+      continue; 
+    GNUNET_free (h->watches[i]->subsystem);
+    GNUNET_free (h->watches[i]->name);
+    GNUNET_free (h->watches[i]);
+  }
+  GNUNET_array_grow (h->watches, h->watches_size, 0);
+  GNUNET_free (h->subsystem);
+  GNUNET_free (h);
+}
+
+
+/**
+ * Schedule the next action to be performed.
+ *
+ * @param h statistics handle
+ */
+static void
+schedule_action (struct GNUNET_STATISTICS_Handle *h)
+{
+  struct GNUNET_TIME_Relative timeout;
+
+  if ( (h->th != NULL) ||
+       (h->backoff_task != GNUNET_SCHEDULER_NO_TASK) )
+    return;                     /* action already pending */
+  if (GNUNET_YES != try_connect (h))
+  {
+    reconnect_later (h);
+    return;
+  }
+  if (NULL != h->current)
+    return; /* action already pending */
+  /* schedule next action */
+  h->current = h->action_head;
+  if (NULL == h->current)
+  {
+    if (h->do_destroy)
+    {
+      h->do_destroy = GNUNET_NO;
+      GNUNET_STATISTICS_destroy (h, GNUNET_YES);
+    }
+    return;
+  }
+  GNUNET_CONTAINER_DLL_remove (h->action_head, h->action_tail, h->current);
+  timeout = GNUNET_TIME_absolute_get_remaining (h->current->timeout);
+  if (NULL ==
+      (h->th =
+       GNUNET_CLIENT_notify_transmit_ready (h->client, h->current->msize,
+                                            timeout, GNUNET_YES,
+                                            &transmit_action, h)))
+  {
+#if DEBUG_STATISTICS
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Failed to transmit request to statistics service.\n");
+#endif
+    do_disconnect (h);
+    reconnect_later (h);
+  }
+}
+
+
+/**
+ * Get statistic from the peer.
+ *
+ * @param handle identification of the statistics service
+ * @param subsystem limit to the specified subsystem, NULL for our subsystem
+ * @param name name of the statistic value, NULL for all values
+ * @param timeout after how long should we give up (and call
+ *        cont with an error code)?
+ * @param cont continuation to call when done (can be NULL)
+ * @param proc function to call on each value
+ * @param cls closure for cont and proc
+ * @return NULL on error
+ */
+struct GNUNET_STATISTICS_GetHandle *
+GNUNET_STATISTICS_get (struct GNUNET_STATISTICS_Handle *handle,
+                       const char *subsystem, const char *name,
+                       struct GNUNET_TIME_Relative timeout,
+                       GNUNET_STATISTICS_Callback cont,
+                       GNUNET_STATISTICS_Iterator proc, void *cls)
+{
+  size_t slen1;
+  size_t slen2;
+  struct GNUNET_STATISTICS_GetHandle *ai;
+
+  if (NULL == handle)
+    return NULL;
+  GNUNET_assert (proc != NULL);
+  GNUNET_assert (GNUNET_NO == handle->do_destroy);
+  if (subsystem == NULL)
+    subsystem = "";
+  if (name == NULL)
+    name = "";
+  slen1 = strlen (subsystem) + 1;
+  slen2 = strlen (name) + 1;
+  GNUNET_assert (slen1 + slen2 + sizeof (struct GNUNET_MessageHeader) <
+                 GNUNET_SERVER_MAX_MESSAGE_SIZE);
+  ai = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_GetHandle));
+  ai->sh = handle;
+  ai->subsystem = GNUNET_strdup (subsystem);
+  ai->name = GNUNET_strdup (name);
+  ai->cont = cont;
+  ai->proc = proc;
+  ai->cls = cls;
+  ai->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+  ai->type = ACTION_GET;
+  ai->msize = slen1 + slen2 + sizeof (struct GNUNET_MessageHeader);
+  GNUNET_CONTAINER_DLL_insert_tail (handle->action_head, handle->action_tail,
+				    ai);
+  schedule_action (handle);
+  return ai;
+}
+
+
+/**
+ * Cancel a 'get' request.  Must be called before the 'cont'
+ * function is called.
+ *
+ * @param gh handle of the request to cancel
+ */
+void
+GNUNET_STATISTICS_get_cancel (struct GNUNET_STATISTICS_GetHandle *gh)
+{
+  if (NULL == gh)
+    return;
+  if (gh->sh->current == gh)
+  {
+    gh->aborted = GNUNET_YES;
+  }
+  else
+  {
+    GNUNET_CONTAINER_DLL_remove (gh->sh->action_head, gh->sh->action_tail, gh);
+    GNUNET_free (gh->name);
+    GNUNET_free (gh->subsystem);
+    GNUNET_free (gh);
+  }
+}
+
+
+/**
+ * Watch statistics from the peer (be notified whenever they change).
+ *
+ * @param handle identification of the statistics service
+ * @param subsystem limit to the specified subsystem, never NULL
+ * @param name name of the statistic value, never NULL
+ * @param proc function to call on each value
+ * @param proc_cls closure for proc
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_STATISTICS_watch (struct GNUNET_STATISTICS_Handle *handle,
+                         const char *subsystem, const char *name,
+                         GNUNET_STATISTICS_Iterator proc, void *proc_cls)
+{
+  struct GNUNET_STATISTICS_WatchEntry *w;
+
+  if (handle == NULL)
+    return GNUNET_SYSERR;
+  w = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_WatchEntry));
+  w->subsystem = GNUNET_strdup (subsystem);
+  w->name = GNUNET_strdup (name);
+  w->proc = proc;
+  w->proc_cls = proc_cls;
+  GNUNET_array_append (handle->watches, handle->watches_size, w);
+  schedule_watch_request (handle, w);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Stop watching statistics from the peer.  
+ *
+ * @param handle identification of the statistics service
+ * @param subsystem limit to the specified subsystem, never NULL
+ * @param name name of the statistic value, never NULL
+ * @param proc function to call on each value
+ * @param proc_cls closure for proc
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error (no such watch)
+ */
+int
+GNUNET_STATISTICS_watch_cancel (struct GNUNET_STATISTICS_Handle *handle,
+				const char *subsystem, const char *name,
+				GNUNET_STATISTICS_Iterator proc, void *proc_cls)
+{
+  struct GNUNET_STATISTICS_WatchEntry *w;
+  unsigned int i;
+
+  if (handle == NULL)
+    return GNUNET_SYSERR;
+  for (i=0;i<handle->watches_size;i++)
+  {
+    w = handle->watches[i];
+    if ( (w->proc == proc) &&
+	 (w->proc_cls == proc_cls) &&
+	 (0 == strcmp (w->name, name)) &&
+	 (0 == strcmp (w->subsystem, subsystem)) )
+    {
+      GNUNET_free (w->name);
+      GNUNET_free (w->subsystem);
+      GNUNET_free (w);
+      handle->watches[i] = NULL;      
+      return GNUNET_OK;
+    }	 
+  }
+  return GNUNET_SYSERR;
+}
+
+
+
+/**
+ * Queue a request to change a statistic.
+ *
+ * @param h statistics handle
+ * @param name name of the value
+ * @param make_persistent  should the value be kept across restarts?
+ * @param value new value or change
+ * @param type type of the action (ACTION_SET or ACTION_UPDATE)
+ */
+static void
+add_setter_action (struct GNUNET_STATISTICS_Handle *h, const char *name,
+                   int make_persistent, uint64_t value, enum ActionType type)
+{
+  struct GNUNET_STATISTICS_GetHandle *ai;
+  size_t slen;
+  size_t nlen;
+  size_t nsize;
+  int64_t delta;
+
+  GNUNET_assert (h != NULL);
+  GNUNET_assert (name != NULL);
+  slen = strlen (h->subsystem) + 1;
+  nlen = strlen (name) + 1;
+  nsize = sizeof (struct GNUNET_STATISTICS_SetMessage) + slen + nlen;
+  if (nsize >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  for (ai = h->action_head; ai != NULL; ai = ai->next)
+  {
+    if (! ( (0 == strcmp (ai->subsystem, h->subsystem)) &&
+	    (0 == strcmp (ai->name, name)) && 
+	    ( (ai->type == ACTION_UPDATE) ||
+	      (ai->type == ACTION_SET) ) ) )
+      continue;
+    if (ai->type == ACTION_SET)
+    {
+      if (type == ACTION_UPDATE)
+      {
+	delta = (int64_t) value;
+	if (delta > 0)
+        {
+	  /* update old set by new delta */
+	  ai->value += delta;
+	}
+	else
+        {
+	  /* update old set by new delta, but never go negative */
+	  if (ai->value < -delta)
+	    ai->value = 0;
+	  else
+	    ai->value += delta;
+	}
+      }
+      else
+      {
+	/* new set overrides old set */
+	ai->value = value;
+      }
+    }
+    else
+    {
+      if (type == ACTION_UPDATE)
+      {
+	/* make delta cummulative */
+	delta = (int64_t) value;
+	ai->value += delta;
+      }
+      else
+      {
+	/* drop old 'update', use new 'set' instead */
+	ai->value = value;
+	ai->type = type;
+      }
+    }
+    ai->timeout = GNUNET_TIME_relative_to_absolute (SET_TRANSMIT_TIMEOUT);
+    ai->make_persistent = make_persistent;
+    return;  
+  }
+  /* no existing entry matches, create a fresh one */
+  ai = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_GetHandle));
+  ai->sh = h;
+  ai->subsystem = GNUNET_strdup (h->subsystem);
+  ai->name = GNUNET_strdup (name);
+  ai->timeout = GNUNET_TIME_relative_to_absolute (SET_TRANSMIT_TIMEOUT);
+  ai->make_persistent = make_persistent;
+  ai->msize = nsize;
+  ai->value = value;
+  ai->type = type;
+  GNUNET_CONTAINER_DLL_insert_tail (h->action_head, h->action_tail,
+				    ai);
+  schedule_action (h);
+}
+
+
+/**
+ * Set statistic value for the peer.  Will always use our
+ * subsystem (the argument used when "handle" was created).
+ *
+ * @param handle identification of the statistics service
+ * @param name name of the statistic value
+ * @param value new value to set
+ * @param make_persistent should the value be kept across restarts?
+ */
+void
+GNUNET_STATISTICS_set (struct GNUNET_STATISTICS_Handle *handle,
+                       const char *name, uint64_t value, int make_persistent)
+{
+  if (handle == NULL)
+    return;
+  GNUNET_assert (GNUNET_NO == handle->do_destroy);
+  add_setter_action (handle, name, make_persistent, value, ACTION_SET);
+}
+
+
+/**
+ * Set statistic value for the peer.  Will always use our
+ * subsystem (the argument used when "handle" was created).
+ *
+ * @param handle identification of the statistics service
+ * @param name name of the statistic value
+ * @param delta change in value (added to existing value)
+ * @param make_persistent should the value be kept across restarts?
+ */
+void
+GNUNET_STATISTICS_update (struct GNUNET_STATISTICS_Handle *handle,
+                          const char *name, int64_t delta, int make_persistent)
+{
+  if (handle == NULL)
+    return;
+  if (delta == 0)
+    return;
+  GNUNET_assert (GNUNET_NO == handle->do_destroy);
+  add_setter_action (handle, name, make_persistent, (uint64_t) delta,
+                     ACTION_UPDATE);
+}
+
+
+/* end of statistics_api.c */