API for peerstore. More...

#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"

Include dependency graph for peerstore_api.c:

Data Structures
struct	GNUNET_PEERSTORE_Handle
	Handle to the PEERSTORE service. More...

struct	GNUNET_PEERSTORE_StoreHelloContext
	Context for a add hello uri request. More...

struct	GNUNET_PEERSTORE_StoreContext
	Context for a store request. More...

struct	StoreHelloCls
	Closure for store callback when storing hello uris. More...

struct	GNUNET_PEERSTORE_IterateContext
	Context for a iterate request. More...

struct	GNUNET_PEERSTORE_NotifyContext
	Context for the info handler. More...

Macros
#define	LOG(kind, ...) GNUNET_log_from (kind, "peerstore-api", __VA_ARGS__)

Functions
static void	reconnect (void *cls)
	Close the existing connection to PEERSTORE and reconnect.

static uint32_t	get_op_id (struct GNUNET_PEERSTORE_Handle *h)
	Get a fresh operation id to distinguish between namestore requests.

static void	flush_pending_operations (struct GNUNET_PEERSTORE_Handle *h, int notify)
	Terminate every operation still pending on h.

static void	disconnect (struct GNUNET_PEERSTORE_Handle *h)
	Disconnect from the peerstore service.

static void	disconnect_and_schedule_reconnect (struct GNUNET_PEERSTORE_Handle *h)
	Function that will schedule the job that will try to connect us again to the client.

static void	handle_client_error (void *cls, enum GNUNET_MQ_Error error)
	Function called when we had trouble talking to the service.

struct GNUNET_PEERSTORE_Handle *	GNUNET_PEERSTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Connect to the PEERSTORE service.

void	GNUNET_PEERSTORE_disconnect (struct GNUNET_PEERSTORE_Handle *h)
	Disconnect from the PEERSTORE service.

static void	destroy_storecontext (struct GNUNET_PEERSTORE_StoreContext *sc)

void	GNUNET_PEERSTORE_store_cancel (struct GNUNET_PEERSTORE_StoreContext *sc)
	Cancel a store request.

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)
	Store a new entry in the PEERSTORE.

static void	handle_store_result (void cls, const struct PeerstoreResultMessage msg)
	When a response for store request is received.

static void	destroy_iteratecontext (struct GNUNET_PEERSTORE_IterateContext *ic)

static void	handle_iterate_end (void cls, const struct PeerstoreResultMessage msg)
	When a response for iterate request is received.

static int	check_iterate_result (void cls, const struct PeerstoreRecordMessage msg)
	When a response for iterate request is received, check the message is well-formed.

static void	handle_iterate_result (void cls, const struct PeerstoreRecordMessage msg)
	When a response for iterate request is received.

void	GNUNET_PEERSTORE_iteration_next (struct GNUNET_PEERSTORE_IterateContext *ic, uint64_t limit)
	Cancel an iterate request Please do not call after the iterate request is done.

void	GNUNET_PEERSTORE_iteration_stop (struct GNUNET_PEERSTORE_IterateContext *ic)
	Cancel an iterate request Please do not call after the iterate request is done.

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)
	Iterate over peerstore entries.

static void	hello_store_success (void *cls, int success)

static void	hello_add_iter (void cls, const struct GNUNET_PEERSTORE_Record record, const char *emsg)

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)
	Add hello to peerstore.

void	GNUNET_PEERSTORE_hello_add_cancel (struct GNUNET_PEERSTORE_StoreHelloContext *huc)
	Cancel the request to add a hello.

Detailed Description

API for peerstore.

Author: Omar Tarabai; Christian Grothoff; Martin Schanzenbach

Definition in file peerstore_api.c.

Macro Definition Documentation

◆ LOG

#define LOG	(	kind,
		...
	)	GNUNET_log_from (kind, "peerstore-api", __VA_ARGS__)

Definition at line 34 of file peerstore_api.c.

Function Documentation

◆ reconnect()

static void reconnect ( void * cls )

static

Close the existing connection to PEERSTORE and reconnect.

Parameters

cls	a `struct GNUNET_PEERSTORE_Handle *h`
cls	a `struct GNUNET_PEERSTORE_Handle *`

Definition at line 915 of file peerstore_api.c.

{
  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);
  }
}

References GNUNET_ARM_Handle::cfg, env, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END, GNUNET_MESSAGE_TYPE_PEERSTORE_RECORD, GNUNET_MESSAGE_TYPE_PEERSTORE_STORE_RESULT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_send(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, h, handle_client_error(), LOG, GNUNET_ARM_Handle::mq, reconnect(), GNUNET_ARM_Handle::reconnect_task, and sc.

Here is the call graph for this function:

◆ get_op_id()

static uint32_t get_op_id ( struct GNUNET_PEERSTORE_Handle * h )

static

Get a fresh operation id to distinguish between namestore requests.

Parameters

h	the namestore handle

Returns: next operation id to use

Definition at line 343 of file peerstore_api.c.

{
  return h->last_op_id++;
}

References h.

Referenced by GNUNET_PEERSTORE_iteration_start(), and GNUNET_PEERSTORE_store().

Here is the caller graph for this function:

◆ flush_pending_operations()

static void flush_pending_operations	(	struct GNUNET_PEERSTORE_Handle *	h,
		int	notify
	)

static

Terminate every operation still pending on h.

The service tracks operations by request id on a per-connection basis, so once the connection is gone nothing can be resumed: an operation that is merely dropped leaves its caller waiting for a callback that can never arrive. disconnect() asserts that both lists are empty, which is what this establishes.

Parameters

h	handle whose operations to terminate
notify	GNUNET_YES to report the outcome to each waiter (we lost the connection), GNUNET_NO to release them silently (our caller is going away and its closures may be gone already)

Definition at line 364 of file peerstore_api.c.

{
  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;
  }
}

References GNUNET_PEERSTORE_IterateContext::callback, GNUNET_PEERSTORE_IterateContext::callback_cls, GNUNET_PEERSTORE_IterateContext::env, GNUNET_free, GNUNET_MQ_discard(), GNUNET_SYSERR, GNUNET_YES, h, GNUNET_PEERSTORE_IterateContext::key, GNUNET_PEERSTORE_StoreContext::next, GNUNET_PEERSTORE_IterateContext::next, sc, and GNUNET_PEERSTORE_IterateContext::sub_system.

Referenced by disconnect_and_schedule_reconnect(), and GNUNET_PEERSTORE_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disconnect()

static void disconnect ( struct GNUNET_PEERSTORE_Handle * h )

static

Disconnect from the peerstore service.

Parameters

h	peerstore handle to disconnect

Definition at line 419 of file peerstore_api.c.

{
  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;
  }
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_MQ_destroy(), h, and GNUNET_ARM_Handle::mq.

Referenced by disconnect_and_schedule_reconnect(), and GNUNET_PEERSTORE_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disconnect_and_schedule_reconnect()

static void disconnect_and_schedule_reconnect ( struct GNUNET_PEERSTORE_Handle * h )

static

Function that will schedule the job that will try to connect us again to the client.

Parameters

h	peerstore to reconnect

Definition at line 443 of file peerstore_api.c.

{
  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);
}

References disconnect(), flush_pending_operations(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_STD_BACKOFF, GNUNET_YES, h, LOG, GNUNET_ARM_Handle::mq, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by handle_client_error().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_client_error()

static void handle_client_error	(	void *	cls,
		enum GNUNET_MQ_Error	error
	)

static

Function called when we had trouble talking to the service.

Definition at line 477 of file peerstore_api.c.

{
  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);
}

References disconnect_and_schedule_reconnect(), GNUNET_ERROR_TYPE_ERROR, h, and LOG.

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_storecontext()

static void destroy_storecontext ( struct GNUNET_PEERSTORE_StoreContext * sc )

static

Definition at line 551 of file peerstore_api.c.

{
  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);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_FS_SearchContext::h, and sc.

Referenced by GNUNET_PEERSTORE_store_cancel(), and handle_store_result().

Here is the caller graph for this function:

◆ handle_store_result()

static void handle_store_result	(	void *	cls,
		const struct PeerstoreResultMessage *	msg
	)

static

When a response for store request is received.

Parameters

cls	a `struct GNUNET_PEERSTORE_Handle *`
msg	message received

Definition at line 660 of file peerstore_api.c.

{
  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);
}

References destroy_storecontext(), GNUNET_ERROR_TYPE_DEBUG, h, LOG, msg, and sc.

Here is the call graph for this function:

◆ destroy_iteratecontext()

static void destroy_iteratecontext ( struct GNUNET_PEERSTORE_IterateContext * ic )

static

Definition at line 699 of file peerstore_api.c.

{
  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);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_PEERSTORE_IterateContext::h, GNUNET_PEERSTORE_Handle::iterate_head, GNUNET_PEERSTORE_Handle::iterate_tail, GNUNET_PEERSTORE_IterateContext::key, and GNUNET_PEERSTORE_IterateContext::sub_system.

Referenced by GNUNET_PEERSTORE_iteration_stop(), and handle_iterate_end().

Here is the caller graph for this function:

◆ handle_iterate_end()

static void handle_iterate_end	(	void *	cls,
		const struct PeerstoreResultMessage *	msg
	)

static

When a response for iterate request is received.

Parameters

cls	a `struct GNUNET_PEERSTORE_Handle *`
msg	message received

Definition at line 715 of file peerstore_api.c.

{
  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);
}

References _, GNUNET_PEERSTORE_IterateContext::callback, GNUNET_PEERSTORE_IterateContext::callback_cls, destroy_iteratecontext(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, h, LOG, msg, GNUNET_PEERSTORE_IterateContext::next, and GNUNET_PEERSTORE_IterateContext::rid.

Here is the call graph for this function:

◆ check_iterate_result()

static int check_iterate_result	(	void *	cls,
		const struct PeerstoreRecordMessage *	msg
	)

static

When a response for iterate request is received, check the message is well-formed.

Parameters

cls	a `struct GNUNET_PEERSTORE_Handle *`
msg	message received

Definition at line 744 of file peerstore_api.c.

{
  /* we defer validation to #handle_iterate_result */
  return GNUNET_OK;
}

References GNUNET_OK.

◆ handle_iterate_result()

static void handle_iterate_result	(	void *	cls,
		const struct PeerstoreRecordMessage *	msg
	)

static

When a response for iterate request is received.

Parameters

cls	a `struct GNUNET_PEERSTORE_Handle *`
msg	message received

Definition at line 758 of file peerstore_api.c.

{
  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);
}

References _, GNUNET_PEERSTORE_IterateContext::callback, GNUNET_PEERSTORE_IterateContext::callback_cls, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_PEERSTORE_iteration_stop(), h, LOG, msg, GNUNET_PEERSTORE_IterateContext::next, PEERSTORE_destroy_record(), PEERSTORE_parse_record_message(), record(), and GNUNET_PEERSTORE_IterateContext::rid.

Here is the call graph for this function:

◆ hello_store_success()

static void hello_store_success	(	void *	cls,
		int	success
	)

static

Definition at line 979 of file peerstore_api.c.

{
  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);
}

References GNUNET_PEERSTORE_StoreHelloContext::cont, GNUNET_PEERSTORE_StoreHelloContext::cont_cls, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_OK, GNUNET_PEERSTORE_StoreHelloContext::hello, LOG, and GNUNET_PEERSTORE_StoreHelloContext::sc.

Referenced by hello_add_iter().

Here is the caller graph for this function:

◆ hello_add_iter()

static void hello_add_iter	(	void *	cls,
		const struct GNUNET_PEERSTORE_Record *	record,
		const char *	emsg
	)

static

If we ever get here, we are newer than the existing record or the only/first record.

Definition at line 1000 of file peerstore_api.c.

{
  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);
}

References GNUNET_PEERSTORE_StoreHelloContext::cont, GNUNET_PEERSTORE_StoreHelloContext::cont_cls, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_get_expiration_time_from_msg(), GNUNET_i2s(), GNUNET_OK, GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_iteration_next(), GNUNET_PEERSTORE_iteration_stop(), GNUNET_PEERSTORE_store(), GNUNET_PEERSTORE_STOREOPTION_REPLACE, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_cmp, GNUNET_PEERSTORE_StoreHelloContext::h, GNUNET_PEERSTORE_StoreHelloContext::hello, hello_store_success(), GNUNET_PEERSTORE_StoreHelloContext::ic, LOG, GNUNET_PEERSTORE_StoreHelloContext::pid, record(), GNUNET_PEERSTORE_StoreHelloContext::sc, and GNUNET_MessageHeader::size.

Referenced by GNUNET_PEERSTORE_hello_add().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG

Function Documentation

◆ reconnect()

◆ get_op_id()

◆ flush_pending_operations()

◆ disconnect()

◆ disconnect_and_schedule_reconnect()

◆ handle_client_error()

◆ destroy_storecontext()

◆ handle_store_result()

◆ destroy_iteratecontext()

◆ handle_iterate_end()

◆ check_iterate_result()

◆ handle_iterate_result()

◆ hello_store_success()

◆ hello_add_iter()