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 (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  LOG (GNUNET_ERROR_TYPE_DEBUG,"Channel ID not in allowed range.");
584  GNUNET_break (0);
586  return;
587  }
588  ch = lookup_channel (c,
589  tcm->ccn);
590  if (NULL != ch)
591  {
592  /* Channel ID already in use. Not allowed. */
593  LOG (GNUNET_ERROR_TYPE_DEBUG,"Channel ID already in use. Not allowed.");
594  GNUNET_break (0);
596  return;
597  }
599  "New channel to %s at port %s requested by %s\n",
600  GNUNET_i2s (&tcm->peer),
601  GNUNET_h2s (&tcm->port),
602  GSC_2s (c));
603 
604  /* Create channel */
605  ch = GCCH_channel_local_new (c,
606  tcm->ccn,
607  GCP_get (&tcm->peer,
608  GNUNET_YES),
609  &tcm->port,
610  ntohl (tcm->opt));
611  if (NULL == ch)
612  {
613  GNUNET_break (0);
615  return;
616  }
619  ntohl (
620  tcm->ccn.
621  channel_of_client),
622  ch,
624 
626 }
627 
628 
635 static void
637  const struct
639 {
640  struct CadetClient *c = cls;
641  struct CadetChannel *ch;
642 
643  ch = lookup_channel (c,
644  msg->ccn);
645  if (NULL == ch)
646  {
647  /* Client attempted to destroy unknown channel.
648  Can happen if the other side went down at the same time.*/
650  "%s tried to destroy unknown channel %X\n",
651  GSC_2s (c),
652  (uint32_t) ntohl (msg->ccn.channel_of_client));
654  return;
655  }
657  "%s is destroying %s\n",
658  GSC_2s (c),
659  GCCH_2s (ch));
662  ntohl (
663  msg->ccn.
664  channel_of_client),
665  ch));
667  c,
668  msg->ccn);
670 }
671 
672 
680 static int
681 check_local_data (void *cls,
682  const struct GNUNET_CADET_LocalData *msg)
683 {
684  size_t payload_size;
685  size_t payload_claimed_size;
686  const char *buf;
687  struct GNUNET_MessageHeader pa;
688 
689  /* FIXME: what is the format we shall allow for @a msg?
690  ONE payload item or multiple? Seems current cadet_api
691  at least in theory allows more than one. Next-gen
692  cadet_api will likely no more, so we could then
693  simplify this mess again. *//* Sanity check for message size */payload_size = ntohs (msg->header.size) - sizeof(*msg);
694  buf = (const char *) &msg[1];
695  while (payload_size >= sizeof(struct GNUNET_MessageHeader))
696  {
697  /* need to memcpy() for alignment */
698  GNUNET_memcpy (&pa,
699  buf,
700  sizeof(pa));
701  payload_claimed_size = ntohs (pa.size);
702  if ((payload_size < payload_claimed_size) ||
703  (payload_claimed_size < sizeof(struct GNUNET_MessageHeader)) ||
704  (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < payload_claimed_size))
705  {
706  GNUNET_break (0);
708  "Local data of %u total size had sub-message %u at %u with %u bytes\n",
709  ntohs (msg->header.size),
710  ntohs (pa.type),
711  (unsigned int) (buf - (const char *) &msg[1]),
712  (unsigned int) payload_claimed_size);
713  return GNUNET_SYSERR;
714  }
715  payload_size -= payload_claimed_size;
716  buf += payload_claimed_size;
717  }
718  if (0 != payload_size)
719  {
720  GNUNET_break_op (0);
721  return GNUNET_SYSERR;
722  }
723  return GNUNET_OK;
724 }
725 
726 
734 static void
735 handle_local_data (void *cls,
736  const struct GNUNET_CADET_LocalData *msg)
737 {
738  struct CadetClient *c = cls;
739  struct CadetChannel *ch;
740  size_t payload_size;
741  const char *buf;
742 
743  ch = lookup_channel (c,
744  msg->ccn);
745  if (NULL == ch)
746  {
747  /* Channel does not exist (anymore) */
749  "Dropping payload for channel %u from client (channel unknown, other endpoint may have disconnected)\n",
750  (unsigned int) ntohl (msg->ccn.channel_of_client));
752  return;
753  }
754  payload_size = ntohs (msg->header.size) - sizeof(*msg);
756  "# payload received from clients",
757  payload_size,
758  GNUNET_NO);
759  buf = (const char *) &msg[1];
761  "Received %u bytes payload from %s for %s\n",
762  (unsigned int) payload_size,
763  GSC_2s (c),
764  GCCH_2s (ch));
765  if (GNUNET_OK !=
767  msg->ccn,
768  buf,
769  payload_size))
770  {
771  GNUNET_break (0);
773  return;
774  }
776 }
777 
778 
785 static void
786 handle_local_ack (void *cls,
787  const struct GNUNET_CADET_LocalAck *msg)
788 {
789  struct CadetClient *c = cls;
790  struct CadetChannel *ch;
791 
792  ch = lookup_channel (c,
793  msg->ccn);
794  if (NULL == ch)
795  {
796  /* Channel does not exist (anymore) */
798  "Ignoring local ACK for channel %u from client (channel unknown, other endpoint may have disconnected)\n",
799  (unsigned int) ntohl (msg->ccn.channel_of_client));
801  return;
802  }
804  "Got a local ACK from %s for %s\n",
805  GSC_2s (c),
806  GCCH_2s (ch));
808  msg->ccn);
810 }
811 
812 
821 static int
823  const struct GNUNET_PeerIdentity *peer,
824  void *value)
825 {
826  struct CadetClient *c = cls;
827  struct CadetPeer *p = value;
828  struct GNUNET_MQ_Envelope *env;
830 
831  env = GNUNET_MQ_msg (msg,
833  msg->destination = *peer;
834  msg->paths = htons (GCP_count_paths (p));
835  msg->tunnel = htons (NULL != GCP_get_tunnel (p,
836  GNUNET_NO));
837  msg->best_path_length = htonl (0); // FIXME: get length of shortest known path!
838  GNUNET_MQ_send (c->mq,
839  env);
840  return GNUNET_YES;
841 }
842 
843 
850 static void
851 handle_get_peers (void *cls,
852  const struct GNUNET_MessageHeader *message)
853 {
854  struct CadetClient *c = cls;
855  struct GNUNET_MQ_Envelope *env;
856  struct GNUNET_MessageHeader *reply;
857 
859  c);
860  env = GNUNET_MQ_msg (reply,
862  GNUNET_MQ_send (c->mq,
863  env);
865 }
866 
867 
878 static int
880  struct CadetPeerPath *path,
881  unsigned int off)
882 {
883  struct GNUNET_MQ_Handle *mq = cls;
884  struct GNUNET_MQ_Envelope *env;
885  struct GNUNET_CADET_LocalInfoPath *resp;
886  struct GNUNET_PeerIdentity *id;
887  size_t path_size;
888  unsigned int path_length;
889 
890  path_length = GCPP_get_length (path);
891  path_size = sizeof(struct GNUNET_PeerIdentity) * path_length;
892  if (sizeof(*resp) + path_size > UINT16_MAX)
893  {
894  /* try just giving the relevant path */
895  path_length = GNUNET_MIN ((UINT16_MAX - sizeof(*resp)) / sizeof(struct
897  off);
898  path_size = sizeof(struct GNUNET_PeerIdentity) * path_length;
899  }
900  if (sizeof(*resp) + path_size > UINT16_MAX)
901  {
903  "Path of %u entries is too long for info message\n",
904  path_length);
905  return GNUNET_YES;
906  }
907  env = GNUNET_MQ_msg_extra (resp,
908  path_size,
910  id = (struct GNUNET_PeerIdentity *) &resp[1];
911 
912  /* Don't copy first peer. First peer is always the local one. Last
913  * peer is always the destination (leave as 0, EOL).
914  */
915  for (unsigned int i = 0; i < path_length; i++)
916  id[i] = *GCP_get_id (GCPP_get_peer_at_offset (path,
917  i));
918  resp->off = htonl (off);
919  GNUNET_MQ_send (mq,
920  env);
921  return GNUNET_YES;
922 }
923 
924 
931 static void
932 handle_show_path (void *cls,
934 {
935  struct CadetClient *c = cls;
936  struct CadetPeer *p;
937  struct GNUNET_MQ_Envelope *env;
938  struct GNUNET_MessageHeader *resp;
939 
940  p = GCP_get (&msg->peer,
941  GNUNET_NO);
942  if (NULL != p)
945  c->mq);
946  env = GNUNET_MQ_msg (resp,
948  GNUNET_MQ_send (c->mq,
949  env);
951 }
952 
953 
962 static int
964  const struct GNUNET_PeerIdentity *peer,
965  void *value)
966 {
967  struct CadetClient *c = cls;
968  struct CadetPeer *p = value;
969  struct GNUNET_MQ_Envelope *env;
971  struct CadetTunnel *t;
972 
973  t = GCP_get_tunnel (p,
974  GNUNET_NO);
975  if (NULL == t)
976  return GNUNET_YES;
977  env = GNUNET_MQ_msg (msg,
979  msg->destination = *peer;
980  msg->channels = htonl (GCT_count_channels (t));
981  msg->connections = htonl (GCT_count_any_connections (t));
982  msg->cstate = htons (0);
983  msg->estate = htons ((uint16_t) GCT_get_estate (t));
984  GNUNET_MQ_send (c->mq,
985  env);
986  return GNUNET_YES;
987 }
988 
989 
996 static void
998  const struct GNUNET_MessageHeader *message)
999 {
1000  struct CadetClient *c = cls;
1001  struct GNUNET_MQ_Envelope *env;
1002  struct GNUNET_MessageHeader *reply;
1003 
1005  c);
1006  env = GNUNET_MQ_msg (reply,
1008  GNUNET_MQ_send (c->mq,
1009  env);
1011 }
1012 
1013 
1020 static void
1022  const struct GNUNET_CADET_RequestDropCadetMessage *message)
1023 {
1024  struct CadetClient *c = cls;
1025  struct CadetChannel *ch;
1026 
1027  ch = lookup_channel (c,
1028  message->ccn);
1029 
1030  GCCH_assign_type_to_drop (ch, message);
1031 
1033 }
1034 
1035 
1044 static void *
1046  struct GNUNET_SERVICE_Client *client,
1047  struct GNUNET_MQ_Handle *mq)
1048 {
1049  struct CadetClient *c;
1050 
1051  c = GNUNET_new (struct CadetClient);
1052  c->client = client;
1053  c->mq = mq;
1054  c->id = next_client_id++; /* overflow not important: just for debug */
1055  c->channels
1057  GNUNET_CONTAINER_DLL_insert (clients_head,
1058  clients_tail,
1059  c);
1060  GNUNET_STATISTICS_update (stats,
1061  "# clients",
1062  +1,
1063  GNUNET_NO);
1065  "%s connected\n",
1066  GSC_2s (c));
1067  return c;
1068 }
1069 
1070 
1078 void
1081  struct CadetChannel *ch)
1082 {
1083  struct GNUNET_MQ_Envelope *env;
1085 
1086  env = GNUNET_MQ_msg (tdm,
1088  tdm->ccn = ccn;
1089  GSC_send_to_client (c,
1090  env);
1093  ntohl (
1094  ccn.channel_of_client),
1095  ch));
1096 }
1097 
1098 
1106 void
1108  struct CadetChannel *ch)
1109 {
1111  GNUNET_CONTAINER_multihashmap_remove (loose_channels,
1112  h_port,
1113  ch));
1114 }
1115 
1116 
1125 static int
1127  uint32_t key,
1128  void *value)
1129 {
1130  struct CadetClient *c = cls;
1132  struct CadetChannel *ch = value;
1133 
1135  "Destroying %s, due to %s disconnecting.\n",
1136  GCCH_2s (ch),
1137  GSC_2s (c));
1138  ccn.channel_of_client = htonl (key);
1140  c,
1141  ccn);
1144  key,
1145  ch));
1146  return GNUNET_OK;
1147 }
1148 
1149 
1158 static int
1160  const struct GNUNET_HashCode *port,
1161  void *value)
1162 {
1163  struct CadetClient *c = cls;
1164  struct OpenPort *op = value;
1165 
1166  GNUNET_assert (c == op->c);
1168  "Closing port %s due to %s disconnect.\n",
1169  GNUNET_h2s (port),
1170  GSC_2s (c));
1173  &op->h_port,
1174  op));
1177  port,
1178  op));
1179  GNUNET_free (op);
1180  return GNUNET_OK;
1181 }
1182 
1183 
1191 static void
1193  struct GNUNET_SERVICE_Client *client,
1194  void *internal_cls)
1195 {
1196  struct CadetClient *c = internal_cls;
1197 
1198  GNUNET_assert (c->client == client);
1200  "%s is disconnecting.\n",
1201  GSC_2s (c));
1202  if (NULL != c->channels)
1203  {
1206  c);
1209  }
1210  if (NULL != c->ports)
1211  {
1214  c);
1216  }
1217  GNUNET_CONTAINER_DLL_remove (clients_head,
1218  clients_tail,
1219  c);
1220  GNUNET_STATISTICS_update (stats,
1221  "# clients",
1222  -1,
1223  GNUNET_NO);
1224  GNUNET_free (c);
1225  if ((NULL == clients_head) &&
1227  shutdown_rest ();
1228 }
1229 
1230 
1238 static void
1239 run (void *cls,
1240  const struct GNUNET_CONFIGURATION_Handle *c,
1242 {
1243  cfg = c;
1244  if (GNUNET_OK !=
1246  "CADET",
1247  "RATCHET_MESSAGES",
1248  &ratchet_messages))
1249  {
1251  "CADET",
1252  "RATCHET_MESSAGES",
1253  "needs to be a number");
1254  ratchet_messages = 64;
1255  }
1256  if (GNUNET_OK !=
1258  "CADET",
1259  "RATCHET_TIME",
1260  &ratchet_time))
1261  {
1263  "CADET",
1264  "RATCHET_TIME",
1265  "need delay value");
1267  }
1268  if (GNUNET_OK !=
1270  "CADET",
1271  "REFRESH_CONNECTION_TIME",
1272  &keepalive_period))
1273  {
1275  "CADET",
1276  "REFRESH_CONNECTION_TIME",
1277  "need delay value");
1279  }
1280  if (GNUNET_OK !=
1282  "CADET",
1283  "DROP_PERCENT",
1284  &drop_percent))
1285  {
1286  drop_percent = 0;
1287  }
1288  else
1289  {
1290  LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1291  LOG (GNUNET_ERROR_TYPE_WARNING, "Cadet is running with DROP enabled.\n");
1292  LOG (GNUNET_ERROR_TYPE_WARNING, "This is NOT a good idea!\n");
1293  LOG (GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n");
1294  LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1295  }
1297  if (NULL == my_private_key)
1298  {
1299  GNUNET_break (0);
1301  return;
1302  }
1303  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
1305  stats = GNUNET_STATISTICS_create ("cadet",
1306  c);
1308  NULL);
1309  ats_ch = GNUNET_ATS_connectivity_init (c);
1310  /* FIXME: optimize code to allow GNUNET_YES here! */
1311  open_ports = GNUNET_CONTAINER_multihashmap_create (16,
1312  GNUNET_NO);
1313  loose_channels = GNUNET_CONTAINER_multihashmap_create (16,
1314  GNUNET_NO);
1316  GNUNET_YES);
1317  connections = GNUNET_CONTAINER_multishortmap_create (256,
1318  GNUNET_YES);
1319  GCH_init (c);
1320  GCD_init (c);
1321  GCO_init (c);
1323  "CADET started for peer %s\n",
1324  GNUNET_i2s (&my_full_id));
1325 }
1326 
1327 
1332  ("cadet",
1334  &run,
1337  NULL,
1338  GNUNET_MQ_hd_fixed_size (port_open,
1340  struct GNUNET_CADET_PortMessage,
1341  NULL),
1342  GNUNET_MQ_hd_fixed_size (port_close,
1344  struct GNUNET_CADET_PortMessage,
1345  NULL),
1346  GNUNET_MQ_hd_fixed_size (channel_create,
1349  NULL),
1353  NULL),
1354  GNUNET_MQ_hd_var_size (local_data,
1356  struct GNUNET_CADET_LocalData,
1357  NULL),
1358  GNUNET_MQ_hd_fixed_size (local_ack,
1360  struct GNUNET_CADET_LocalAck,
1361  NULL),
1364  struct GNUNET_MessageHeader,
1365  NULL),
1366  GNUNET_MQ_hd_fixed_size (show_path,
1369  NULL),
1370  GNUNET_MQ_hd_fixed_size (info_tunnels,
1372  struct GNUNET_MessageHeader,
1373  NULL),
1374  GNUNET_MQ_hd_fixed_size (drop_message,
1377  NULL),
1379 
1380 /* 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:489
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:213
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
Peer description.
void GCCH_assign_type_to_drop(struct CadetChannel *ch, const struct GNUNET_CADET_RequestDropCadetMessage *message)
Assign type of message to drop.
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:280
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:110
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:235
#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:1331
#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:181
uint32_t best_path_length
Shortest known path.
Definition: cadet.h:444
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:474
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.
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Tunnels that belong to this client, indexed by local id, value is a struct CadetChannel.
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.
Message to inform the client about channels in the service.
Definition: cadet.h:344
#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.
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_hd_fixed_size(drop_message, GNUNET_MESSAGE_TYPE_CADET_DROP_CADET_MESSAGE, struct GNUNET_CADET_RequestDropCadetMessage, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
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:434
#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:359
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:531
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:439
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.
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel we want to drop a message for.
Definition: cadet.h:337
Message to inform the client about one of the paths known to the service.
Definition: cadet.h:407
#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.
static void handle_drop_message(void *cls, const struct GNUNET_CADET_RequestDropCadetMessage *message)
Handler for client&#39;s GNUNET_MESSAGE_TYPE_CADET_DROP_CADET_MESSAGE request.
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:93
#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:424
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:417
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
#define GNUNET_MESSAGE_TYPE_CADET_DROP_CADET_MESSAGE
Request to drop a message of type X to peer y.
Number uniquely identifying a channel of a client.
Definition: cadet.h:101
struct GNUNET_HashCode port
Port number.
Message to inform the client about one of the tunnels in the service.
Definition: cadet.h:458
#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:262
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2323
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:194
struct GNUNET_HashCode key
The key used in the DHT.
Internal representation of the hash map.
Message for a client to create channels.
Definition: cadet.h:201
#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:290
uint32_t connections
Number of connections.
Definition: cadet.h:479
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:193
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:469
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:484
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:245
static uint16_t port
Port number.
Definition: gnunet-bcd.c:82
configuration data
Definition: configuration.c:84
#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:449
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:257
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:355
Message for cadet data traffic.
Definition: cadet.h:252
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.
Message to drop another message of specific type.
Definition: cadet.h:321
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:218
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:2242
#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:223
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.