GNUnet  0.19.3
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 798 of file peerstore_api.c.

799 {
800  struct GNUNET_PEERSTORE_Handle *h = cls;
801  struct GNUNET_MQ_MessageHandler mq_handlers[] =
802  { GNUNET_MQ_hd_fixed_size (iterate_end,
804  struct GNUNET_MessageHeader,
805  h),
806  GNUNET_MQ_hd_var_size (iterate_result,
808  struct StoreRecordMessage,
809  h),
810  GNUNET_MQ_hd_var_size (watch_record,
812  struct StoreRecordMessage,
813  h),
815  struct GNUNET_MQ_Envelope *ev;
816 
817  h->reconnect_task = NULL;
818  LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting...\n");
820  "peerstore",
821  mq_handlers,
823  h);
824  if (NULL == h->mq)
825  {
826  h->reconnect_task =
827  GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
828  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
829  return;
830  }
832  "Resending pending requests after reconnect.\n");
833  if (NULL != h->watches)
835  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
836  ic = ic->next)
837  {
838  ev =
839  PEERSTORE_create_record_mq_envelope (ic->sub_system,
840  &ic->peer,
841  ic->key,
842  NULL,
843  0,
845  0,
847  GNUNET_MQ_send (h->mq, ev);
848  }
849  for (struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head; NULL != sc;
850  sc = sc->next)
851  {
852  ev =
854  &sc->peer,
855  sc->key,
856  sc->value,
857  sc->size,
858  sc->expiry,
859  sc->options,
862  GNUNET_MQ_send (h->mq, ev);
863  }
864 }
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:87
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:1057
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback 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:304
#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:638
#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:1241
#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:1598
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
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:683
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:569
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  if (NULL != sc)
327  {
328  cont = sc->cont;
329  cont_cls = sc->cont_cls;
331  if (NULL != cont)
333  }
334 }
@ GNUNET_OK
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 346 of file peerstore_api.c.

347 {
348  struct GNUNET_PEERSTORE_Handle *h = cls;
349 
351  "Received an error notification from MQ of type: %d\n",
352  error);
354 }
@ 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 366 of file peerstore_api.c.

367 {
368  struct GNUNET_PEERSTORE_Handle *h = cls;
370  struct StoreKeyHashMessage *hm;
371  struct GNUNET_MQ_Envelope *ev;
372 
374  hm->keyhash = wc->keyhash;
375  GNUNET_MQ_send (h->mq, ev);
376  return GNUNET_YES;
377 }
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:77
#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 389 of file peerstore_api.c.

390 {
392 
394  return GNUNET_YES;
395 }
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 406 of file peerstore_api.c.

407 {
408  if (NULL != h->mq)
409  {
411  h->mq = NULL;
412  }
413  GNUNET_free (h);
414 }
#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 592 of file peerstore_api.c.

593 {
594  struct GNUNET_PEERSTORE_Handle *h = cls;
597  void *callback_cls;
598 
599  ic = h->iterate_head;
600  if (NULL == ic)
601  {
603  _ ("Unexpected iteration response, this should not happen.\n"));
605  return;
606  }
607  callback = ic->callback;
609  ic->iterating = GNUNET_NO;
611  /* NOTE: set this here and not after callback because callback may free h */
612  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
613  if (NULL != callback)
614  callback (callback_cls, NULL, NULL);
615 }
@ GNUNET_NO
#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 626 of file peerstore_api.c.

627 {
628  /* we defer validation to #handle_iterate_result */
629  return GNUNET_OK;
630 }

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

641 {
642  struct GNUNET_PEERSTORE_Handle *h = cls;
645  void *callback_cls;
647 
648  ic = h->iterate_head;
649  if (NULL == ic)
650  {
652  _ ("Unexpected iteration response, this should not happen.\n"));
654  return;
655  }
656  ic->iterating = GNUNET_YES;
657  callback = ic->callback;
658  callback_cls = ic->callback_cls;
659  if (NULL == callback)
660  return;
662  if (NULL == record)
663  {
664  callback (callback_cls,
665  NULL,
666  _ ("Received a malformed response from service."));
667  }
668  else
669  {
670  callback (callback_cls, record, NULL);
672  }
673 }
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 746 of file peerstore_api.c.

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

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

761 {
762  struct GNUNET_PEERSTORE_Handle *h = cls;
764  struct GNUNET_HashCode keyhash;
766 
767  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received a watch record from service.\n");
769  if (NULL == record)
770  {
772  return;
773  }
774  PEERSTORE_hash_key (record->sub_system, &record->peer, record->key, &keyhash);
775  // FIXME: what if there are multiple watches for the same key?
776  wc = GNUNET_CONTAINER_multihashmap_get (h->watches, &keyhash);
777  if (NULL == wc)
778  {
780  _ ("Received a watch result for a non existing watch.\n"));
783  return;
784  }
785  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
786  if (NULL != wc->callback)
787  wc->callback (wc->callback_cls, record, NULL);
789 }
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: