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 
41 {
42 
47 
52 
57 
62 
67 
72 
77 
82 
87 
92 };
93 
98 {
103 
108 
113 
118 
122  void *cont_cls;
123 
127  char *sub_system;
128 
132  char *key;
133 
137  void *value;
138 
143 
147  size_t size;
148 
152  struct GNUNET_TIME_Absolute expiry;
153 
158 };
159 
164 {
169 
174 
179 
183  char *sub_system;
184 
189 
193  char *key;
194 
199 
204 
209 };
210 
215 {
220 
225 
230 
235 
240 
244  struct GNUNET_HashCode keyhash;
245 };
246 
247 /******************************************************************************/
248 /******************* DECLARATIONS *********************/
249 /******************************************************************************/
250 
256 static void
257 reconnect (void *cls);
258 
259 
265 static void
267 {
269 
270  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
271  ic = next)
272  {
273  next = ic->next;
274  if (GNUNET_YES == ic->iterating)
275  {
277  void *icb_cls;
278 
279  icb = ic->callback;
280  icb_cls = ic->callback_cls;
282  if (NULL != icb)
283  icb (icb_cls, NULL, "Iteration canceled due to reconnection");
284  }
285  }
286 
287  if (NULL != h->mq)
288  {
289  GNUNET_MQ_destroy (h->mq);
290  h->mq = NULL;
291  }
292 }
293 
294 
301 static void
303 {
304  GNUNET_assert (NULL == h->reconnect_task);
305  disconnect (h);
307  "Scheduling task to reconnect to PEERSTORE service in %s.\n",
309  h->reconnect_task =
312 }
313 
314 
320 static void
322 {
323  struct GNUNET_PEERSTORE_StoreContext *sc = cls;
325  void *cont_cls;
326 
327  cont = sc->cont;
328  cont_cls = sc->cont_cls;
330  if (NULL != cont)
331  cont (cont_cls, GNUNET_OK);
332 }
333 
334 
335 /******************************************************************************/
336 /******************* CONNECTION FUNCTIONS *********************/
337 /******************************************************************************/
338 
339 
343 static void
344 handle_client_error (void *cls, enum GNUNET_MQ_Error error)
345 {
346  struct GNUNET_PEERSTORE_Handle *h = cls;
347 
349  "Received an error notification from MQ of type: %d\n",
350  error);
352 }
353 
354 
363 static int
364 rewatch_it (void *cls, const struct GNUNET_HashCode *key, void *value)
365 {
366  struct GNUNET_PEERSTORE_Handle *h = cls;
368  struct StoreKeyHashMessage *hm;
369  struct GNUNET_MQ_Envelope *ev;
370 
372  hm->keyhash = wc->keyhash;
373  GNUNET_MQ_send (h->mq, ev);
374  return GNUNET_YES;
375 }
376 
377 
386 static int
387 destroy_watch (void *cls, const struct GNUNET_HashCode *key, void *value)
388 {
390 
392  return GNUNET_YES;
393 }
394 
395 
403 static void
405 {
406  if (NULL != h->mq)
407  {
408  GNUNET_MQ_destroy (h->mq);
409  h->mq = NULL;
410  }
411  GNUNET_free (h);
412 }
413 
414 
423 {
424  struct GNUNET_PEERSTORE_Handle *h;
425 
426  h = GNUNET_new (struct GNUNET_PEERSTORE_Handle);
427  h->cfg = cfg;
429  reconnect (h);
430  if (NULL == h->mq)
431  {
432  GNUNET_free (h);
433  return NULL;
434  }
435  return h;
436 }
437 
438 
447 void
449 {
452 
453  LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting.\n");
454  if (NULL != h->watches)
455  {
458  h->watches = NULL;
459  }
460  while (NULL != (ic = h->iterate_head))
461  {
462  GNUNET_break (0);
464  }
465  if (NULL != h->store_head)
466  {
467  if (GNUNET_YES == sync_first)
468  {
470  "Delaying disconnection due to pending store requests.\n");
472  return;
473  }
474  while (NULL != (sc = h->store_head))
476  }
477  final_disconnect (h);
478 }
479 
480 
481 /******************************************************************************/
482 /******************* STORE FUNCTIONS *********************/
483 /******************************************************************************/
484 
485 
491 void
493 {
494  struct GNUNET_PEERSTORE_Handle *h = sc->h;
495 
497  GNUNET_free (sc->sub_system);
498  GNUNET_free (sc->value);
499  GNUNET_free (sc->key);
500  GNUNET_free (sc);
501  if ((GNUNET_YES == h->disconnecting) && (NULL == h->store_head))
502  final_disconnect (h);
503 }
504 
505 
524  const char *sub_system,
525  const struct GNUNET_PeerIdentity *peer,
526  const char *key,
527  const void *value,
528  size_t size,
532  void *cont_cls)
533 {
534  struct GNUNET_MQ_Envelope *ev;
536 
538  "Storing value (size: %lu) for subsytem `%s', peer `%s', key `%s'\n",
539  size,
540  sub_system,
541  GNUNET_i2s (peer),
542  key);
543  ev =
545  peer,
546  key,
547  value,
548  size,
549  expiry,
550  options,
553 
554  sc->sub_system = GNUNET_strdup (sub_system);
555  sc->peer = *peer;
556  sc->key = GNUNET_strdup (key);
557  sc->value = GNUNET_memdup (value, size);
558  sc->size = size;
559  sc->expiry = expiry;
560  sc->options = options;
561  sc->cont = cont;
562  sc->cont_cls = cont_cls;
563  sc->h = h;
564 
567  GNUNET_MQ_send (h->mq, ev);
568  return sc;
569 }
570 
571 
572 /******************************************************************************/
573 /******************* ITERATE FUNCTIONS *********************/
574 /******************************************************************************/
575 
576 
583 static void
584 handle_iterate_end (void *cls, const struct GNUNET_MessageHeader *msg)
585 {
586  struct GNUNET_PEERSTORE_Handle *h = cls;
589  void *callback_cls;
590 
591  ic = h->iterate_head;
592  if (NULL == ic)
593  {
595  _ ("Unexpected iteration response, this should not happen.\n"));
597  return;
598  }
599  callback = ic->callback;
600  callback_cls = ic->callback_cls;
601  ic->iterating = GNUNET_NO;
603  if (NULL != callback)
604  callback (callback_cls, NULL, NULL);
606 }
607 
608 
616 static int
617 check_iterate_result (void *cls, const struct StoreRecordMessage *msg)
618 {
619  /* we defer validation to #handle_iterate_result */
620  return GNUNET_OK;
621 }
622 
623 
630 static void
631 handle_iterate_result (void *cls, const struct StoreRecordMessage *msg)
632 {
633  struct GNUNET_PEERSTORE_Handle *h = cls;
636  void *callback_cls;
638 
639  ic = h->iterate_head;
640  if (NULL == ic)
641  {
643  _ ("Unexpected iteration response, this should not happen.\n"));
645  return;
646  }
647  ic->iterating = GNUNET_YES;
648  callback = ic->callback;
649  callback_cls = ic->callback_cls;
650  if (NULL == callback)
651  return;
652  record = PEERSTORE_parse_record_message (msg);
653  if (NULL == record)
654  {
655  callback (callback_cls,
656  NULL,
657  _ ("Received a malformed response from service."));
658  }
659  else
660  {
661  callback (callback_cls, record, NULL);
662  PEERSTORE_destroy_record (record);
663  }
664 }
665 
666 
673 void
675 {
676  if (GNUNET_NO == ic->iterating)
677  {
679  GNUNET_free (ic->sub_system);
681  GNUNET_free (ic);
682  }
683  else
684  ic->callback = NULL;
685 }
686 
687 
701  const char *sub_system,
702  const struct GNUNET_PeerIdentity *peer,
703  const char *key,
705  void *callback_cls)
706 {
707  struct GNUNET_MQ_Envelope *ev;
709 
710  ev =
712  peer,
713  key,
714  NULL,
715  0,
717  0,
720  ic->callback = callback;
722  ic->h = h;
723  ic->sub_system = GNUNET_strdup (sub_system);
724  if (NULL != peer)
725  ic->peer = *peer;
726  if (NULL != key)
727  ic->key = GNUNET_strdup (key);
730  "Sending an iterate request for sub system `%s'\n",
731  sub_system);
732  GNUNET_MQ_send (h->mq, ev);
733  return ic;
734 }
735 
736 
737 /******************************************************************************/
738 /******************* WATCH FUNCTIONS *********************/
739 /******************************************************************************/
740 
747 static int
748 check_watch_record (void *cls, const struct StoreRecordMessage *msg)
749 {
750  /* we defer validation to #handle_watch_result */
751  return GNUNET_OK;
752 }
753 
754 
761 static void
762 handle_watch_record (void *cls, const struct StoreRecordMessage *msg)
763 {
764  struct GNUNET_PEERSTORE_Handle *h = cls;
766  struct GNUNET_HashCode keyhash;
768 
769  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received a watch record from service.\n");
770  record = PEERSTORE_parse_record_message (msg);
771  if (NULL == record)
772  {
774  return;
775  }
776  PEERSTORE_hash_key (record->sub_system, &record->peer, record->key, &keyhash);
777  // FIXME: what if there are multiple watches for the same key?
778  wc = GNUNET_CONTAINER_multihashmap_get (h->watches, &keyhash);
779  if (NULL == wc)
780  {
782  _ ("Received a watch result for a non existing watch.\n"));
783  PEERSTORE_destroy_record (record);
785  return;
786  }
787  if (NULL != wc->callback)
788  wc->callback (wc->callback_cls, record, NULL);
790  PEERSTORE_destroy_record (record);
791 }
792 
793 
799 static void
800 reconnect (void *cls)
801 {
802  struct GNUNET_PEERSTORE_Handle *h = cls;
803  struct GNUNET_MQ_MessageHandler mq_handlers[] =
804  {GNUNET_MQ_hd_fixed_size (iterate_end,
806  struct GNUNET_MessageHeader,
807  h),
808  GNUNET_MQ_hd_var_size (iterate_result,
810  struct StoreRecordMessage,
811  h),
812  GNUNET_MQ_hd_var_size (watch_record,
814  struct StoreRecordMessage,
815  h),
817  struct GNUNET_MQ_Envelope *ev;
818 
819  h->reconnect_task = NULL;
820  LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting...\n");
821  h->mq = GNUNET_CLIENT_connect (h->cfg,
822  "peerstore",
823  mq_handlers,
825  h);
826  if (NULL == h->mq)
827  return;
829  "Resending pending requests after reconnect.\n");
830  if (NULL != h->watches)
832  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
833  ic = ic->next)
834  {
835  ev =
836  PEERSTORE_create_record_mq_envelope (ic->sub_system,
837  &ic->peer,
838  ic->key,
839  NULL,
840  0,
842  0,
844  GNUNET_MQ_send (h->mq, ev);
845  }
846  for (struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head; NULL != sc;
847  sc = sc->next)
848  {
849  ev =
851  &sc->peer,
852  sc->key,
853  sc->value,
854  sc->size,
855  sc->expiry,
856  sc->options,
859  GNUNET_MQ_send (h->mq, ev);
860  }
861 }
862 
863 
869 void
871 {
872  struct GNUNET_PEERSTORE_Handle *h = wc->h;
873  struct GNUNET_MQ_Envelope *ev;
874  struct StoreKeyHashMessage *hm;
875 
876  LOG (GNUNET_ERROR_TYPE_DEBUG, "Canceling watch.\n");
878  hm->keyhash = wc->keyhash;
879  GNUNET_MQ_send (h->mq, ev);
880  GNUNET_assert (
881  GNUNET_YES ==
883  GNUNET_free (wc);
884 }
885 
886 
901  const char *sub_system,
902  const struct GNUNET_PeerIdentity *peer,
903  const char *key,
905  void *callback_cls)
906 {
907  struct GNUNET_MQ_Envelope *ev;
908  struct StoreKeyHashMessage *hm;
910 
912  PEERSTORE_hash_key (sub_system, peer, key, &hm->keyhash);
914  wc->callback = callback;
916  wc->h = h;
917  wc->keyhash = hm->keyhash;
918  if (NULL == h->watches)
921  h->watches,
922  &wc->keyhash,
923  wc,
926  "Sending a watch request for subsystem `%s', peer `%s', key `%s'.\n",
927  sub_system,
928  GNUNET_i2s (peer),
929  key);
930  GNUNET_MQ_send (h->mq, ev);
931  return wc;
932 }
933 
934 /* 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:66
#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.
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:901
struct GNUNET_PEERSTORE_IterateContext * iterate_tail
Tail of active ITERATE requests.
Definition: peerstore_api.c:71
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:1621
#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.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_HashMapIterator it, void *it_cls)
Iterate over all entries in the map.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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:208
IPC messages.
#define GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD
Iteration record message.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: peerstore_api.c:46
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:1246
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:774
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:97
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:61
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:727
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:107
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:91
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:67
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:51
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:85
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:85
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:134
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:91
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:824
#define GNUNET_YES
Definition: gnunet_common.h:80
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:353
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:56
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:86
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
struct GNUNET_CONTAINER_MultiHashMap * watches
Hashmap of watch requests.
Definition: peerstore_api.c:76
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:81
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.