GNUnet  0.10.x
gnunet-service-cadet.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2001-2013, 2017 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 
35 #include "platform.h"
36 #include "gnunet_util_lib.h"
37 #include "cadet.h"
39 #include "gnunet-service-cadet.h"
48 
49 #define LOG(level, ...) GNUNET_log (level,__VA_ARGS__)
50 
51 
56 {
60  struct CadetClient *next;
61 
65  struct CadetClient *prev;
66 
72 
77 
82 
88 
94 
98  unsigned int id;
99 };
100 
101 
102 /******************************************************************************/
103 /*********************** GLOBAL VARIABLES ****************************/
104 /******************************************************************************/
105 
106 /****************************** Global variables ******************************/
107 
112 
117 
122 
127 
132 
137 
141 static struct CadetClient *clients_head;
142 
146 static struct CadetClient *clients_tail;
147 
151 static unsigned int next_client_id;
152 
158 
165 
170 
176 
180 unsigned long long ratchet_messages;
181 
186 
191 
195 unsigned long long drop_percent;
196 
197 
204 void
206  struct GNUNET_MQ_Envelope *env)
207 {
208  GNUNET_MQ_send (c->mq,
209  env);
210 }
211 
212 
219 const char *
220 GSC_2s (struct CadetClient *c)
221 {
222  static char buf[32];
223 
224  GNUNET_snprintf (buf,
225  sizeof (buf),
226  "Client(%u)",
227  c->id);
228  return buf;
229 }
230 
231 
239 static struct CadetChannel *
242 {
244  ntohl (ccn.channel_of_client));
245 }
246 
247 
256 {
257  struct GNUNET_CADET_ClientChannelNumber ccn = c->next_ccn;
258 
259  /* increment until we have a free one... */
260  while (NULL !=
261  lookup_channel (c,
262  ccn))
263  {
265  = htonl (1 + (ntohl (ccn.channel_of_client)));
266  if (ntohl (ccn.channel_of_client) >=
268  ccn.channel_of_client = htonl (0);
269  }
270  c->next_ccn.channel_of_client
271  = htonl (1 + (ntohl (ccn.channel_of_client)));
272  return ccn;
273 }
274 
275 
290  struct CadetChannel *ch,
291  struct CadetPeer *dest,
292  const struct GNUNET_HashCode *port,
293  uint32_t options)
294 {
295  struct GNUNET_MQ_Envelope *env;
298 
299  ccn = client_get_next_ccn (c);
302  ntohl (ccn.channel_of_client),
303  ch,
306  "Accepting incoming %s from %s on open port %s (%u), assigning ccn %X\n",
307  GCCH_2s (ch),
308  GCP_2s (dest),
309  GNUNET_h2s (port),
310  (uint32_t) ntohl (options),
311  (uint32_t) ntohl (ccn.channel_of_client));
312  /* notify local client about incoming connection! */
313  env = GNUNET_MQ_msg (cm,
315  cm->ccn = ccn;
316  cm->port = *port;
317  cm->opt = htonl (options);
318  cm->peer = *GCP_get_id (dest);
320  env);
321  return ccn;
322 }
323 
324 
334 static int
336  const struct GNUNET_PeerIdentity *pid,
337  void *value)
338 {
339  struct CadetPeer *cp = value;
340  struct CadetTunnel *t = GCP_get_tunnel (cp,
341  GNUNET_NO);
342 
343  if (NULL != t)
345  return GNUNET_OK;
346 }
347 
348 
358 static int
359 destroy_paths_now (void *cls,
360  const struct GNUNET_PeerIdentity *pid,
361  void *value)
362 {
363  struct CadetPeer *cp = value;
364 
366  return GNUNET_OK;
367 }
368 
369 
373 static void
375 {
376  if (NULL != stats)
377  {
379  GNUNET_NO);
380  stats = NULL;
381  }
382  /* Destroy tunnels. Note that all channels must be destroyed first! */
384  NULL);
385  /* All tunnels, channels, connections and CORE must be down before this point. */
387  NULL);
388  /* All paths, tunnels, channels, connections and CORE must be down before this point. */
390  if (NULL != open_ports)
391  {
393  open_ports = NULL;
394  }
395  if (NULL != loose_channels)
396  {
397  GNUNET_CONTAINER_multihashmap_destroy (loose_channels);
398  loose_channels = NULL;
399  }
400  if (NULL != peers)
401  {
403  peers = NULL;
404  }
405  if (NULL != connections)
406  {
408  connections = NULL;
409  }
410  if (NULL != ats_ch)
411  {
413  ats_ch = NULL;
414  }
415  GCD_shutdown ();
416  GCH_shutdown ();
417  GNUNET_free_non_null (my_private_key);
418  my_private_key = NULL;
419 }
420 
421 
427 static void
428 shutdown_task (void *cls)
429 {
431  "Shutting down\n");
433  GCO_shutdown ();
434  if (NULL == clients_head)
435  shutdown_rest ();
436 }
437 
438 
448 static int
450  const struct GNUNET_HashCode *port,
451  void *value)
452 {
453  struct OpenPort *op = cls;
454  struct CadetChannel *ch = value;
455 
456  GCCH_bind (ch,
457  op->c,
458  &op->port);
460  GNUNET_CONTAINER_multihashmap_remove (loose_channels,
461  &op->h_port,
462  ch));
463  return GNUNET_YES;
464 }
465 
466 
476 static void
477 handle_port_open (void *cls,
478  const struct GNUNET_CADET_PortMessage *pmsg)
479 {
480  struct CadetClient *c = cls;
481  struct OpenPort *op;
482 
484  "Open port %s requested by %s\n",
485  GNUNET_h2s (&pmsg->port),
486  GSC_2s (c));
487  if (NULL == c->ports)
489  GNUNET_NO);
490  op = GNUNET_new (struct OpenPort);
491  op->c = c;
492  op->port = pmsg->port;
493  GCCH_hash_port (&op->h_port,
494  &pmsg->port,
495  &my_full_id);
496  if (GNUNET_OK !=
498  &op->port,
499  op,
501  {
502  GNUNET_break (0);
504  return;
505  }
506  (void) GNUNET_CONTAINER_multihashmap_put (open_ports,
507  &op->h_port,
508  op,
511  &op->h_port,
513  op);
515 }
516 
517 
527 static void
528 handle_port_close (void *cls,
529  const struct GNUNET_CADET_PortMessage *pmsg)
530 {
531  struct CadetClient *c = cls;
532  struct OpenPort *op;
533 
535  "Closing port %s as requested by %s\n",
536  GNUNET_h2s (&pmsg->port),
537  GSC_2s (c));
538  if (NULL == c->ports)
539  {
540  /* Client closed a port despite _never_ having opened one? */
541  GNUNET_break (0);
543  return;
544  }
546  &pmsg->port);
547  if (NULL == op)
548  {
549  GNUNET_break (0);
551  return;
552  }
555  &op->port,
556  op));
559  &op->h_port,
560  op));
561  GNUNET_free (op);
563 }
564 
565 
572 static void
574  const struct GNUNET_CADET_LocalChannelCreateMessage *tcm)
575 {
576  struct CadetClient *c = cls;
577  struct CadetChannel *ch;
578 
580  {
581  /* Channel ID not in allowed range. */
582  GNUNET_break (0);
584  return;
585  }
586  ch = lookup_channel (c,
587  tcm->ccn);
588  if (NULL != ch)
589  {
590  /* Channel ID already in use. Not allowed. */
591  GNUNET_break (0);
593  return;
594  }
596  "New channel to %s at port %s requested by %s\n",
597  GNUNET_i2s (&tcm->peer),
598  GNUNET_h2s (&tcm->port),
599  GSC_2s (c));
600 
601  /* Create channel */
602  ch = GCCH_channel_local_new (c,
603  tcm->ccn,
604  GCP_get (&tcm->peer,
605  GNUNET_YES),
606  &tcm->port,
607  ntohl (tcm->opt));
608  if (NULL == ch)
609  {
610  GNUNET_break (0);
612  return;
613  }
616  ntohl (tcm->ccn.channel_of_client),
617  ch,
619 
621 }
622 
623 
630 static void
633 {
634  struct CadetClient *c = cls;
635  struct CadetChannel *ch;
636 
637  ch = lookup_channel (c,
638  msg->ccn);
639  if (NULL == ch)
640  {
641  /* Client attempted to destroy unknown channel.
642  Can happen if the other side went down at the same time.*/
644  "%s tried to destroy unknown channel %X\n",
645  GSC_2s(c),
646  (uint32_t) ntohl (msg->ccn.channel_of_client));
648  return;
649  }
651  "%s is destroying %s\n",
652  GSC_2s(c),
653  GCCH_2s (ch));
656  ntohl (msg->ccn.channel_of_client),
657  ch));
659  c,
660  msg->ccn);
662 }
663 
664 
672 static int
673 check_local_data (void *cls,
674  const struct GNUNET_CADET_LocalData *msg)
675 {
676  size_t payload_size;
677  size_t payload_claimed_size;
678  const char *buf;
679  struct GNUNET_MessageHeader pa;
680 
681  /* FIXME: what is the format we shall allow for @a msg?
682  ONE payload item or multiple? Seems current cadet_api
683  at least in theory allows more than one. Next-gen
684  cadet_api will likely no more, so we could then
685  simplify this mess again. */
686  /* Sanity check for message size */
687  payload_size = ntohs (msg->header.size) - sizeof (*msg);
688  buf = (const char *) &msg[1];
689  while (payload_size >= sizeof (struct GNUNET_MessageHeader))
690  {
691  /* need to memcpy() for alignment */
692  GNUNET_memcpy (&pa,
693  buf,
694  sizeof (pa));
695  payload_claimed_size = ntohs (pa.size);
696  if ( (payload_size < payload_claimed_size) ||
697  (payload_claimed_size < sizeof (struct GNUNET_MessageHeader)) ||
698  (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < payload_claimed_size) )
699  {
700  GNUNET_break (0);
702  "Local data of %u total size had sub-message %u at %u with %u bytes\n",
703  ntohs (msg->header.size),
704  ntohs (pa.type),
705  (unsigned int) (buf - (const char *) &msg[1]),
706  (unsigned int) payload_claimed_size);
707  return GNUNET_SYSERR;
708  }
709  payload_size -= payload_claimed_size;
710  buf += payload_claimed_size;
711  }
712  if (0 != payload_size)
713  {
714  GNUNET_break_op (0);
715  return GNUNET_SYSERR;
716  }
717  return GNUNET_OK;
718 }
719 
720 
728 static void
729 handle_local_data (void *cls,
730  const struct GNUNET_CADET_LocalData *msg)
731 {
732  struct CadetClient *c = cls;
733  struct CadetChannel *ch;
734  size_t payload_size;
735  const char *buf;
736 
737  ch = lookup_channel (c,
738  msg->ccn);
739  if (NULL == ch)
740  {
741  /* Channel does not exist (anymore) */
743  "Dropping payload for channel %u from client (channel unknown, other endpoint may have disconnected)\n",
744  (unsigned int) ntohl (msg->ccn.channel_of_client));
746  return;
747  }
748  payload_size = ntohs (msg->header.size) - sizeof (*msg);
750  "# payload received from clients",
751  payload_size,
752  GNUNET_NO);
753  buf = (const char *) &msg[1];
755  "Received %u bytes payload from %s for %s\n",
756  (unsigned int) payload_size,
757  GSC_2s (c),
758  GCCH_2s (ch));
759  if (GNUNET_OK !=
761  msg->ccn,
762  buf,
763  payload_size))
764  {
765  GNUNET_break (0);
767  return;
768  }
770 }
771 
772 
779 static void
780 handle_local_ack (void *cls,
781  const struct GNUNET_CADET_LocalAck *msg)
782 {
783  struct CadetClient *c = cls;
784  struct CadetChannel *ch;
785 
786  ch = lookup_channel (c,
787  msg->ccn);
788  if (NULL == ch)
789  {
790  /* Channel does not exist (anymore) */
792  "Ignoring local ACK for channel %u from client (channel unknown, other endpoint may have disconnected)\n",
793  (unsigned int) ntohl (msg->ccn.channel_of_client));
795  return;
796  }
798  "Got a local ACK from %s for %s\n",
799  GSC_2s(c),
800  GCCH_2s (ch));
802  msg->ccn);
804 }
805 
806 
815 static int
817  const struct GNUNET_PeerIdentity *peer,
818  void *value)
819 {
820  struct CadetClient *c = cls;
821  struct CadetPeer *p = value;
822  struct GNUNET_MQ_Envelope *env;
824 
825  env = GNUNET_MQ_msg (msg,
827  msg->destination = *peer;
828  msg->paths = htons (GCP_count_paths (p));
829  msg->tunnel = htons (NULL != GCP_get_tunnel (p,
830  GNUNET_NO));
831  msg->best_path_length = htonl (0); // FIXME: get length of shortest known path!
832  GNUNET_MQ_send (c->mq,
833  env);
834  return GNUNET_YES;
835 }
836 
837 
844 static void
845 handle_get_peers (void *cls,
846  const struct GNUNET_MessageHeader *message)
847 {
848  struct CadetClient *c = cls;
849  struct GNUNET_MQ_Envelope *env;
850  struct GNUNET_MessageHeader *reply;
851 
853  c);
854  env = GNUNET_MQ_msg (reply,
856  GNUNET_MQ_send (c->mq,
857  env);
859 }
860 
861 
872 static int
874  struct CadetPeerPath *path,
875  unsigned int off)
876 {
877  struct GNUNET_MQ_Handle *mq = cls;
878  struct GNUNET_MQ_Envelope *env;
879  struct GNUNET_CADET_LocalInfoPath *resp;
880  struct GNUNET_PeerIdentity *id;
881  size_t path_size;
882  unsigned int path_length;
883 
884  path_length = GCPP_get_length (path);
885  path_size = sizeof (struct GNUNET_PeerIdentity) * path_length;
886  if (sizeof (*resp) + path_size > UINT16_MAX)
887  {
888  /* try just giving the relevant path */
889  path_length = GNUNET_MIN ((UINT16_MAX - sizeof (*resp)) / sizeof (struct GNUNET_PeerIdentity),
890  off);
891  path_size = sizeof (struct GNUNET_PeerIdentity) * path_length;
892  }
893  if (sizeof (*resp) + path_size > UINT16_MAX)
894  {
896  "Path of %u entries is too long for info message\n",
897  path_length);
898  return GNUNET_YES;
899  }
900  env = GNUNET_MQ_msg_extra (resp,
901  path_size,
903  id = (struct GNUNET_PeerIdentity *) &resp[1];
904 
905  /* Don't copy first peer. First peer is always the local one. Last
906  * peer is always the destination (leave as 0, EOL).
907  */
908  for (unsigned int i = 0; i < path_length; i++)
909  id[i] = *GCP_get_id (GCPP_get_peer_at_offset (path,
910  i));
911  resp->off = htonl (off);
912  GNUNET_MQ_send (mq,
913  env);
914  return GNUNET_YES;
915 }
916 
917 
924 static void
925 handle_show_path (void *cls,
927 {
928  struct CadetClient *c = cls;
929  struct CadetPeer *p;
930  struct GNUNET_MQ_Envelope *env;
931  struct GNUNET_MessageHeader *resp;
932 
933  p = GCP_get (&msg->peer,
934  GNUNET_NO);
935  if (NULL != p)
938  c->mq);
939  env = GNUNET_MQ_msg (resp,
941  GNUNET_MQ_send (c->mq,
942  env);
944 }
945 
946 
955 static int
957  const struct GNUNET_PeerIdentity *peer,
958  void *value)
959 {
960  struct CadetClient *c = cls;
961  struct CadetPeer *p = value;
962  struct GNUNET_MQ_Envelope *env;
964  struct CadetTunnel *t;
965 
966  t = GCP_get_tunnel (p,
967  GNUNET_NO);
968  if (NULL == t)
969  return GNUNET_YES;
970  env = GNUNET_MQ_msg (msg,
972  msg->destination = *peer;
973  msg->channels = htonl (GCT_count_channels (t));
974  msg->connections = htonl (GCT_count_any_connections (t));
975  msg->cstate = htons (0);
976  msg->estate = htons ((uint16_t) GCT_get_estate (t));
977  GNUNET_MQ_send (c->mq,
978  env);
979  return GNUNET_YES;
980 }
981 
982 
989 static void
991  const struct GNUNET_MessageHeader *message)
992 {
993  struct CadetClient *c = cls;
994  struct GNUNET_MQ_Envelope *env;
995  struct GNUNET_MessageHeader *reply;
996 
998  c);
999  env = GNUNET_MQ_msg (reply,
1001  GNUNET_MQ_send (c->mq,
1002  env);
1004 }
1005 
1006 
1015 static void *
1017  struct GNUNET_SERVICE_Client *client,
1018  struct GNUNET_MQ_Handle *mq)
1019 {
1020  struct CadetClient *c;
1021 
1022  c = GNUNET_new (struct CadetClient);
1023  c->client = client;
1024  c->mq = mq;
1025  c->id = next_client_id++; /* overflow not important: just for debug */
1026  c->channels
1028  GNUNET_CONTAINER_DLL_insert (clients_head,
1029  clients_tail,
1030  c);
1031  GNUNET_STATISTICS_update (stats,
1032  "# clients",
1033  +1,
1034  GNUNET_NO);
1036  "%s connected\n",
1037  GSC_2s (c));
1038  return c;
1039 }
1040 
1041 
1049 void
1052  struct CadetChannel *ch)
1053 {
1054  struct GNUNET_MQ_Envelope *env;
1056 
1057  env = GNUNET_MQ_msg (tdm,
1059  tdm->ccn = ccn;
1060  GSC_send_to_client (c,
1061  env);
1064  ntohl (ccn.channel_of_client),
1065  ch));
1066 }
1067 
1068 
1076 void
1078  struct CadetChannel *ch)
1079 {
1081  GNUNET_CONTAINER_multihashmap_remove (loose_channels,
1082  h_port,
1083  ch));
1084 }
1085 
1086 
1095 static int
1097  uint32_t key,
1098  void *value)
1099 {
1100  struct CadetClient *c = cls;
1102  struct CadetChannel *ch = value;
1103 
1105  "Destroying %s, due to %s disconnecting.\n",
1106  GCCH_2s (ch),
1107  GSC_2s (c));
1108  ccn.channel_of_client = htonl (key);
1110  c,
1111  ccn);
1114  key,
1115  ch));
1116  return GNUNET_OK;
1117 }
1118 
1119 
1128 static int
1130  const struct GNUNET_HashCode *port,
1131  void *value)
1132 {
1133  struct CadetClient *c = cls;
1134  struct OpenPort *op = value;
1135 
1136  GNUNET_assert (c == op->c);
1138  "Closing port %s due to %s disconnect.\n",
1139  GNUNET_h2s (port),
1140  GSC_2s (c));
1143  &op->h_port,
1144  op));
1147  port,
1148  op));
1149  GNUNET_free (op);
1150  return GNUNET_OK;
1151 }
1152 
1153 
1161 static void
1163  struct GNUNET_SERVICE_Client *client,
1164  void *internal_cls)
1165 {
1166  struct CadetClient *c = internal_cls;
1167 
1168  GNUNET_assert (c->client == client);
1170  "%s is disconnecting.\n",
1171  GSC_2s (c));
1172  if (NULL != c->channels)
1173  {
1176  c);
1179  }
1180  if (NULL != c->ports)
1181  {
1184  c);
1186  }
1187  GNUNET_CONTAINER_DLL_remove (clients_head,
1188  clients_tail,
1189  c);
1190  GNUNET_STATISTICS_update (stats,
1191  "# clients",
1192  -1,
1193  GNUNET_NO);
1194  GNUNET_free (c);
1195  if ( (NULL == clients_head) &&
1196  (GNUNET_YES == shutting_down) )
1197  shutdown_rest ();
1198 }
1199 
1200 
1208 static void
1209 run (void *cls,
1210  const struct GNUNET_CONFIGURATION_Handle *c,
1212 {
1213  cfg = c;
1214  if (GNUNET_OK !=
1216  "CADET",
1217  "RATCHET_MESSAGES",
1218  &ratchet_messages))
1219  {
1221  "CADET",
1222  "RATCHET_MESSAGES",
1223  "needs to be a number");
1224  ratchet_messages = 64;
1225  }
1226  if (GNUNET_OK !=
1228  "CADET",
1229  "RATCHET_TIME",
1230  &ratchet_time))
1231  {
1233  "CADET",
1234  "RATCHET_TIME",
1235  "need delay value");
1237  }
1238  if (GNUNET_OK !=
1240  "CADET",
1241  "REFRESH_CONNECTION_TIME",
1242  &keepalive_period))
1243  {
1245  "CADET",
1246  "REFRESH_CONNECTION_TIME",
1247  "need delay value");
1249  }
1250  if (GNUNET_OK !=
1252  "CADET",
1253  "DROP_PERCENT",
1254  &drop_percent))
1255  {
1256  drop_percent = 0;
1257  }
1258  else
1259  {
1260  LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1261  LOG (GNUNET_ERROR_TYPE_WARNING, "Cadet is running with DROP enabled.\n");
1262  LOG (GNUNET_ERROR_TYPE_WARNING, "This is NOT a good idea!\n");
1263  LOG (GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n");
1264  LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1265  }
1267  if (NULL == my_private_key)
1268  {
1269  GNUNET_break (0);
1271  return;
1272  }
1273  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
1275  stats = GNUNET_STATISTICS_create ("cadet",
1276  c);
1278  NULL);
1279  ats_ch = GNUNET_ATS_connectivity_init (c);
1280  /* FIXME: optimize code to allow GNUNET_YES here! */
1281  open_ports = GNUNET_CONTAINER_multihashmap_create (16,
1282  GNUNET_NO);
1283  loose_channels = GNUNET_CONTAINER_multihashmap_create (16,
1284  GNUNET_NO);
1286  GNUNET_YES);
1287  connections = GNUNET_CONTAINER_multishortmap_create (256,
1288  GNUNET_YES);
1289  GCH_init (c);
1290  GCD_init (c);
1291  GCO_init (c);
1293  "CADET started for peer %s\n",
1294  GNUNET_i2s (&my_full_id));
1295 
1296 }
1297 
1298 
1303 ("cadet",
1305  &run,
1308  NULL,
1309  GNUNET_MQ_hd_fixed_size (port_open,
1311  struct GNUNET_CADET_PortMessage,
1312  NULL),
1313  GNUNET_MQ_hd_fixed_size (port_close,
1315  struct GNUNET_CADET_PortMessage,
1316  NULL),
1317  GNUNET_MQ_hd_fixed_size (channel_create,
1320  NULL),
1324  NULL),
1325  GNUNET_MQ_hd_var_size (local_data,
1327  struct GNUNET_CADET_LocalData,
1328  NULL),
1329  GNUNET_MQ_hd_fixed_size (local_ack,
1331  struct GNUNET_CADET_LocalAck,
1332  NULL),
1335  struct GNUNET_MessageHeader,
1336  NULL),
1337  GNUNET_MQ_hd_fixed_size (show_path,
1340  NULL),
1341  GNUNET_MQ_hd_fixed_size (info_tunnels,
1343  struct GNUNET_MessageHeader,
1344  NULL),
1346 
1347 /* end of gnunet-service-cadet-new.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct CadetChannel * lookup_channel(struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn)
Lookup channel of client c by ccn.
static void handle_local_data(void *cls, const struct GNUNET_CADET_LocalData *msg)
Handler for client payload traffic to be send on a channel to another peer.
uint16_t cstate
Connection state.
Definition: cadet.h:404
static unsigned int next_client_id
Next ID to assign to a client.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH
Local information of service about a specific path.
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:150
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
Peer description.
int 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_MessageHeader * msg
Definition: 005.c:2
Message to allow the client send more data to the service (always service -> client).
Definition: cadet.h:217
GNUnet CADET service with encryption.
#define GNUNET_TIME_UNIT_HOURS
One hour.
static struct CadetClient * clients_head
DLL with all the clients, head.
int 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.
static void channel_destroy(struct CadetChannel *ch)
Destroy the given channel.
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
enum CadetTunnelEState GCT_get_estate(struct CadetTunnel *t)
Get the encryption state of a tunnel.
void GCP_drop_owned_paths(struct CadetPeer *cp)
Drop all paths owned by this peer, and do not allow new ones to be added: We are shutting down...
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct CadetTunnel * GCP_get_tunnel(struct CadetPeer *cp, int create)
Get the tunnel towards a peer.
struct GNUNET_CONTAINER_MultiPeerMap * peers
Map from PIDs to struct CadetPeer entries.
Message for or to a client to destroy tunnel.
Definition: cadet.h:172
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY
Tell client that a channel was destroyed.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
static int path_info_iterator(void *cls, struct CadetPeerPath *path, unsigned int off)
Iterator over all paths of a peer to build an InfoPeer message.
static void shutdown_rest()
Shutdown everything once the clients have disconnected.
A connection is a live end-to-end messaging mechanism where the peers are identified by a path and kn...
Handle to a service.
Definition: service.c:116
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
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, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1293
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct CadetPeer * dest
Destinaton to ping.
static int destroy_tunnels_now(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Callback invoked on all peers to destroy all tunnels that may still exist.
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
struct GNUNET_PeerIdentity my_full_id
Local peer own ID.
Message for a client to create and destroy channels.
Definition: cadet.h:118
uint32_t best_path_length
Shortest known path.
Definition: cadet.h:359
static void handle_get_peers(void *cls, const struct GNUNET_MessageHeader *message)
Handler for client&#39;s INFO PEERS request.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GCD_shutdown(void)
Shut down the DHT subsystem.
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *internal_cls)
Callback called when a client disconnected from the service.
struct GNUNET_ATS_ConnectivityHandle * ats_ch
Handle to communicate with ATS.
struct GNUNET_PeerIdentity destination
ID of the destination of the tunnel (can be local peer).
Definition: cadet.h:389
static void handle_port_close(void *cls, const struct GNUNET_CADET_PortMessage *pmsg)
Handler for port close requests.
static void handle_channel_create(void *cls, const struct GNUNET_CADET_LocalChannelCreateMessage *tcm)
Handler for requests for us creating a new channel to another peer and port.
unsigned int GCT_count_any_connections(const struct CadetTunnel *t)
Count all created connections of a tunnel.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
static struct CadetClient * clients_tail
DLL with all the clients, tail.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_HashMapIterator it, void *it_cls)
Iterate over all entries in the map.
static void handle_local_ack(void *cls, const struct GNUNET_CADET_LocalAck *msg)
Handler for client&#39;s ACKs for payload traffic.
#define GNUNET_NO
Definition: gnunet_common.h:81
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Tunnels that belong to this client, indexed by local id, value is a struct CadetChannel.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
Information we track per tunnel.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Message to inform the client about channels in the service.
Definition: cadet.h:259
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct CadetChannel * GCCH_channel_local_new(struct CadetClient *owner, struct GNUNET_CADET_ClientChannelNumber ccn, struct CadetPeer *destination, const struct GNUNET_HashCode *port, uint32_t options)
Create a new channel.
void GSC_handle_remote_channel_destroy(struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn, struct CadetChannel *ch)
A channel was destroyed by the other peer.
void GCH_shutdown()
Shut down the hello subsystem.
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.
static struct GNUNET_SCHEDULER_Task * t
Main task.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GCCH_hash_port(struct GNUNET_HashCode *h_port, const struct GNUNET_HashCode *port, const struct GNUNET_PeerIdentity *listener)
Hash the port and initiator and listener to calculate the "challenge" h_port we send to the other pee...
unsigned int id
ID of the client, mainly for debug messages.
uint16_t paths
Number of paths.
Definition: cadet.h:349
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE
Ask the cadet service to create a new channel.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS
Local information about all tunnels of service.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_PeerIdentity peer
ID of the destination of the channel (can be local peer).
Definition: cadet.h:274
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_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
Handle for the service.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
Callback called when a client connects to the service.
struct GNUNET_CONTAINER_MultiShortmap * connections
Map from struct GNUNET_CADET_ConnectionTunnelIdentifier hash codes to struct CadetConnection objects...
static struct GNUNET_CADET_ClientChannelNumber client_get_next_ccn(struct CadetClient *c)
Obtain the next LID to use for incoming connections to the given client.
int GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
int16_t tunnel
Do we have a tunnel toward this peer?
Definition: cadet.h:354
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...
void GCCH_handle_local_ack(struct CadetChannel *ch, struct GNUNET_CADET_ClientChannelNumber client_ccn)
Handle ACK from client on local channel.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
const char * GCP_2s(const struct CadetPeer *cp)
Get the static string for a peer ID.
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.
struct GNUNET_CONTAINER_MultiHashMap * open_ports
All ports clients of this peer have opened.
Handle to a client that is connected to a service.
Definition: service.c:249
struct GNUNET_CONTAINER_MultiHashMap * loose_channels
Map from ports to channels where the ports were closed at the time we got the inbound connection...
void GCP_destroy_all_peers()
Clean up all entries about all peers.
Message to inform the client about one of the paths known to the service.
Definition: cadet.h:322
#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 GNUNET_TIME_Relative ratchet_time
How long until we trigger a ratched advance due to time.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK
Local ACK for data.
Information we track per peer.
#define GNUNET_memcpy(dst, src, n)
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
int GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
static char * value
Value of the record to add/remove.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS_END
End of local information about all peers known to the service.
void * GNUNET_CONTAINER_multihashmap32_get(const struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key)
Given a key find a value in the map matching the key.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_HashCode h_port
Port hashed with our PID (matches incoming OPEN messages).
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
Struct containing all information regarding a channel to a remote client.
struct GNUNET_SERVICE_Client * client
Client handle.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:83
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN
Start listening on a port.
#define LOG(level,...)
Message to inform the client about one of the peers in the service.
Definition: cadet.h:339
static void shutdown_task(void *cls)
Task run during shutdown.
unsigned int GNUNET_CONTAINER_multihashmap32_size(const struct GNUNET_CONTAINER_MultiHashMap32 *map)
Get the number of key-value pairs in the map.
static char buf[2048]
uint32_t off
Offset of the peer that was requested.
Definition: cadet.h:332
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.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH
Request local information of service about paths to specific peer.
cadet service; dealing with hello messages
static void get_peers(void *cls)
Call CADET&#39;s meta API, get all peers known to a peer.
Definition: gnunet-cadet.c:605
Number uniquely identifying a channel of a client.
Definition: cadet.h:102
struct GNUNET_HashCode port
Port number.
Message to inform the client about one of the tunnels in the service.
Definition: cadet.h:373
#define GNUNET_CADET_LOCAL_CHANNEL_ID_CLI
Minimum value for channel IDs of local clients.
Definition: cadet.h:71
Internal representation of the hash map.
Internal representation of the hash map.
struct GNUNET_CONTAINER_MultiShortmap * GNUNET_CONTAINER_multishortmap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
struct GNUNET_CADET_ClientChannelNumber next_ccn
Channel ID to use for the next incoming channel for this client.
A 512-bit hashcode.
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel.
Definition: cadet.h:199
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2618
GNUNET_SERVICE_MAIN("cadet", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(port_open, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN, struct GNUNET_CADET_PortMessage, NULL), GNUNET_MQ_hd_fixed_size(port_close, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE, struct GNUNET_CADET_PortMessage, NULL), GNUNET_MQ_hd_fixed_size(channel_create, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE, struct GNUNET_CADET_LocalChannelCreateMessage, NULL), GNUNET_MQ_hd_fixed_size(channel_destroy, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, struct GNUNET_CADET_LocalChannelDestroyMessage, NULL), GNUNET_MQ_hd_var_size(local_data, GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, struct GNUNET_CADET_LocalData, NULL), GNUNET_MQ_hd_fixed_size(local_ack, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK, struct GNUNET_CADET_LocalAck, NULL), GNUNET_MQ_hd_fixed_size(get_peers, GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PEERS, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(show_path, GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH, struct GNUNET_CADET_RequestPathInfoMessage, NULL), GNUNET_MQ_hd_fixed_size(info_tunnels, GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_TUNNELS, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
struct CadetClient * next
Linked list next.
unsigned long long drop_percent
Set to non-zero values to create random drops to test retransmissions.
#define GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
Maximum message size that can be sent on CADET.
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash map.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PEERS
Request local information about all peers known to the service.
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
Struct containing all information regarding a tunnel to a peer.
void GCO_shutdown()
Shut down the CORE subsystem.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
Struct containing information about a client of the service.
unsigned long long ratchet_messages
How many messages are needed to trigger an AXOLOTL ratchet advance.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_HashCode port
Port to open/close.
Definition: cadet.h:131
struct GNUNET_HashCode key
The key used in the DHT.
Internal representation of the hash map.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
Message for a client to create channels.
Definition: cadet.h:138
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS_END
End of local information about all tunnels of service.
void GCCH_channel_local_destroy(struct CadetChannel *ch, struct CadetClient *c, struct GNUNET_CADET_ClientChannelNumber ccn)
Destroy locally created channel.
static int destroy_paths_now(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Callback invoked on all peers to destroy all tunnels that may still exist.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
void GCT_destroy_tunnel_now(struct CadetTunnel *t)
Destroys the tunnel t now, without delay.
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel allowed to send more data.
Definition: cadet.h:227
uint32_t connections
Number of connections.
Definition: cadet.h:394
static int get_all_peers_iterator(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Iterator over all peers to send a monitoring client info about each peer.
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_CADET_LOCAL_REQUEST_INFO_TUNNELS
Request local information about all tunnels of service.
void GNUNET_CONTAINER_multishortmap_destroy(struct GNUNET_CONTAINER_MultiShortmap *map)
Destroy a hash map.
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:272
const char * GCCH_2s(const struct CadetChannel *ch)
Get the static string for identification of the channel.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_HashMapIterator32 it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_CONTAINER_MultiHashMap * ports
Ports that this client has declared interest in.
uint32_t channels
Number of channels.
Definition: cadet.h:384
int shutting_down
Signal that shutdown is happening: prevent recovery measures.
unsigned int GCP_iterate_indirect_paths(struct CadetPeer *cp, GCP_PathIterator callback, void *callback_cls)
Iterate over the paths to a peer without direct link.
struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Own private key.
Allow multiple values with the same key.
static int get_all_tunnels_iterator(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Iterator over all tunnels to send a monitoring client info about each tunnel.
Handle to a message queue.
Definition: mq.c:85
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.
Private ECC key encoded for transmission.
void GCD_init(const struct GNUNET_CONFIGURATION_Handle *c)
Initialize the DHT subsystem.
uint16_t estate
Encryption state.
Definition: cadet.h:399
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:182
static uint16_t port
Port number.
Definition: gnunet-bcd.c:79
configuration data
Definition: configuration.c:85
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE
Stop listening on a port.
static void handle_port_open(void *cls, const struct GNUNET_CADET_PortMessage *pmsg)
Handle port open request.
struct CadetPeer * GCP_get(const struct GNUNET_PeerIdentity *peer_id, int create)
Retrieve the CadetPeer stucture associated with the peer.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS
Local information about all peers known to the service.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA
Payload client <-> service.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH_END
End of local information of service about a specific path.
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_HashMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
unsigned int GCT_count_channels(struct CadetTunnel *t)
Count channels of a tunnel.
#define GNUNET_log(kind,...)
const char * GSC_2s(struct CadetClient *c)
Return identifier for a client as a string.
const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our configuration.
void GSC_send_to_client(struct CadetClient *c, struct GNUNET_MQ_Envelope *env)
Send a message to a client.
struct CadetClient * prev
Linked list prev.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Setup CADET internals.
struct CadetPeer * GCPP_get_peer_at_offset(struct CadetPeerPath *path, unsigned int off)
Obtain the peer at offset off in path.
static int client_release_ports(void *cls, const struct GNUNET_HashCode *port, void *value)
Remove client&#39;s ports from the global hashmap on disconnect.
struct GNUNET_PeerIdentity destination
ID of the peer (can be local peer).
Definition: cadet.h:364
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_configuration(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new private key by reading our peer&#39;s key from the file specified in the configuration...
struct GNUNET_TIME_Relative keepalive_period
How frequently do we send KEEPALIVE messages on idle connections?
static void handle_channel_destroy(void *cls, const struct GNUNET_CADET_LocalChannelDestroyMessage *msg)
Handler for requests of destroying an existing channel.
Header for all communications.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA.
Definition: cadet.h:194
#define GNUNET_YES
Definition: gnunet_common.h:80
void GCO_init(const struct GNUNET_CONFIGURATION_Handle *c)
Initialize the CORE subsystem.
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
Message for cadet data traffic.
Definition: cadet.h:189
void GSC_drop_loose_channel(const struct GNUNET_HashCode *h_port, struct CadetChannel *ch)
A client that created a loose channel that was not bound to a port disconnected, drop it from the loo...
cadet service; dealing with DHT requests and results
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
void GCP_iterate_all(GNUNET_CONTAINER_PeerMapIterator iter, void *cls)
Iterate over all known peers.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
cadet service; interaction with CORE service
static void handle_info_tunnels(void *cls, const struct GNUNET_MessageHeader *message)
Handler for client&#39;s GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_TUNNELS request.
Information regarding a possible path to reach a peer.
unsigned int GCP_count_paths(const struct CadetPeer *cp)
Count the number of known paths toward the peer.
Handle to the ATS subsystem for connectivity management.
void GCH_init(const struct GNUNET_CONFIGURATION_Handle *c)
Initialize the hello subsystem.
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.
static int bind_loose_channel(void *cls, const struct GNUNET_HashCode *port, void *value)
We had a remote connection value to port h_port before client cls opened port port.
static int channel_destroy_iterator(void *cls, uint32_t key, void *value)
Iterator for deleting each channel whose client endpoint disconnected.
unsigned int GCPP_get_length(struct CadetPeerPath *path)
Return the length of the path.
struct GNUNET_PeerIdentity peer
Channel&#39;s peer.
Definition: cadet.h:155
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct CadetClient * c
Client that opened the port.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
int GCCH_handle_local_data(struct CadetChannel *ch, struct GNUNET_CADET_ClientChannelNumber sender_ccn, const char *buf, size_t buf_len)
Handle data given by a client.
struct GNUNET_HashCode port
Port of the channel.
Definition: cadet.h:160
Port opened by a client.
static int check_local_data(void *cls, const struct GNUNET_CADET_LocalData *msg)
Check for client traffic data message is well-formed.
struct GNUNET_MQ_Handle * mq
Handle to communicate with the client.
#define GNUNET_free(ptr)
Wrapper around free.
const struct GNUNET_PeerIdentity * GCP_get_id(struct CadetPeer *cp)
Obtain the peer identity for a struct CadetPeer.
Time for relative time used by GNUnet, in microseconds.
static void handle_show_path(void *cls, const struct GNUNET_CADET_RequestPathInfoMessage *msg)
Handler for client&#39;s GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH request.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
void GCCH_bind(struct CadetChannel *ch, struct CadetClient *c, const struct GNUNET_HashCode *port)
A client is bound to the port that we have a channel open to.
Information we track per peer.
struct GNUNET_CADET_ClientChannelNumber GSC_bind(struct CadetClient *c, struct CadetChannel *ch, struct CadetPeer *dest, const struct GNUNET_HashCode *port, uint32_t options)
Bind incoming channel to this client, and notify client about incoming connection.