GNUnet  0.11.x
Data Structures | Macros | Functions
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_HandleGNUNET_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_StoreContextGNUNET_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_IterateContextGNUNET_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_WatchContextGNUNET_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
clsa struct GNUNET_PEERSTORE_Handle *h
clsa struct GNUNET_PEERSTORE_Handle *

Definition at line 799 of file peerstore_api.c.

800 {
801  struct GNUNET_PEERSTORE_Handle *h = cls;
802  struct GNUNET_MQ_MessageHandler mq_handlers[] =
803  { GNUNET_MQ_hd_fixed_size (iterate_end,
805  struct GNUNET_MessageHeader,
806  h),
807  GNUNET_MQ_hd_var_size (iterate_result,
809  struct StoreRecordMessage,
810  h),
811  GNUNET_MQ_hd_var_size (watch_record,
813  struct StoreRecordMessage,
814  h),
816  struct GNUNET_MQ_Envelope *ev;
817 
818  h->reconnect_task = NULL;
819  LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting...\n");
821  "peerstore",
822  mq_handlers,
824  h);
825  if (NULL == h->mq)
826  {
827  h->reconnect_task =
828  GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
829  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
830  return;
831  }
833  "Resending pending requests after reconnect.\n");
834  if (NULL != h->watches)
836  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
837  ic = ic->next)
838  {
839  ev =
840  PEERSTORE_create_record_mq_envelope (ic->sub_system,
841  &ic->peer,
842  ic->key,
843  NULL,
844  0,
846  0,
848  GNUNET_MQ_send (h->mq, ev);
849  }
850  for (struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head; NULL != sc;
851  sc = sc->next)
852  {
853  ev =
855  &sc->peer,
856  sc->key,
857  sc->value,
858  sc->size,
859  sc->expiry,
860  sc->options,
863  GNUNET_MQ_send (h->mq, ev);
864  }
865 }
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1064
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
@ GNUNET_ERROR_TYPE_DEBUG
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:787
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_PEERSTORE_STORE
Store request message.
#define GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD
Iteration record message.
#define GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE
Iteration request.
#define GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD
Watch response.
#define GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END
Iteration end message.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
static void handle_client_error(void *cls, enum GNUNET_MQ_Error error)
Function called when we had trouble talking to the service.
static void reconnect(void *cls)
Close the existing connection to PEERSTORE and reconnect.
static int rewatch_it(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over previous watches to resend them.
static void store_request_sent(void *cls)
Callback after MQ envelope is sent.
#define LOG(kind,...)
Definition: peerstore_api.c:31
struct GNUNET_MQ_Envelope * PEERSTORE_create_record_mq_envelope(const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, const void *value, size_t value_size, struct GNUNET_TIME_Absolute expiry, enum GNUNET_PEERSTORE_StoreOption options, uint16_t msg_type)
Creates a MQ envelope for a single record.
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:107
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:147
enum GNUNET_FS_SearchOptions options
Options for the search.
Definition: fs_api.h:1597
Message handler for a specific message type.
Header for all communications.
Handle to the PEERSTORE service.
Definition: peerstore_api.c:41
Context for a iterate request.
Context for a store request.
Definition: peerstore_api.c:97
Message carrying a PEERSTORE record message.
Definition: peerstore.h:37

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
hpeerstore handle to disconnect

Definition at line 265 of file peerstore_api.c.

266 {
268 
269  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
270  ic = next)
271  {
272  next = ic->next;
273  if (GNUNET_YES == ic->iterating)
274  {
276  void *icb_cls;
277 
278  icb = ic->callback;
279  icb_cls = ic->callback_cls;
281  if (NULL != icb)
282  icb (icb_cls, NULL, "Iteration canceled due to reconnection");
283  }
284  }
285 
286  if (NULL != h->mq)
287  {
289  h->mq = NULL;
290  }
291 }
@ GNUNET_YES
Definition: gnunet_common.h:97
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
void GNUNET_PEERSTORE_iterate_cancel(struct GNUNET_PEERSTORE_IterateContext *ic)
Cancel an iterate request Please do not call after the iterate request is done.
void(* GNUNET_PEERSTORE_Processor)(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
Function called by PEERSTORE for each matching record.
struct GNUNET_PEERSTORE_IterateContext * next
Kept in a DLL.

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
hpeerstore to reconnect

Definition at line 301 of file peerstore_api.c.

302 {
303  GNUNET_assert (NULL == h->reconnect_task);
304  disconnect (h);
306  "Scheduling task to reconnect to PEERSTORE service in %s.\n",
308  h->reconnect_task =
309  GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
310  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
311 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:557
static void disconnect(struct GNUNET_PEERSTORE_Handle *h)
Disconnect from the peerstore service.

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
clsa struct GNUNET_PEERSTORE_StoreContext *

Definition at line 320 of file peerstore_api.c.

321 {
322  struct GNUNET_PEERSTORE_StoreContext *sc = cls;
324  void *cont_cls;
325 
326  cont = sc->cont;
327  cont_cls = sc->cont_cls;
329  if (NULL != cont)
331 }
@ GNUNET_OK
Definition: gnunet_common.h:95
void GNUNET_PEERSTORE_store_cancel(struct GNUNET_PEERSTORE_StoreContext *sc)
Cancel a store request.
void(* GNUNET_PEERSTORE_Continuation)(void *cls, int success)
Continuation called with a status result.
void * cont_cls
Closure for cont.
GNUNET_PEERSTORE_Continuation cont
Continuation called with service response.

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

344 {
345  struct GNUNET_PEERSTORE_Handle *h = cls;
346 
348  "Received an error notification from MQ of type: %d\n",
349  error);
351 }
@ GNUNET_ERROR_TYPE_ERROR
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.

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
clsthe struct GNUNET_PEERSTORE_Handle
keykey for the watch
valuethe struct GNUNET_PEERSTORE_WatchContext *
Returns
GNUNET_YES (continue to iterate)

Definition at line 363 of file peerstore_api.c.

364 {
365  struct GNUNET_PEERSTORE_Handle *h = cls;
367  struct StoreKeyHashMessage *hm;
368  struct GNUNET_MQ_Envelope *ev;
369 
371  hm->keyhash = wc->keyhash;
372  GNUNET_MQ_send (h->mq, ev);
373  return GNUNET_YES;
374 }
static char * value
Value of the record to add/remove.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH
Watch request.
Context for a watch request.
struct GNUNET_HashCode keyhash
Hash of the combined key.
Message carrying record key hash.
Definition: peerstore.h:90
struct GNUNET_HashCode keyhash
Hash of a record key.
Definition: peerstore.h:104

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
clsunused
keykey to the watch request
valuewatch context
Returns
GNUNET_YES to continue iteration

Definition at line 386 of file peerstore_api.c.

387 {
389 
391  return GNUNET_YES;
392 }
void GNUNET_PEERSTORE_watch_cancel(struct GNUNET_PEERSTORE_WatchContext *wc)
Cancel a watch request.

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
hHandle to the service.

Definition at line 403 of file peerstore_api.c.

404 {
405  if (NULL != h->mq)
406  {
408  h->mq = NULL;
409  }
410  GNUNET_free (h);
411 }
#define GNUNET_free(ptr)
Wrapper around free.

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
clsa struct GNUNET_PEERSTORE_Handle *
msgmessage received

Definition at line 583 of file peerstore_api.c.

584 {
585  struct GNUNET_PEERSTORE_Handle *h = cls;
588  void *callback_cls;
589 
590  ic = h->iterate_head;
591  if (NULL == ic)
592  {
594  _ ("Unexpected iteration response, this should not happen.\n"));
596  return;
597  }
598  callback = ic->callback;
600  ic->iterating = GNUNET_NO;
602  if (NULL != callback)
603  callback (callback_cls, NULL, NULL);
604  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
605 }
@ GNUNET_NO
Definition: gnunet_common.h:94
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
void * callback_cls
Closure for callback.
int iterating
GNUNET_YES if we are currently processing records.
GNUNET_PEERSTORE_Processor callback
Callback with each matching record.

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
clsa struct GNUNET_PEERSTORE_Handle *
msgmessage received

Definition at line 616 of file peerstore_api.c.

617 {
618  /* we defer validation to #handle_iterate_result */
619  return GNUNET_OK;
620 }

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
clsa struct GNUNET_PEERSTORE_Handle *
msgmessage received

Definition at line 630 of file peerstore_api.c.

631 {
632  struct GNUNET_PEERSTORE_Handle *h = cls;
635  void *callback_cls;
637 
638  ic = h->iterate_head;
639  if (NULL == ic)
640  {
642  _ ("Unexpected iteration response, this should not happen.\n"));
644  return;
645  }
646  ic->iterating = GNUNET_YES;
647  callback = ic->callback;
648  callback_cls = ic->callback_cls;
649  if (NULL == callback)
650  return;
652  if (NULL == record)
653  {
654  callback (callback_cls,
655  NULL,
656  _ ("Received a malformed response from service."));
657  }
658  else
659  {
660  callback (callback_cls, record, NULL);
662  }
663 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
struct GNUNET_PEERSTORE_Record * PEERSTORE_parse_record_message(const struct StoreRecordMessage *srm)
Parses a message carrying a record.
void PEERSTORE_destroy_record(struct GNUNET_PEERSTORE_Record *record)
Free any memory allocated for this record.
Single PEERSTORE 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
clsa struct GNUNET_PEERSTORE_Handle *
msgmessage received

Definition at line 747 of file peerstore_api.c.

748 {
749  /* we defer validation to #handle_watch_result */
750  return GNUNET_OK;
751 }

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
clsa struct GNUNET_PEERSTORE_Handle *
msgmessage received

Definition at line 761 of file peerstore_api.c.

762 {
763  struct GNUNET_PEERSTORE_Handle *h = cls;
765  struct GNUNET_HashCode keyhash;
767 
768  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received a watch record from service.\n");
770  if (NULL == record)
771  {
773  return;
774  }
775  PEERSTORE_hash_key (record->sub_system, &record->peer, record->key, &keyhash);
776  // FIXME: what if there are multiple watches for the same key?
777  wc = GNUNET_CONTAINER_multihashmap_get (h->watches, &keyhash);
778  if (NULL == wc)
779  {
781  _ ("Received a watch result for a non existing watch.\n"));
784  return;
785  }
786  if (NULL != wc->callback)
787  wc->callback (wc->callback_cls, record, NULL);
788  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
790 }
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
void PEERSTORE_hash_key(const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, struct GNUNET_HashCode *ret)
Creates a hash of the given key combination.
A 512-bit hashcode.
void * callback_cls
Closure for callback.
GNUNET_PEERSTORE_Processor callback
Callback with each record received.

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: