peerstore_api.c File Reference

API for peerstore. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "peerstore.h"
#include "peerstore_common.h"

Include dependency graph for peerstore_api.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_PEERSTORE_Handle
	Handle to the PEERSTORE service. More...
struct	GNUNET_PEERSTORE_StoreContext
	Context for a store request. More...
struct	GNUNET_PEERSTORE_IterateContext
	Context for a iterate request. More...
struct	GNUNET_PEERSTORE_WatchContext
	Context for a watch request. 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. More...
static void	disconnect (struct GNUNET_PEERSTORE_Handle *h)
	Disconnect from the peerstore service. More...
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. More...
static void	store_request_sent (void *cls)
	Callback after MQ envelope is sent. More...
static void	handle_client_error (void *cls, enum GNUNET_MQ_Error error)
	Function called when we had trouble talking to the service. More...
static int	rewatch_it (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator over previous watches to resend them. More...
static int	destroy_watch (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator over watch requests to cancel them. More...
static void	final_disconnect (struct GNUNET_PEERSTORE_Handle *h)
	Kill the connection to the service. More...
struct GNUNET_PEERSTORE_Handle *	GNUNET_PEERSTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Connect to the PEERSTORE service. More...
void	GNUNET_PEERSTORE_disconnect (struct GNUNET_PEERSTORE_Handle *h, int sync_first)
	Disconnect from the PEERSTORE service. More...
void	GNUNET_PEERSTORE_store_cancel (struct GNUNET_PEERSTORE_StoreContext *sc)
	Cancel a store request. More...
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. More...
static void	handle_iterate_end (void *cls, const struct GNUNET_MessageHeader *msg)
	When a response for iterate request is received. More...
static int	check_iterate_result (void *cls, const struct StoreRecordMessage *msg)
	When a response for iterate request is received, check the message is well-formed. More...
static void	handle_iterate_result (void *cls, const struct StoreRecordMessage *msg)
	When a response for iterate request is received. More...
void	GNUNET_PEERSTORE_iterate_cancel (struct GNUNET_PEERSTORE_IterateContext *ic)
	Cancel an iterate request Please do not call after the iterate request is done. More...
struct GNUNET_PEERSTORE_IterateContext *	GNUNET_PEERSTORE_iterate (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 records matching supplied key information. More...
static int	check_watch_record (void *cls, const struct StoreRecordMessage *msg)
	When a watch record is received, validate it is well-formed. More...
static void	handle_watch_record (void *cls, const struct StoreRecordMessage *msg)
	When a watch record is received, process it. More...
void	GNUNET_PEERSTORE_watch_cancel (struct GNUNET_PEERSTORE_WatchContext *wc)
	Cancel a watch request. More...
struct GNUNET_PEERSTORE_WatchContext *	GNUNET_PEERSTORE_watch (struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_PEERSTORE_Processor callback, void *callback_cls)
	Request watching a given key User will be notified with any new values added to key. More...

Detailed Description

API for peerstore.

Author

Omar Tarabai

Christian Grothoff

Definition in file peerstore_api.c.

Macro Definition Documentation

LOG

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

Definition at line 31 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 798 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 GNUNET_MessageHeader,
                             h),
    GNUNET_MQ_hd_var_size (iterate_result,
                           GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD,
                           struct StoreRecordMessage,
                           h),
    GNUNET_MQ_hd_var_size (watch_record,
                           GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD,
                           struct StoreRecordMessage,
                           h),
    GNUNET_MQ_handler_end () };
  struct GNUNET_MQ_Envelope *ev;
 
  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");
  if (NULL != h->watches)
    GNUNET_CONTAINER_multihashmap_iterate (h->watches, &rewatch_it, h);
  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
       ic = ic->next)
  {
    ev =
      PEERSTORE_create_record_mq_envelope (ic->sub_system,
                                           &ic->peer,
                                           ic->key,
                                           NULL,
                                           0,
                                           GNUNET_TIME_UNIT_FOREVER_ABS,
                                           0,
                                           GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE);
    GNUNET_MQ_send (h->mq, ev);
  }
  for (struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head; NULL != sc;
       sc = sc->next)
  {
    ev =
      PEERSTORE_create_record_mq_envelope (sc->sub_system,
                                           &sc->peer,
                                           sc->key,
                                           sc->value,
                                           sc->size,
                                           sc->expiry,
                                           sc->options,
                                           GNUNET_MESSAGE_TYPE_PEERSTORE_STORE);
    GNUNET_MQ_notify_sent (ev, &store_request_sent, sc);
    GNUNET_MQ_send (h->mq, ev);
  }
}

