Peer Store service

Collaboration diagram for Peer Store service:

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

Macros
#define	GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY   "transport-communicator-url"
	Key used for storing addresses in URL format in the peerstore. More...
#define	GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY   "transport-peer-hello"
	Key used for storing HELLOs in the peerstore. More...
#define	GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME    "transport-backchannel-monotonic-time"
	Key used to store sender's monotonic time from backchannel messages. More...
#define	GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME    "transport-dv-learn-monotonic-time"
	Key used to store sender's monotonic time from DV learn messages. More...
#define	GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE    "transport-tcp-communicator-handshake"
	Key used to store sender's monotonic time from handshake message. More...
#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. More...
#define	GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY    "transport-tcp-communicator-rekey"
	Key used to store sender's monotonic time from rekey message. More...

Typedefs
typedef void(*	GNUNET_PEERSTORE_Continuation) (void *cls, int success)
	Continuation called with a status result. More...
typedef void(*	GNUNET_PEERSTORE_Processor) (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
	Function called by PEERSTORE for each matching record. More...

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_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...
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...
void	GNUNET_PEERSTORE_store_cancel (struct GNUNET_PEERSTORE_StoreContext *sc)
	Cancel a store request. 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...
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_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...
void	GNUNET_PEERSTORE_watch_cancel (struct GNUNET_PEERSTORE_WatchContext *wc)
	Cancel a watch request. More...

Detailed Description

See also

Documentation

Macro Definition Documentation

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 53 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 58 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 64 of file gnunet_peerstore_service.h.

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 71 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 77 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 83 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 89 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 169 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.

Parameters

cls	closure
record	peerstore record information
emsg	error message, or NULL if no errors

Definition at line 179 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 96 of file gnunet_peerstore_service.h.

{
  GNUNET_PEERSTORE_STOREOPTION_MULTIPLE = 0,
 
  GNUNET_PEERSTORE_STOREOPTION_REPLACE = 1
};

Function Documentation

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

{
  struct GNUNET_PEERSTORE_Handle *h;
 
  h = GNUNET_new (struct GNUNET_PEERSTORE_Handle);
  h->cfg = cfg;
  h->disconnecting = GNUNET_NO;
  reconnect (h);
  if (NULL == h->mq)
  {
    GNUNET_free (h);
    return NULL;
  }
  return h;
}

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

Referenced by GNUNET_TRANSPORT_TESTING_start_peer(), GSF_connected_peer_init_(), 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,
		int	sync_first
	)

Disconnect from the PEERSTORE service.

Any pending ITERATE and WATCH requests will be canceled. Any pending STORE requests will depend on snyc_first flag.

Parameters

h	handle to disconnect
sync_first	send any pending STORE requests before disconnecting

Definition at line 450 of file peerstore_api.c.

{
  struct GNUNET_PEERSTORE_IterateContext *ic;
  struct GNUNET_PEERSTORE_StoreContext *sc;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting.\n");
  if (NULL != h->watches)
  {
    GNUNET_CONTAINER_multihashmap_iterate (h->watches, &destroy_watch, NULL);
    GNUNET_CONTAINER_multihashmap_destroy (h->watches);
    h->watches = NULL;
  }
  while (NULL != (ic = h->iterate_head))
  {
    GNUNET_break (0);
    GNUNET_PEERSTORE_iterate_cancel (ic);
  }
  if (NULL != h->store_head)
  {
    if (GNUNET_YES == sync_first)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Delaying disconnection due to pending store requests.\n");
      h->disconnecting = GNUNET_YES;
      return;
    }
    while (NULL != (sc = h->store_head))
      GNUNET_PEERSTORE_store_cancel (sc);
  }
  final_disconnect (h);
}

References destroy_watch(), final_disconnect(), GNUNET_break, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_PEERSTORE_iterate_cancel(), GNUNET_PEERSTORE_store_cancel(), GNUNET_YES, h, LOG, and sc.

Referenced by do_shutdown(), GNUNET_TRANSPORT_TESTING_stop_peer(), GSF_connected_peer_done_(), 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 531 of file peerstore_api.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_PEERSTORE_StoreContext *sc;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Storing value (size: %lu) for subsystem `%s', peer `%s', key `%s'\n",
       size,
       sub_system,
       GNUNET_i2s (peer),
       key);
  ev =
    PEERSTORE_create_record_mq_envelope (sub_system,
                                         peer,
                                         key,
                                         value,
                                         size,
                                         expiry,
                                         options,
                                         GNUNET_MESSAGE_TYPE_PEERSTORE_STORE);
  sc = GNUNET_new (struct GNUNET_PEERSTORE_StoreContext);
 
  sc->sub_system = GNUNET_strdup (sub_system);
  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;
 
  GNUNET_CONTAINER_DLL_insert_tail (h->store_head, h->store_tail, sc);
  GNUNET_MQ_notify_sent (ev, &store_request_sent, sc);
  GNUNET_MQ_send (h->mq, ev);
  return sc;
}

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

Referenced by flush_respect(), handle_dv_learn(), handle_validation_response(), handshake_ack_monotime_cb(), handshake_monotime_cb(), rekey_monotime_cb(), store_pi(), 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 494 of file peerstore_api.c.

{
  struct GNUNET_PEERSTORE_Handle *h = sc->h;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "store cancel with sc %p \n",
              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);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "store cancel with sc %p is null\n",
              sc);
  if ((GNUNET_YES == h->disconnecting) && (NULL == h->store_head))
    final_disconnect (h);
}

References final_disconnect(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_YES, h, GNUNET_FS_SearchContext::h, and sc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_iterate()

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.

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, all NULL's on end
callback_cls	closure for callback

Returns

Handle to iteration request

Definition at line 698 of file peerstore_api.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_PEERSTORE_IterateContext *ic;
 
  ev =
    PEERSTORE_create_record_mq_envelope (sub_system,
                                         peer,
                                         key,
                                         NULL,
                                         0,
                                         GNUNET_TIME_UNIT_FOREVER_ABS,
                                         0,
                                         GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE);
  ic = GNUNET_new (struct GNUNET_PEERSTORE_IterateContext);
  ic->callback = callback;
  ic->callback_cls = callback_cls;
  ic->h = h;
  ic->sub_system = GNUNET_strdup (sub_system);
  if (NULL != peer)
    ic->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, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE, GNUNET_MQ_send(), GNUNET_new, GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_ABS, h, GNUNET_PEERSTORE_IterateContext::h, key, GNUNET_PEERSTORE_IterateContext::key, LOG, GNUNET_ARM_Handle::mq, GNUNET_PEERSTORE_IterateContext::peer, peer, PEERSTORE_create_record_mq_envelope(), and GNUNET_PEERSTORE_IterateContext::sub_system.

Referenced by decrypt_and_check_tc(), do_rekey(), GNUNET_TRANSPORT_TESTING_restart_peer(), GSF_peer_connect_handler(), handle_add_queue_message(), handle_dv_box(), retrieve_hello(), and try_handle_plaintext().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_iterate_cancel()

void GNUNET_PEERSTORE_iterate_cancel

(

struct GNUNET_PEERSTORE_IterateContext *

ic

)

Cancel an iterate request Please do not call after the iterate request is done.

Parameters

ic	Iterate request context as returned by GNUNET_PEERSTORE_iterate()

Definition at line 683 of file peerstore_api.c.

{
  if (GNUNET_NO == ic->iterating)
  {
    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);
  }
  else
    ic->callback = NULL;
}

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

Referenced by disconnect(), free_backtalker(), free_neighbour(), GNUNET_PEERSTORE_disconnect(), GNUNET_TRANSPORT_TESTING_restart_peer(), GNUNET_TRANSPORT_TESTING_stop_peer(), GSF_peer_disconnect_handler(), handle_iterate_end(), hello_iter_cb(), peer_respect_cb(), queue_destroy(), and stop_peer_run().

Here is the caller graph for this function:

GNUNET_PEERSTORE_watch()

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.

Parameters

h	handle to the PEERSTORE service
sub_system	name of sub system
peer	Peer identity
key	entry key string
callback	function called with each new value
callback_cls	closure for callback

Returns

Handle to watch request

Definition at line 903 of file peerstore_api.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct StoreKeyHashMessage *hm;
  struct GNUNET_PEERSTORE_WatchContext *wc;
 
  ev = GNUNET_MQ_msg (hm, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH);
  PEERSTORE_hash_key (sub_system, peer, key, &hm->keyhash);
  wc = GNUNET_new (struct GNUNET_PEERSTORE_WatchContext);
  wc->callback = callback;
  wc->callback_cls = callback_cls;
  wc->h = h;
  wc->keyhash = hm->keyhash;
  if (NULL == h->watches)
    h->watches = GNUNET_CONTAINER_multihashmap_create (5, GNUNET_NO);
  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (
                   h->watches,
                   &wc->keyhash,
                   wc,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending a watch request for subsystem `%s', peer `%s', key `%s'.\n",
       sub_system,
       GNUNET_i2s (peer),
       key);
  GNUNET_MQ_send (h->mq, ev);
  return wc;
}

References GNUNET_PEERSTORE_WatchContext::callback, GNUNET_PEERSTORE_WatchContext::callback_cls, GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_NO, GNUNET_OK, h, GNUNET_PEERSTORE_WatchContext::h, key, StoreKeyHashMessage::keyhash, GNUNET_PEERSTORE_WatchContext::keyhash, LOG, GNUNET_ARM_Handle::mq, peer, and PEERSTORE_hash_key().

Referenced by handle_suggest(), and handle_validation_challenge().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PEERSTORE_watch_cancel()

void GNUNET_PEERSTORE_watch_cancel

(

struct GNUNET_PEERSTORE_WatchContext *

wc

)

Cancel a watch request.

Parameters

wc	handle to the watch request

Definition at line 873 of file peerstore_api.c.

{
  struct GNUNET_PEERSTORE_Handle *h = wc->h;
  struct GNUNET_MQ_Envelope *ev;
  struct StoreKeyHashMessage *hm;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Canceling watch.\n");
  ev = GNUNET_MQ_msg (hm, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL);
  hm->keyhash = wc->keyhash;
  GNUNET_MQ_send (h->mq, ev);
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multihashmap_remove (h->watches, &wc->keyhash, wc));
  GNUNET_free (wc);
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_YES, h, GNUNET_PEERSTORE_WatchContext::h, StoreKeyHashMessage::keyhash, GNUNET_PEERSTORE_WatchContext::keyhash, LOG, and GNUNET_ARM_Handle::mq.

Referenced by free_incoming_request(), and stop_peer_request().

Here is the call graph for this function:

Here is the caller graph for this function: