peerstore_api.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2013-2016, 2019, 2026 GNUnet e.V.
 
     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     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
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_hello_uri_lib.h"
#include "peerstore.h"
#include "peerstore_common.h"
#include "gnunet_peerstore_service.h"
 
#define LOG(kind, ...) GNUNET_log_from (kind, "peerstore-api", __VA_ARGS__)
 
/******************************************************************************/
/************************      DATA STRUCTURES     ****************************/
/******************************************************************************/
 
struct GNUNET_PEERSTORE_Handle
{
  const struct GNUNET_CONFIGURATION_Handle *cfg;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_PEERSTORE_StoreContext *store_head;
 
  struct GNUNET_PEERSTORE_StoreContext *store_tail;
 
  struct GNUNET_PEERSTORE_IterateContext *iterate_head;
 
  struct GNUNET_PEERSTORE_IterateContext *iterate_tail;
 
  struct GNUNET_CONTAINER_MultiHashMap *watches;
 
  struct GNUNET_SCHEDULER_Task *reconnect_task;
 
  struct GNUNET_TIME_Relative reconnect_delay;
 
  uint32_t last_op_id;
 
};
 
struct GNUNET_PEERSTORE_StoreHelloContext
{
  struct GNUNET_PEERSTORE_Handle *h;
 
  GNUNET_PEERSTORE_Continuation cont;
 
  void *cont_cls;
 
  struct GNUNET_MessageHeader *hello;
 
  struct GNUNET_PeerIdentity pid;
 
  struct GNUNET_PEERSTORE_StoreContext *sc;
 
  struct GNUNET_PEERSTORE_IterateContext *ic;
};
 
struct GNUNET_PEERSTORE_StoreContext
{
  struct GNUNET_PEERSTORE_StoreContext *next;
 
  struct GNUNET_PEERSTORE_StoreContext *prev;
 
  struct GNUNET_PEERSTORE_Handle *h;
 
  GNUNET_PEERSTORE_Continuation cont;
 
  uint32_t rid;
 
  void *cont_cls;
 
  char *sub_system;
 
  char *key;
 
  void *value;
 
  struct GNUNET_PeerIdentity peer;
 
  size_t size;
 
  struct GNUNET_TIME_Absolute expiry;
 
  enum GNUNET_PEERSTORE_StoreOption options;
 
  struct GNUNET_MQ_Envelope *env;
};
 
struct StoreHelloCls
{
  struct GNUNET_PEERSTORE_StoreContext *sc;
 
  struct GNUNET_PEERSTORE_StoreHelloContext *huc;
};
 
struct GNUNET_PEERSTORE_IterateContext
{
  struct GNUNET_PEERSTORE_IterateContext *next;
 
  struct GNUNET_PEERSTORE_IterateContext *prev;
 
  struct GNUNET_PEERSTORE_Handle *h;
 
  char *sub_system;
 
  struct GNUNET_PeerIdentity peer;
 
  char *key;
 
  GNUNET_PEERSTORE_Processor callback;
 
  void *callback_cls;
 
  uint32_t rid;
 
  struct GNUNET_MQ_Envelope *env;
};
 
 
struct GNUNET_PEERSTORE_NotifyContext
{
  struct GNUNET_PEERSTORE_Handle *h;
 
  GNUNET_PEERSTORE_hello_notify_cb callback;
 
  void *callback_cls;
 
  struct GNUNET_PEERSTORE_Monitor *wc;
 
  unsigned int canceled;
 
  uint32_t rid;
 
};
 
/******************************************************************************/
/*******************             DECLARATIONS             *********************/
/******************************************************************************/
 
static void
reconnect (void *cls);
 
static uint32_t
get_op_id (struct GNUNET_PEERSTORE_Handle *h)
{
  return h->last_op_id++;
}
 
 
static void
flush_pending_operations (struct GNUNET_PEERSTORE_Handle *h, int notify)
{
  struct GNUNET_PEERSTORE_IterateContext *ic;
  struct GNUNET_PEERSTORE_StoreContext *sc;
 
  /* Splice both lists out before running a single callback: a callback may
     legitimately start a new operation -- #hello_add_iter() does -- and that
     one has to survive to be replayed by #reconnect() rather than be flushed
     by the loop we are still inside. */
  ic = h->iterate_head;
  h->iterate_head = NULL;
  h->iterate_tail = NULL;
  sc = h->store_head;
  h->store_head = NULL;
  h->store_tail = NULL;
 
  while (NULL != ic)
  {
    struct GNUNET_PEERSTORE_IterateContext *next = ic->next;
 
    /* A NULL record is the end-of-iteration signal every caller already
       handles by clearing its handle; that is exactly what we need here,
       and unlike an @a emsg it is understood by all of them. */
    if ((GNUNET_YES == notify) && (NULL != ic->callback))
      ic->callback (ic->callback_cls, NULL, NULL);
    if (NULL != ic->env)
      GNUNET_MQ_discard (ic->env);
    GNUNET_free (ic->sub_system);
    GNUNET_free (ic->key);
    GNUNET_free (ic);
    ic = next;
  }
  while (NULL != sc)
  {
    struct GNUNET_PEERSTORE_StoreContext *next = sc->next;
 
    if ((GNUNET_YES == notify) && (NULL != sc->cont))
      sc->cont (sc->cont_cls, GNUNET_SYSERR);
    if (NULL != sc->env)
      GNUNET_MQ_discard (sc->env);
    GNUNET_free (sc->sub_system);
    GNUNET_free (sc->value);
    GNUNET_free (sc->key);
    GNUNET_free (sc);
    sc = next;
  }
}
 
 
static void
disconnect (struct GNUNET_PEERSTORE_Handle *h)
{
  if (NULL != h->watches)
  {
    GNUNET_assert (0 != GNUNET_CONTAINER_multihashmap_size (h->watches));
    GNUNET_CONTAINER_multihashmap_destroy (h->watches);
  }
  GNUNET_assert (NULL == h->iterate_head);
  GNUNET_assert (NULL == h->store_head);
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
}
 
 
static void
disconnect_and_schedule_reconnect (struct GNUNET_PEERSTORE_Handle *h)
{
  GNUNET_assert (NULL == h->reconnect_task);
  /* Tear the MQ down first: a callback in #flush_pending_operations() may
     start a new operation, and with no MQ that operation stashes its
     envelope for #reconnect() to send instead of handing it to a queue we
     are about to destroy. */
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
  /* Without this, #disconnect() below aborts the whole process the moment
     PEERSTORE hiccups while anything at all is in flight. */
  flush_pending_operations (h, GNUNET_YES);
  disconnect (h);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Scheduling task to reconnect to PEERSTORE service in %s.\n",
       GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay, GNUNET_YES));
  h->reconnect_task =
    GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
}
 
 
/******************************************************************************/
/*******************         CONNECTION FUNCTIONS         *********************/
/******************************************************************************/
 
 
static void
handle_client_error (void *cls, enum GNUNET_MQ_Error error)
{
  struct GNUNET_PEERSTORE_Handle *h = cls;
 
  LOG (GNUNET_ERROR_TYPE_ERROR,
       "Received an error notification from MQ of type: %d\n",
       error);
  disconnect_and_schedule_reconnect (h);
}
 
 
struct GNUNET_PEERSTORE_Handle *
GNUNET_PEERSTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  struct GNUNET_PEERSTORE_Handle *h;
 
  h = GNUNET_new (struct GNUNET_PEERSTORE_Handle);
  h->cfg = cfg;
  reconnect (h);
  if (NULL == h->mq)
  {
    /* #reconnect() has scheduled a retry against @a h; freeing the handle
       without cancelling it leaves the scheduler holding a pointer into
       freed memory. */
    if (NULL != h->reconnect_task)
    {
      GNUNET_SCHEDULER_cancel (h->reconnect_task);
      h->reconnect_task = NULL;
    }
    GNUNET_free (h);
    return NULL;
  }
  return h;
}
 
 
void
GNUNET_PEERSTORE_disconnect (struct GNUNET_PEERSTORE_Handle *h)
{
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnect initiated from client.\n");
  if (NULL != h->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (h->reconnect_task);
    h->reconnect_task = NULL;
  }
  /* Silently: the caller is tearing down and the closures behind these
     callbacks may already be gone, so this is not the moment to invoke
     them.  #disconnect() asserts both lists are empty, and until now a
     caller that still had anything in flight -- which, with the request-id
     truncation, was every caller that had ever stored twice -- aborted here
     instead of shutting down. */
  flush_pending_operations (h, GNUNET_NO);
  disconnect (h);
  GNUNET_free (h);
}
 
 
/******************************************************************************/
/*******************            STORE FUNCTIONS           *********************/
/******************************************************************************/
 
static void
destroy_storecontext (struct GNUNET_PEERSTORE_StoreContext *sc)
{
  GNUNET_CONTAINER_DLL_remove (sc->h->store_head, sc->h->store_tail, sc);
  GNUNET_free (sc->sub_system);
  GNUNET_free (sc->value);
  GNUNET_free (sc->key);
  GNUNET_free (sc);
}
 
 
void
GNUNET_PEERSTORE_store_cancel (struct GNUNET_PEERSTORE_StoreContext *sc)
{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "store cancel with sc %p \n",
       sc);
  destroy_storecontext (sc);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "store cancel with sc %p is null\n",
       sc);
}
 
 
struct GNUNET_PEERSTORE_StoreContext *
GNUNET_PEERSTORE_store (struct GNUNET_PEERSTORE_Handle *h,
                        const char *sub_system,
                        const struct GNUNET_PeerIdentity *peer,
                        const char *key,
                        const void *value,
                        size_t size,
                        struct GNUNET_TIME_Absolute expiry,
                        enum GNUNET_PEERSTORE_StoreOption options,
                        GNUNET_PEERSTORE_Continuation cont,
                        void *cont_cls)
{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_PEERSTORE_StoreContext *sc;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Storing value (size: %llu) for subsystem `%s', peer `%s', key `%s'\n",
       (unsigned long long) size,
       sub_system,
       GNUNET_i2s (peer),
       key);
  sc = GNUNET_new (struct GNUNET_PEERSTORE_StoreContext);
  sc->rid = get_op_id (h);
  sc->sub_system = GNUNET_strdup (sub_system);
  GNUNET_assert (NULL != peer);
  sc->peer = *peer;
  sc->key = GNUNET_strdup (key);
  sc->value = GNUNET_memdup (value, size);
  sc->size = size;
  sc->expiry = expiry;
  sc->options = options;
  sc->cont = cont;
  sc->cont_cls = cont_cls;
  sc->h = h;
  ev =
    PEERSTORE_create_record_mq_envelope (sc->rid,
                                         sub_system,
                                         peer,
                                         key,
                                         value,
                                         size,
                                         expiry,
                                         options,
                                         GNUNET_MESSAGE_TYPE_PEERSTORE_STORE);
 
  GNUNET_CONTAINER_DLL_insert_tail (h->store_head, h->store_tail, sc);
  if (NULL == h->mq)
  {
    sc->env = ev;
  }
  else
  {
    GNUNET_MQ_send (h->mq, ev);
  }
  return sc;
}
 
 
static void
handle_store_result (void *cls, const struct PeerstoreResultMessage *msg)
{
  struct GNUNET_PEERSTORE_Handle *h = cls;
  struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Got PeerstoreResultMessage\n");
  for (sc = h->store_head; NULL != sc; sc = sc->next)
  {
    /* @e rid is a uint32_t, written with htonl() by
       #PEERSTORE_create_record_mq_envelope() and echoed back verbatim by
       #store_record_continuation().  Reading it with ntohs() truncated it
       to 16 bits, so the comparison only ever succeeded for rid 0 -- the
       very first operation of the process.  Every store after that lost
       its result: the continuation was never called and the context never
       freed, so #GNUNET_PEERSTORE_store() leaked one context per call and
       callers that wait for their continuation waited forever. */
    if (sc->rid == ntohl (msg->rid))
      break;
  }
  if (NULL == sc)
  {
    /* Routine, not an error: the service has no cancel message, so every
       #GNUNET_PEERSTORE_store_cancel() leaves exactly one result behind
       with nothing left to match it against. */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Store response for an unknown or cancelled request, ignoring.\n");
    return;
  }
  if (NULL != sc->cont)
    sc->cont (sc->cont_cls, ntohl (msg->result));
  destroy_storecontext (sc);
}
 
 
/******************************************************************************/
/*******************           ITERATE FUNCTIONS          *********************/
/******************************************************************************/
 
static void
destroy_iteratecontext (struct GNUNET_PEERSTORE_IterateContext *ic)
{
  GNUNET_CONTAINER_DLL_remove (ic->h->iterate_head, ic->h->iterate_tail, ic);
  GNUNET_free (ic->sub_system);
  GNUNET_free (ic->key);
  GNUNET_free (ic);
}
 
 
static void
handle_iterate_end (void *cls, const struct PeerstoreResultMessage *msg)
{
  struct GNUNET_PEERSTORE_Handle *h = cls;
  struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head;
 
  for (ic = h->iterate_head; NULL != ic; ic = ic->next)
    if (ic->rid == ntohl (msg->rid))
      break;
  if (NULL == ic)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         _ ("Unexpected iteration response.\n"));
    return;
  }
  if (NULL != ic->callback)
    ic->callback (ic->callback_cls, NULL, NULL);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up iteration with rid %u\n", ic->rid);
  destroy_iteratecontext (ic);
}
 
 
static int
check_iterate_result (void *cls, const struct PeerstoreRecordMessage *msg)
{
  /* we defer validation to #handle_iterate_result */
  return GNUNET_OK;
}
 
 
static void
handle_iterate_result (void *cls, const struct PeerstoreRecordMessage *msg)
{
  struct GNUNET_PEERSTORE_Handle *h = cls;
  struct GNUNET_PEERSTORE_IterateContext *ic;
  struct GNUNET_PEERSTORE_Record *record;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RecordMessage\n");
  for (ic = h->iterate_head; NULL != ic; ic = ic->next)
    if (ic->rid == ntohl (msg->rid))
      break;
  if (NULL == ic)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         _ (
           "Unexpected iteration response, no iterating client found, discarding message.\n"));
    return;
  }
  record = PEERSTORE_parse_record_message (msg);
  if (NULL == record)
  {
    /* A NULL record is how #handle_iterate_end() signals that the iteration
       is over and @a ic is gone, and that is how every caller reads it: they
       clear their handle and return.  Passing NULL here without ending the
       iteration therefore left them holding a pointer they believe is dead
       while @a ic was still live, and the ITERATE_END that followed invoked
       the callback a second time -- which trips, for instance,
       #backtalker_monotime_cb()'s `GNUNET_assert (NULL != b->cmc)' in
       transport.  Make the signal mean one thing. */
    if (NULL != ic->callback)
      ic->callback (ic->callback_cls,
                    NULL,
                    _ ("Received a malformed response from service."));
    GNUNET_PEERSTORE_iteration_stop (ic);
    return;
  }
  if (NULL != ic->callback)
    ic->callback (ic->callback_cls, record, NULL);
  PEERSTORE_destroy_record (record);
}
 
 
void
GNUNET_PEERSTORE_iteration_next (struct GNUNET_PEERSTORE_IterateContext *ic,
                                 uint64_t limit)
{
  struct GNUNET_MQ_Envelope *ev;
  struct PeerstoreIterationNextMessage *inm;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending PEERSTORE_ITERATION_NEXT message\n");
  ev = GNUNET_MQ_msg (inm, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_NEXT);
  inm->rid = htonl (ic->rid);
  inm->limit = GNUNET_htonll (limit);
  if (NULL == ic->h->mq)
  {
    ic->env = ev;
  }
  else
  {
    GNUNET_MQ_send (ic->h->mq, ev);
  }
}
 
 
void
GNUNET_PEERSTORE_iteration_stop (struct GNUNET_PEERSTORE_IterateContext *ic)
{
  struct GNUNET_MQ_Envelope *ev;
  struct PeerstoreIterationStopMessage *ism;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending PEERSTORE_ITERATION_STOP message\n");
  if (NULL != ic->h->mq)
  {
    ev = GNUNET_MQ_msg (ism, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_STOP);
    ism->rid = htonl (ic->rid);
    if (NULL != ic->h->mq)
      GNUNET_MQ_send (ic->h->mq, ev);
  }
  destroy_iteratecontext (ic);
}
 
 
struct GNUNET_PEERSTORE_IterateContext *
GNUNET_PEERSTORE_iteration_start (struct GNUNET_PEERSTORE_Handle *h,
                                  const char *sub_system,
                                  const struct GNUNET_PeerIdentity *peer,
                                  const char *key,
                                  GNUNET_PEERSTORE_Processor callback,
                                  void *callback_cls)
{
  struct GNUNET_MQ_Envelope *ev;
  struct PeerstoreIterationStartMessage *srm;
  struct GNUNET_PEERSTORE_IterateContext *ic;
  size_t ss_size;
  size_t key_size;
  size_t msg_size;
  void *dummy;
 
  ic = GNUNET_new (struct GNUNET_PEERSTORE_IterateContext);
  ic->rid = get_op_id (h);
 
  GNUNET_assert (NULL != sub_system);
  ss_size = strlen (sub_system) + 1;
  if (NULL == key)
    key_size = 0;
  else
    key_size = strlen (key) + 1;
  msg_size = ss_size + key_size;
  ev = GNUNET_MQ_msg_extra (srm, msg_size,
                            GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_START);
  srm->key_size = htons (key_size);
  srm->rid = htonl (ic->rid);
  srm->sub_system_size = htons (ss_size);
  dummy = &srm[1];
  GNUNET_memcpy (dummy, sub_system, ss_size);
  dummy += ss_size;
  GNUNET_memcpy (dummy, key, key_size);
  ic->callback = callback;
  ic->callback_cls = callback_cls;
  ic->h = h;
  ic->sub_system = GNUNET_strdup (sub_system);
  if (NULL != peer)
  {
    ic->peer = *peer;
    srm->peer_set = htons (GNUNET_YES);
    srm->peer = *peer;
  }
  if (NULL != key)
    ic->key = GNUNET_strdup (key);
  GNUNET_CONTAINER_DLL_insert_tail (h->iterate_head, h->iterate_tail, ic);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending an iterate request for sub system `%s'\n",
       sub_system);
  GNUNET_MQ_send (h->mq, ev);
  return ic;
}
 
 
static void
reconnect (void *cls)
{
  struct GNUNET_PEERSTORE_Handle *h = cls;
  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
    GNUNET_MQ_hd_fixed_size (iterate_end,
                             GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END,
                             struct PeerstoreResultMessage,
                             h),
    GNUNET_MQ_hd_fixed_size (store_result,
                             GNUNET_MESSAGE_TYPE_PEERSTORE_STORE_RESULT,
                             struct PeerstoreResultMessage,
                             h),
    GNUNET_MQ_hd_var_size (iterate_result,
                           GNUNET_MESSAGE_TYPE_PEERSTORE_RECORD,
                           struct PeerstoreRecordMessage,
                           h),
    GNUNET_MQ_handler_end ()
  };
 
  h->reconnect_task = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting...\n");
  h->mq = GNUNET_CLIENT_connect (h->cfg,
                                 "peerstore",
                                 mq_handlers,
                                 &handle_client_error,
                                 h);
  if (NULL == h->mq)
  {
    h->reconnect_task =
      GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
    h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Resending pending requests after reconnect.\n");
  /* Only requests that were created while we had no MQ carry a stashed
     envelope; everything else was handed to the MQ directly and no longer
     exists.  Sending NULL dereferences it, and sending the same envelope
     twice (a second reconnect) uses it after the MQ freed it -- so take
     each envelope exactly once. */
  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
       ic = ic->next)
  {
    struct GNUNET_MQ_Envelope *env = ic->env;
 
    if (NULL == env)
      continue;
    ic->env = NULL;
    GNUNET_MQ_send (h->mq, env);
  }
  for (struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head; NULL != sc;
       sc = sc->next)
  {
    struct GNUNET_MQ_Envelope *env = sc->env;
 
    if (NULL == env)
      continue;
    sc->env = NULL;
    GNUNET_MQ_send (h->mq, env);
  }
}
 
 
static void
hello_store_success (void *cls, int success)
{
  struct GNUNET_PEERSTORE_StoreHelloContext *huc = cls;
 
  huc->sc = NULL;
  if (GNUNET_OK != success)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Storing hello uri failed\n");
    huc->cont (huc->cont_cls, success);
    GNUNET_free (huc->hello);
    GNUNET_free (huc);
    return;
  }
  huc->cont (huc->cont_cls, GNUNET_OK);
  GNUNET_free (huc->hello);
  GNUNET_free (huc);
}
 
 
static void
hello_add_iter (void *cls, const struct GNUNET_PEERSTORE_Record *record,
                const char *emsg)
{
  struct GNUNET_PEERSTORE_StoreHelloContext *huc = cls;
  struct GNUNET_TIME_Absolute hello_exp =
    GNUNET_HELLO_get_expiration_time_from_msg (huc->hello);
  struct GNUNET_TIME_Absolute hello_record_exp;
 
  if ((NULL == record) && (NULL == emsg))
  {
    /* The iteration ended with this call and @e ic is about to be freed by
       #handle_iterate_end(); keeping the pointer would leave
       #GNUNET_PEERSTORE_hello_add_cancel() stopping a dead iteration. */
    huc->ic = NULL;
    huc->sc = GNUNET_PEERSTORE_store (huc->h,
                                      "peerstore",
                                      &huc->pid,
                                      GNUNET_PEERSTORE_HELLO_KEY,
                                      huc->hello,
                                      ntohs (huc->hello->size),
                                      hello_exp,
                                      GNUNET_PEERSTORE_STOREOPTION_REPLACE,
                                      &hello_store_success,
                                      huc);
    return;
  }
  if (NULL != emsg)
  {
    /* @a emsg only ever accompanies a NULL record, which ends the iteration
       and destroys @e ic.  Asking for another record here used a context
       that no longer exists, and left @a huc -- and our caller's
       continuation -- hanging forever. */
    LOG (GNUNET_ERROR_TYPE_ERROR, "%s\n", emsg);
    huc->ic = NULL;
    huc->cont (huc->cont_cls, GNUNET_SYSERR);
    GNUNET_free (huc->hello);
    GNUNET_free (huc);
    return;
  }
  hello_record_exp = GNUNET_HELLO_get_expiration_time_from_msg (record->value);
  if (GNUNET_TIME_absolute_cmp (hello_record_exp, >, hello_exp))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Not storing hello for %s since we seem to have a newer version on record expiring `%s' and after `%s'.\n",
         GNUNET_i2s (&huc->pid),
         GNUNET_STRINGS_absolute_time_to_string (hello_record_exp),
         GNUNET_STRINGS_absolute_time_to_string (hello_exp));
    huc->cont (huc->cont_cls, GNUNET_OK);
    GNUNET_PEERSTORE_iteration_stop (huc->ic);
    GNUNET_free (huc->hello);
    GNUNET_free (huc);
    return;
  }
  GNUNET_PEERSTORE_iteration_next (huc->ic, 1);
}
 
 
struct GNUNET_PEERSTORE_StoreHelloContext *
GNUNET_PEERSTORE_hello_add (struct GNUNET_PEERSTORE_Handle *h,
                            const struct GNUNET_MessageHeader *msg,
                            GNUNET_PEERSTORE_Continuation cont,
                            void *cont_cls)
{
  struct GNUNET_HELLO_Parser *parser = GNUNET_HELLO_parser_from_msg (msg, NULL);
  struct GNUNET_PEERSTORE_StoreHelloContext *huc;
  const struct GNUNET_PeerIdentity *pid;
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
  struct GNUNET_TIME_Absolute hello_exp =
    GNUNET_HELLO_get_expiration_time_from_msg (msg);
  struct GNUNET_TIME_Absolute huc_exp;
  uint16_t size_msg = ntohs (msg->size);
 
  if (NULL == parser)
    return NULL;
  if (GNUNET_TIME_absolute_cmp (hello_exp, <, now))
  {
    GNUNET_HELLO_parser_free (parser);
    return NULL;
  }
 
  huc = GNUNET_new (struct GNUNET_PEERSTORE_StoreHelloContext);
  huc->h = h;
  huc->cont = cont;
  huc->cont_cls = cont_cls;
  huc->hello = GNUNET_malloc (size_msg);
  GNUNET_memcpy (huc->hello, msg, size_msg);
  huc_exp =
    GNUNET_HELLO_get_expiration_time_from_msg (huc->hello);
  pid = GNUNET_HELLO_parser_get_id (parser);
  huc->pid = *pid;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Adding hello for peer %s with expiration %s msg size %u\n",
       GNUNET_i2s (&huc->pid),
       GNUNET_STRINGS_absolute_time_to_string (huc_exp),
       size_msg);
 
  huc->ic = GNUNET_PEERSTORE_iteration_start (h, "peerstore", &huc->pid,
                                              GNUNET_PEERSTORE_HELLO_KEY,
                                              &hello_add_iter,
                                              huc);
  GNUNET_HELLO_parser_free (parser);
  return huc;
}
 
 
void
GNUNET_PEERSTORE_hello_add_cancel (struct
                                   GNUNET_PEERSTORE_StoreHelloContext *huc)
{
  if (NULL != huc->sc)
    GNUNET_PEERSTORE_store_cancel (huc->sc);
  if (NULL != huc->ic)
    GNUNET_PEERSTORE_iteration_stop (huc->ic);
  GNUNET_free (huc->hello);
  GNUNET_free (huc);
}
 
 
/* end of peerstore_api.c */