GNUnet  0.11.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 (
303  ccn.channel_of_client),
304  ch,
307  "Accepting incoming %s from %s on open port %s (%u), assigning ccn %X\n",
308  GCCH_2s (ch),
309  GCP_2s (dest),
310  GNUNET_h2s (port),
311  (uint32_t) ntohl (options),
312  (uint32_t) ntohl (ccn.channel_of_client));
313  /* notify local client about incoming connection! */
314  env = GNUNET_MQ_msg (cm,
316  cm->ccn = ccn;
317  cm->port = *port;
318  cm->opt = htonl (options);
319  cm->peer = *GCP_get_id (dest);
321  env);
322  return ccn;
323 }
324 
325 
335 static int
337  const struct GNUNET_PeerIdentity *pid,
338  void *value)
339 {
340  struct CadetPeer *cp = value;
341  struct CadetTunnel *t = GCP_get_tunnel (cp,
342  GNUNET_NO);
343 
344  if (NULL != t)
346  return GNUNET_OK;
347 }
348 
349 
359 static int
360 destroy_paths_now (void *cls,
361  const struct GNUNET_PeerIdentity *pid,
362  void *value)
363 {
364  struct CadetPeer *cp = value;
365 
367  return GNUNET_OK;
368 }
369 
370 
374 static void
376 {
377  if (NULL != stats)
378  {
380  GNUNET_NO);
381  stats = NULL;
382  }
383  /* Destroy tunnels. Note that all channels must be destroyed first! */
385  NULL);
386  /* All tunnels, channels, connections and CORE must be down before this point. */
388  NULL);
389  /* All paths, tunnels, channels, connections and CORE must be down before this point. */
391  if (NULL != open_ports)
392  {
394  open_ports = NULL;
395  }
396  if (NULL != loose_channels)
397  {
398  GNUNET_CONTAINER_multihashmap_destroy (loose_channels);
399  loose_channels = NULL;
400  }
401  if (NULL != peers)
402  {
404  peers = NULL;
405  }
406  if (NULL != connections)
407  {
409  connections = NULL;
410  }
411  if (NULL != ats_ch)
412  {
414  ats_ch = NULL;
415  }
416  GCD_shutdown ();
417  GCH_shutdown ();
418  GNUNET_free_non_null (my_private_key);
419  my_private_key = NULL;
420 }
421 
422 
428 static void
429 shutdown_task (void *cls)
430 {
432  "Shutting down\n");
434  GCO_shutdown ();
435  if (NULL == clients_head)
436  shutdown_rest ();
437 }
438 
439 
449 static int
451  const struct GNUNET_HashCode *port,
452  void *value)
453 {
454  struct OpenPort *op = cls;
455  struct CadetChannel *ch = value;
456 
457  GCCH_bind (ch,
458  op->c,
459  &op->port);
461  GNUNET_CONTAINER_multihashmap_remove (loose_channels,
462  &op->h_port,
463  ch));
464  return GNUNET_YES;
465 }
466 
467 
477 static void
478 handle_port_open (void *cls,
479  const struct GNUNET_CADET_PortMessage *pmsg)
480 {
481  struct CadetClient *c = cls;
482  struct OpenPort *op;
483 
485  "Open port %s requested by %s\n",
486  GNUNET_h2s (&pmsg->port),
487  GSC_2s (c));
488  if (NULL == c->ports)
490  GNUNET_NO);
491  op = GNUNET_new (struct OpenPort);
492  op->c = c;
493  op->port = pmsg->port;
494  GCCH_hash_port (&op->h_port,
495  &pmsg->port,
496  &my_full_id);
497  if (GNUNET_OK !=
499  &op->port,
500  op,
502  {
503  GNUNET_break (0);
505  return;
506  }
507  (void) GNUNET_CONTAINER_multihashmap_put (open_ports,
508  &op->h_port,
509  op,
512  &op->h_port,
514  op);
516 }
517 
518 
528 static void
529 handle_port_close (void *cls,
530  const struct GNUNET_CADET_PortMessage *pmsg)
531 {
532  struct CadetClient *c = cls;
533  struct OpenPort *op;
534 
536  "Closing port %s as requested by %s\n",
537  GNUNET_h2s (&pmsg->port),
538  GSC_2s (c));
539  if (NULL == c->ports)
540  {
541  /* Client closed a port despite _never_ having opened one? */
542  GNUNET_break (0);
544  return;
545  }
547  &pmsg->port);
548  if (NULL == op)
549  {
550  GNUNET_break (0);
552  return;
553  }
556  &op->port,
557  op));
560  &op->h_port,
561  op));
562  GNUNET_free (op);
564 }
565 
566 
573 static void
575  const struct GNUNET_CADET_LocalChannelCreateMessage *tcm)
576 {
577  struct CadetClient *c = cls;
578  struct CadetChannel *ch;
579 
581  {
582  /* Channel ID not in allowed range. */
583  GNUNET_break (0);
585  return;
586  }
587  ch = lookup_channel (c,
588  tcm->ccn);
589  if (NULL != ch)
590  {
591  /* Channel ID already in use. Not allowed. */
592  GNUNET_break (0);
594  return;
595  }
597  "New channel to %s at port %s requested by %s\n",
598  GNUNET_i2s (&tcm->peer),
599  GNUNET_h2s (&tcm->port),
600  GSC_2s (c));
601 
602  /* Create channel */
603  ch = GCCH_channel_local_new (c,
604  tcm->ccn,
605  GCP_get (&tcm->peer,
606  GNUNET_YES),
607  &tcm->port,
608  ntohl (tcm->opt));
609  if (NULL == ch)
610  {
611  GNUNET_break (0);
613  return;
614  }
617  ntohl (
618  tcm->ccn.
619  channel_of_client),
620  ch,
622 
624 }
625 
626 
633 static void
635  const struct
637 {
638  struct CadetClient *c = cls;
639  struct CadetChannel *ch;
640 
641  ch = lookup_channel (c,
642  msg->ccn);
643  if (NULL == ch)
644  {
645  /* Client attempted to destroy unknown channel.
646  Can happen if the other side went down at the same time.*/
648  "%s tried to destroy unknown channel %X\n",
649  GSC_2s (c),
650  (uint32_t) ntohl (msg->ccn.channel_of_client));
652  return;
653  }
655  "%s is destroying %s\n",
656  GSC_2s (c),
657  GCCH_2s (ch));
660  ntohl (
661  msg->ccn.
662  channel_of_client),
663  ch));
665  c,
666  msg->ccn);
668 }
669 
670 
678 static int
679 check_local_data (void *cls,
680  const struct GNUNET_CADET_LocalData *msg)
681 {
682  size_t payload_size;
683  size_t payload_claimed_size;
684  const char *buf;
685  struct GNUNET_MessageHeader pa;
686 
687  /* FIXME: what is the format we shall allow for @a msg?
688  ONE payload item or multiple? Seems current cadet_api
689  at least in theory allows more than one. Next-gen
690  cadet_api will likely no more, so we could then
691  simplify this mess again. *//* Sanity check for message size */payload_size = ntohs (msg->header.size) - sizeof(*msg);
692  buf = (const char *) &msg[1];
693  while (payload_size >= sizeof(struct GNUNET_MessageHeader))
694  {
695  /* need to memcpy() for alignment */
696  GNUNET_memcpy (&pa,
697  buf,
698  sizeof(pa));
699  payload_claimed_size = ntohs (pa.size);
700  if ((payload_size < payload_claimed_size) ||
701  (payload_claimed_size < sizeof(struct GNUNET_MessageHeader)) ||
702  (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < payload_claimed_size))
703  {
704  GNUNET_break (0);
706  "Local data of %u total size had sub-message %u at %u with %u bytes\n",
707  ntohs (msg->header.size),
708  ntohs (pa.type),
709  (unsigned int) (buf - (const char *) &msg[1]),
710  (unsigned int) payload_claimed_size);
711  return GNUNET_SYSERR;
712  }
713  payload_size -= payload_claimed_size;
714  buf += payload_claimed_size;
715  }
716  if (0 != payload_size)
717  {
718  GNUNET_break_op (0);
719  return GNUNET_SYSERR;
720  }
721  return GNUNET_OK;
722 }
723 
724 
732 static void
733 handle_local_data (void *cls,
734  const struct GNUNET_CADET_LocalData *msg)
735 {
736  struct CadetClient *c = cls;
737  struct CadetChannel *ch;
738  size_t payload_size;
739  const char *buf;
740 
741  ch = lookup_channel (c,
742  msg->ccn);
743  if (NULL == ch)
744  {
745  /* Channel does not exist (anymore) */
747  "Dropping payload for channel %u from client (channel unknown, other endpoint may have disconnected)\n",
748  (unsigned int) ntohl (msg->ccn.channel_of_client));
750  return;
751  }
752  payload_size = ntohs (msg->header.size) - sizeof(*msg);
754  "# payload received from clients",
755  payload_size,
756  GNUNET_NO);
757  buf = (const char *) &msg[1];
759  "Received %u bytes payload from %s for %s\n",
760  (unsigned int) payload_size,
761  GSC_2s (c),
762  GCCH_2s (ch));
763  if (GNUNET_OK !=
765  msg->ccn,
766  buf,
767  payload_size))
768  {
769  GNUNET_break (0);
771  return;
772  }
774 }
775 
776 
783 static void
784 handle_local_ack (void *cls,
785  const struct GNUNET_CADET_LocalAck *msg)
786 {
787  struct CadetClient *c = cls;
788  struct CadetChannel *ch;
789 
790  ch = lookup_channel (c,
791  msg->ccn);
792  if (NULL == ch)
793  {
794  /* Channel does not exist (anymore) */
796  "Ignoring local ACK for channel %u from client (channel unknown, other endpoint may have disconnected)\n",
797  (unsigned int) ntohl (msg->ccn.channel_of_client));
799  return;
800  }
802  "Got a local ACK from %s for %s\n",
803  GSC_2s (c),
804  GCCH_2s (ch));
806  msg->ccn);
808 }
809 
810 
819 static int
821  const struct GNUNET_PeerIdentity *peer,
822  void *value)
823 {
824  struct CadetClient *c = cls;
825  struct CadetPeer *p = value;
826  struct GNUNET_MQ_Envelope *env;
828 
829  env = GNUNET_MQ_msg (msg,
831  msg->destination = *peer;
832  msg->paths = htons (GCP_count_paths (p));
833  msg->tunnel = htons (NULL != GCP_get_tunnel (p,
834  GNUNET_NO));
835  msg->best_path_length = htonl (0); // FIXME: get length of shortest known path!
836  GNUNET_MQ_send (c->mq,
837  env);
838  return GNUNET_YES;
839 }
840 
841 
848 static void
849 handle_get_peers (void *cls,
850  const struct GNUNET_MessageHeader *message)
851 {
852  struct CadetClient *c = cls;
853  struct GNUNET_MQ_Envelope *env;
854  struct GNUNET_MessageHeader *reply;
855 
857  c);
858  env = GNUNET_MQ_msg (reply,
860  GNUNET_MQ_send (c->mq,
861  env);
863 }
864 
865 
876 static int
878  struct CadetPeerPath *path,
879  unsigned int off)
880 {
881  struct GNUNET_MQ_Handle *mq = cls;
882  struct GNUNET_MQ_Envelope *env;
883  struct GNUNET_CADET_LocalInfoPath *resp;
884  struct GNUNET_PeerIdentity *id;
885  size_t path_size;
886  unsigned int path_length;
887 
888  path_length = GCPP_get_length (path);
889  path_size = sizeof(struct GNUNET_PeerIdentity) * path_length;
890  if (sizeof(*resp) + path_size > UINT16_MAX)
891  {
892  /* try just giving the relevant path */
893  path_length = GNUNET_MIN ((UINT16_MAX - sizeof(*resp)) / sizeof(struct
895  off);
896  path_size = sizeof(struct GNUNET_PeerIdentity) * path_length;
897  }
898  if (sizeof(*resp) + path_size > UINT16_MAX)
899  {
901  "Path of %u entries is too long for info message\n",
902  path_length);
903  return GNUNET_YES;
904  }
905  env = GNUNET_MQ_msg_extra (resp,
906  path_size,
908  id = (struct GNUNET_PeerIdentity *) &resp[1];
909 
910  /* Don't copy first peer. First peer is always the local one. Last
911  * peer is always the destination (leave as 0, EOL).
912  */
913  for (unsigned int i = 0; i < path_length; i++)
914  id[i] = *GCP_get_id (GCPP_get_peer_at_offset (path,
915  i));
916  resp->off = htonl (off);
917  GNUNET_MQ_send (mq,
918  env);
919  return GNUNET_YES;
920 }
921 
922 
929 static void
930 handle_show_path (void *cls,
932 {
933  struct CadetClient *c = cls;
934  struct CadetPeer *p;
935  struct GNUNET_MQ_Envelope *env;
936  struct GNUNET_MessageHeader *resp;
937 
938  p = GCP_get (&msg->peer,
939  GNUNET_NO);
940  if (NULL != p)
943  c->mq);
944  env = GNUNET_MQ_msg (resp,
946  GNUNET_MQ_send (c->mq,
947  env);
949 }
950 
951 
960 static int
962  const struct GNUNET_PeerIdentity *peer,
963  void *value)
964 {
965  struct CadetClient *c = cls;
966  struct CadetPeer *p = value;
967  struct GNUNET_MQ_Envelope *env;
969  struct CadetTunnel *t;
970 
971  t = GCP_get_tunnel (p,
972  GNUNET_NO);
973  if (NULL == t)
974  return GNUNET_YES;
975  env = GNUNET_MQ_msg (msg,
977  msg->destination = *peer;
978  msg->channels = htonl (GCT_count_channels (t));
979  msg->connections = htonl (GCT_count_any_connections (t));
980  msg->cstate = htons (0);
981  msg->estate = htons ((uint16_t) GCT_get_estate (t));
982  GNUNET_MQ_send (c->mq,
983  env);
984  return GNUNET_YES;
985 }
986 
987 
994 static void
996  const struct GNUNET_MessageHeader *message)
997 {
998  struct CadetClient *c = cls;
999  struct GNUNET_MQ_Envelope *env;
1000  struct GNUNET_MessageHeader *reply;
1001 
1003  c);
1004  env = GNUNET_MQ_msg (reply,
1006  GNUNET_MQ_send (c->mq,
1007  env);
1009 }
1010 
1011 
1020 static void *
1022  struct GNUNET_SERVICE_Client *client,
1023  struct GNUNET_MQ_Handle *mq)
1024 {
1025  struct CadetClient *c;
1026 
1027  c = GNUNET_new (struct CadetClient);
1028  c->client = client;
1029  c->mq = mq;
1030  c->id = next_client_id++; /* overflow not important: just for debug */
1031  c->channels
1033  GNUNET_CONTAINER_DLL_insert (clients_head,
1034  clients_tail,
1035  c);
1036  GNUNET_STATISTICS_update (stats,
1037  "# clients",
1038  +1,
1039  GNUNET_NO);
1041  "%s connected\n",
1042  GSC_2s (c));
1043  return c;
1044 }
1045 
1046 
1054 void
1057  struct CadetChannel *ch)
1058 {
1059  struct GNUNET_MQ_Envelope *env;
1061 
1062  env = GNUNET_MQ_msg (tdm,
1064  tdm->ccn = ccn;
1065  GSC_send_to_client (c,
1066  env);
1069  ntohl (
1070  ccn.channel_of_client),
1071  ch));
1072 }
1073 
1074 
1082 void
1084  struct CadetChannel *ch)
1085 {
1087  GNUNET_CONTAINER_multihashmap_remove (loose_channels,
1088  h_port,
1089  ch));
1090 }
1091 
1092 
1101 static int
1103  uint32_t key,
1104  void *value)
1105 {
1106  struct CadetClient *c = cls;
1108  struct CadetChannel *ch = value;
1109 
1111  "Destroying %s, due to %s disconnecting.\n",
1112  GCCH_2s (ch),
1113  GSC_2s (c));
1114  ccn.channel_of_client = htonl (key);
1116  c,
1117  ccn);
1120  key,
1121  ch));
1122  return GNUNET_OK;
1123 }
1124 
1125 
1134 static int
1136  const struct GNUNET_HashCode *port,
1137  void *value)
1138 {
1139  struct CadetClient *c = cls;
1140  struct OpenPort *op = value;
1141 
1142  GNUNET_assert (c == op->c);
1144  "Closing port %s due to %s disconnect.\n",
1145  GNUNET_h2s (port),
1146  GSC_2s (c));
1149  &op->h_port,
1150  op));
1153  port,
1154  op));
1155  GNUNET_free (op);
1156  return GNUNET_OK;
1157 }
1158 
1159 
1167 static void
1169  struct GNUNET_SERVICE_Client *client,
1170  void *internal_cls)
1171 {
1172  struct CadetClient *c = internal_cls;
1173 
1174  GNUNET_assert (c->client == client);
1176  "%s is disconnecting.\n",
1177  GSC_2s (c));
1178  if (NULL != c->channels)
1179  {
1182  c);
1185  }
1186  if (NULL != c->ports)
1187  {
1190  c);
1192  }
1193  GNUNET_CONTAINER_DLL_remove (clients_head,
1194  clients_tail,
1195  c);
1196  GNUNET_STATISTICS_update (stats,
1197  "# clients",
1198  -1,
1199  GNUNET_NO);
1200  GNUNET_free (c);
1201  if ((NULL == clients_head) &&
1203  shutdown_rest ();
1204 }
1205 
1206 
1214 static void
1215 run (void *cls,
1216  const struct GNUNET_CONFIGURATION_Handle *c,
1218 {
1219  cfg = c;
1220  if (GNUNET_OK !=
1222  "CADET",
1223  "RATCHET_MESSAGES",
1224  &ratchet_messages))
1225  {
1227  "CADET",
1228  "RATCHET_MESSAGES",
1229  "needs to be a number");
1230  ratchet_messages = 64;
1231  }
1232  if (GNUNET_OK !=
1234  "CADET",
1235  "RATCHET_TIME",
1236  &ratchet_time))
1237  {
1239  "CADET",
1240  "RATCHET_TIME",
1241  "need delay value");
1243  }
1244  if (GNUNET_OK !=
1246  "CADET",
1247  "REFRESH_CONNECTION_TIME",
1248  &keepalive_period))
1249  {
1251  "CADET",
1252  "REFRESH_CONNECTION_TIME",
1253  "need delay value");
1255  }
1256  if (GNUNET_OK !=
1258  "CADET",
1259  "DROP_PERCENT",
1260  &drop_percent))
1261  {
1262  drop_percent = 0;
1263  }
1264  else
1265  {
1266  LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1267  LOG (GNUNET_ERROR_TYPE_WARNING, "Cadet is running with DROP enabled.\n");
1268  LOG (GNUNET_ERROR_TYPE_WARNING, "This is NOT a good idea!\n");
1269  LOG (GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n");
1270  LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1271  }
1273  if (NULL == my_private_key)
1274  {
1275  GNUNET_break (0);
1277  return;
1278  }
1279  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
1281  stats = GNUNET_STATISTICS_create ("cadet",
1282  c);
1284  NULL);
1285  ats_ch = GNUNET_ATS_connectivity_init (c);
1286  /* FIXME: optimize code to allow GNUNET_YES here! */
1287  open_ports = GNUNET_CONTAINER_multihashmap_create (16,
1288  GNUNET_NO);
1289  loose_channels = GNUNET_CONTAINER_multihashmap_create (16,
1290  GNUNET_NO);
1292  GNUNET_YES);
1293  connections = GNUNET_CONTAINER_multishortmap_create (256,
1294  GNUNET_YES);
1295  GCH_init (c);
1296  GCD_init (c);
1297  GCO_init (c);
1299  "CADET started for peer %s\n",
1300  GNUNET_i2s (&my_full_id));
1301 }
1302 
1303 
1308  ("cadet",
1310  &run,
1313  NULL,
1314  GNUNET_MQ_hd_fixed_size (port_open,
1316  struct GNUNET_CADET_PortMessage,
1317  NULL),
1318  GNUNET_MQ_hd_fixed_size (port_close,
1320  struct GNUNET_CADET_PortMessage,
1321  NULL),
1322  GNUNET_MQ_hd_fixed_size (channel_create,
1325  NULL),
1329  NULL),
1330  GNUNET_MQ_hd_var_size (local_data,
1332  struct GNUNET_CADET_LocalData,
1333  NULL),
1334  GNUNET_MQ_hd_fixed_size (local_ack,
1336  struct GNUNET_CADET_LocalAck,
1337  NULL),
1340  struct GNUNET_MessageHeader,
1341  NULL),
1342  GNUNET_MQ_hd_fixed_size (show_path,
1345  NULL),
1346  GNUNET_MQ_hd_fixed_size (info_tunnels,
1348  struct GNUNET_MessageHeader,
1349  NULL),
1351 
1352 /* 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:1300
#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.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
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_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#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
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:78
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:75
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:526
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:250
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.
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:80
#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:584
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:2324
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:76
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:270
const char * GCCH_2s(const struct CadetChannel *ch)
Get the static string for identification of the channel.
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).
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
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:81
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.
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:77
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:144
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
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
static void handle_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:2243
#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.