GNUnet  0.11.x
gnunet-service-cadet_core.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 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 
32 #include "platform.h"
38 #include "gnunet_core_service.h"
40 #include "cadet_protocol.h"
41 
42 #define LOG(level, ...) GNUNET_log_from (level, "cadet-cor", __VA_ARGS__)
43 
47 struct RouteDirection;
48 
55 struct Rung
56 {
60  struct Rung *next;
61 
65  struct Rung *prev;
66 
71 
76 
80  unsigned int num_routes;
81 
86  unsigned int rung_off;
87 };
88 
89 
94 {
99 
104 
108  struct Rung *rung;
109 
114 
119 
123  struct CadetPeer *hop;
124 
129 
134 
138  int is_ready;
139 };
140 
141 
151 {
156 
161 
166 
170  struct GNUNET_TIME_Absolute last_use;
171 
176 };
177 
178 
182 static struct GNUNET_CORE_Handle *core;
183 
188 
193 
197 static struct Rung rung_zero;
198 
203 static struct Rung *rung_head = &rung_zero;
204 
208 static struct Rung *rung_tail = &rung_zero;
209 
213 static unsigned long long max_routes;
214 
218 static unsigned long long max_buffers;
219 
223 static unsigned long long cur_buffers;
224 
229 
230 
236 static struct CadetRoute *
238 {
239  return GNUNET_CONTAINER_multishortmap_get (routes,
240  &cid->connection_of_tunnel);
241 }
242 
243 
249 static void
251 {
252  struct Rung *rung = dir->rung;
253  struct Rung *prev;
254 
255  GNUNET_CONTAINER_DLL_remove (rung->rd_head, rung->rd_tail, dir);
256  prev = rung->prev;
257  GNUNET_assert (NULL != prev);
258  if (prev->rung_off != rung->rung_off - 1)
259  {
260  prev = GNUNET_new (struct Rung);
261  prev->rung_off = rung->rung_off - 1;
262  GNUNET_CONTAINER_DLL_insert_after (rung_head, rung_tail, rung->prev, prev);
263  }
264  GNUNET_assert (NULL != prev);
265  GNUNET_CONTAINER_DLL_insert (prev->rd_head, prev->rd_tail, dir);
266  dir->rung = prev;
267 }
268 
269 
277 static void
279 {
280  GNUNET_MQ_dll_remove (&dir->env_head, &dir->env_tail, env);
281  cur_buffers--;
282  GNUNET_MQ_discard (env);
283  lower_rung (dir);
284  GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
285 }
286 
287 
291 static void
293 {
294  struct Rung *tail = rung_tail;
295  struct RouteDirection *dir;
296 
297  while (NULL != (dir = tail->rd_head))
298  {
300  "Queue full due new message %s on connection %s, dropping old message\n",
303  "# messages dropped due to full buffer",
304  1,
305  GNUNET_NO);
306  discard_buffer (dir, dir->env_head);
307  }
308  GNUNET_CONTAINER_DLL_remove (rung_head, rung_tail, tail);
309  GNUNET_free (tail);
310 }
311 
312 
322 static void
324  const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
325  const struct GNUNET_MessageHeader *msg,
326  const enum GNUNET_MQ_PriorityPreferences priority)
327 {
328  struct CadetRoute *route;
329  struct RouteDirection *dir;
330  struct Rung *rung;
331  struct Rung *nxt;
332  struct GNUNET_MQ_Envelope *env;
333 
334  route = get_route (cid);
335  if (NULL == route)
336  {
337  struct GNUNET_MQ_Envelope *env;
339 
341  "Failed to route message of type %u from %s on connection %s: no route\n",
342  ntohs (msg->type),
343  GCP_2s (prev),
345  switch (ntohs (msg->type))
346  {
349  /* No need to respond to these! */
350  return;
351  }
353  bm->cid = *cid;
354  bm->peer1 = my_full_id;
355  GCP_send_ooo (prev, env);
356  return;
357  }
360  dir = (prev == route->prev.hop) ? &route->next : &route->prev;
361  if (GNUNET_YES == dir->is_ready)
362  {
364  "Routing message of type %u from %s to %s on connection %s\n",
365  ntohs (msg->type),
366  GCP_2s (prev),
367  GNUNET_i2s (GCP_get_id (dir->hop)),
369  dir->is_ready = GNUNET_NO;
370  GCP_send (dir->mqm, GNUNET_MQ_msg_copy (msg));
371  return;
372  }
373  /* Check if low latency is required and if the previous message was
374  unreliable; if so, make sure we only queue one message per
375  direction (no buffering). */
376  if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) &&
377  (NULL != dir->env_head) &&
378  (0 ==
380  discard_buffer (dir, dir->env_head);
381  /* Check for duplicates */
382  for (const struct GNUNET_MQ_Envelope *env = dir->env_head; NULL != env;
383  env = GNUNET_MQ_env_next (env))
384  {
385  const struct GNUNET_MessageHeader *hdr = GNUNET_MQ_env_get_msg (env);
386 
387  if ((hdr->size == msg->size) && (0 == memcmp (hdr, msg, ntohs (msg->size))))
388  {
390  "Received duplicate of message already in buffer, dropping\n");
392  "# messages dropped due to duplicate in buffer",
393  1,
394  GNUNET_NO);
395  return;
396  }
397  }
398 
399  rung = dir->rung;
400  if (cur_buffers == max_buffers)
401  {
402  /* Need to make room. */
403  if (NULL != rung->next)
404  {
405  /* Easy case, drop messages from route directions in highest rung */
407  }
408  else
409  {
410  /* We are in the highest rung, drop our own! */
412  "Queue full due new message %s on connection %s, dropping old message\n",
415  "# messages dropped due to full buffer",
416  1,
417  GNUNET_NO);
418  discard_buffer (dir, dir->env_head);
419  rung = dir->rung;
420  }
421  }
422  /* remove 'dir' from current rung */
423  GNUNET_CONTAINER_DLL_remove (rung->rd_head, rung->rd_tail, dir);
424  /* make 'nxt' point to the next higher rung, create if necessary */
425  nxt = rung->next;
426  if ((NULL == nxt) || (rung->rung_off + 1 != nxt->rung_off))
427  {
428  nxt = GNUNET_new (struct Rung);
429  nxt->rung_off = rung->rung_off + 1;
430  GNUNET_CONTAINER_DLL_insert_after (rung_head, rung_tail, rung, nxt);
431  }
432  /* insert 'dir' into next higher rung */
433  GNUNET_CONTAINER_DLL_insert (nxt->rd_head, nxt->rd_tail, dir);
434  dir->rung = nxt;
435 
436  /* add message into 'dir' buffer */
438  "Queueing new message of type %u from %s to %s on connection %s\n",
439  ntohs (msg->type),
440  GCP_2s (prev),
441  GNUNET_i2s (GCP_get_id (dir->hop)),
443  env = GNUNET_MQ_msg_copy (msg);
444  GNUNET_MQ_env_set_options (env, priority);
445  if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) &&
446  (0 != (priority & GNUNET_MQ_PREF_OUT_OF_ORDER)) &&
447  (NULL != dir->env_head) &&
448  (0 == (GNUNET_MQ_env_get_options (dir->env_head)
449  & GNUNET_MQ_PREF_LOW_LATENCY)))
450  GNUNET_MQ_dll_insert_head (&dir->env_head, &dir->env_tail, env);
451  else
452  GNUNET_MQ_dll_insert_tail (&dir->env_head, &dir->env_tail, env);
453  cur_buffers++;
454  GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
455  /* Clean up 'rung' if now empty (and not head) */
456  if ((NULL == rung->rd_head) && (rung != rung_head))
457  {
458  GNUNET_CONTAINER_DLL_remove (rung_head, rung_tail, rung);
459  GNUNET_free (rung);
460  }
461 }
462 
463 
472 static int
475 {
476  uint16_t size = ntohs (msg->header.size) - sizeof(*msg);
477 
478  if (0 != (size % sizeof(struct GNUNET_PeerIdentity)))
479  {
480  GNUNET_break_op (0);
481  return GNUNET_NO;
482  }
483  return GNUNET_YES;
484 }
485 
486 
492 static void
494 {
495  struct GNUNET_MQ_Envelope *env;
496 
497  while (NULL != (env = dir->env_head))
498  {
500  "# messages dropped due to route destruction",
501  1,
502  GNUNET_NO);
503  discard_buffer (dir, env);
504  }
505  if (NULL != dir->mqm)
506  {
507  GCP_request_mq_cancel (dir->mqm, NULL);
508  dir->mqm = NULL;
509  }
510  GNUNET_CONTAINER_DLL_remove (rung_head->rd_head, rung_head->rd_tail, dir);
511 }
512 
513 
519 static void
520 destroy_route (struct CadetRoute *route)
521 {
523  "Destroying route from %s to %s of connection %s\n",
524  GNUNET_i2s (GCP_get_id (route->prev.hop)),
525  GNUNET_i2s2 (GCP_get_id (route->next.hop)),
528  GNUNET_assert (
529  GNUNET_YES ==
531  &route->cid.connection_of_tunnel,
532  route));
534  "# routes",
536  GNUNET_NO);
537  destroy_direction (&route->prev);
538  destroy_direction (&route->next);
539  GNUNET_free (route);
540 }
541 
542 
551 static void
552 send_broken (struct RouteDirection *target,
553  const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
554  const struct GNUNET_PeerIdentity *peer1,
555  const struct GNUNET_PeerIdentity *peer2)
556 {
557  struct GNUNET_MQ_Envelope *env;
559 
560  if (NULL == target->mqm)
561  return; /* Can't send notification, connection is down! */
563  "Notifying %s about BROKEN route at %s-%s of connection %s\n",
564  GCP_2s (target->hop),
565  GNUNET_i2s (peer1),
566  GNUNET_i2s2 (peer2),
568 
570  bm->cid = *cid;
571  if (NULL != peer1)
572  bm->peer1 = *peer1;
573  if (NULL != peer2)
574  bm->peer2 = *peer2;
575  GCP_request_mq_cancel (target->mqm, env);
576  target->mqm = NULL;
577 }
578 
579 
587 static void
588 timeout_cb (void *cls)
589 {
590  struct CadetRoute *r;
591  struct GNUNET_TIME_Relative linger;
592  struct GNUNET_TIME_Absolute exp;
593 
594  timeout_task = NULL;
596  while (NULL != (r = GNUNET_CONTAINER_heap_peek (route_heap)))
597  {
598  exp = GNUNET_TIME_absolute_add (r->last_use, linger);
599  if (0 != GNUNET_TIME_absolute_get_remaining (exp).rel_value_us)
600  {
601  /* Route not yet timed out, wait until it does. */
602  timeout_task = GNUNET_SCHEDULER_add_at (exp, &timeout_cb, NULL);
603  return;
604  }
606  "Sending BROKEN due to timeout (%s was last use, %s linger)\n",
609  send_broken (&r->prev, &r->cid, NULL, NULL);
610  send_broken (&r->next, &r->cid, NULL, NULL);
611  destroy_route (r);
612  }
613  /* No more routes left, so no need for a #timeout_task */
614 }
615 
616 
629 static void
630 dir_ready_cb (void *cls, int ready)
631 {
632  struct RouteDirection *dir = cls;
633  struct CadetRoute *route = dir->my_route;
634  struct RouteDirection *odir;
635 
636  if (GNUNET_YES == ready)
637  {
638  struct GNUNET_MQ_Envelope *env;
639 
640  dir->is_ready = GNUNET_YES;
641  if (NULL != (env = dir->env_head))
642  {
643  GNUNET_MQ_dll_remove (&dir->env_head, &dir->env_tail, env);
644  cur_buffers--;
645  GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
646  lower_rung (dir);
647  dir->is_ready = GNUNET_NO;
648  GCP_send (dir->mqm, env);
649  }
650  return;
651  }
652  odir = (dir == &route->next) ? &route->prev : &route->next;
653  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending BROKEN due to MQ going down\n");
654  send_broken (&route->next, &route->cid, GCP_get_id (odir->hop), &my_full_id);
655  destroy_route (route);
656 }
657 
658 
666 static void
668  struct CadetRoute *route,
669  struct CadetPeer *hop)
670 {
671  dir->hop = hop;
672  dir->my_route = route;
673  dir->mqm = GCP_request_mq (hop, &dir_ready_cb, dir);
674  GNUNET_CONTAINER_DLL_insert (rung_head->rd_head, rung_head->rd_tail, dir);
675  dir->rung = rung_head;
677 }
678 
679 
690 static void
692  struct CadetPeer *target,
693  const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
694  const struct GNUNET_PeerIdentity *failure_at)
695 {
696  struct GNUNET_MQ_Envelope *env;
698 
700  bm->cid = *cid;
701  bm->peer1 = my_full_id;
702  if (NULL != failure_at)
703  bm->peer2 = *failure_at;
704  GCP_send_ooo (target, env);
705 }
706 
707 
714 static void
716  void *cls,
718 {
719  struct CadetPeer *sender = cls;
720  struct CadetPeer *next;
721  const struct GNUNET_PeerIdentity *pids =
722  (const struct GNUNET_PeerIdentity *) &msg[1];
723  struct CadetRoute *route;
724  uint16_t size = ntohs (msg->header.size) - sizeof(*msg);
725  unsigned int path_length;
726  unsigned int off;
727 
728  path_length = size / sizeof(struct GNUNET_PeerIdentity);
729  if (0 == path_length)
730  {
732  "Dropping CADET_CONNECTION_CREATE with empty path\n");
733  GNUNET_break_op (0);
734  return;
735  }
737  "Handling CADET_CONNECTION_CREATE from %s for CID %s with %u hops\n",
738  GCP_2s (sender),
740  path_length);
741  /* Check for loops */
742  {
744 
745  map = GNUNET_CONTAINER_multipeermap_create (path_length * 2, GNUNET_YES);
746  GNUNET_assert (NULL != map);
747  for (unsigned int i = 0; i < path_length; i++)
748  {
750  "CADET_CONNECTION_CREATE has peer %s at offset %u\n",
751  GNUNET_i2s (&pids[i]),
752  i);
754  map,
755  &pids[i],
756  NULL,
758  {
759  /* bogus request */
762  "Dropping CADET_CONNECTION_CREATE with cyclic path\n");
763  GNUNET_break_op (0);
764  return;
765  }
766  }
768  }
769  /* Initiator is at offset 0, find us */
770  for (off = 1; off < path_length; off++)
771  if (0 == GNUNET_memcmp (&my_full_id, &pids[off]))
772  break;
773  if (off == path_length)
774  {
776  "Dropping CADET_CONNECTION_CREATE without us in the path\n");
777  GNUNET_break_op (0);
778  return;
779  }
780  /* Check previous hop */
781  if (sender != GCP_get (&pids[off - 1], GNUNET_NO))
782  {
784  "Dropping CADET_CONNECTION_CREATE without sender at previous hop in the path\n");
785  GNUNET_break_op (0);
786  return;
787  }
788  if (NULL != (route = get_route (&msg->cid)))
789  {
790  /* Duplicate CREATE, pass it on, previous one might have been lost! */
791 
793  "Passing on duplicate CADET_CONNECTION_CREATE message on connection %s\n",
795  route_message (sender,
796  &msg->cid,
797  &msg->header,
800  return;
801  }
802  if (off == path_length - 1)
803  {
804  /* We are the destination, create connection */
805  struct CadetConnection *cc;
806  struct CadetPeerPath *path;
807  struct CadetPeer *origin;
808 
809  cc = GCC_lookup (&msg->cid);
810  if (NULL != cc)
811  {
813  "Received duplicate CADET_CONNECTION_CREATE message on connection %s\n",
816  return;
817  }
818 
819  origin = GCP_get (&pids[0], GNUNET_YES);
821  "I am destination for CADET_CONNECTION_CREATE message from %s for connection %s, building inverse path\n",
822  GCP_2s (origin),
824  path = GCPP_get_path_from_route (path_length - 1, pids);
825  if (GNUNET_OK !=
827  &msg->cid,
828  path))
829  {
830  /* Send back BROKEN: duplicate connection on the same path,
831  we will use the other one. */
833  "Received CADET_CONNECTION_CREATE from %s for %s, but %s already has a connection. Sending BROKEN\n",
834  GCP_2s (sender),
836  GCPP_2s (path));
837  send_broken_without_mqm (sender, &msg->cid, NULL);
838  return;
839  }
840  return;
841  }
842  /* We are merely a hop on the way, check if we can support the route */
843  next = GCP_get (&pids[off + 1], GNUNET_NO);
844  if ((NULL == next) || (GNUNET_NO == GCP_has_core_connection (next)))
845  {
846  /* unworkable, send back BROKEN notification */
848  "Received CADET_CONNECTION_CREATE from %s for %s. Next hop %s:%u is down. Sending BROKEN\n",
849  GCP_2s (sender),
851  GNUNET_i2s (&pids[off + 1]),
852  off + 1);
853  send_broken_without_mqm (sender, &msg->cid, &pids[off + 1]);
854  return;
855  }
857  {
859  "Received CADET_CONNECTION_CREATE from %s for %s. We have reached our route limit. Sending BROKEN\n",
860  GCP_2s (sender),
862  send_broken_without_mqm (sender, &msg->cid, &pids[off - 1]);
863  return;
864  }
865 
866  /* Workable route, create routing entry */
868  "Received CADET_CONNECTION_CREATE from %s for %s. Next hop %s:%u is up. Creating route\n",
869  GCP_2s (sender),
871  GNUNET_i2s (&pids[off + 1]),
872  off + 1);
873  route = GNUNET_new (struct CadetRoute);
874  route->cid = msg->cid;
876  dir_init (&route->prev, route, sender);
877  dir_init (&route->next, route, next);
880  routes,
881  &route->cid.connection_of_tunnel,
882  route,
885  "# routes",
887  GNUNET_NO);
888  route->hn = GNUNET_CONTAINER_heap_insert (route_heap,
889  route,
890  route->last_use.abs_value_us);
891  if (NULL == timeout_task)
892  timeout_task =
895  3),
896  &timeout_cb,
897  NULL);
898  /* also pass CREATE message along to next hop */
899  route_message (sender,
900  &msg->cid,
901  &msg->header,
903 }
904 
905 
912 static void
914  void *cls,
916 {
917  struct CadetPeer *peer = cls;
918  struct CadetConnection *cc;
919 
920  /* First, check if ACK belongs to a connection that ends here. */
921  cc = GCC_lookup (&msg->cid);
922  if (NULL != cc)
923  {
924  /* verify ACK came from the right direction */
925  unsigned int len;
926  struct CadetPeerPath *path = GCC_get_path (cc, &len);
927 
928  if (peer != GCPP_get_peer_at_offset (path, 0))
929  {
930  /* received ACK from unexpected direction, ignore! */
931  GNUNET_break_op (0);
932  return;
933  }
935  "Received CONNECTION_CREATE_ACK for connection %s.\n",
938  return;
939  }
940 
941  /* We're just an intermediary peer, route the message along its path */
942  route_message (peer,
943  &msg->cid,
944  &msg->header,
946 }
947 
948 
956 static void
958  void *cls,
960 {
961  struct CadetPeer *peer = cls;
962  struct CadetConnection *cc;
963  struct CadetRoute *route;
964 
965  /* First, check if message belongs to a connection that ends here. */
966  cc = GCC_lookup (&msg->cid);
967  if (NULL != cc)
968  {
969  /* verify message came from the right direction */
970  unsigned int len;
971  struct CadetPeerPath *path = GCC_get_path (cc, &len);
972 
973  if (peer != GCPP_get_peer_at_offset (path, 0))
974  {
975  /* received message from unexpected direction, ignore! */
976  GNUNET_break_op (0);
977  return;
978  }
980  "Received CONNECTION_BROKEN for connection %s. Destroying it.\n",
983 
984  /* FIXME: also destroy the path up to the specified link! */
985  return;
986  }
987 
988  /* We're just an intermediary peer, route the message along its path */
989  route_message (peer,
990  &msg->cid,
991  &msg->header,
993  route = get_route (&msg->cid);
994  if (NULL != route)
995  destroy_route (route);
996  /* FIXME: also destroy paths we MAY have up to the specified link! */
997 }
998 
999 
1006 static void
1008  void *cls,
1010 {
1011  struct CadetPeer *peer = cls;
1012  struct CadetConnection *cc;
1013  struct CadetRoute *route;
1014 
1015  /* First, check if message belongs to a connection that ends here. */
1016  cc = GCC_lookup (&msg->cid);
1017  if (NULL != cc)
1018  {
1019  /* verify message came from the right direction */
1020  unsigned int len;
1021  struct CadetPeerPath *path = GCC_get_path (cc, &len);
1022 
1023  if (peer != GCPP_get_peer_at_offset (path, 0))
1024  {
1025  /* received message from unexpected direction, ignore! */
1026  GNUNET_break_op (0);
1027  return;
1028  }
1030  "Received CONNECTION_DESTROY for connection %s. Destroying connection.\n",
1032 
1034  return;
1035  }
1036 
1037  /* We're just an intermediary peer, route the message along its path */
1039  "Received CONNECTION_DESTROY for connection %s. Destroying route.\n",
1041  route_message (peer,
1042  &msg->cid,
1043  &msg->header,
1045  route = get_route (&msg->cid);
1046  if (NULL != route)
1047  destroy_route (route);
1048 }
1049 
1050 
1057 static void
1058 handle_tunnel_kx (void *cls,
1060 {
1061  struct CadetPeer *peer = cls;
1062  struct CadetConnection *cc;
1063 
1064  /* First, check if message belongs to a connection that ends here. */
1066  "Routing KX with ephemeral %s on CID %s\n",
1067  GNUNET_e2s (&msg->ephemeral_key),
1069 
1070 
1071  cc = GCC_lookup (&msg->cid);
1072  if (NULL != cc)
1073  {
1074  /* verify message came from the right direction */
1075  unsigned int len;
1076  struct CadetPeerPath *path = GCC_get_path (cc, &len);
1077 
1078  if (peer != GCPP_get_peer_at_offset (path, 0))
1079  {
1080  /* received message from unexpected direction, ignore! */
1081  GNUNET_break_op (0);
1082  return;
1083  }
1084  GCC_handle_kx (cc, msg);
1085  return;
1086  }
1087 
1088  /* We're just an intermediary peer, route the message along its path */
1089  route_message (peer,
1090  &msg->cid,
1091  &msg->header,
1093 }
1094 
1095 
1102 static void
1104  void *cls,
1106 {
1107  struct CadetPeer *peer = cls;
1108  struct CadetConnection *cc;
1109 
1110  /* First, check if message belongs to a connection that ends here. */
1111  cc = GCC_lookup (&msg->kx.cid);
1112  if (NULL != cc)
1113  {
1114  /* verify message came from the right direction */
1115  unsigned int len;
1116  struct CadetPeerPath *path = GCC_get_path (cc, &len);
1117 
1118  if (peer != GCPP_get_peer_at_offset (path, 0))
1119  {
1120  /* received message from unexpected direction, ignore! */
1121  GNUNET_break_op (0);
1122  return;
1123  }
1124  GCC_handle_kx_auth (cc, msg);
1125  return;
1126  }
1127 
1128  /* We're just an intermediary peer, route the message along its path */
1129  route_message (peer,
1130  &msg->kx.cid,
1131  &msg->kx.header,
1133 }
1134 
1135 
1144 static int
1147 {
1148  return GNUNET_YES;
1149 }
1150 
1151 
1158 static void
1161 {
1162  struct CadetPeer *peer = cls;
1163  struct CadetConnection *cc;
1164 
1165  /* First, check if message belongs to a connection that ends here. */
1166  cc = GCC_lookup (&msg->cid);
1167  if (NULL != cc)
1168  {
1169  /* verify message came from the right direction */
1170  unsigned int len;
1171  struct CadetPeerPath *path = GCC_get_path (cc, &len);
1172 
1173  if (peer != GCPP_get_peer_at_offset (path, 0))
1174  {
1175  /* received message from unexpected direction, ignore! */
1176  GNUNET_break_op (0);
1177  return;
1178  }
1179  GCC_handle_encrypted (cc, msg);
1180  return;
1181  }
1182  /* We're just an intermediary peer, route the message along its path */
1183  route_message (peer, &msg->cid, &msg->header, GNUNET_MQ_PRIO_BEST_EFFORT);
1184 }
1185 
1186 
1199 static void
1201 {
1202  if (NULL == my_identity)
1203  {
1204  GNUNET_break (0);
1205  return;
1206  }
1207  GNUNET_break (0 == GNUNET_memcmp (my_identity, &my_full_id));
1208 }
1209 
1210 
1217 static void *
1218 core_connect_cb (void *cls,
1219  const struct GNUNET_PeerIdentity *peer,
1220  struct GNUNET_MQ_Handle *mq)
1221 {
1222  struct CadetPeer *cp;
1223 
1225  "CORE connection to peer %s was established.\n",
1226  GNUNET_i2s (peer));
1227  cp = GCP_get (peer, GNUNET_YES);
1228  GCP_set_mq (cp, mq);
1229  return cp;
1230 }
1231 
1232 
1239 static void
1241  const struct GNUNET_PeerIdentity *peer,
1242  void *peer_cls)
1243 {
1244  struct CadetPeer *cp = peer_cls;
1245 
1247  "CORE connection to peer %s went down.\n",
1248  GNUNET_i2s (peer));
1249  GCP_set_mq (cp, NULL);
1250 }
1251 
1252 
1258 void
1260 {
1261  struct GNUNET_MQ_MessageHandler handlers[] =
1265  NULL),
1266  GNUNET_MQ_hd_fixed_size (connection_create_ack,
1269  NULL),
1270  GNUNET_MQ_hd_fixed_size (connection_broken,
1273  NULL),
1274  GNUNET_MQ_hd_fixed_size (connection_destroy,
1277  NULL),
1278  GNUNET_MQ_hd_fixed_size (tunnel_kx,
1281  NULL),
1282  GNUNET_MQ_hd_fixed_size (tunnel_kx_auth,
1285  NULL),
1286  GNUNET_MQ_hd_var_size (tunnel_encrypted,
1289  NULL),
1290  GNUNET_MQ_handler_end () };
1291 
1293  "CADET",
1294  "MAX_ROUTES",
1295  &max_routes))
1296  max_routes = 5000;
1298  "CADET",
1299  "MAX_MSGS_QUEUE",
1300  &max_buffers))
1301  max_buffers = 10000;
1304  core = GNUNET_CORE_connect (c,
1305  NULL,
1306  &core_init_cb,
1307  &core_connect_cb,
1309  handlers);
1310 }
1311 
1312 
1316 void
1318 {
1319  if (NULL != core)
1320  {
1321  GNUNET_CORE_disconnect (core);
1322  core = NULL;
1323  }
1326  routes = NULL;
1327  GNUNET_CONTAINER_heap_destroy (route_heap);
1328  route_heap = NULL;
1329  if (NULL != timeout_task)
1330  {
1331  GNUNET_SCHEDULER_cancel (timeout_task);
1332  timeout_task = NULL;
1333  }
1334 }
1335 
1336 
1337 /* end of gnunet-cadet-service_core.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
void GNUNET_MQ_dll_insert_tail(struct GNUNET_MQ_Envelope **env_head, struct GNUNET_MQ_Envelope **env_tail, struct GNUNET_MQ_Envelope *env)
Insert env into the envelope DLL starting at env_head Note that env must not be in any MQ while this ...
Definition: mq.c:1174
Axolotl-encrypted tunnel message with application payload.
#define GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED
Axolotl encrypted data.
void GNUNET_MQ_dll_insert_head(struct GNUNET_MQ_Envelope **env_head, struct GNUNET_MQ_Envelope **env_tail, struct GNUNET_MQ_Envelope *env)
Insert env into the envelope DLL starting at env_head Note that env must not be in any MQ while this ...
Definition: mq.c:1153
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89
static void handle_tunnel_kx(void *cls, const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg)
Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX.
static unsigned long long max_buffers
Maximum number of envelopes we will buffer at this peer.
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
void GNUNET_CONTAINER_heap_update_cost(struct GNUNET_CONTAINER_HeapNode *node, GNUNET_CONTAINER_HeapCostType new_cost)
Updates the cost of any node in the tree.
unsigned int num_routes
Total number of route directions in this rung.
static void dir_init(struct RouteDirection *dir, struct CadetRoute *route, struct CadetPeer *hop)
Initialize one of the directions of a route.
struct GNUNET_MQ_Envelope * GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
Create a new envelope by copying an existing message.
Definition: mq.c:653
Peer description.
const char * GNUNET_i2s2(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env_head
Head of DLL of envelopes we have in the buffer for this direction.
struct RouteDirection * next
DLL of other route directions within the same struct Rung.
Low-level connection to a destination.
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.
const struct GNUNET_MessageHeader * GNUNET_MQ_env_get_msg(const struct GNUNET_MQ_Envelope *env)
Obtain message contained in envelope.
Definition: mq.c:1080
Message to destroy a connection.
#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.
unsigned int GNUNET_CONTAINER_multishortmap_size(const struct GNUNET_CONTAINER_MultiShortmap *map)
Get the number of key-value pairs in the map.
Context for the core service connection.
Definition: core_api.c:77
struct GNUNET_CONTAINER_HeapNode * GNUNET_CONTAINER_heap_insert(struct GNUNET_CONTAINER_Heap *heap, void *element, GNUNET_CONTAINER_HeapCostType cost)
Inserts a new element into the heap.
static void handle_tunnel_kx_auth(void *cls, const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg)
Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH.
Information we keep per direction for a route.
A connection is a live end-to-end messaging mechanism where the peers are identified by a path and kn...
struct GNUNET_CONTAINER_HeapNode * hn
Position of this route in the route_heap.
static unsigned long long max_routes
Maximum number of concurrent routes this peer will support.
#define LOG(level,...)
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE.
Data structure used to track whom we have to notify about changes to our message queue.
struct GNUNET_CADET_TunnelKeyExchangeMessage kx
Message header with key material.
static void core_disconnect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, void *peer_cls)
Method called whenever a peer disconnects.
struct GNUNET_PeerIdentity my_full_id
Local peer own ID.
void GCC_destroy_without_core(struct CadetConnection *cc)
Destroy a connection, called when the CORE layer is already done (i.e.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Message for ack&#39;ing a connection.
static unsigned long long cur_buffers
Current number of envelopes we have buffered at this peer.
void GCC_handle_kx(struct CadetConnection *cc, const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg)
Handle KX message.
void GNUNET_MQ_env_set_options(struct GNUNET_MQ_Envelope *env, enum GNUNET_MQ_PriorityPreferences pp)
Set application-specific options for this envelope.
Definition: mq.c:1005
int GNUNET_CONTAINER_multishortmap_remove(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
static struct CadetConnection * connection_create(struct CadetPeer *destination, struct CadetPeerPath *path, unsigned int off, struct CadetTConnection *ct, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, enum CadetConnectionState init_state, GCC_ReadyCallback ready_cb, void *ready_cb_cls)
Create a connection to destination via path and notify cb whenever we are ready for more data...
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
void GCC_handle_connection_create_ack(struct CadetConnection *cc)
A GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK was received for this connection, implying that the end-to-end connection is up.
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_PeerIdentity peer2
ID of the endpoint.
void GCP_set_mq(struct CadetPeer *cp, struct GNUNET_MQ_Handle *mq)
Set the message queue to mq for peer cp and notify watchers.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
GNUNET_MQ_PriorityPreferences
Per envelope preferences and priorities.
Information we track per tunnel.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:395
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GCP_send(struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *env)
Send the message in env to cp.
static struct GNUNET_PeerIdentity my_identity
Identity of this peer.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
static void * core_connect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
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_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).
Set of CadetRoutes that have exactly the same number of messages in their buffer. ...
struct Rung * prev
Rung of RouteDirections with one less buffer entry each.
static int check_tunnel_encrypted(void *cls, const struct GNUNET_CADET_TunnelEncryptedMessage *msg)
Check if the encrypted message has the appropriate size.
uint64_t abs_value_us
The actual value.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
const struct GNUNET_MQ_Envelope * GNUNET_MQ_env_next(const struct GNUNET_MQ_Envelope *env)
Return next envelope in queue.
Definition: mq.c:1093
struct Rung * next
Rung of RouteDirections with one more buffer entry each.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
static void destroy_direction(struct RouteDirection *dir)
Free internal data of a route direction.
static struct GNUNET_CONTAINER_MultiPeerMap * map
Handle to the map used to store old latency values for peers.
const char * GCP_2s(const struct CadetPeer *cp)
Get the static string for a peer ID.
static void handle_connection_create_ack(void *cls, const struct GNUNET_CADET_ConnectionCreateAckMessage *msg)
Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK.
Flag to indicate that low latency is important.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
Unique identifier for the connection that uses this route.
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:1020
Best-effort traffic (i.e.
struct CadetRoute * my_route
Route this direction is part of.
const char * GCPP_2s(struct CadetPeerPath *path)
Convert a path to a human-readable string.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK.
struct RouteDirection * rd_head
DLL of route directions with a number of buffer entries matching this rung.
static void destroy_route(struct CadetRoute *route)
Destroy our state for route.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
static struct CadetRoute * get_route(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Get the route corresponding to a hash.
Information we track per peer.
static struct Rung rung_zero
Rung zero (always pointed to by rung_head).
struct CadetPeerPath * GCPP_get_path_from_route(unsigned int path_length, const struct GNUNET_PeerIdentity *pids)
We got an incoming connection, obtain the corresponding path.
#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_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
int GCT_add_inbound_connection(struct CadetTunnel *t, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, struct CadetPeerPath *path)
Add a connection to the tunnel.
Message for a Key eXchange for a tunnel, with authentication.
struct RouteDirection prev
Information about the previous hop on this route.
void * GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
Get element stored at the root of heap.
void GCP_send_ooo(struct CadetPeer *cp, struct GNUNET_MQ_Envelope *env)
Send the message in env to cp, overriding queueing logic.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
Description of a segment of a struct CadetConnection at the intermediate peers.
struct CadetPeer * hop
Target peer.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
struct GNUNET_TIME_Absolute last_use
When was this route last in use?
static struct Rung * rung_head
DLL of rungs, with the head always point to a rung of route directions with no messages in the queue...
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
int GNUNET_CONTAINER_multishortmap_put(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE
Request the creation of a connection.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
#define GNUNET_CONTAINER_DLL_insert_after(head, tail, other, element)
Insert an element into a DLL after the given other element.
Message for notifying a disconnection in a path.
Handle to a node in a heap.
static void dir_ready_cb(void *cls, int ready)
Function called when the message queue to the previous hop becomes available/unavailable.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK
Send origin an ACK that the connection is complete.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
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).
Heap with the minimum cost at the root.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct RouteDirection next
Information about the next hop on this route.
void GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap)
Destroys the heap.
Message handler for a specific message type.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
void GNUNET_MQ_dll_remove(struct GNUNET_MQ_Envelope **env_head, struct GNUNET_MQ_Envelope **env_tail, struct GNUNET_MQ_Envelope *env)
Remove env from the envelope DLL starting at env_head.
Definition: mq.c:1195
static void lower_rung(struct RouteDirection *dir)
Lower the rung in which dir is by 1.
void GCC_handle_duplicate_create(struct CadetConnection *cc)
We got a GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE for a connection that we already have...
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:321
Node in the heap.
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 GNUNET_TESTBED_Peer * peer
The peer associated with this model.
Internal representation of the hash map.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct RouteDirection * rd_tail
DLL of route directions with a number of buffer entries matching this rung.
static unsigned int size
Size of the "table".
Definition: peer.c:67
static void core_init_cb(void *cls, const struct GNUNET_PeerIdentity *my_identity)
Function called after GNUNET_CORE_connect has succeeded (or failed for good).
static void send_broken(struct RouteDirection *target, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, const struct GNUNET_PeerIdentity *peer1, const struct GNUNET_PeerIdentity *peer2)
Send message that a route is broken between peer1 and peer2.
unsigned int rung_off
Number of messages route directions at this rung have in their buffer.
struct GNUNET_CORE_Handle * GNUNET_CORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Connect to the core service.
Definition: core_api.c:692
struct GNUNET_PeerIdentity peer1
ID of the endpoint.
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:730
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct CadetPeerPath * GCC_get_path(struct CadetConnection *cc, unsigned int *off)
Obtain the path used by this connection.
struct GCP_MessageQueueManager * mqm
Message queue manager for hop.
void GNUNET_CONTAINER_multishortmap_destroy(struct GNUNET_CONTAINER_MultiShortmap *map)
Destroy a hash map.
struct GNUNET_CONTAINER_Heap * GNUNET_CONTAINER_heap_create(enum GNUNET_CONTAINER_HeapOrder order)
Create a new heap.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
P2P messages used by CADET.
int GCP_has_core_connection(struct CadetPeer *cp)
Test if cp has a core-level connection.
Handle to a message queue.
Definition: mq.c:85
struct CadetConnection * GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
Lookup a connection by its identifier.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
static void handle_tunnel_encrypted(void *cls, const struct GNUNET_CADET_TunnelEncryptedMessage *msg)
Handle for GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED.
The identity of the host (wraps the signing key of the peer).
Hash uniquely identifying a connection below a tunnel.
static struct GNUNET_CONTAINER_Heap * route_heap
Heap of routes, MIN-sorted by last activity.
static struct GNUNET_SCHEDULER_Task * timeout_task
Task to timeout routes.
configuration data
Definition: configuration.c:85
void * GNUNET_CONTAINER_multishortmap_get(const struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key)
Given a key find a value in the map matching the key.
void GCC_handle_encrypted(struct CadetConnection *cc, const struct GNUNET_CADET_TunnelEncryptedMessage *msg)
Handle encrypted message.
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_CONNECTION_DESTROY
Request the destuction of a connection.
void GCP_request_mq_cancel(struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *last_env)
Stops message queue change notifications.
Message for a Key eXchange for a tunnel.
static void handle_connection_create(void *cls, const struct GNUNET_CADET_ConnectionCreateMessage *msg)
Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX or GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH as part of stru...
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
Flag to indicate that out-of-order delivery is OK.
static void handle_connection_broken(void *cls, const struct GNUNET_CADET_ConnectionBrokenMessage *msg)
Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN.
static struct PendingResolutions * tail
Tail of list of pending resolution requests.
Definition: gnunet-ats.c:235
struct CadetPeer * GCPP_get_peer_at_offset(struct CadetPeerPath *path, unsigned int off)
Obtain the peer at offset off in path.
struct GNUNET_TIME_Relative keepalive_period
How frequently do we send KEEPALIVE messages on idle connections?
struct Rung * rung
Rung of this route direction (matches length of the buffer DLL).
#define GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH
Axolotl key exchange response with authentication.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
static void route_message(struct CadetPeer *prev, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, const struct GNUNET_MessageHeader *msg, const enum GNUNET_MQ_PriorityPreferences priority)
We message msg from prev.
Header for all communications.
void GCC_handle_kx_auth(struct CadetConnection *cc, const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg)
Handle KX_AUTH message.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
void GCO_init(const struct GNUNET_CONFIGURATION_Handle *c)
Initialize the CORE subsystem.
int is_ready
Is mqm currently ready for transmission?
Flag to indicate that unreliable delivery is acceptable.
static void send_broken_without_mqm(struct CadetPeer *target, const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, const struct GNUNET_PeerIdentity *failure_at)
We could not create the desired route.
static void timeout_cb(void *cls)
Function called to check if any routes have timed out, and if so, to clean them up.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:742
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key
Sender&#39;s ephemeral public ECC key encoded in a format suitable for network transmission, as created using &#39;gcry_sexp_sprint&#39;.
Highest priority, control traffic (i.e.
const char * GNUNET_e2s(const struct GNUNET_CRYPTO_EcdhePublicKey *p)
Convert a public key value to a string (for printing debug messages).
static void discard_all_from_rung_tail()
Discard all messages from the highest rung, to make space.
static int check_connection_create(void *cls, const struct GNUNET_CADET_ConnectionCreateMessage *msg)
Check if the create_connection message has the appropriate size.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run at the specified time.
Definition: scheduler.c:1230
cadet service; interaction with CORE service
static void discard_buffer(struct RouteDirection *dir, struct GNUNET_MQ_Envelope *env)
Discard the buffer env from the route direction dir and move dir down a rung.
struct RouteDirection * prev
DLL of other route directions within the same struct Rung.
Information regarding a possible path to reach a peer.
struct GNUNET_ShortHashCode connection_of_tunnel
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
static void handle_connection_destroy(void *cls, const struct GNUNET_CADET_ConnectionDestroyMessage *msg)
Handle for GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY.
struct GNUNET_CADET_ConnectionTunnelIdentifier cid
ID of the connection.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN.
static struct Rung * rung_tail
Tail of the rung_head DLL.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN
Notify that a connection is no longer valid.
Message for cadet connection creation.
struct GNUNET_MQ_Envelope * env_tail
Tail of DLL of envelopes we have in the buffer for this direction.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
static struct GNUNET_CORE_Handle * core
Handle to the CORE service.
#define GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX
Axolotl key exchange.
#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.
struct GCP_MessageQueueManager * GCP_request_mq(struct CadetPeer *cp, GCP_MessageQueueNotificationCallback cb, void *cb_cls)
Start message queue change notifications.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY.
static struct GNUNET_CONTAINER_MultiShortmap * routes
Routes on which this peer is an intermediate.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966