Peer Store service

Collaboration diagram for Peer Store service:

Data Structures
struct	GNUNET_PEERSTORE_Record
	Single PEERSTORE record. More...

Macros
#define	GNUNET_PEERSTORE_HELLO_KEY   "peerstore-peer-hello-uri"
	Key used for storing HELLO in the peerstore.
#define	GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY   "transport-communicator-url"
	Key used for storing addresses in URL format in the peerstore.
#define	GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY   "transport-peer-hello"
	Key used for storing HELLOs in the peerstore.
#define	GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME    "transport-backchannel-monotonic-time"
	Key used to store sender's monotonic time from backchannel messages.
#define	GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME    "transport-dv-learn-monotonic-time"
	Key used to store sender's monotonic time from DV learn messages.
#define	GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE    "transport-tcp-communicator-handshake"
	Key used to store sender's monotonic time from handshake message.
#define	GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_ACK    "transport-tcp-communicator-handshake-ack"
	Key used to store sender's monotonic time from handshake ack message.
#define	GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY    "transport-tcp-communicator-rekey"
	Key used to store sender's monotonic time from rekey message.

Typedefs
typedef void(*	GNUNET_PEERSTORE_Continuation) (void *cls, int success)
	Continuation called with a status result.
typedef void(*	GNUNET_PEERSTORE_Processor) (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
	Function called by PEERSTORE for each matching record.
typedef void(*	GNUNET_PEERSTORE_hello_notify_cb) (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_MessageHeader *hello, const char *err_msg)
	Function called by PEERSTORE when notifying a client about a changed hello.

Enumerations
enum	GNUNET_PEERSTORE_StoreOption { GNUNET_PEERSTORE_STOREOPTION_MULTIPLE = 0 , GNUNET_PEERSTORE_STOREOPTION_REPLACE = 1 }
	Options for storing values in PEERSTORE. More...

Functions
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.
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.
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.
void	GNUNET_PEERSTORE_store_cancel (struct GNUNET_PEERSTORE_StoreContext *sc)
	Cancel a store request.
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.
void	GNUNET_PEERSTORE_iteration_next (struct GNUNET_PEERSTORE_IterateContext *ic, uint64_t limit)
	Continue an iteration.
void	GNUNET_PEERSTORE_iteration_stop (struct GNUNET_PEERSTORE_IterateContext *ic)
	Cancel an iteration.
struct GNUNET_PEERSTORE_Monitor *	GNUNET_PEERSTORE_monitor_start (const struct GNUNET_CONFIGURATION_Handle *cfg, int iterate_first, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_SCHEDULER_TaskCallback sync_cb, void *sync_cb_cls, GNUNET_PEERSTORE_Processor callback, void *callback_cls)
	Request watching a given key The monitoring can be filtered to contain only records matching peer and/or key.
void	GNUNET_PEERSTORE_monitor_next (struct GNUNET_PEERSTORE_Monitor *zm, uint64_t limit)
	Calls the monitor processor specified in GNUNET_PEERSTORE_monitor_start for the next record(s).
void	GNUNET_PEERSTORE_monitor_stop (struct GNUNET_PEERSTORE_Monitor *zm)
	Stop monitoring.

Detailed Description

See also

Documentation

Macro Definition Documentation

GNUNET_PEERSTORE_HELLO_KEY

#define GNUNET_PEERSTORE_HELLO_KEY   "peerstore-peer-hello-uri"

Key used for storing HELLO in the peerstore.

Definition at line 52 of file gnunet_peerstore_service.h.

GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY

#define GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY   "transport-communicator-url"

Key used for storing addresses in URL format in the peerstore.

Definition at line 57 of file gnunet_peerstore_service.h.

GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY

#define GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY   "transport-peer-hello"

Key used for storing HELLOs in the peerstore.

Definition at line 62 of file gnunet_peerstore_service.h.

GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME

#define GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME    "transport-backchannel-monotonic-time"

Key used to store sender's monotonic time from backchannel messages.

Definition at line 68 of file gnunet_peerstore_service.h.

{
  GNUNET_PEERSTORE_STOREOPTION_MULTIPLE = 0,
 
  GNUNET_PEERSTORE_STOREOPTION_REPLACE = 1,
 
};
 
struct GNUNET_PEERSTORE_Handle;
 
struct GNUNET_PEERSTORE_StoreContext;
 
struct GNUNET_PEERSTORE_NotifyContext;
 
struct GNUNET_PEERSTORE_Record
{
  char *sub_system;
 
  struct GNUNET_PeerIdentity peer;
 
  char *key;
 
  void *value;
 
  size_t value_size;
 
  struct GNUNET_TIME_Absolute expiry;
 
};
 
 
typedef void (*GNUNET_PEERSTORE_Continuation) (void *cls, int success);
 
 
struct GNUNET_PEERSTORE_StoreHelloContext;
 
 
typedef void (*GNUNET_PEERSTORE_Processor) (
  void *cls,
  const struct GNUNET_PEERSTORE_Record *record,
  const char *emsg);
 
typedef void (*GNUNET_PEERSTORE_hello_notify_cb) (
  void *cls,
  const struct GNUNET_PeerIdentity *peer,
  const struct GNUNET_MessageHeader *hello,
  const char *err_msg);
 
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);
 
 
void
GNUNET_PEERSTORE_hello_add_cancel (struct
                                   GNUNET_PEERSTORE_StoreHelloContext *huc);
 
 
struct GNUNET_PEERSTORE_Handle *
GNUNET_PEERSTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg);
 
 
void
GNUNET_PEERSTORE_disconnect (struct GNUNET_PEERSTORE_Handle *h);
 
 
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);
 
 
void
GNUNET_PEERSTORE_store_cancel (struct GNUNET_PEERSTORE_StoreContext *sc);
 
 
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);
 
 
void
GNUNET_PEERSTORE_iteration_next (struct GNUNET_PEERSTORE_IterateContext *ic,
                                 uint64_t limit);
 
 
void
GNUNET_PEERSTORE_iteration_stop (struct GNUNET_PEERSTORE_IterateContext *ic);
 
struct GNUNET_PEERSTORE_Monitor *
GNUNET_PEERSTORE_monitor_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                int iterate_first,
                                const char *sub_system,
                                const struct GNUNET_PeerIdentity *peer,
                                const char *key,
                                GNUNET_SCHEDULER_TaskCallback error_cb,
                                void *error_cb_cls,
                                GNUNET_SCHEDULER_TaskCallback sync_cb,
                                void *sync_cb_cls,
                                GNUNET_PEERSTORE_Processor callback,
                                void *callback_cls);
 
void
GNUNET_PEERSTORE_monitor_next (struct GNUNET_PEERSTORE_Monitor *zm,
                               uint64_t limit);
 
void
GNUNET_PEERSTORE_monitor_stop (struct GNUNET_PEERSTORE_Monitor *zm);
 
#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
#endif
 
 

GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME

#define GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME    "transport-dv-learn-monotonic-time"

Key used to store sender's monotonic time from DV learn messages.

Definition at line 75 of file gnunet_peerstore_service.h.

GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE

#define GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE    "transport-tcp-communicator-handshake"

Key used to store sender's monotonic time from handshake message.

Definition at line 81 of file gnunet_peerstore_service.h.

GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_ACK

#define GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_ACK    "transport-tcp-communicator-handshake-ack"

Key used to store sender's monotonic time from handshake ack message.

Definition at line 87 of file gnunet_peerstore_service.h.

GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY

#define GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY    "transport-tcp-communicator-rekey"

Key used to store sender's monotonic time from rekey message.

Definition at line 93 of file gnunet_peerstore_service.h.

Typedef Documentation

GNUNET_PEERSTORE_Continuation

typedef void(* GNUNET_PEERSTORE_Continuation) (void *cls, int success)

Continuation called with a status result.

Parameters

cls	closure
success	GNUNET_OK or GNUNET_SYSERR

Definition at line 174 of file gnunet_peerstore_service.h.

GNUNET_PEERSTORE_Processor

typedef void(* GNUNET_PEERSTORE_Processor) (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)

Function called by PEERSTORE for each matching record.

A NULL record terminates the iteration, with or without an emsg: the ‘struct GNUNET_PEERSTORE_IterateContext’ has been released by the time this call returns. A handler must therefore drop its handle on a NULL record and must not call GNUNET_PEERSTORE_iteration_next() or GNUNET_PEERSTORE_iteration_stop() on it.

Parameters

cls	closure
record	peerstore record information, NULL to end the iteration
emsg	error message, or NULL if no errors

Definition at line 196 of file gnunet_peerstore_service.h.

GNUNET_PEERSTORE_hello_notify_cb

typedef void(* GNUNET_PEERSTORE_hello_notify_cb) (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_MessageHeader *hello, const char *err_msg)

Function called by PEERSTORE when notifying a client about a changed hello.

Parameters

cls	closure
hello_uri	Hello uri.

Definition at line 207 of file gnunet_peerstore_service.h.

Enumeration Type Documentation

GNUNET_PEERSTORE_StoreOption

enum GNUNET_PEERSTORE_StoreOption

Options for storing values in PEERSTORE.

Enumerator
GNUNET_PEERSTORE_STOREOPTION_MULTIPLE	Possibly store multiple values under given key.
GNUNET_PEERSTORE_STOREOPTION_REPLACE	Delete any previous values for the given key before storing the given value.

Definition at line 100 of file gnunet_peerstore_service.h.

{
  GNUNET_PEERSTORE_STOREOPTION_MULTIPLE = 0,
 
  GNUNET_PEERSTORE_STOREOPTION_REPLACE = 1,
 
};

Function Documentation

GNUNET_PEERSTORE_hello_add()

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.

Parameters

h	handle for peerstore.
msg	The hello to add.
cont	The continuation function to execute after storing.
cont_cls	The continuation function closure.

Returns

The context for storing.

Definition at line 1061 of file peerstore_api.c.

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

References GNUNET_PEERSTORE_StoreHelloContext::cont, GNUNET_PEERSTORE_StoreHelloContext::cont_cls, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_get_expiration_time_from_msg(), GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_get_id(), GNUNET_i2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_iteration_start(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_cmp, GNUNET_TIME_absolute_get(), h, GNUNET_PEERSTORE_StoreHelloContext::h, GNUNET_PEERSTORE_StoreHelloContext::hello, hello_add_iter(), GNUNET_PEERSTORE_StoreHelloContext::ic, LOG, msg, GNUNET_PEERSTORE_StoreHelloContext::pid, and GNUNET_MessageHeader::size.

Referenced by callback_download(), handle_hello(), pils_pid_change_cb(), pils_sign_hello_cb(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_hello_add_cancel()

void GNUNET_PEERSTORE_hello_add_cancel

(

struct GNUNET_PEERSTORE_StoreHelloContext *

huc

)

Cancel the request to add a hello.

Parameters

huc	The context for storing a hello.

Definition at line 1106 of file peerstore_api.c.

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

References GNUNET_free, GNUNET_PEERSTORE_iteration_stop(), GNUNET_PEERSTORE_store_cancel(), GNUNET_PEERSTORE_StoreHelloContext::hello, GNUNET_PEERSTORE_StoreHelloContext::ic, and GNUNET_PEERSTORE_StoreHelloContext::sc.

Referenced by cancel_address_store(), cleaning_task(), free_address_list_entry(), GNUNET_HOSTLIST_client_stop(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_connect()

struct GNUNET_PEERSTORE_Handle * GNUNET_PEERSTORE_connect

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Connect to the PEERSTORE service.

Returns

NULL on error

Parameters

cfg	configuration to use

Returns

NULL on error

Definition at line 495 of file peerstore_api.c.

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

References cfg, GNUNET_ARM_Handle::cfg, GNUNET_free, GNUNET_new, GNUNET_SCHEDULER_cancel(), h, GNUNET_ARM_Handle::mq, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by DHTU_gnunet_init(), GCH_init(), GNUNET_HOSTLIST_client_start(), GNUNET_HOSTLIST_server_start(), GNUNET_TRANSPORT_TESTING_start_peer(), GSF_connected_peer_init_(), run(), run(), run(), run(), run(), run(), and start_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_disconnect()

void GNUNET_PEERSTORE_disconnect

(

struct GNUNET_PEERSTORE_Handle *

h

)

Disconnect from the PEERSTORE service.

Any pending ITERATE and WATCH and STORE requests will be canceled.

Parameters

h	handle to disconnect

Any pending ITERATE and STORE requests are released without invoking their callbacks.

Parameters

h	handle to disconnect

Definition at line 526 of file peerstore_api.c.

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

References disconnect(), flush_pending_operations(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_cancel(), h, LOG, and GNUNET_ARM_Handle::reconnect_task.

Referenced by cleaning_task(), DHTU_gnunet_done(), do_shutdown(), do_shutdown(), do_shutdown(), GCH_shutdown(), GNUNET_HOSTLIST_client_stop(), GNUNET_HOSTLIST_server_stop(), GNUNET_TRANSPORT_TESTING_stop_peer(), GSF_connected_peer_done_(), shutdown_task(), shutdown_task(), and stop_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_store()

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.

Note that stored entries can be lost in some cases such as power failure.

Parameters

h	Handle to the PEERSTORE service
sub_system	name of the sub system
peer	Peer Identity
key	entry key
value	entry value BLOB
size	size of value
expiry	absolute time after which the entry is (possibly) deleted
options	options specific to the storage operation
cont	Continuation function after the store request is sent
cont_cls	Closure for cont

Definition at line 596 of file peerstore_api.c.

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

References GNUNET_PEERSTORE_StoreContext::cont, GNUNET_PEERSTORE_StoreContext::cont_cls, GNUNET_PEERSTORE_StoreContext::expiry, get_op_id(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_memdup, GNUNET_MESSAGE_TYPE_PEERSTORE_STORE, GNUNET_MQ_send(), GNUNET_new, GNUNET_strdup, h, GNUNET_FS_SearchContext::h, key, LOG, GNUNET_ARM_Handle::mq, options, GNUNET_FS_SearchContext::options, GNUNET_PEERSTORE_StoreContext::peer, PEERSTORE_create_record_mq_envelope(), sc, size, GNUNET_PEERSTORE_StoreContext::sub_system, and value.

Referenced by flush_respect(), handle_dv_learn(), handle_validation_response(), handshake_ack_monotime_cb(), handshake_ack_monotime_cb(), handshake_monotime_cb(), handshake_monotime_cb(), rekey_monotime_cb(), rekey_monotime_cb(), store_signed_address(), and update_backtalker_monotime().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_store_cancel()

void GNUNET_PEERSTORE_store_cancel

(

struct GNUNET_PEERSTORE_StoreContext *

sc

)

Cancel a store request.

Parameters

sc	Store request context

Definition at line 567 of file peerstore_api.c.

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

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

Referenced by cancel_address_store(), free_address_list_entry(), free_backtalker(), free_neighbour(), free_validation_state(), handle_dv_learn(), queue_destroy(), queue_destroy(), and update_backtalker_monotime().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_iteration_start()

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.

The iteration can be filtered to contain only records matching peer and/or key. The sub_system to match must be provided. callback will be called with (each) matching record. GNUNET_PEERSTORE_iteration_next() must be invoked to continue processing until the end of the iteration is reached.

Parameters

h	handle to the PEERSTORE service
sub_system	name of sub system
peer	Peer identity (can be NULL)
key	entry key string (can be NULL)
callback	function called with each matching record. The record will be NULL to indicate end.
callback_cls	closure for callback

Returns

Handle to iteration request

Definition at line 854 of file peerstore_api.c.

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

References GNUNET_PEERSTORE_IterateContext::callback, GNUNET_PEERSTORE_IterateContext::callback_cls, dummy, get_op_id(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_START, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_strdup, GNUNET_YES, h, GNUNET_PEERSTORE_IterateContext::h, key, GNUNET_PEERSTORE_IterateContext::key, PeerstoreIterationStartMessage::key_size, LOG, GNUNET_ARM_Handle::mq, PeerstoreIterationStartMessage::peer, GNUNET_PEERSTORE_IterateContext::peer, PeerstoreIterationStartMessage::peer_set, PeerstoreIterationStartMessage::rid, GNUNET_PEERSTORE_IterateContext::rid, GNUNET_PEERSTORE_IterateContext::sub_system, and PeerstoreIterationStartMessage::sub_system_size.

Referenced by decaps_dv_box_cont(), decrypt_and_check_tc(), decrypt_and_check_tc(), do_rekey(), do_rekey(), GNUNET_PEERSTORE_hello_add(), GNUNET_TRANSPORT_TESTING_restart_peer(), GSF_peer_connect_handler(), handle_add_queue_message(), queue_burst(), retrieve_hello(), retrieve_hello(), run(), try_handle_plaintext(), and try_handle_plaintext().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_iteration_next()

void GNUNET_PEERSTORE_iteration_next	(	struct GNUNET_PEERSTORE_IterateContext *	ic,
		uint64_t	limit
	)

Continue an iteration.

Do NOT call after the iterate request is done.

Parameters

ic	Iterate request context as returned by GNUNET_PEERSTORE_iteration_start()
limit	how many records to return max until #GNUNET_PEERSTORE_iterate_next() needs to be called again.

Continue an iteration.

Parameters

ic	Iterate request context as returned by GNUNET_PEERSTORE_iterate()

Definition at line 806 of file peerstore_api.c.

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

References GNUNET_PEERSTORE_IterateContext::env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_htonll(), GNUNET_log, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_NEXT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_PEERSTORE_IterateContext::h, PeerstoreIterationNextMessage::limit, GNUNET_PEERSTORE_Handle::mq, PeerstoreIterationNextMessage::rid, and GNUNET_PEERSTORE_IterateContext::rid.

Referenced by backtalker_monotime_cb(), handshake_ack_monotime_cb(), handshake_ack_monotime_cb(), handshake_ack_monotime_store_cb(), handshake_ack_monotime_store_cb(), handshake_monotime_cb(), handshake_monotime_cb(), handshake_monotime_store_cb(), handshake_monotime_store_cb(), hello_add_iter(), hello_iter(), neighbour_dv_monotime_cb(), peer_respect_cb(), rekey_monotime_cb(), rekey_monotime_cb(), rekey_monotime_store_cb(), and rekey_monotime_store_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_iteration_stop()

void GNUNET_PEERSTORE_iteration_stop

(

struct GNUNET_PEERSTORE_IterateContext *

ic

)

Cancel an iteration.

Do NOT call after the iterate request is done

Parameters

ic	Iterate request context as returned by GNUNET_PEERSTORE_iteration_start()

Cancel an iteration.

Parameters

ic	Iterate request context as returned by GNUNET_PEERSTORE_iterate()

Definition at line 835 of file peerstore_api.c.

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

References destroy_iteratecontext(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_STOP, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_PEERSTORE_IterateContext::h, GNUNET_PEERSTORE_Handle::mq, PeerstoreIterationStopMessage::rid, and GNUNET_PEERSTORE_IterateContext::rid.

Referenced by check_for_burst_address(), free_backtalker(), free_neighbour(), free_virtual_link(), GNUNET_PEERSTORE_hello_add_cancel(), GNUNET_TRANSPORT_TESTING_restart_peer(), GNUNET_TRANSPORT_TESTING_stop_peer(), GSF_peer_disconnect_handler(), handle_iterate_result(), handshake_ack_monotime_cb(), handshake_ack_monotime_cb(), handshake_monotime_cb(), handshake_monotime_cb(), hello_add_iter(), hello_iter_cb(), hello_iter_cb(), peer_respect_cb(), queue_destroy(), queue_destroy(), rekey_monotime_cb(), rekey_monotime_cb(), shutdown_task(), and stop_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_monitor_start()

struct GNUNET_PEERSTORE_Monitor * GNUNET_PEERSTORE_monitor_start	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		int	iterate_first,
		const char *	sub_system,
		const struct GNUNET_PeerIdentity *	peer,
		const char *	key,
		GNUNET_SCHEDULER_TaskCallback	error_cb,
		void *	error_cb_cls,
		GNUNET_SCHEDULER_TaskCallback	sync_cb,
		void *	sync_cb_cls,
		GNUNET_PEERSTORE_Processor	callback,
		void *	callback_cls
	)

Request watching a given key The monitoring can be filtered to contain only records matching peer and/or key.

The sub_system to match must be provided. callback will be called with (each) matching new record. GNUNET_PEERSTORE_monitor_next() must be invoked to continue processing until sync_cb is called, indicating that the caller should be up-to-date. The caller will be notified with any new values added to key through callback. If iterate_first is set to GNUNET_YES, the monitor will first iterate over all existing, matching records. In any case, after sync_cb is called the first time monitoring starts.

Parameters

h	handle to the PEERSTORE service
iterate_first	first iterated of all results if GNUNET_YES
sub_system	name of sub system
peer	Peer identity
key	entry key string
error_cb	function to call on error (i.e. disconnect); note that unlike the other error callbacks in this API, a call to this function does NOT destroy the monitor handle, it merely signals that monitoring is down. You need to still explicitly call GNUNET_PEERSTORE_monitor_stop().
error_cb_cls	closure for error_cb
sync_cb	function called when we're in sync with the peerstore
sync_cb_cls	closure for sync_cb
callback	function called with each new value
callback_cls	closure for callback

Returns

Handle to watch request

Definition at line 253 of file peerstore_api_monitor.c.

{
  struct GNUNET_PEERSTORE_Monitor *mc;
 
  mc = GNUNET_new (struct GNUNET_PEERSTORE_Monitor);
  mc->callback = callback;
  mc->callback_cls = callback_cls;
  mc->sync_cb = sync_cb;
  mc->sync_cb_cls = sync_cb_cls;
  mc->error_cb = error_cb;
  mc->error_cb_cls = error_cb_cls;
  if (NULL != key)
    mc->key = GNUNET_strdup (key);
  if (NULL != peer)
  {
    mc->peer_buf = *peer;
    mc->peer = &mc->peer_buf;
  }
  mc->iterate_first = iterate_first;
  mc->sub_system = GNUNET_strdup (sub_system);
  mc->cfg = cfg;
  reconnect (mc);
  if (NULL == mc->mq)
  {
    GNUNET_free (mc->sub_system);
    GNUNET_free (mc->key);
    GNUNET_free (mc);
    return NULL;
  }
  return mc;
}

References GNUNET_PEERSTORE_Monitor::callback, GNUNET_PEERSTORE_Monitor::callback_cls, cfg, error_cb(), GNUNET_PEERSTORE_Monitor::error_cb_cls, GNUNET_free, GNUNET_new, GNUNET_strdup, GNUNET_PEERSTORE_Monitor::iterate_first, key, mc, GNUNET_PEERSTORE_Monitor::peer, reconnect(), GNUNET_PEERSTORE_Monitor::sub_system, sync_cb(), and GNUNET_PEERSTORE_Monitor::sync_cb_cls.

Referenced by core_init_cb(), GCH_init(), handle_add_queue_message(), handle_suggest(), process_peer(), run(), start_notify(), start_notify(), and try_to_bring_link_up().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_monitor_next()

void GNUNET_PEERSTORE_monitor_next	(	struct GNUNET_PEERSTORE_Monitor *	zm,
		uint64_t	limit
	)

Calls the monitor processor specified in GNUNET_PEERSTORE_monitor_start for the next record(s).

This function is used to allow clients that merely monitor the NAMESTORE to still throttle namestore operations, so we can be sure that the monitors can keep up.

Note that GNUNET_PEERSTORE_store() only waits for this call if the previous limit set by the client was already reached. Thus, by using a limit greater than 1, monitors basically enable a queue of notifications to be processed asynchronously with some delay. Note that even with a limit of 1 the GNUNET_PEERSTORE_store() function will run asynchronously and the continuation may be invoked before the monitors completed (or even started) processing the notification. Thus, monitors will only closely track the current state of the peerstore, but not be involved in the transactions.

Parameters

zm	the monitor
limit	number of records to return to the iterator in one shot (before GNUNET_PEERSTORE_monitor_next is to be called again)

Definition at line 317 of file peerstore_api_monitor.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct PeerstoreMonitorNextMessage *nm;
 
  if (NULL == zm->mq)
  {
    /* Disconnected; #reconnect() re-sends MONITOR_START and the service
       starts over, so there is nothing to ask for right now. */
    return;
  }
  env = GNUNET_MQ_msg (nm, GNUNET_MESSAGE_TYPE_PEERSTORE_MONITOR_NEXT);
  nm->limit = GNUNET_htonll (limit);
  GNUNET_MQ_send (zm->mq, env);
}

References env, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_PEERSTORE_MONITOR_NEXT, GNUNET_MQ_msg, GNUNET_MQ_send(), PeerstoreMonitorNextMessage::limit, GNUNET_NAMESTORE_ZoneMonitor::mq, and zm.

Referenced by check_for_global_natted(), got_hello(), handle_hello_for_client(), handle_hello_for_incoming(), peerinfo_cb(), process_notify(), process_peer(), and process_peerinfo_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_monitor_stop()

void GNUNET_PEERSTORE_monitor_stop

(

struct GNUNET_PEERSTORE_Monitor *

zm

)

Stop monitoring.

Parameters

zm	handle to the monitor activity to stop

Definition at line 303 of file peerstore_api_monitor.c.

{
  if (NULL != zm->mq)
  {
    GNUNET_MQ_destroy (zm->mq);
    zm->mq = NULL;
  }
  GNUNET_free (zm->sub_system);
  GNUNET_free (zm->key);
  GNUNET_free (zm);
}

References GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NAMESTORE_ZoneMonitor::mq, and zm.

Referenced by cleaning_task(), DHTU_gnunet_done(), free_incoming_request(), free_queue(), GCH_shutdown(), GNUNET_HOSTLIST_server_stop(), process_peer(), shutdown_task(), and stop_peer_request().

Here is the call graph for this function:

Here is the caller graph for this function: