GNUnet  0.11.x
rps_api.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C)
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 
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "rps.h"
29 #include "gnunet_rps_service.h"
30 #include "rps-sampler_client.h"
31 
32 #include "gnunet_nse_service.h"
33 
34 #include <inttypes.h>
35 
36 #define LOG(kind, ...) GNUNET_log_from (kind, "rps-api", __VA_ARGS__)
37 
42 {
47 
52 
56  void *ready_cb_cls;
57 
62 
67 
72 };
73 
74 
79 {
84 
89 
94 
99 
104 
109 
114 
119 
124 
129 
134 
139 
145 
153 };
154 
155 
160 {
165 
169  uint32_t num_requests;
170 
175 
180 
186 
191 
196 
201 
206 };
207 
208 
213 {
218 
223 
228 
234 
239 
244 
249 
254 };
255 
256 
262 {
267 
271  void *cls;
272 
276  struct GNUNET_CLIENT_Connection *service_conn;
277 };
278 
279 
285 
290 static uint64_t srh_callback_num_peers;
291 
292 
303 static struct GNUNET_RPS_StreamRequestHandle *
306  void *cls)
307 {
308  struct GNUNET_RPS_StreamRequestHandle *srh;
309 
311  srh->rps_handle = rps_handle;
312  srh->ready_cb = ready_cb;
313  srh->ready_cb_cls = cls;
315  rps_handle->stream_requests_tail,
316  srh);
317 
318  return srh;
319 }
320 
321 
327 static void
329 {
330  struct GNUNET_RPS_Handle *rps_handle = srh->rps_handle;
331 
332  GNUNET_assert (NULL != srh);
333  if (NULL != srh->callback_task)
334  {
336  srh->callback_task = NULL;
337  }
339  rps_handle->stream_requests_tail,
340  srh);
341  GNUNET_free (srh);
342 }
343 
344 
354 static void
356  uint32_t num_peers,
357  void *cls)
358 {
359  struct GNUNET_RPS_Request_Handle *rh = cls;
360 
361  rh->sampler_rh = NULL;
362  rh->ready_cb (rh->ready_cb_cls,
363  num_peers,
364  peers);
366 }
367 
368 
380 static void
382  void *cls,
383  double probability,
384  uint32_t num_observed)
385 {
386  struct GNUNET_RPS_Request_Handle_Single_Info *rh = cls;
387 
388  rh->sampler_rh = NULL;
389  rh->ready_cb (rh->ready_cb_cls,
390  peers,
391  probability,
392  num_observed);
394 }
395 
396 
405 static void
406 collect_peers_cb (void *cls,
407  uint64_t num_peers,
408  const struct GNUNET_PeerIdentity *peers)
409 {
410  struct GNUNET_RPS_Request_Handle *rh = cls;
411 
413  "Service sent %" PRIu64 " peers from stream\n",
414  num_peers);
415  for (uint64_t i = 0; i < num_peers; i++)
416  {
417  RPS_sampler_update (rh->sampler, &peers[i]);
418  }
419 }
420 
421 
432 static void
434  uint64_t num_peers,
435  const struct GNUNET_PeerIdentity *peers)
436 {
437  struct GNUNET_RPS_Request_Handle_Single_Info *rhs = cls;
438 
440  "Service sent %" PRIu64 " peers from stream\n",
441  num_peers);
442  for (uint64_t i = 0; i < num_peers; i++)
443  {
444  RPS_sampler_update (rhs->sampler, &peers[i]);
445  }
446 }
447 
448 
449 /* Get internals for debugging/profiling purposes */
450 
460 void
462  uint32_t num_updates,
464  void *cls)
465 {
466  struct GNUNET_MQ_Envelope *ev;
468 
470  "Client requests %" PRIu32 " view updates\n",
471  num_updates);
472  rps_handle->view_update_cb = view_update_cb;
473  rps_handle->view_update_cls = cls;
474 
476  msg->num_updates = htonl (num_updates);
477  GNUNET_MQ_send (rps_handle->mq, ev);
478 }
479 
480 
481 void
483 {
484  struct GNUNET_MQ_Envelope *ev;
485 
486  GNUNET_assert (NULL != rps_handle->view_update_cb);
487 
488  rps_handle->view_update_cb = NULL;
489 
491  GNUNET_MQ_send (rps_handle->mq, ev);
492 }
493 
494 
504  GNUNET_RPS_NotifyReadyCB stream_input_cb,
505  void *cls)
506 {
507  struct GNUNET_RPS_StreamRequestHandle *srh;
508  struct GNUNET_MQ_Envelope *ev;
510 
511  srh = new_stream_request (rps_handle,
512  stream_input_cb,
513  cls);
514  LOG (GNUNET_ERROR_TYPE_DEBUG, "Client requests biased stream updates\n");
515 
517  GNUNET_MQ_send (rps_handle->mq, ev);
518  return srh;
519 }
520 
521 
530 static int
531 check_view_update (void *cls,
532  const struct GNUNET_RPS_CS_DEBUG_ViewReply *msg)
533 {
534  uint16_t msize = ntohs (msg->header.size);
535  uint32_t num_peers = ntohl (msg->num_peers);
536 
537  (void) cls;
538 
539  msize -= sizeof(struct GNUNET_RPS_CS_DEBUG_ViewReply);
540  if ((msize / sizeof(struct GNUNET_PeerIdentity) != num_peers) ||
541  (msize % sizeof(struct GNUNET_PeerIdentity) != 0))
542  {
543  GNUNET_break (0);
544  return GNUNET_SYSERR;
545  }
546  return GNUNET_OK;
547 }
548 
549 
557 static void
559  const struct GNUNET_RPS_CS_DEBUG_ViewReply *msg)
560 {
561  struct GNUNET_RPS_Handle *h = cls;
562  struct GNUNET_PeerIdentity *peers;
563 
564  /* Give the peers back */
566  "New view of %" PRIu32 " peers:\n",
567  ntohl (msg->num_peers));
568 
569  peers = (struct GNUNET_PeerIdentity *) &msg[1];
570  GNUNET_assert (NULL != h);
571  GNUNET_assert (NULL != h->view_update_cb);
572  h->view_update_cb (h->view_update_cls, ntohl (msg->num_peers), peers);
573 }
574 
575 
582 static void
584 {
585  struct GNUNET_MQ_Envelope *ev;
586 
588  GNUNET_MQ_send (rps_handle->mq, ev);
589 }
590 
591 
597 void
599 {
601 
602  rps_handle = srh->rps_handle;
603  remove_stream_request (srh);
604  if (NULL == rps_handle->stream_requests_head)
605  cancel_stream (rps_handle);
606 }
607 
608 
619 static int
621  const struct GNUNET_RPS_CS_DEBUG_StreamReply *msg)
622 {
623  uint16_t msize = ntohs (msg->header.size);
624  uint32_t num_peers = ntohl (msg->num_peers);
625 
626  (void) cls;
627 
628  msize -= sizeof(struct GNUNET_RPS_CS_DEBUG_StreamReply);
629  if ((msize / sizeof(struct GNUNET_PeerIdentity) != num_peers) ||
630  (msize % sizeof(struct GNUNET_PeerIdentity) != 0))
631  {
632  GNUNET_break (0);
633  return GNUNET_SYSERR;
634  }
635  return GNUNET_OK;
636 }
637 
638 
644 static void
646 {
647  struct GNUNET_RPS_StreamRequestHandle *srh = cls;
648 
649  srh->callback_task = NULL;
650  srh->ready_cb (srh->ready_cb_cls,
652  srh_callback_peers);
653 }
654 
655 
664 static void
666  const struct GNUNET_RPS_CS_DEBUG_StreamReply *msg)
667 {
668  struct GNUNET_RPS_Handle *h = cls;
669  // const struct GNUNET_PeerIdentity *peers;
670  uint64_t num_peers;
671  struct GNUNET_RPS_StreamRequestHandle *srh_iter;
672  struct GNUNET_RPS_StreamRequestHandle *srh_next;
673 
674  // peers = (struct GNUNET_PeerIdentity *) &msg[1];
675  num_peers = ntohl (msg->num_peers);
677  GNUNET_free_non_null (srh_callback_peers);
678  srh_callback_peers = GNUNET_new_array (num_peers,
679  struct GNUNET_PeerIdentity);
680  GNUNET_memcpy (srh_callback_peers,
681  &msg[1],
682  num_peers * sizeof(struct GNUNET_PeerIdentity));
684  "Received %" PRIu64 " peer(s) from stream input.\n",
685  num_peers);
686  for (srh_iter = h->stream_requests_head;
687  NULL != srh_iter;
688  srh_iter = srh_next)
689  {
690  LOG (GNUNET_ERROR_TYPE_DEBUG, "Calling srh \n");
691  /* Store next pointer - srh might be removed/freed in callback */
692  srh_next = srh_iter->next;
693  if (NULL != srh_iter->callback_task)
695  srh_iter->callback_task =
697  srh_iter);
698  }
699 
700  if (NULL == h->stream_requests_head)
701  {
702  cancel_stream (h);
703  }
704 }
705 
706 
710 static void
711 reconnect (struct GNUNET_RPS_Handle *h);
712 
713 
723 static void
724 mq_error_handler (void *cls,
725  enum GNUNET_MQ_Error error)
726 {
727  struct GNUNET_RPS_Handle *h = cls;
728 
729  // TODO LOG
731  "Problem with message queue. error: %i\n\
732  1: READ,\n\
733  2: WRITE,\n\
734  4: TIMEOUT\n",
735  // TODO: write GNUNET_MQ_strerror (error)
736  error);
737  reconnect (h);
738  /* Resend all pending request as the service destroyed its knowledge
739  * about them */
740 }
741 
742 
750 static void
751 hash_from_share_val (const char *share_val,
752  struct GNUNET_HashCode *hash)
753 {
754  GNUNET_CRYPTO_kdf (hash,
755  sizeof(struct GNUNET_HashCode),
756  "rps",
757  strlen ("rps"),
758  share_val,
759  strlen (share_val),
760  NULL, 0);
761 }
762 
763 
775 static void
776 nse_cb (void *cls,
777  struct GNUNET_TIME_Absolute timestamp,
778  double logestimate,
779  double std_dev)
780 {
781  struct GNUNET_RPS_Handle *h = cls;
782 
783  (void) timestamp;
784  (void) std_dev;
785 
786  for (struct GNUNET_RPS_Request_Handle *rh_iter = h->rh_head;
787  NULL != rh_iter && NULL != rh_iter->next;
788  rh_iter = rh_iter->next)
789  {
790  RPS_sampler_update_with_nw_size (rh_iter->sampler,
792  logestimate));
793  }
794  for (struct GNUNET_RPS_Request_Handle_Single_Info *rhs_iter = h->rhs_head;
795  NULL != rhs_iter && NULL != rhs_iter->next;
796  rhs_iter = rhs_iter->next)
797  {
798  RPS_sampler_update_with_nw_size (rhs_iter->sampler,
800  logestimate));
801  }
802 }
803 
804 
808 static void
810 {
811  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
815  h),
819  h),
821  };
822 
823  if (NULL != h->mq)
824  GNUNET_MQ_destroy (h->mq);
825  h->mq = GNUNET_CLIENT_connect (h->cfg,
826  "rps",
827  mq_handlers,
829  h);
830  if (NULL != h->nse)
832  h->nse = GNUNET_NSE_connect (h->cfg, &nse_cb, h);
833 }
834 
835 
842 struct GNUNET_RPS_Handle *
844 {
845  struct GNUNET_RPS_Handle *h;
846 
847  h = GNUNET_new (struct GNUNET_RPS_Handle);
848  h->cfg = cfg;
849  if (GNUNET_OK !=
851  "RPS",
852  "DESIRED_PROBABILITY",
853  &h->desired_probability))
854  {
856  "RPS", "DESIRED_PROBABILITY");
857  GNUNET_free (h);
858  return NULL;
859  }
860  if ((0 > h->desired_probability) ||
861  (1 < h->desired_probability) )
862  {
864  "The desired probability must be in the interval [0;1]\n");
865  GNUNET_free (h);
866  return NULL;
867  }
868  if (GNUNET_OK !=
870  "RPS",
871  "DEFICIENCY_FACTOR",
872  &h->deficiency_factor))
873  {
875  "RPS", "DEFICIENCY_FACTOR");
876  GNUNET_free (h);
877  return NULL;
878  }
879  if ((0 > h->desired_probability) ||
880  (1 < h->desired_probability) )
881  {
883  "The deficiency factor must be in the interval [0;1]\n");
884  GNUNET_free (h);
885  return NULL;
886  }
887  reconnect (h);
888  if (NULL == h->mq)
889  {
890  GNUNET_free (h);
891  return NULL;
892  }
893  return h;
894 }
895 
896 
903 void
905  const char *shared_value)
906 {
908  struct GNUNET_MQ_Envelope *ev;
909 
911  hash_from_share_val (shared_value, &msg->hash);
912  msg->round_interval = GNUNET_TIME_relative_hton ( // TODO read from config!
915 
916  GNUNET_MQ_send (h->mq, ev);
917 }
918 
919 
926 void
928  const char *shared_value)
929 {
931  struct GNUNET_MQ_Envelope *ev;
932 
934  hash_from_share_val (shared_value, &msg->hash);
935 
936  GNUNET_MQ_send (h->mq, ev);
937 }
938 
939 
951  uint32_t num_req_peers,
953  void *cls)
954 {
955  struct GNUNET_RPS_Request_Handle *rh;
956 
958  "Client requested %" PRIu32 " peers\n",
959  num_req_peers);
961  rh->rps_handle = rps_handle;
962  rh->num_requests = num_req_peers;
963  rh->sampler = RPS_sampler_mod_init (num_req_peers,
964  GNUNET_TIME_UNIT_SECONDS); // TODO remove this time-stuff
966  rps_handle->desired_probability);
968  rps_handle->deficiency_factor);
970  num_req_peers,
972  rh);
973  rh->srh = GNUNET_RPS_stream_request (rps_handle,
975  rh); /* cls */
976  rh->ready_cb = ready_cb;
977  rh->ready_cb_cls = cls;
979  rps_handle->rh_tail,
980  rh);
981 
982  return rh;
983 }
984 
985 
997  void *cls)
998 {
1000  uint32_t num_req_peers = 1;
1001 
1003  "Client requested peer with additional info\n");
1005  rhs->rps_handle = rps_handle;
1006  rhs->sampler = RPS_sampler_mod_init (num_req_peers,
1007  GNUNET_TIME_UNIT_SECONDS); // TODO remove this time-stuff
1009  rps_handle->desired_probability);
1011  rps_handle->deficiency_factor);
1014  rhs);
1015  rhs->srh = GNUNET_RPS_stream_request (rps_handle,
1017  rhs); /* cls */
1018  rhs->ready_cb = ready_cb;
1019  rhs->ready_cb_cls = cls;
1021  rps_handle->rhs_tail,
1022  rhs);
1023 
1024  return rhs;
1025 }
1026 
1027 
1035 void
1037  uint32_t n,
1038  const struct GNUNET_PeerIdentity *ids)
1039 {
1040  size_t size_needed;
1041  uint32_t num_peers_max;
1042  const struct GNUNET_PeerIdentity *tmp_peer_pointer;
1043  struct GNUNET_MQ_Envelope *ev;
1045 
1047  "Client wants to seed %" PRIu32 " peers:\n",
1048  n);
1049  for (unsigned int i = 0; i < n; i++)
1051  "%u. peer: %s\n",
1052  i,
1053  GNUNET_i2s (&ids[i]));
1054 
1055  /* The actual size the message occupies */
1056  size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage)
1057  + n * sizeof(struct GNUNET_PeerIdentity);
1058  /* The number of peers that fits in one message together with
1059  * the respective header */
1060  num_peers_max = (GNUNET_MAX_MESSAGE_SIZE
1061  - sizeof(struct GNUNET_RPS_CS_SeedMessage))
1062  / sizeof(struct GNUNET_PeerIdentity);
1063  tmp_peer_pointer = ids;
1064 
1065  while (GNUNET_MAX_MESSAGE_SIZE < size_needed)
1066  {
1067  ev = GNUNET_MQ_msg_extra (msg,
1068  num_peers_max * sizeof(struct
1069  GNUNET_PeerIdentity),
1071  msg->num_peers = htonl (num_peers_max);
1072  GNUNET_memcpy (&msg[1],
1073  tmp_peer_pointer,
1074  num_peers_max * sizeof(struct GNUNET_PeerIdentity));
1075  GNUNET_MQ_send (h->mq,
1076  ev);
1077  n -= num_peers_max;
1078  size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage)
1079  + n * sizeof(struct GNUNET_PeerIdentity);
1080  /* Set pointer to beginning of next block of num_peers_max peers */
1081  tmp_peer_pointer = &ids[num_peers_max];
1082  }
1083 
1084  ev = GNUNET_MQ_msg_extra (msg,
1085  n * sizeof(struct GNUNET_PeerIdentity),
1087  msg->num_peers = htonl (n);
1088  GNUNET_memcpy (&msg[1],
1089  tmp_peer_pointer,
1090  n * sizeof(struct GNUNET_PeerIdentity));
1091  GNUNET_MQ_send (h->mq,
1092  ev);
1093 }
1094 
1095 
1096 #if ENABLE_MALICIOUS
1097 
1111 void
1112 GNUNET_RPS_act_malicious (struct GNUNET_RPS_Handle *h,
1113  uint32_t type,
1114  uint32_t num_peers,
1115  const struct GNUNET_PeerIdentity *peer_ids,
1116  const struct GNUNET_PeerIdentity *target_peer)
1117 {
1118  size_t size_needed;
1119  uint32_t num_peers_max;
1120  const struct GNUNET_PeerIdentity *tmp_peer_pointer;
1121  struct GNUNET_MQ_Envelope *ev;
1122  struct GNUNET_RPS_CS_ActMaliciousMessage *msg;
1123 
1124  unsigned int i;
1125 
1127  "Client turns malicious (type %" PRIu32 ") with %" PRIu32
1128  " other peers:\n",
1129  type,
1130  num_peers);
1131  for (i = 0; i < num_peers; i++)
1133  "%u. peer: %s\n",
1134  i,
1135  GNUNET_i2s (&peer_ids[i]));
1136 
1137  /* The actual size the message would occupy */
1138  size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage)
1139  + num_peers * sizeof(struct GNUNET_PeerIdentity);
1140  /* The number of peers that fit in one message together with
1141  * the respective header */
1142  num_peers_max = (GNUNET_MAX_MESSAGE_SIZE
1143  - sizeof(struct GNUNET_RPS_CS_SeedMessage))
1144  / sizeof(struct GNUNET_PeerIdentity);
1145  tmp_peer_pointer = peer_ids;
1146 
1147  while (GNUNET_MAX_MESSAGE_SIZE < size_needed)
1148  {
1150  "Too many peers to send at once, sending %" PRIu32
1151  " (all we can so far)\n",
1152  num_peers_max);
1153  ev = GNUNET_MQ_msg_extra (msg,
1154  num_peers_max * sizeof(struct
1155  GNUNET_PeerIdentity),
1156  GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS);
1157  msg->type = htonl (type);
1158  msg->num_peers = htonl (num_peers_max);
1159  if ((2 == type) ||
1160  (3 == type))
1161  msg->attacked_peer = peer_ids[num_peers];
1162  GNUNET_memcpy (&msg[1],
1163  tmp_peer_pointer,
1164  num_peers_max * sizeof(struct GNUNET_PeerIdentity));
1165 
1166  GNUNET_MQ_send (h->mq, ev);
1167 
1168  num_peers -= num_peers_max;
1169  size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage)
1170  + num_peers * sizeof(struct GNUNET_PeerIdentity);
1171  /* Set pointer to beginning of next block of num_peers_max peers */
1172  tmp_peer_pointer = &peer_ids[num_peers_max];
1173  }
1174 
1175  ev = GNUNET_MQ_msg_extra (msg,
1176  num_peers * sizeof(struct GNUNET_PeerIdentity),
1177  GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS);
1178  msg->type = htonl (type);
1179  msg->num_peers = htonl (num_peers);
1180  if ((2 == type) ||
1181  (3 == type))
1182  msg->attacked_peer = *target_peer;
1183  GNUNET_memcpy (&msg[1],
1184  tmp_peer_pointer,
1185  num_peers * sizeof(struct GNUNET_PeerIdentity));
1186 
1187  GNUNET_MQ_send (h->mq, ev);
1188 }
1189 
1190 
1191 #endif /* ENABLE_MALICIOUS */
1192 
1193 
1199 void
1201 {
1202  struct GNUNET_RPS_Handle *h;
1203 
1204  h = rh->rps_handle;
1205  GNUNET_assert (NULL != rh);
1206  GNUNET_assert (NULL != rh->srh);
1207  GNUNET_assert (h == rh->srh->rps_handle);
1209  rh->srh = NULL;
1210  if (NULL == h->stream_requests_head)
1211  cancel_stream (h);
1212  if (NULL != rh->sampler_rh)
1213  {
1215  }
1217  rh->sampler = NULL;
1219  h->rh_tail,
1220  rh);
1221  GNUNET_free (rh);
1222 }
1223 
1224 
1230 void
1233 {
1234  struct GNUNET_RPS_Handle *h;
1235 
1236  h = rhs->rps_handle;
1237  GNUNET_assert (NULL != rhs);
1238  GNUNET_assert (NULL != rhs->srh);
1239  GNUNET_assert (h == rhs->srh->rps_handle);
1241  rhs->srh = NULL;
1242  if (NULL == h->stream_requests_head)
1243  cancel_stream (h);
1244  if (NULL != rhs->sampler_rh)
1245  {
1247  }
1249  rhs->sampler = NULL;
1251  h->rhs_tail,
1252  rhs);
1253  GNUNET_free (rhs);
1254 }
1255 
1256 
1262 void
1264 {
1265  if (NULL != h->stream_requests_head)
1266  {
1267  struct GNUNET_RPS_StreamRequestHandle *srh_next;
1268 
1270  "Still waiting for replies\n");
1271  for (struct GNUNET_RPS_StreamRequestHandle *srh_iter =
1273  NULL != srh_iter;
1274  srh_iter = srh_next)
1275  {
1276  srh_next = srh_iter->next;
1277  GNUNET_RPS_stream_cancel (srh_iter);
1278  }
1279  }
1280  if (NULL != h->rh_head)
1281  {
1283  "Not all requests were cancelled!\n");
1284  for (struct GNUNET_RPS_Request_Handle *rh_iter = h->rh_head;
1285  h->rh_head != NULL;
1286  rh_iter = h->rh_head)
1287  {
1288  GNUNET_RPS_request_cancel (rh_iter);
1289  }
1290  }
1291  if (NULL != h->rhs_head)
1292  {
1294  "Not all requests were cancelled!\n");
1295  for (struct GNUNET_RPS_Request_Handle_Single_Info *rhs_iter = h->rhs_head;
1296  h->rhs_head != NULL;
1297  rhs_iter = h->rhs_head)
1298  {
1300  }
1301  }
1302  if (NULL != srh_callback_peers)
1303  {
1304  GNUNET_free (srh_callback_peers);
1305  srh_callback_peers = NULL;
1306  }
1307  if (NULL != h->view_update_cb)
1308  {
1310  "Still waiting for view updates\n");
1312  }
1313  if (NULL != h->nse)
1315  GNUNET_MQ_destroy (h->mq);
1316  GNUNET_free (h);
1317 }
1318 
1319 
1320 /* end of rps_api.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_RPS_Request_Handle_Single_Info * rhs_head
Pointer to the head element in DLL of single request handles.
Definition: rps_api.c:133
#define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REPLY
Send peer of biased stream.
static void collect_peers_cb(void *cls, uint64_t num_peers, const struct GNUNET_PeerIdentity *peers)
Callback to collect the peers from the biased stream and put those into the sampler.
Definition: rps_api.c:406
#define GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START
RPS client-service message to start a sub sampler.
struct GNUNET_RPS_Request_Handle * GNUNET_RPS_request_peers(struct GNUNET_RPS_Handle *rps_handle, uint32_t num_req_peers, GNUNET_RPS_NotifyReadyCB ready_cb, void *cls)
Request n random peers.
Definition: rps_api.c:950
Handle for a request to get peers from biased stream of ids.
Definition: rps_api.c:41
Message from service to client containing current update of view.
Definition: rps.h:185
struct GNUNET_RPS_Request_Handle * rh_tail
Pointer to the tail element in DLL of request handles.
Definition: rps_api.c:128
struct GNUNET_MessageHeader header
Header including size and type in NBO.
Definition: rps.h:224
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static void nse_cb(void *cls, struct GNUNET_TIME_Absolute timestamp, double logestimate, double std_dev)
Callback for network size estimate - called with new estimates about the network size, updates all samplers with the new estimate.
Definition: rps_api.c:776
Message from client to service indicating that clients wants to get stream of biased peers...
Definition: rps.h:208
struct GNUNET_RPS_StreamRequestHandle * srh
Request handle of the request of the biased stream of peers - needed to cancel the request...
Definition: rps_api.c:185
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static void reconnect(struct GNUNET_RPS_Handle *h)
Reconnect to the service.
Definition: rps_api.c:809
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
GNUNET_RPS_NotifyReadyCB ready_cb
The callback to be called when we receive an answer.
Definition: rps_api.c:190
uint32_t num_updates
Number of updates 0 for sending updates until cancellation.
Definition: rps.h:179
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
void GNUNET_RPS_seed_ids(struct GNUNET_RPS_Handle *h, uint32_t n, const struct GNUNET_PeerIdentity *ids)
Seed rps service with peerIDs.
Definition: rps_api.c:1036
struct RPS_Sampler * sampler
The Sampler for the client request.
Definition: rps_api.c:174
Message from client to service indicating that clients wants to get updates of the view...
Definition: rps.h:168
GNUNET_MQ_Error
Error codes for the queue.
struct GNUNET_RPS_Request_Handle * rh_head
Pointer to the head element in DLL of request handles.
Definition: rps_api.c:123
#define GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP
RPS client-service message to stop a sub sampler.
void GNUNET_RPS_view_request(struct GNUNET_RPS_Handle *rps_handle, uint32_t num_updates, GNUNET_RPS_NotifyReadyCB view_update_cb, void *cls)
Request updates of view.
Definition: rps_api.c:461
#define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST
Request updates of the view.
void RPS_sampler_set_deficiency_factor(struct RPS_Sampler *sampler, double deficiency_factor)
Set the deficiency factor.
GNUNET_RPS_NotifyReadyCB ready_cb
The callback to be called when we receive an answer.
Definition: rps_api.c:51
client sampler implementation
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void RPS_sampler_set_desired_probability(struct RPS_Sampler *sampler, double desired_probability)
Set the probability that is needed at least with what a sampler element has to have observed all elem...
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_NSE_Handle * GNUNET_NSE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_NSE_Callback func, void *func_cls)
Connect to the network size estimation service.
Definition: nse_api.c:165
uint64_t rel_value_us__
The actual value (in network byte order).
struct GNUNET_RPS_Request_Handle_Single_Info * next
Pointer to next element in DLL.
Definition: rps_api.c:248
static int stream_input
Do we want to receive updates of the view? (Option –view)
Definition: gnunet-rps.c:56
void RPS_sampler_request_single_info_cancel(struct RPS_SamplerRequestHandleSingleInfo *req_single_info_handle)
Cancle a request issued through RPS_sampler_sinlge_info_ready_cb.
float deficiency_factor
A factor that catches the &#39;bias&#39; of a random stream of peer ids.
Definition: rps_api.c:152
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
int GNUNET_CONFIGURATION_get_value_float(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, float *number)
Get a configuration value that should be a floating point number.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
void RPS_sampler_update(struct RPS_Sampler *sampler, const struct GNUNET_PeerIdentity *id)
Update every sampler element of this sampler with given peer.
void GNUNET_RPS_stream_cancel(struct GNUNET_RPS_StreamRequestHandle *srh)
Cancel a specific request for updates from the biased peer stream.
Definition: rps_api.c:598
static void peers_ready_cb(const struct GNUNET_PeerIdentity *peers, uint32_t num_peers, void *cls)
Called once the sampler has collected all requested peers.
Definition: rps_api.c:355
void * ready_cb_cls
The closure for the callback.
Definition: rps_api.c:243
static void cancel_stream(struct GNUNET_RPS_Handle *rps_handle)
Send message to service that this client does not want to receive further updates from the biased pee...
Definition: rps_api.c:583
static void remove_stream_request(struct GNUNET_RPS_StreamRequestHandle *srh)
Remove the given stream request from the list of requests and memory.
Definition: rps_api.c:328
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static void collect_peers_info_cb(void *cls, uint64_t num_peers, const struct GNUNET_PeerIdentity *peers)
Callback to collect the peers from the biased stream and put those into the sampler.
Definition: rps_api.c:433
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REPLY
Send update of the view.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
example IPC messages between RPS API and GNS service
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_RPS_disconnect(struct GNUNET_RPS_Handle *h)
Disconnect from the rps service.
Definition: rps_api.c:1263
static void handle_view_update(void *cls, const struct GNUNET_RPS_CS_DEBUG_ViewReply *msg)
This function is called, when the service updated its view.
Definition: rps_api.c:558
Handler to handle requests from a client.
Definition: rps_api.c:78
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:217
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
GNUNET_RPS_NotifyReadyCB cb
Callback provided by the client.
Definition: rps_api.c:266
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
void GNUNET_RPS_sub_stop(struct GNUNET_RPS_Handle *h, const char *shared_value)
Stop a sub with the given shared value.
Definition: rps_api.c:927
static void srh_callback_scheduled(void *cls)
Called by the scheduler to call the callbacks of the srh handlers.
Definition: rps_api.c:645
Message from client to service with seed of peers.
Definition: rps.h:66
Closure to _get_n_rand_peers_ready_cb()
struct GNUNET_RPS_Handle * GNUNET_RPS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the rps service.
Definition: rps_api.c:843
void * cls
Closure provided by the client.
Definition: rps_api.c:271
#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:52
struct RPS_Sampler * RPS_sampler_mod_init(size_t init_size, struct GNUNET_TIME_Relative max_round_interval)
Initialise a modified tuple of sampler elements.
struct GNUNET_CLIENT_Connection * service_conn
Handle to the service connection.
Definition: rps_api.c:276
GNUNET_RPS_NotifyReadyCB view_update_cb
Callback called on each update of the view.
Definition: rps_api.c:93
uint64_t num_peers
Number of peers.
Definition: rps.h:229
#define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_CANCEL
Cancel getting updates of the view.
struct GNUNET_RPS_Request_Handle * prev
Pointer to previous element in DLL.
Definition: rps_api.c:205
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
void GNUNET_RPS_request_single_info_cancel(struct GNUNET_RPS_Request_Handle_Single_Info *rhs)
Cancle an issued single info request.
Definition: rps_api.c:1231
struct GNUNET_MQ_Handle * mq
The message queue to the client.
Definition: rps_api.c:88
static struct GNUNET_PeerIdentity * peer_ids
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:164
static struct GNUNET_CONTAINER_MultiPeerMap * ids
GNUNET_PeerIdentity -> CadetPeer.
void view_update_cb(void *cls, uint64_t view_size, const struct GNUNET_PeerIdentity *peers)
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
struct GNUNET_RPS_Request_Handle * next
Pointer to next element in DLL.
Definition: rps_api.c:200
static struct GNUNET_RPS_StreamRequestHandle * new_stream_request(struct GNUNET_RPS_Handle *rps_handle, GNUNET_RPS_NotifyReadyCB ready_cb, void *cls)
Create a new handle for a stream request.
Definition: rps_api.c:304
struct GNUNET_HashCode hash
Length of the shared value represented as string.
Definition: rps.h:158
static void peer_info_ready_cb(const struct GNUNET_PeerIdentity *peers, void *cls, double probability, uint32_t num_observed)
Called once the sampler has collected the requested peer.
Definition: rps_api.c:381
struct GNUNET_RPS_StreamRequestHandle * stream_requests_tail
Tail of the DLL of stream requests.
Definition: rps_api.c:113
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
Message from client to service telling it to stop a new sub.
Definition: rps.h:148
void RPS_sampler_destroy(struct RPS_Sampler *sampler)
Cleans the samplers.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
struct RPS_SamplerRequestHandle * RPS_sampler_get_n_rand_peers(struct RPS_Sampler *sampler, uint32_t num_peers, RPS_sampler_n_rand_peers_ready_cb cb, void *cls)
Get n random peers out of the sampled peers.
void * stream_input_cls
Closure to each requested peer from the biased stream.
Definition: rps_api.c:103
Closure to _get_rand_peer_info()
struct GNUNET_RPS_Request_Handle_Single_Info * GNUNET_RPS_request_peer_info(struct GNUNET_RPS_Handle *rps_handle, GNUNET_RPS_NotifyReadySingleInfoCB ready_cb, void *cls)
Request one random peer, getting additional information.
Definition: rps_api.c:995
struct RPS_SamplerRequestHandle * sampler_rh
Request handle of the request to the sampler - needed to cancel the request.
Definition: rps_api.c:179
struct GNUNET_RPS_StreamRequestHandle * stream_requests_head
Head of the DLL of stream requests.
Definition: rps_api.c:108
#define GNUNET_MESSAGE_TYPE_RPS_CS_SEED
RPS CS SEED Message for the Client to seed peers into rps.
void RPS_sampler_update_with_nw_size(struct RPS_Sampler *sampler, uint32_t num_peers)
Update the current estimate of the network size stored at the sampler.
A 512-bit hashcode.
void(* GNUNET_RPS_NotifyReadySingleInfoCB)(void *cls, const struct GNUNET_PeerIdentity *peer, double probability, uint32_t num_observed)
Callback called when requested random peer with additional information is available.
Message handler for a specific message type.
static int view_update
Do we want to receive updates of the view? (Option –view)
Definition: gnunet-rps.c:51
struct RPS_SamplerRequestHandleSingleInfo * RPS_sampler_get_rand_peer_info(struct RPS_Sampler *sampler, RPS_sampler_sinlge_info_ready_cb cb, void *cls)
Get one random peer with additional information.
Handler for a single request from a client.
Definition: rps_api.c:212
Message from service to client containing peer from biased stream.
Definition: rps.h:219
#define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_CANCEL
Cancel getting biased strem.
void GNUNET_NSE_disconnect(struct GNUNET_NSE_Handle *h)
Disconnect from network size estimation service.
Definition: nse_api.c:193
void * ready_cb_cls
The closure for the callback.
Definition: rps_api.c:195
Message from client to service telling it to start a new sub.
Definition: rps.h:121
uint32_t num_requests
The number of requested peers.
Definition: rps_api.c:169
Handle for talking with the NSE service.
Definition: nse_api.c:40
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static void hash_from_share_val(const char *share_val, struct GNUNET_HashCode *hash)
Create the hash value from the share value that defines the sub (-group)
Definition: rps_api.c:751
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:625
struct GNUNET_RPS_StreamRequestHandle * srh
Request handle of the request of the biased stream of peers - needed to cancel the request...
Definition: rps_api.c:233
uint32_t num_peers
Number of peers.
Definition: rps.h:76
static unsigned int num_peers
static struct GNUNET_PeerIdentity * target_peer
ID of the targeted peer.
struct RPS_SamplerRequestHandleSingleInfo * sampler_rh
Request handle of the request to the sampler - needed to cancel the request.
Definition: rps_api.c:227
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
struct GNUNET_MessageHeader header
Header including size and type in NBO.
Definition: rps.h:190
Handle to a message queue.
Definition: mq.c:85
#define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST
Request biased input stream.
GNUNET_RPS_NotifyReadySingleInfoCB ready_cb
The callback to be called when we receive an answer.
Definition: rps_api.c:238
struct GNUNET_TIME_RelativeNBO round_interval
Mean interval between two rounds.
Definition: rps.h:136
struct GNUNET_SCHEDULER_Task * callback_task
Scheduler task for scheduled callback.
Definition: rps_api.c:61
void GNUNET_RPS_view_request_cancel(struct GNUNET_RPS_Handle *rps_handle)
Definition: rps_api.c:482
#define GNUNET_MQ_msg_header(type)
Allocate a GNUNET_MQ_Envelope, where the message only consists of a header.
Definition: gnunet_mq_lib.h:76
The identity of the host (wraps the signing key of the peer).
const struct GNUNET_CONFIGURATION_Handle * cfg
The handle to the client configuration.
Definition: rps_api.c:83
struct RPS_Sampler * sampler
The Sampler for the client request.
Definition: rps_api.c:222
Struct used to pack the callback, its closure (provided by the caller) and the connection handler to ...
Definition: rps_api.c:261
void GNUNET_RPS_request_cancel(struct GNUNET_RPS_Request_Handle *rh)
Cancle an issued request.
Definition: rps_api.c:1200
configuration data
Definition: configuration.c:85
struct GNUNET_NSE_Handle * nse
Handle to nse service.
Definition: rps_api.c:118
static struct CadetPeer * peers
Operation to get peer ids.
static struct GNUNET_PeerIdentity * srh_callback_peers
Peers received from the biased stream to be passed to all srh_handlers.
Definition: rps_api.c:284
void * view_update_cls
Closure to each requested update of the view.
Definition: rps_api.c:98
struct GNUNET_RPS_StreamRequestHandle * prev
Previous element of the DLL.
Definition: rps_api.c:71
struct GNUNET_RPS_Request_Handle_Single_Info * rhs_tail
Pointer to the tail element in DLL of single request handles.
Definition: rps_api.c:138
Entry in list of pending tasks.
Definition: scheduler.c:134
struct GNUNET_RPS_StreamRequestHandle * GNUNET_RPS_stream_request(struct GNUNET_RPS_Handle *rps_handle, GNUNET_RPS_NotifyReadyCB stream_input_cb, void *cls)
Request biased stream of peers that are being put into the sampler.
Definition: rps_api.c:503
struct GNUNET_RPS_Request_Handle_Single_Info * prev
Pointer to previous element in DLL.
Definition: rps_api.c:253
void GNUNET_RPS_sub_start(struct GNUNET_RPS_Handle *h, const char *shared_value)
Start a sub with the given shared value.
Definition: rps_api.c:904
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Error handler for mq.
Definition: rps_api.c:724
static void handle_stream_input(void *cls, const struct GNUNET_RPS_CS_DEBUG_StreamReply *msg)
This function is called, when the service sends another peer from the biased stream.
Definition: rps_api.c:665
void * ready_cb_cls
The closure for the callback.
Definition: rps_api.c:56
struct GNUNET_RPS_StreamRequestHandle * next
Next element of the DLL.
Definition: rps_api.c:66
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Handler for a single request from a client.
Definition: rps_api.c:159
float desired_probability
The desired probability with which we want to have observed all peers.
Definition: rps_api.c:144
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
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
void(* GNUNET_RPS_NotifyReadyCB)(void *cls, uint64_t num_peers, const struct GNUNET_PeerIdentity *peers)
Callback called when requested random peers are available.
void RPS_sampler_request_cancel(struct RPS_SamplerRequestHandle *req_handle)
Cancle a request issued through RPS_sampler_n_rand_peers_ready_cb.
uint64_t num_peers
Number of peers in the view.
Definition: rps.h:200
#define GNUNET_NSE_log_estimate_to_n(loge)
Convert the logarithmic estimated returned to the &#39;GNUNET_NSE_Callback&#39; into an absolute estimate in ...
static int check_stream_input(void *cls, const struct GNUNET_RPS_CS_DEBUG_StreamReply *msg)
This function is called, when the service sends another peer from the biased stream.
Definition: rps_api.c:620
int GNUNET_CRYPTO_kdf(void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
Derive key.
Definition: crypto_kdf.c:89
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Sampler with its own array of SamplerElements.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
static uint64_t srh_callback_num_peers
Number of peers in the biased stream that are to be passed to all srh_handlers.
Definition: rps_api.c:290
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:46
#define LOG(kind,...)
Definition: rps_api.c:36
static int check_view_update(void *cls, const struct GNUNET_RPS_CS_DEBUG_ViewReply *msg)
This function is called, when the service updates the view.
Definition: rps_api.c:531
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
struct GNUNET_HashCode hash
Length of the shared value represented as string.
Definition: rps.h:141