GNUnet  0.10.x
peerstore_api.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2013-2016, 2019 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "peerstore.h"
29 #include "peerstore_common.h"
30 
31 #define LOG(kind, ...) GNUNET_log_from(kind, "peerstore-api", __VA_ARGS__)
32 
33 /******************************************************************************/
34 /************************ DATA STRUCTURES ****************************/
35 /******************************************************************************/
36 
45 
50 
55 
60 
65 
70 
75 
80 
85 
90 };
91 
100 
105 
110 
115 
119  void *cont_cls;
120 
124  char *sub_system;
125 
129  char *key;
130 
134  void *value;
135 
140 
144  size_t size;
145 
149  struct GNUNET_TIME_Absolute expiry;
150 
155 };
156 
165 
170 
175 
179  char *sub_system;
180 
185 
189  char *key;
190 
195 
200 
205 };
206 
215 
220 
225 
230 
235 
239  struct GNUNET_HashCode keyhash;
240 };
241 
242 /******************************************************************************/
243 /******************* DECLARATIONS *********************/
244 /******************************************************************************/
245 
251 static void
252 reconnect(void *cls);
253 
254 
260 static void
262 {
264 
265  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
266  ic = next)
267  {
268  next = ic->next;
269  if (GNUNET_YES == ic->iterating)
270  {
272  void *icb_cls;
273 
274  icb = ic->callback;
275  icb_cls = ic->callback_cls;
277  if (NULL != icb)
278  icb(icb_cls, NULL, "Iteration canceled due to reconnection");
279  }
280  }
281 
282  if (NULL != h->mq)
283  {
284  GNUNET_MQ_destroy(h->mq);
285  h->mq = NULL;
286  }
287 }
288 
289 
296 static void
298 {
299  GNUNET_assert(NULL == h->reconnect_task);
300  disconnect(h);
302  "Scheduling task to reconnect to PEERSTORE service in %s.\n",
304  h->reconnect_task =
307 }
308 
309 
315 static void
317 {
318  struct GNUNET_PEERSTORE_StoreContext *sc = cls;
320  void *cont_cls;
321 
322  cont = sc->cont;
323  cont_cls = sc->cont_cls;
325  if (NULL != cont)
326  cont(cont_cls, GNUNET_OK);
327 }
328 
329 
330 /******************************************************************************/
331 /******************* CONNECTION FUNCTIONS *********************/
332 /******************************************************************************/
333 
334 
338 static void
339 handle_client_error(void *cls, enum GNUNET_MQ_Error error)
340 {
341  struct GNUNET_PEERSTORE_Handle *h = cls;
342 
344  "Received an error notification from MQ of type: %d\n",
345  error);
347 }
348 
349 
358 static int
359 rewatch_it(void *cls, const struct GNUNET_HashCode *key, void *value)
360 {
361  struct GNUNET_PEERSTORE_Handle *h = cls;
363  struct StoreKeyHashMessage *hm;
364  struct GNUNET_MQ_Envelope *ev;
365 
367  hm->keyhash = wc->keyhash;
368  GNUNET_MQ_send(h->mq, ev);
369  return GNUNET_YES;
370 }
371 
372 
381 static int
382 destroy_watch(void *cls, const struct GNUNET_HashCode *key, void *value)
383 {
385 
387  return GNUNET_YES;
388 }
389 
390 
398 static void
400 {
401  if (NULL != h->mq)
402  {
403  GNUNET_MQ_destroy(h->mq);
404  h->mq = NULL;
405  }
406  GNUNET_free(h);
407 }
408 
409 
418 {
419  struct GNUNET_PEERSTORE_Handle *h;
420 
422  h->cfg = cfg;
424  reconnect(h);
425  if (NULL == h->mq)
426  {
427  GNUNET_free(h);
428  return NULL;
429  }
430  return h;
431 }
432 
433 
442 void
444 {
447 
448  LOG(GNUNET_ERROR_TYPE_DEBUG, "Disconnecting.\n");
449  if (NULL != h->watches)
450  {
453  h->watches = NULL;
454  }
455  while (NULL != (ic = h->iterate_head))
456  {
457  GNUNET_break(0);
459  }
460  if (NULL != h->store_head)
461  {
462  if (GNUNET_YES == sync_first)
463  {
465  "Delaying disconnection due to pending store requests.\n");
467  return;
468  }
469  while (NULL != (sc = h->store_head))
471  }
472  final_disconnect(h);
473 }
474 
475 
476 /******************************************************************************/
477 /******************* STORE FUNCTIONS *********************/
478 /******************************************************************************/
479 
480 
486 void
488 {
489  struct GNUNET_PEERSTORE_Handle *h = sc->h;
490 
492  GNUNET_free(sc->sub_system);
493  GNUNET_free(sc->value);
494  GNUNET_free(sc->key);
495  GNUNET_free(sc);
496  if ((GNUNET_YES == h->disconnecting) && (NULL == h->store_head))
497  final_disconnect(h);
498 }
499 
500 
519  const char *sub_system,
520  const struct GNUNET_PeerIdentity *peer,
521  const char *key,
522  const void *value,
523  size_t size,
527  void *cont_cls)
528 {
529  struct GNUNET_MQ_Envelope *ev;
531 
533  "Storing value (size: %lu) for subsytem `%s', peer `%s', key `%s'\n",
534  size,
535  sub_system,
536  GNUNET_i2s(peer),
537  key);
538  ev =
540  peer,
541  key,
542  value,
543  size,
544  expiry,
545  options,
548 
549  sc->sub_system = GNUNET_strdup(sub_system);
550  sc->peer = *peer;
551  sc->key = GNUNET_strdup(key);
552  sc->value = GNUNET_memdup(value, size);
553  sc->size = size;
554  sc->expiry = expiry;
555  sc->options = options;
556  sc->cont = cont;
557  sc->cont_cls = cont_cls;
558  sc->h = h;
559 
562  GNUNET_MQ_send(h->mq, ev);
563  return sc;
564 }
565 
566 
567 /******************************************************************************/
568 /******************* ITERATE FUNCTIONS *********************/
569 /******************************************************************************/
570 
571 
578 static void
579 handle_iterate_end(void *cls, const struct GNUNET_MessageHeader *msg)
580 {
581  struct GNUNET_PEERSTORE_Handle *h = cls;
584  void *callback_cls;
585 
586  ic = h->iterate_head;
587  if (NULL == ic)
588  {
590  _("Unexpected iteration response, this should not happen.\n"));
592  return;
593  }
594  callback = ic->callback;
595  callback_cls = ic->callback_cls;
596  ic->iterating = GNUNET_NO;
598  if (NULL != callback)
599  callback(callback_cls, NULL, NULL);
601 }
602 
603 
611 static int
612 check_iterate_result(void *cls, const struct StoreRecordMessage *msg)
613 {
614  /* we defer validation to #handle_iterate_result */
615  return GNUNET_OK;
616 }
617 
618 
625 static void
627 {
628  struct GNUNET_PEERSTORE_Handle *h = cls;
631  void *callback_cls;
633 
634  ic = h->iterate_head;
635  if (NULL == ic)
636  {
638  _("Unexpected iteration response, this should not happen.\n"));
640  return;
641  }
642  ic->iterating = GNUNET_YES;
643  callback = ic->callback;
644  callback_cls = ic->callback_cls;
645  if (NULL == callback)
646  return;
647  record = PEERSTORE_parse_record_message(msg);
648  if (NULL == record)
649  {
650  callback(callback_cls,
651  NULL,
652  _("Received a malformed response from service."));
653  }
654  else
655  {
656  callback(callback_cls, record, NULL);
657  PEERSTORE_destroy_record(record);
658  }
659 }
660 
661 
668 void
670 {
671  if (GNUNET_NO == ic->iterating)
672  {
674  GNUNET_free(ic->sub_system);
676  GNUNET_free(ic);
677  }
678  else
679  ic->callback = NULL;
680 }
681 
682 
696  const char *sub_system,
697  const struct GNUNET_PeerIdentity *peer,
698  const char *key,
700  void *callback_cls)
701 {
702  struct GNUNET_MQ_Envelope *ev;
704 
705  ev =
707  peer,
708  key,
709  NULL,
710  0,
712  0,
715  ic->callback = callback;
717  ic->h = h;
718  ic->sub_system = GNUNET_strdup(sub_system);
719  if (NULL != peer)
720  ic->peer = *peer;
721  if (NULL != key)
722  ic->key = GNUNET_strdup(key);
725  "Sending an iterate request for sub system `%s'\n",
726  sub_system);
727  GNUNET_MQ_send(h->mq, ev);
728  return ic;
729 }
730 
731 
732 /******************************************************************************/
733 /******************* WATCH FUNCTIONS *********************/
734 /******************************************************************************/
735 
742 static int
743 check_watch_record(void *cls, const struct StoreRecordMessage *msg)
744 {
745  /* we defer validation to #handle_watch_result */
746  return GNUNET_OK;
747 }
748 
749 
756 static void
757 handle_watch_record(void *cls, const struct StoreRecordMessage *msg)
758 {
759  struct GNUNET_PEERSTORE_Handle *h = cls;
761  struct GNUNET_HashCode keyhash;
763 
764  LOG(GNUNET_ERROR_TYPE_DEBUG, "Received a watch record from service.\n");
765  record = PEERSTORE_parse_record_message(msg);
766  if (NULL == record)
767  {
769  return;
770  }
771  PEERSTORE_hash_key(record->sub_system, &record->peer, record->key, &keyhash);
772  // FIXME: what if there are multiple watches for the same key?
773  wc = GNUNET_CONTAINER_multihashmap_get(h->watches, &keyhash);
774  if (NULL == wc)
775  {
777  _("Received a watch result for a non existing watch.\n"));
778  PEERSTORE_destroy_record(record);
780  return;
781  }
782  if (NULL != wc->callback)
783  wc->callback(wc->callback_cls, record, NULL);
785  PEERSTORE_destroy_record(record);
786 }
787 
788 
794 static void
795 reconnect(void *cls)
796 {
797  struct GNUNET_PEERSTORE_Handle *h = cls;
798  struct GNUNET_MQ_MessageHandler mq_handlers[] =
799  { GNUNET_MQ_hd_fixed_size(iterate_end,
801  struct GNUNET_MessageHeader,
802  h),
803  GNUNET_MQ_hd_var_size(iterate_result,
805  struct StoreRecordMessage,
806  h),
807  GNUNET_MQ_hd_var_size(watch_record,
809  struct StoreRecordMessage,
810  h),
812  struct GNUNET_MQ_Envelope *ev;
813 
814  h->reconnect_task = NULL;
815  LOG(GNUNET_ERROR_TYPE_DEBUG, "Reconnecting...\n");
816  h->mq = GNUNET_CLIENT_connect(h->cfg,
817  "peerstore",
818  mq_handlers,
820  h);
821  if (NULL == h->mq)
822  return;
824  "Resending pending requests after reconnect.\n");
825  if (NULL != h->watches)
827  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
828  ic = ic->next)
829  {
830  ev =
832  &ic->peer,
833  ic->key,
834  NULL,
835  0,
837  0,
839  GNUNET_MQ_send(h->mq, ev);
840  }
841  for (struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head; NULL != sc;
842  sc = sc->next)
843  {
844  ev =
846  &sc->peer,
847  sc->key,
848  sc->value,
849  sc->size,
850  sc->expiry,
851  sc->options,
854  GNUNET_MQ_send(h->mq, ev);
855  }
856 }
857 
858 
864 void
866 {
867  struct GNUNET_PEERSTORE_Handle *h = wc->h;
868  struct GNUNET_MQ_Envelope *ev;
869  struct StoreKeyHashMessage *hm;
870 
871  LOG(GNUNET_ERROR_TYPE_DEBUG, "Canceling watch.\n");
873  hm->keyhash = wc->keyhash;
874  GNUNET_MQ_send(h->mq, ev);
876  GNUNET_YES ==
878  GNUNET_free(wc);
879 }
880 
881 
896  const char *sub_system,
897  const struct GNUNET_PeerIdentity *peer,
898  const char *key,
900  void *callback_cls)
901 {
902  struct GNUNET_MQ_Envelope *ev;
903  struct StoreKeyHashMessage *hm;
905 
907  PEERSTORE_hash_key(sub_system, peer, key, &hm->keyhash);
909  wc->callback = callback;
911  wc->h = h;
912  wc->keyhash = hm->keyhash;
913  if (NULL == h->watches)
916  h->watches,
917  &wc->keyhash,
918  wc,
921  "Sending a watch request for subsystem `%s', peer `%s', key `%s'.\n",
922  sub_system,
923  GNUNET_i2s(peer),
924  key);
925  GNUNET_MQ_send(h->mq, ev);
926  return wc;
927 }
928 
929 /* end of peerstore_api.c */
struct GNUNET_PEERSTORE_WatchContext * prev
Kept in a DLL.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_PEERSTORE_IterateContext * iterate_head
Head of active ITERATE requests.
Definition: peerstore_api.c:64
#define GNUNET_MESSAGE_TYPE_PEERSTORE_STORE
Store request message.
Helper peerstore functions.
static void handle_client_error(void *cls, enum GNUNET_MQ_Error error)
Function called when we had trouble talking to the service.
GNUNET_PEERSTORE_Processor callback
Callback with each record received.
void GNUNET_PEERSTORE_watch_cancel(struct GNUNET_PEERSTORE_WatchContext *wc)
Cancel a watch request.
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_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.
struct GNUNET_PEERSTORE_Record * PEERSTORE_parse_record_message(const struct StoreRecordMessage *srm)
Parses a message carrying a record.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_PEERSTORE_StoreContext * next
Kept in a DLL.
Definition: peerstore_api.c:99
static void handle_watch_record(void *cls, const struct StoreRecordMessage *msg)
When a watch record is received, process it.
struct GNUNET_PeerIdentity peer
Peer Identity.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
void PEERSTORE_destroy_record(struct GNUNET_PEERSTORE_Record *record)
Free any memory allocated for this record.
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:900
struct GNUNET_PEERSTORE_IterateContext * iterate_tail
Tail of active ITERATE requests.
Definition: peerstore_api.c:69
GNUNET_MQ_Error
Error codes for the queue.
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.
enum GNUNET_FS_SearchOptions options
Options for the search.
Definition: fs_api.h:1579
#define GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL
Watch cancel request.
struct GNUNET_PEERSTORE_Handle * h
Handle to the PEERSTORE service.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void * callback_cls
Closure for callback.
static void handle_iterate_end(void *cls, const struct GNUNET_MessageHeader *msg)
When a response for iterate request is received.
#define LOG(kind,...)
Definition: peerstore_api.c:31
static void store_request_sent(void *cls)
Callback after MQ envelope is sent.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_PEERSTORE_IterateContext * prev
Kept in a DLL.
struct GNUNET_PeerIdentity peer
Peer the store is for.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
char * sub_system
Which subsystem does the store?
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE
Iteration request.
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.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Internal representation of the hash map.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
#define GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD
Watch response.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
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.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
IPC messages.
#define GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD
Iteration record message.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: peerstore_api.c:44
char * key
Record key string.
struct GNUNET_PEERSTORE_IterateContext * next
Kept in a DLL.
GNUNET_PEERSTORE_Processor callback
Callback with each matching record.
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:1237
struct GNUNET_HashCode keyhash
Hash of the combined key.
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:772
static char * value
Value of the record to add/remove.
struct GNUNET_PEERSTORE_Handle * h
Handle to the PEERSTORE service.
void * callback_cls
Closure for callback.
static int rewatch_it(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over previous watches to resend them.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_PEERSTORE_disconnect(struct GNUNET_PEERSTORE_Handle *h, int sync_first)
Disconnect from the PEERSTORE service.
Context for a store request.
Definition: peerstore_api.c:95
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_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_PEERSTORE_StoreContext * store_tail
Tail of active STORE requests.
Definition: peerstore_api.c:59
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:686
void * cont_cls
Closure for cont.
static void disconnect(struct GNUNET_PEERSTORE_Handle *h)
Disconnect from the peerstore service.
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
struct GNUNET_HashCode keyhash
Hash of a record key.
Definition: peerstore.h:102
GNUNET_PEERSTORE_StoreOption
Options for storing values in PEERSTORE.
void GNUNET_PEERSTORE_store_cancel(struct GNUNET_PEERSTORE_StoreContext *sc)
Cancel a store request.
void * value
Contains size bytes.
struct GNUNET_PEERSTORE_Handle * h
Handle to the PEERSTORE service.
Context for a watch request.
int disconnecting
Are we in the process of disconnecting but need to sync first?
Definition: peerstore_api.c:89
Handle to the PEERSTORE service.
Definition: peerstore_api.c:40
static void final_disconnect(struct GNUNET_PEERSTORE_Handle *h)
Kill the connection to the service.
char * key
Key for the store operation.
A 512-bit hashcode.
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.
static void reconnect(void *cls)
Close the existing connection to PEERSTORE and reconnect.
#define GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH
Watch request.
Message handler for a specific message type.
char * sub_system
Which subsystem does the store?
char * key
Key for the store operation.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_HashCode key
The key used in the DHT.
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.
static unsigned int size
Size of the "table".
Definition: peer.c:66
void(* GNUNET_PEERSTORE_Continuation)(void *cls, int success)
Continuation called with a status result.
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: peerstore_api.c:49
struct GNUNET_PEERSTORE_Handle * GNUNET_PEERSTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the PEERSTORE service.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
struct GNUNET_PEERSTORE_StoreContext * prev
Kept in a DLL.
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
#define GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END
Iteration end message.
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
Allow multiple values with the same key.
Handle to a message queue.
Definition: mq.c:84
The identity of the host (wraps the signing key of the peer).
struct GNUNET_TIME_Absolute expiry
When does the value expire?
size_t size
Number of bytes in value.
static int destroy_watch(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over watch requests to cancel them.
configuration data
Definition: configuration.c:83
char * sub_system
Responsible sub system string.
struct GNUNET_PeerIdentity peer
Peer the store is for.
Single PEERSTORE record.
Entry in list of pending tasks.
Definition: scheduler.c:131
GNUNET_PEERSTORE_Continuation cont
Continuation called with service response.
static int check_watch_record(void *cls, const struct StoreRecordMessage *msg)
When a watch record is received, validate it is well-formed.
Message carrying record key hash.
Definition: peerstore.h:88
void GNUNET_PEERSTORE_iterate_cancel(struct GNUNET_PEERSTORE_IterateContext *ic)
Cancel an iterate request Please do not call after the iterate request is done.
struct GNUNET_PEERSTORE_WatchContext * next
Kept in a DLL.
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
Message carrying a PEERSTORE record message.
Definition: peerstore.h:36
enum GNUNET_PEERSTORE_StoreOption options
Options for the store operation.
Header for all communications.
Time for absolute times used by GNUnet, in microseconds.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:821
#define GNUNET_YES
Definition: gnunet_common.h:77
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:351
int iterating
GNUNET_YES if we are currently processing records.
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.
struct GNUNET_PEERSTORE_StoreContext * store_head
Head of active STORE requests.
Definition: peerstore_api.c:54
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
static void handle_iterate_result(void *cls, const struct StoreRecordMessage *msg)
When a response for iterate request is received.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_TIME_Relative reconnect_delay
Delay until we try to reconnect.
Definition: peerstore_api.c:84
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
struct GNUNET_CONTAINER_MultiHashMap * watches
Hashmap of watch requests.
Definition: peerstore_api.c:74
Context for a iterate request.
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the task trying to reconnect to the service.
Definition: peerstore_api.c:79
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.