References GNUNET_ARM_Handle::cfg, GNUNET_CLIENT_connect(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD, GNUNET_MESSAGE_TYPE_PEERSTORE_STORE, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, GNUNET_TIME_UNIT_FOREVER_ABS, h, handle_client_error(), LOG, GNUNET_ARM_Handle::mq, GNUNET_FS_SearchContext::options, PEERSTORE_create_record_mq_envelope(), GNUNET_ARM_Handle::reconnect_task, rewatch_it(), sc, and store_request_sent().

Referenced by disconnect_and_schedule_reconnect(), and GNUNET_PEERSTORE_connect().

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 265 of file peerstore_api.c.

{
  struct GNUNET_PEERSTORE_IterateContext *next;
 
  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
       ic = next)
  {
    next = ic->next;
    if (GNUNET_YES == ic->iterating)
    {
      GNUNET_PEERSTORE_Processor icb;
      void *icb_cls;
 
      icb = ic->callback;
      icb_cls = ic->callback_cls;
      GNUNET_PEERSTORE_iterate_cancel (ic);
      if (NULL != icb)
        icb (icb_cls, NULL, "Iteration canceled due to reconnection");
    }
  }
 
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
}

References GNUNET_MQ_destroy(), GNUNET_PEERSTORE_iterate_cancel(), GNUNET_YES, h, GNUNET_ARM_Handle::mq, and GNUNET_PEERSTORE_IterateContext::next.

Referenced by disconnect_and_schedule_reconnect(), and reconnect().

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 301 of file peerstore_api.c.

{
  GNUNET_assert (NULL == h->reconnect_task);
  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(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_STD_BACKOFF, GNUNET_YES, h, LOG, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by handle_client_error(), handle_iterate_end(), handle_iterate_result(), and handle_watch_record().

Here is the call graph for this function:

Here is the caller graph for this function:

store_request_sent()

static void store_request_sent ( void *  cls )

static

Callback after MQ envelope is sent.

Parameters

cls	a struct GNUNET_PEERSTORE_StoreContext *

Definition at line 320 of file peerstore_api.c.

{
  struct GNUNET_PEERSTORE_StoreContext *sc = cls;
  GNUNET_PEERSTORE_Continuation cont;
  void *cont_cls;
 
  if (NULL != sc)
  {
    cont = sc->cont;
    cont_cls = sc->cont_cls;
    GNUNET_PEERSTORE_store_cancel (sc);
    if (NULL != cont)
      cont (cont_cls, GNUNET_OK);
  }
}

References GNUNET_PEERSTORE_StoreContext::cont, GNUNET_PEERSTORE_StoreContext::cont_cls, GNUNET_OK, GNUNET_PEERSTORE_store_cancel(), and sc.

Referenced by GNUNET_PEERSTORE_store(), and reconnect().

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 346 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:

rewatch_it()

static int rewatch_it ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterator over previous watches to resend them.

Parameters

cls	the struct GNUNET_PEERSTORE_Handle
key	key for the watch
value	the struct GNUNET_PEERSTORE_WatchContext *

Returns

GNUNET_YES (continue to iterate)

Definition at line 366 of file peerstore_api.c.

{
  struct GNUNET_PEERSTORE_Handle *h = cls;
  struct GNUNET_PEERSTORE_WatchContext *wc = value;
  struct StoreKeyHashMessage *hm;
  struct GNUNET_MQ_Envelope *ev;
 
  ev = GNUNET_MQ_msg (hm, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH);
  hm->keyhash = wc->keyhash;
  GNUNET_MQ_send (h->mq, ev);
  return GNUNET_YES;
}

References GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_YES, h, StoreKeyHashMessage::keyhash, GNUNET_PEERSTORE_WatchContext::keyhash, GNUNET_ARM_Handle::mq, and value.

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_watch()

static int destroy_watch ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterator over watch requests to cancel them.

Parameters

cls	unused
key	key to the watch request
value	watch context

Returns

GNUNET_YES to continue iteration

Definition at line 389 of file peerstore_api.c.

{
  struct GNUNET_PEERSTORE_WatchContext *wc = value;
 
  GNUNET_PEERSTORE_watch_cancel (wc);
  return GNUNET_YES;
}

References GNUNET_PEERSTORE_watch_cancel(), GNUNET_YES, and value.

Referenced by GNUNET_PEERSTORE_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

final_disconnect()

static void final_disconnect ( struct GNUNET_PEERSTORE_Handle *  h )

static

Kill the connection to the service.

This can be delayed in case of pending STORE requests and the user explicitly asked to sync first. Otherwise it is performed instantly.

Parameters

h	Handle to the service.

Definition at line 406 of file peerstore_api.c.

{
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
  GNUNET_free (h);
}

References GNUNET_free, GNUNET_MQ_destroy(), h, and GNUNET_ARM_Handle::mq.

Referenced by GNUNET_PEERSTORE_disconnect(), and GNUNET_PEERSTORE_store_cancel().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_iterate_end()

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

static

When a response for iterate request is received.

Parameters

cls	a struct GNUNET_PEERSTORE_Handle *
msg	message received

Definition at line 592 of file peerstore_api.c.

{
  struct GNUNET_PEERSTORE_Handle *h = cls;
  struct GNUNET_PEERSTORE_IterateContext *ic;
  GNUNET_PEERSTORE_Processor callback;
  void *callback_cls;
 
  ic = h->iterate_head;
  if (NULL == ic)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Unexpected iteration response, this should not happen.\n"));
    disconnect_and_schedule_reconnect (h);
    return;
  }
  callback = ic->callback;
  callback_cls = ic->callback_cls;
  ic->iterating = GNUNET_NO;
  GNUNET_PEERSTORE_iterate_cancel (ic);
  /* NOTE: set this here and not after callback because callback may free h */
  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
  if (NULL != callback)
    callback (callback_cls, NULL, NULL);
}

References _, GNUNET_PEERSTORE_IterateContext::callback, GNUNET_PEERSTORE_IterateContext::callback_cls, disconnect_and_schedule_reconnect(), GNUNET_ERROR_TYPE_ERROR, GNUNET_NO, GNUNET_PEERSTORE_iterate_cancel(), GNUNET_TIME_UNIT_ZERO, h, GNUNET_PEERSTORE_IterateContext::iterating, and LOG.

Here is the call graph for this function:

check_iterate_result()

static int check_iterate_result ( void *  cls, const struct StoreRecordMessage *  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 626 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 StoreRecordMessage *  msg  )

static

When a response for iterate request is received.

Parameters

cls	a struct GNUNET_PEERSTORE_Handle *
msg	message received

Definition at line 640 of file peerstore_api.c.

{
  struct GNUNET_PEERSTORE_Handle *h = cls;
  struct GNUNET_PEERSTORE_IterateContext *ic;
  GNUNET_PEERSTORE_Processor callback;
  void *callback_cls;
  struct GNUNET_PEERSTORE_Record *record;
 
  ic = h->iterate_head;
  if (NULL == ic)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Unexpected iteration response, this should not happen.\n"));
    disconnect_and_schedule_reconnect (h);
    return;
  }
  ic->iterating = GNUNET_YES;
  callback = ic->callback;
  callback_cls = ic->callback_cls;
  if (NULL == callback)
    return;
  record = PEERSTORE_parse_record_message (msg);
  if (NULL == record)
  {
    callback (callback_cls,
              NULL,
              _ ("Received a malformed response from service."));
  }
  else
  {
    callback (callback_cls, record, NULL);
    PEERSTORE_destroy_record (record);
  }
}

References _, GNUNET_PEERSTORE_IterateContext::callback, GNUNET_PEERSTORE_IterateContext::callback_cls, disconnect_and_schedule_reconnect(), GNUNET_ERROR_TYPE_ERROR, GNUNET_YES, h, GNUNET_PEERSTORE_IterateContext::iterating, LOG, msg, PEERSTORE_destroy_record(), PEERSTORE_parse_record_message(), and record().

Here is the call graph for this function:

check_watch_record()

static int check_watch_record ( void *  cls, const struct StoreRecordMessage *  msg  )

static

When a watch record is received, validate it is well-formed.

Parameters

cls	a struct GNUNET_PEERSTORE_Handle *
msg	message received

Definition at line 746 of file peerstore_api.c.

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

References GNUNET_OK.

handle_watch_record()

static void handle_watch_record ( void *  cls, const struct StoreRecordMessage *  msg  )

static

When a watch record is received, process it.

Parameters

cls	a struct GNUNET_PEERSTORE_Handle *
msg	message received

Definition at line 760 of file peerstore_api.c.

{
  struct GNUNET_PEERSTORE_Handle *h = cls;
  struct GNUNET_PEERSTORE_Record *record;
  struct GNUNET_HashCode keyhash;
  struct GNUNET_PEERSTORE_WatchContext *wc;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received a watch record from service.\n");
  record = PEERSTORE_parse_record_message (msg);
  if (NULL == record)
  {
    disconnect_and_schedule_reconnect (h);
    return;
  }
  PEERSTORE_hash_key (record->sub_system, &record->peer, record->key, &keyhash);
  // FIXME: what if there are multiple watches for the same key?
  wc = GNUNET_CONTAINER_multihashmap_get (h->watches, &keyhash);
  if (NULL == wc)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Received a watch result for a non existing watch.\n"));
    PEERSTORE_destroy_record (record);
    disconnect_and_schedule_reconnect (h);
    return;
  }
  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
  if (NULL != wc->callback)
    wc->callback (wc->callback_cls, record, NULL);
  PEERSTORE_destroy_record (record);
}

References _, GNUNET_PEERSTORE_WatchContext::callback, GNUNET_PEERSTORE_WatchContext::callback_cls, disconnect_and_schedule_reconnect(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_TIME_UNIT_ZERO, h, GNUNET_PEERSTORE_WatchContext::keyhash, LOG, msg, PEERSTORE_destroy_record(), PEERSTORE_hash_key(), PEERSTORE_parse_record_message(), and record().

Here is the call graph for this function: