GNUnet  0.19.2
gnunet-service-revocation.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2013, 2014, 2016 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  */
20 
38 #include "platform.h"
39 #include <math.h>
40 #include "gnunet_util_lib.h"
41 #include "gnunet_block_lib.h"
42 #include "gnunet_constants.h"
43 #include "gnunet_protocols.h"
44 #include "gnunet_signatures.h"
46 #include "gnunet_core_service.h"
48 #include "gnunet_setu_service.h"
49 #include "revocation.h"
50 #include <gcrypt.h>
51 
52 
56 struct PeerEntry
57 {
62 
66  struct GNUNET_PeerIdentity id;
67 
72 
77 };
78 
79 
84 
90 
94 static const struct GNUNET_CONFIGURATION_Handle *cfg;
95 
100 
105 
110 
114 static struct GNUNET_PeerIdentity my_identity;
115 
120 
125 
129 static unsigned long long revocation_work_required;
130 
135 
141 
142 
149 static struct PeerEntry *
151 {
152  struct PeerEntry *peer_entry;
153 
154  peer_entry = GNUNET_new (struct PeerEntry);
155  peer_entry->id = *peer;
158  &peer_entry->id,
159  peer_entry,
161  return peer_entry;
162 }
163 
164 
172 static enum GNUNET_GenericReturnValue
173 verify_revoke_message (const struct RevokeMessage *rm)
174 {
175  const struct GNUNET_REVOCATION_PowP *pow
176  = (const struct GNUNET_REVOCATION_PowP *) &rm[1];
177 
178  if (GNUNET_YES !=
180  (unsigned int) revocation_work_required,
182  {
184  "Proof of work invalid!\n");
185  GNUNET_break_op (0);
186  return GNUNET_NO;
187  }
188  return GNUNET_YES;
189 }
190 
191 
200 static void *
201 client_connect_cb (void *cls,
202  struct GNUNET_SERVICE_Client *client,
203  struct GNUNET_MQ_Handle *mq)
204 {
205  return client;
206 }
207 
208 
216 static void
218  struct GNUNET_SERVICE_Client *client,
219  void *app_cls)
220 {
221  GNUNET_assert (client == app_cls);
222 }
223 
224 static int
226  const struct QueryMessage *qm)
227 {
228  uint16_t size;
229 
230  size = ntohs (qm->header.size);
231  if (size <= sizeof(struct RevokeMessage) ||
232  (size > UINT16_MAX))
233  {
234  GNUNET_break (0);
235  return GNUNET_SYSERR;
236  }
237  return GNUNET_OK;
238 
239 }
240 
241 
248 static void
250  const struct QueryMessage *qm)
251 {
252  struct GNUNET_SERVICE_Client *client = cls;
254  struct GNUNET_MQ_Envelope *env;
255  struct QueryResponseMessage *qrm;
256  struct GNUNET_HashCode hc;
257  int res;
258  size_t key_len;
259  size_t read;
260 
261  key_len = ntohl (qm->key_len);
262  if ((GNUNET_SYSERR ==
264  &zone, &read)) ||
265  (read != key_len))
266  {
268  "Unable to parse query public key\n");
270  return;
271  }
272  GNUNET_CRYPTO_hash (&qm[1],
273  key_len,
274  &hc);
276  &hc);
278  (GNUNET_NO == res)
279  ? "Received revocation check for valid key `%s' from client\n"
280  : "Received revocation check for revoked key `%s' from client\n",
281  GNUNET_h2s (&hc));
282  env = GNUNET_MQ_msg (qrm,
284  qrm->is_valid = htonl ((GNUNET_YES == res) ? GNUNET_NO : GNUNET_YES);
286  env);
288 }
289 
290 
299 static enum GNUNET_GenericReturnValue
300 do_flood (void *cls,
301  const struct GNUNET_PeerIdentity *target,
302  void *value)
303 {
304  const struct RevokeMessage *rm = cls;
305  struct PeerEntry *pe = value;
306  struct GNUNET_MQ_Envelope *e;
307  struct RevokeMessage *cp;
308 
309  if (NULL == pe->mq)
310  return GNUNET_OK; /* peer connected to us via SET,
311  but we have no direct CORE
312  connection for flooding */
313  e = GNUNET_MQ_msg_extra (cp,
314  htonl (rm->pow_size),
316  *cp = *rm;
317  memcpy (&cp[1],
318  &rm[1],
319  htonl (rm->pow_size));
321  "Flooding revocation to `%s'\n",
322  GNUNET_i2s (target));
323  GNUNET_MQ_send (pe->mq,
324  e);
325  return GNUNET_OK;
326 }
327 
328 
338 static enum GNUNET_GenericReturnValue
339 publicize_rm (const struct RevokeMessage *rm)
340 {
341  struct RevokeMessage *cp;
342  struct GNUNET_HashCode hc;
343  struct GNUNET_SETU_Element e;
344  ssize_t pklen;
345  const struct GNUNET_REVOCATION_PowP *pow
346  = (const struct GNUNET_REVOCATION_PowP *) &rm[1];
347  const struct GNUNET_IDENTITY_PublicKey *pk
348  = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1];
349 
352  if (0 > pklen)
353  {
354  GNUNET_break_op (0);
355  return GNUNET_SYSERR;
356  }
358  pklen,
359  &hc);
360  if (GNUNET_YES ==
362  &hc))
363  {
365  "Duplicate revocation received from peer. Ignored.\n");
366  return GNUNET_OK;
367  }
368  if (GNUNET_OK !=
370  {
371  GNUNET_break_op (0);
372  return GNUNET_SYSERR;
373  }
374  /* write to disk */
375  if (sizeof(struct RevokeMessage) !=
377  rm,
378  sizeof(struct RevokeMessage)))
379  {
381  "write");
382  return GNUNET_NO;
383  }
384  if (GNUNET_OK !=
386  {
388  "sync");
389  return GNUNET_NO;
390  }
391  /* keep copy in memory */
392  cp = (struct RevokeMessage *) GNUNET_copy_message (&rm->header);
395  &hc,
396  cp,
398  /* add to set for future connections */
399  e.size = htons (rm->header.size);
400  e.element_type = GNUNET_BLOCK_TYPE_REVOCATION;
401  e.data = rm;
402  if (GNUNET_OK !=
404  &e,
405  NULL,
406  NULL))
407  {
408  GNUNET_break (0);
409  return GNUNET_OK;
410  }
411  else
412  {
414  "Added revocation info to SET\n");
415  }
416  /* flood to neighbours */
418  &do_flood,
419  cp);
420  return GNUNET_OK;
421 }
422 
423 
424 static int
426  const struct RevokeMessage *rm)
427 {
428  uint16_t size;
429 
430  size = ntohs (rm->header.size);
431  if (size <= sizeof(struct RevokeMessage) ||
432  (size > UINT16_MAX))
433  {
434  GNUNET_break (0);
435  return GNUNET_SYSERR;
436  }
437  return GNUNET_OK;
438 
439 }
440 
441 
448 static void
450  const struct RevokeMessage *rm)
451 {
452  struct GNUNET_SERVICE_Client *client = cls;
453  struct GNUNET_MQ_Envelope *env;
454  struct RevocationResponseMessage *rrm;
455  int ret;
456 
458  "Received REVOKE message from client\n");
459  if (GNUNET_SYSERR == (ret = publicize_rm (rm)))
460  {
461  GNUNET_break_op (0);
463  return;
464  }
465  env = GNUNET_MQ_msg (rrm,
467  rrm->is_valid = htonl ((GNUNET_OK == ret) ? GNUNET_NO : GNUNET_YES);
469  env);
471 }
472 
473 
474 static int
475 check_p2p_revoke (void *cls,
476  const struct RevokeMessage *rm)
477 {
478  uint16_t size;
479 
480  size = ntohs (rm->header.size);
481  if (size <= sizeof(struct RevokeMessage))
482  {
483  GNUNET_break (0);
484  return GNUNET_SYSERR;
485  }
486  return GNUNET_OK;
487 
488 }
489 
490 
497 static void
498 handle_p2p_revoke (void *cls,
499  const struct RevokeMessage *rm)
500 {
502  "Received REVOKE message\n");
504  publicize_rm (rm));
505 }
506 
507 
518 static void
519 add_revocation (void *cls,
520  const struct GNUNET_SETU_Element *element,
521  uint64_t current_size,
523 {
524  struct PeerEntry *peer_entry = cls;
525  const struct RevokeMessage *rm;
526 
527  switch (status)
528  {
530  if (element->size != sizeof(struct RevokeMessage))
531  {
532  GNUNET_break_op (0);
533  return;
534  }
536  {
538  gettext_noop (
539  "# unsupported revocations received via set union"),
540  1,
541  GNUNET_NO);
542  return;
543  }
544  rm = element->data;
545  (void) handle_p2p_revoke (NULL,
546  rm);
548  gettext_noop (
549  "# revocation messages received via set union"),
550  1, GNUNET_NO);
551  break;
554  _ ("Error computing revocation set union with %s\n"),
555  GNUNET_i2s (&peer_entry->id));
556  peer_entry->so = NULL;
558  gettext_noop ("# revocation set unions failed"),
559  1,
560  GNUNET_NO);
561  break;
563  peer_entry->so = NULL;
565  gettext_noop (
566  "# revocation set unions completed"),
567  1,
568  GNUNET_NO);
569  break;
570  default:
571  GNUNET_break (0);
572  break;
573  }
574 }
575 
576 
583 static void
584 transmit_task_cb (void *cls)
585 {
586  struct PeerEntry *peer_entry = cls;
587 
589  "Starting set exchange with peer `%s'\n",
590  GNUNET_i2s (&peer_entry->id));
591  peer_entry->transmit_task = NULL;
592  GNUNET_assert (NULL == peer_entry->so);
593  peer_entry->so = GNUNET_SETU_prepare (&peer_entry->id,
595  NULL,
596  (struct GNUNET_SETU_Option[]) { { 0 } },
598  peer_entry);
599  if (GNUNET_OK !=
600  GNUNET_SETU_commit (peer_entry->so,
602  {
604  _ ("SET service crashed, terminating revocation service\n"));
606  return;
607  }
608 }
609 
610 
618 static void *
620  const struct GNUNET_PeerIdentity *peer,
621  struct GNUNET_MQ_Handle *mq)
622 {
623  struct PeerEntry *peer_entry;
624  struct GNUNET_HashCode my_hash;
625  struct GNUNET_HashCode peer_hash;
626 
627  if (0 == GNUNET_memcmp (peer,
628  &my_identity))
629  {
630  return NULL;
631  }
632 
634  "Peer `%s' connected to us\n",
635  GNUNET_i2s (peer));
637  "# peers connected",
638  1,
639  GNUNET_NO);
641  peer);
642  if (NULL != peer_entry)
643  {
644  /* This can happen if "core"'s notification is a tad late
645  and CADET+SET were faster and already produced a
646  #handle_revocation_union_request() for us to deal
647  with. This should be rare, but isn't impossible. */
648  peer_entry->mq = mq;
649  return peer_entry;
650  }
651  peer_entry = new_peer_entry (peer);
652  peer_entry->mq = mq;
654  sizeof(my_identity),
655  &my_hash);
657  sizeof(*peer),
658  &peer_hash);
659  if (0 < GNUNET_CRYPTO_hash_cmp (&my_hash,
660  &peer_hash))
661  {
663  "Starting SET operation with peer `%s'\n",
664  GNUNET_i2s (peer));
665  peer_entry->transmit_task =
668  peer_entry);
669  }
670  return peer_entry;
671 }
672 
673 
682 static void
684  const struct GNUNET_PeerIdentity *peer,
685  void *internal_cls)
686 {
687  struct PeerEntry *peer_entry = internal_cls;
688 
689  if (0 == GNUNET_memcmp (peer,
690  &my_identity))
691  return;
692  GNUNET_assert (NULL != peer_entry);
694  "Peer `%s' disconnected from us\n",
695  GNUNET_i2s (peer));
698  peer,
699  peer_entry));
700  if (NULL != peer_entry->transmit_task)
701  {
703  peer_entry->transmit_task = NULL;
704  }
705  if (NULL != peer_entry->so)
706  {
707  GNUNET_SETU_operation_cancel (peer_entry->so);
708  peer_entry->so = NULL;
709  }
710  GNUNET_free (peer_entry);
712  "# peers connected",
713  -1,
714  GNUNET_NO);
715 }
716 
717 
726 static int
727 free_entry (void *cls,
728  const struct GNUNET_HashCode *key,
729  void *value)
730 {
731  GNUNET_free (value);
732  return GNUNET_OK;
733 }
734 
735 
741 static void
742 shutdown_task (void *cls)
743 {
744  if (NULL != revocation_set)
745  {
747  revocation_set = NULL;
748  }
749  if (NULL != revocation_union_listen_handle)
750  {
753  }
754  if (NULL != core_api)
755  {
757  core_api = NULL;
758  }
759  if (NULL != stats)
760  {
762  stats = NULL;
763  }
764  if (NULL != peers)
765  {
767  peers = NULL;
768  }
769  if (NULL != revocation_db)
770  {
772  revocation_db = NULL;
773  }
775  &free_entry,
776  NULL);
778 }
779 
780 
787 static void
788 core_init (void *cls,
789  const struct GNUNET_PeerIdentity *identity)
790 {
791  if (NULL == identity)
792  {
794  "Connection to core FAILED!\n");
796  return;
797  }
799 }
800 
801 
817 static void
819  const struct GNUNET_PeerIdentity *other_peer,
820  const struct GNUNET_MessageHeader *context_msg,
822 {
823  struct PeerEntry *peer_entry;
824 
825  if (NULL == request)
826  {
827  GNUNET_break (0);
828  return;
829  }
831  "Received set exchange request from peer `%s'\n",
832  GNUNET_i2s (other_peer));
834  other_peer);
835  if (NULL == peer_entry)
836  {
837  peer_entry = new_peer_entry (other_peer);
838  }
839  if (NULL != peer_entry->so)
840  {
841  GNUNET_break_op (0);
842  return;
843  }
844  peer_entry->so = GNUNET_SETU_accept (request,
845  (struct GNUNET_SETU_Option[]) { { 0 } },
847  peer_entry);
848  if (GNUNET_OK !=
849  GNUNET_SETU_commit (peer_entry->so,
851  {
852  GNUNET_break (0);
854  return;
855  }
856 }
857 
858 
866 static void
867 run (void *cls,
868  const struct GNUNET_CONFIGURATION_Handle *c,
870 {
871  struct GNUNET_MQ_MessageHandler core_handlers[] = {
872  GNUNET_MQ_hd_var_size (p2p_revoke,
874  struct RevokeMessage,
875  NULL),
877  };
878  char *fn;
879  uint64_t left;
880  struct RevokeMessage *rm;
881  struct GNUNET_HashCode hc;
882  const struct GNUNET_IDENTITY_PublicKey *pk;
883 
884  GNUNET_CRYPTO_hash ("revocation-set-union-application-id",
885  strlen ("revocation-set-union-application-id"),
887  if (GNUNET_OK !=
889  "REVOCATION",
890  "DATABASE",
891  &fn))
892  {
894  "REVOCATION",
895  "DATABASE");
897  return;
898  }
899  cfg = c;
901  GNUNET_NO);
902  if (GNUNET_OK !=
904  "REVOCATION",
905  "WORKBITS",
907  {
909  "REVOCATION",
910  "WORKBITS");
912  GNUNET_free (fn);
913  return;
914  }
915  if (revocation_work_required >= sizeof(struct GNUNET_HashCode) * 8)
916  {
918  "REVOCATION",
919  "WORKBITS",
920  _ ("Value is too large.\n"));
922  GNUNET_free (fn);
923  return;
924  }
925  if (GNUNET_OK !=
927  "REVOCATION",
928  "EPOCH_DURATION",
929  &epoch_duration))
930  {
932  "REVOCATION",
933  "EPOCH_DURATION");
935  GNUNET_free (fn);
936  return;
937  }
938 
944  NULL);
952  if (NULL == revocation_db)
953  {
955  "REVOCATION",
956  "DATABASE",
957  _ ("Could not open revocation database file!"));
959  GNUNET_free (fn);
960  return;
961  }
962  if (GNUNET_OK !=
964  left = 0;
965  while (left > sizeof(struct RevokeMessage))
966  {
967  rm = GNUNET_new (struct RevokeMessage);
968  if (sizeof(struct RevokeMessage) !=
970  rm,
971  sizeof(struct RevokeMessage)))
972  {
974  "read",
975  fn);
976  GNUNET_free (rm);
978  GNUNET_free (fn);
979  return;
980  }
981  struct GNUNET_REVOCATION_PowP *pow = (struct
982  GNUNET_REVOCATION_PowP *) &rm[1];
983  ssize_t ksize;
984  pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1];
986  if (0 > ksize)
987  {
988  GNUNET_break_op (0);
989  GNUNET_free (rm);
990  GNUNET_free (fn);
991  return;
992  }
994  ksize,
995  &hc);
998  &hc,
999  rm,
1001  }
1002  GNUNET_free (fn);
1003 
1005  NULL);
1007  GNUNET_YES);
1008  /* Connect to core service and register core handlers */
1009  core_api = GNUNET_CORE_connect (cfg, /* Main configuration */
1010  NULL, /* Closure passed to functions */
1011  &core_init, /* Call core_init once connected */
1012  &handle_core_connect, /* Handle connects */
1013  &handle_core_disconnect, /* Handle disconnects */
1014  core_handlers); /* Register these handlers */
1015  if (NULL == core_api)
1016  {
1018  return;
1019  }
1020  stats = GNUNET_STATISTICS_create ("revocation",
1021  cfg);
1022 }
1023 
1024 
1029  ("revocation",
1031  &run,
1034  NULL,
1035  GNUNET_MQ_hd_var_size (query_message,
1037  struct QueryMessage,
1038  NULL),
1039  GNUNET_MQ_hd_var_size (revoke_message,
1041  struct RevokeMessage,
1042  NULL),
1044 
1045 
1046 #if defined(__linux__) && defined(__GLIBC__)
1047 #include <malloc.h>
1048 
1052 void __attribute__ ((constructor))
1053 GNUNET_REVOCATION_memory_init ()
1054 {
1055  mallopt (M_TRIM_THRESHOLD, 4 * 1024);
1056  mallopt (M_TOP_PAD, 1 * 1024);
1057  malloc_trim (0);
1058 }
1059 
1060 
1061 #endif
1062 
1063 
1064 /* end of gnunet-service-revocation.c */
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
@ GNUNET_BLOCK_TYPE_REVOCATION
Block type for a revocation message by which a key is revoked.
#define gettext_noop(String)
Definition: gettext.h:70
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static struct Experiment * e
static int res
struct GNUNET_HashCode key
The key used in the DHT.
uint16_t status
See PRISM_STATUS_*-constants.
enum RadiotapType __attribute__
struct GNUNET_IDENTITY_PrivateKey pk
Private key from command line option, or NULL.
static char * zone
Name of the zone being managed.
static char * value
Value of the record to add/remove.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static struct GNUNET_SETU_ListenHandle * revocation_union_listen_handle
Handle for us listening to incoming revocation set union requests.
static struct GNUNET_CONTAINER_MultiPeerMap * peers
Map of all connected peers.
static struct GNUNET_DISK_FileHandle * revocation_db
File handle for the revocation database.
static void transmit_task_cb(void *cls)
The timeout for performing the set union has expired, run the set operation on the revocation certifi...
static void core_init(void *cls, const struct GNUNET_PeerIdentity *identity)
Called on core init/fail.
static struct GNUNET_PeerIdentity my_identity
The peer identity of this peer.
static void handle_revoke_message(void *cls, const struct RevokeMessage *rm)
Handle REVOKE message from client.
static struct GNUNET_CONTAINER_MultiHashMap * revocation_map
Hash map with all revoked keys, maps the hash of the public key to the respective struct RevokeMessag...
static struct GNUNET_TIME_Relative epoch_duration
Length of an expiration expoch.
static struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our current configuration.
static int free_entry(void *cls, const struct GNUNET_HashCode *key, void *value)
Free all values in a hash map.
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
Handle client connecting to the service.
static void shutdown_task(void *cls)
Task run during shutdown.
static int check_revoke_message(void *cls, const struct RevokeMessage *rm)
static void handle_query_message(void *cls, const struct QueryMessage *qm)
Handle QUERY message from client.
static struct GNUNET_CORE_Handle * core_api
Handle to the core service (for flooding)
static struct PeerEntry * new_peer_entry(const struct GNUNET_PeerIdentity *peer)
Create a new PeerEntry and add it to the peers multipeermap.
static struct GNUNET_SETU_Handle * revocation_set
Set from all revocations known to us.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Handle network size estimate clients.
static enum GNUNET_GenericReturnValue publicize_rm(const struct RevokeMessage *rm)
Publicize revocation message.
static int check_p2p_revoke(void *cls, const struct RevokeMessage *rm)
static enum GNUNET_GenericReturnValue do_flood(void *cls, const struct GNUNET_PeerIdentity *target, void *value)
Flood the given revocation message to all neighbours.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
Handle client connecting to the service.
static struct GNUNET_HashCode revocation_set_union_app_id
Our application ID for set union operations.
static enum GNUNET_GenericReturnValue verify_revoke_message(const struct RevokeMessage *rm)
An revoke message has been received, check that it is well-formed.
static void add_revocation(void *cls, const struct GNUNET_SETU_Element *element, uint64_t current_size, enum GNUNET_SETU_Status status)
Callback for set operation results.
static void handle_core_disconnect(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
Method called whenever a peer disconnects.
GNUNET_SERVICE_MAIN("revocation", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(query_message, GNUNET_MESSAGE_TYPE_REVOCATION_QUERY, struct QueryMessage, NULL), GNUNET_MQ_hd_var_size(revoke_message, GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE, struct RevokeMessage, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
static int check_query_message(void *cls, const struct QueryMessage *qm)
static void * handle_core_connect(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a peer connects.
static unsigned long long revocation_work_required
Amount of work required (W-bit collisions) for REVOCATION proofs, in collision-bits.
static void handle_revocation_union_request(void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SETU_Request *request)
Called when another peer wants to do a set operation with the local peer.
static void handle_p2p_revoke(void *cls, const struct RevokeMessage *rm)
Core handler for flooded revocation messages.
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:40
Library for data block manipulation.
Core service; the main API for encrypted P2P communications.
Constants for network protocols.
API to perform and access key revocations.
Two-peer set union operations.
API to create, modify and access statistics.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
struct GNUNET_CORE_Handle * GNUNET_CORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Connect to the core service.
Definition: core_api.c:691
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:729
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1234
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:685
enum GNUNET_GenericReturnValue GNUNET_DISK_file_size(const char *filename, uint64_t *size, int include_symbolic_links, int single_file_mode)
Get the size of the file (or directory) of the given file (in bytes).
Definition: disk.c:221
enum GNUNET_GenericReturnValue GNUNET_DISK_file_sync(const struct GNUNET_DISK_FileHandle *h)
Write file changes to disk.
Definition: disk.c:1424
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1305
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:621
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.
@ GNUNET_DISK_OPEN_READWRITE
Open the file for both reading and writing.
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_GROUP_READ
Group can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
@ GNUNET_DISK_PERM_OTHER_READ
Everybody can read.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition: crypto_hash.c:220
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL).
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
enum GNUNET_GenericReturnValue 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.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
ssize_t GNUNET_IDENTITY_public_key_get_length(const struct GNUNET_IDENTITY_PublicKey *key)
Get the compacted length of a GNUNET_IDENTITY_PublicKey.
Definition: identity_api.c:830
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_read_public_key_from_buffer(const void *buffer, size_t len, struct GNUNET_IDENTITY_PublicKey *key, size_t *kb_read)
Reads a GNUNET_IDENTITY_PublicKey from a compact buffer.
Definition: identity_api.c:865
#define GNUNET_log(kind,...)
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
GNUNET_GenericReturnValue
Named constants for return values.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
void GNUNET_log_config_invalid(enum GNUNET_ErrorType kind, const char *section, const char *option, const char *required)
Log error message about invalid configuration option value.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
#define GNUNET_free(ptr)
Wrapper around free.
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_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:62
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_REVOCATION_QUERY
Client to service: was this key revoked?
#define GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE
Client to service OR peer-to-peer: revoke this key!
#define GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE_RESPONSE
Service to client: revocation confirmed.
#define GNUNET_MESSAGE_TYPE_REVOCATION_QUERY_RESPONSE
Service to client: answer if key was revoked!
enum GNUNET_GenericReturnValue GNUNET_REVOCATION_check_pow(const struct GNUNET_REVOCATION_PowP *pow, unsigned int matching_bits, struct GNUNET_TIME_Relative epoch_duration)
Check if the given proof-of-work is valid.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:534
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1303
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:944
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
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2330
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2443
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2249
@ GNUNET_SERVICE_OPTION_NONE
Use defaults.
struct GNUNET_SETU_Handle * GNUNET_SETU_create(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create an empty set, supporting the specified operation.
Definition: setu_api.c:384
void GNUNET_SETU_operation_cancel(struct GNUNET_SETU_OperationHandle *oh)
Cancel the given set operation.
Definition: setu_api.c:320
struct GNUNET_SETU_ListenHandle * GNUNET_SETU_listen(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_HashCode *app_id, GNUNET_SETU_ListenCallback listen_cb, void *listen_cls)
Wait for set operation requests for the given application ID.
Definition: setu_api.c:717
struct GNUNET_SETU_OperationHandle * GNUNET_SETU_prepare(const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, const struct GNUNET_SETU_Option options[], GNUNET_SETU_ResultIterator result_cb, void *result_cls)
Prepare a set operation to be evaluated with another peer.
Definition: setu_api.c:497
void GNUNET_SETU_destroy(struct GNUNET_SETU_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: setu_api.c:471
struct GNUNET_SETU_OperationHandle * GNUNET_SETU_accept(struct GNUNET_SETU_Request *request, const struct GNUNET_SETU_Option options[], GNUNET_SETU_ResultIterator result_cb, void *result_cls)
Accept a request we got via GNUNET_SETU_listen().
Definition: setu_api.c:769
int GNUNET_SETU_commit(struct GNUNET_SETU_OperationHandle *oh, struct GNUNET_SETU_Handle *set)
Commit a set to be used with a set operation.
Definition: setu_api.c:851
GNUNET_SETU_Status
Status for the result callback.
void GNUNET_SETU_listen_cancel(struct GNUNET_SETU_ListenHandle *lh)
Cancel the given listen operation.
Definition: setu_api.c:749
int GNUNET_SETU_add_element(struct GNUNET_SETU_Handle *set, const struct GNUNET_SETU_Element *element, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Add an element to the given set.
Definition: setu_api.c:429
@ GNUNET_SETU_STATUS_DONE
Success, all elements have been sent (and received).
@ GNUNET_SETU_STATUS_FAILURE
The other peer refused to do the operation with us, or something went wrong.
@ GNUNET_SETU_STATUS_ADD_LOCAL
Element should be added to the result set of the local peer, i.e.
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
#define GNUNET_TIME_UNIT_SECONDS
One second.
static unsigned int size
Size of the "table".
Definition: peer.c:68
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
messages for key revocation
Internal representation of the hash map.
Internal representation of the hash map.
Context for the core service connection.
Definition: core_api.c:78
Handle used to access files (and pipes).
A 512-bit hashcode.
An identity key as per LSD0001.
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
Header for all communications.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
The identity of the host (wraps the signing key of the peer).
Struct for a proof of work as part of the revocation.
Entry in list of pending tasks.
Definition: scheduler.c:136
Handle to a client that is connected to a service.
Definition: service.c:252
Handle to a service.
Definition: service.c:118
Element stored in a set.
uint16_t element_type
Application-specific element type.
uint16_t size
Number of bytes in the buffer pointed to by data.
const void * data
Actual data of the element.
Opaque handle to a set.
Definition: setu_api.c:40
Opaque handle to a listen operation.
Definition: setu_api.c:146
Handle to an operation.
Definition: setu_api.c:95
Option for set operations.
Handle for a set operation request from another peer.
Definition: setu_api.c:75
Handle for the service.
Time for relative time used by GNUnet, in microseconds.
Per-peer information.
struct GNUNET_PeerIdentity id
What is the identity of the peer?
struct GNUNET_SCHEDULER_Task * transmit_task
Tasked used to trigger the set union operation.
struct GNUNET_SETU_OperationHandle * so
Handle to active set union operation (over revocation sets).
struct GNUNET_MQ_Handle * mq
Queue for sending messages to this peer.
Query key revocation status.
Definition: revocation.h:38
uint32_t key_len
Key length.
Definition: revocation.h:47
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_REVOCATION_QUERY.
Definition: revocation.h:42
Key revocation response.
Definition: revocation.h:59
uint32_t is_valid
GNUNET_NO if revoked, GNUNET_YES if valid.
Definition: revocation.h:68
Key revocation response.
Definition: revocation.h:99
uint32_t is_valid
GNUNET_NO if revocation failed for internal reasons (e.g.
Definition: revocation.h:109
Revoke key.
Definition: revocation.h:80
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE.
Definition: revocation.h:84
uint32_t pow_size
Length of PoW with signature.
Definition: revocation.h:89
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.