GNUnet  0.19.3
gnunet-service-testbed_oc.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2008--2016 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 
27 #include "platform.h"
28 #include "gnunet-service-testbed.h"
31 
35 #ifdef LOG
36 #undef LOG
37 #endif
38 #define LOG(kind, ...) \
39  GNUNET_log_from (kind, "testbed-OC", __VA_ARGS__)
40 
41 
46 {
51 
56 
62 
67 
72 };
73 
74 
79 {
85 
91 
97 };
98 
99 
105 {
111 
116 };
117 
118 
124 {
131 
137 
143 
148  struct Neighbour *p2n;
149 };
150 
155 {
160 
165 
171 
175  struct Peer *peer;
176 
182 
187 
193 
198 
203 
207  char *emsg;
208 
212  union
213  {
217  struct LocalPeer2Context local;
218 
222  struct RemotePeer2Context remote;
223  } p2ctx;
224 
229 
234 
238  uint64_t op_id;
239 
245 
250 
255 
260 
264  uint32_t other_peer_id;
265 };
266 
267 
276 {
281 
286 
290  struct Peer *peer;
291 
296 
301 
306 
310  struct GNUNET_PeerIdentity a_id;
311 
316 
321 
325  uint64_t op_id;
326 };
327 
328 
333 
338 
344 
349 
350 
356 void
358 {
359  struct RegisteredHostContext *rhc = focc->rhc;
360 
362  rhc->focc_dll_tail,
363  focc);
364  GNUNET_free (focc->orig_msg);
365  GNUNET_free (focc);
366 }
367 
368 
374 static void
376 {
377  struct ForwardedOperationContext *fopc = cls;
378  struct RegisteredHostContext *rhc;
379  struct ForwardedOverlayConnectContext *focc;
380 
381  fopc->timeout_task = NULL;
382  rhc = fopc->cls;
383  focc = rhc->focc_dll_head;
384  LOG_DEBUG ("Overlay linking between peers %u and %u failed\n",
385  focc->peer1,
386  focc->peer2);
387  GST_cleanup_focc (focc);
389  if (NULL != rhc->focc_dll_head)
391 }
392 
393 
402 static void
404  const struct GNUNET_MessageHeader *msg)
405 {
406  struct ForwardedOperationContext *fopc = cls;
407  struct RegisteredHostContext *rhc;
408  struct ForwardedOverlayConnectContext *focc;
409 
410  rhc = fopc->cls;
412  focc = rhc->focc_dll_head;
413  GST_cleanup_focc (focc);
414  if (NULL != rhc->focc_dll_head)
416 }
417 
418 
424 void
426 {
427  struct ForwardedOperationContext *fopc;
428  struct ForwardedOverlayConnectContext *focc;
429  struct Peer *peer;
430  struct Slave *slave;
431 
432  focc = rhc->focc_dll_head;
433  GNUNET_assert (NULL != focc);
434  GNUNET_assert (RHC_DONE == rhc->state);
436  peer = GST_peer_list[focc->peer1];
437  GNUNET_assert (GNUNET_YES == peer->is_remote);
438  GNUNET_assert (NULL != (slave = peer->details.remote.slave));
439  fopc = GNUNET_new (struct ForwardedOperationContext);
440  fopc->client = focc->client;
441  fopc->operation_id = focc->operation_id;
442  fopc->cls = rhc;
443  fopc->type = OP_OVERLAY_CONNECT;
444  fopc->opc =
446  focc->operation_id,
447  focc->orig_msg,
449  fopc);
450  GNUNET_free (focc->orig_msg);
451  focc->orig_msg = NULL;
453  &
455  fopc);
457  fopcq_tail,
458  fopc);
459 }
460 
461 
467 static void
469 {
470  if (NULL != lp2c->ohh)
471  {
473  lp2c->ohh = NULL;
474  }
475  if (NULL != lp2c->tcc.cgh_p2_th)
476  {
478  lp2c->tcc.cgh_p2_th = NULL;
479  }
480  if (NULL != lp2c->tcc.cgh_p2_ats)
481  {
483  lp2c->tcc.cgh_p2_ats = NULL;
484  }
485  if (NULL != lp2c->tcc.csh)
486  {
488  lp2c->tcc.csh = NULL;
489  }
490 }
491 
492 
499 static void
501 {
502  if (NULL != rp2c->opc)
503  {
505  rp2c->opc = NULL;
506  }
507  if (NULL != rp2c->ncn)
508  {
510  rp2c->ncn = NULL;
511  }
512  if ((NULL != rp2c->p2c) && (NULL != rp2c->p2n))
513  {
515  rp2c->p2n = NULL;
516  }
517 }
518 
519 
525 #define PEER_EXPIRED(peer) \
526  ((GNUNET_YES == peer->destroy_flag) && (0 == peer->reference_cnt))
527 
533 static void
535 {
536  struct Peer *peer2;
537 
538  LOG_DEBUG ("0x%llx: Cleaning up occ\n",
539  (unsigned long long) occ->op_id);
540  GNUNET_free (occ->emsg);
541  GNUNET_free (occ->hello);
542  if (NULL != occ->send_hello_task)
544  if (NULL != occ->cleanup_task)
546  if (NULL != occ->timeout_task)
548  if (NULL != occ->cgh_ch)
550  if (NULL != occ->ghh)
553  GNUNET_assert (NULL != GST_peer_list);
554  GNUNET_assert (occ->peer->reference_cnt > 0);
555  occ->peer->reference_cnt--;
556  if (PEER_EXPIRED (occ->peer))
557  GST_destroy_peer (occ->peer);
558  switch (occ->type)
559  {
560  case OCC_TYPE_LOCAL:
561  peer2 = GST_peer_list[occ->other_peer_id];
562  GNUNET_assert (peer2->reference_cnt > 0);
563  peer2->reference_cnt--;
564  if (PEER_EXPIRED (peer2))
565  GST_destroy_peer (peer2);
566  cleanup_occ_lp2c (&occ->p2ctx.local);
567  break;
568 
571  cleanup_occ_rp2c (&occ->p2ctx.remote);
572  break;
573  }
575  occq_tail,
576  occ);
577  GNUNET_free (occ);
578 }
579 
580 
586 static void
587 do_cleanup_occ (void *cls)
588 {
589  struct OverlayConnectContext *occ = cls;
590 
591  occ->cleanup_task = NULL;
592  cleanup_occ (occ);
593 }
594 
595 
601 static void
603 {
604  struct OverlayConnectContext *occ = cls;
605 
606  GNUNET_assert (NULL != occ->timeout_task);
607  occ->timeout_task = NULL;
608  /* LOG (GNUNET_ERROR_TYPE_WARNING, */
609  /* "0x%llx: Timeout while connecting peers %u and %u: %s\n", occ->op_id, */
610  /* occ->peer->id, occ->other_peer_id, occ->emsg); */
612  occ->op_id,
613  occ->emsg);
614  cleanup_occ (occ);
615 }
616 
617 
623 void
625 {
626  struct ForwardedOperationContext *fopc;
627  struct ForwardedOperationContext *fopcn;
628  struct OverlayConnectContext *occ;
629  struct OverlayConnectContext *occn;
630 
631  for (fopc = fopcq_head; NULL != fopc; fopc = fopcn)
632  {
633  fopcn = fopc->next;
634  if (fopc->client == client)
635  {
638  }
639  }
640  for (occ = occq_head; NULL != occ; occ = occn)
641  {
642  occn = occ->next;
643  if (occ->client == client)
644  cleanup_occ (occ);
645  }
646  // FIXME: implement clean up for client_keep replacements!
647 }
648 
649 
653 static void
655 {
656  struct GNUNET_MQ_Envelope *env;
658 
659  LOG_DEBUG ("0x%llx: Peers connected - Sending overlay connect success\n",
660  (unsigned long long) occ->op_id);
661  env = GNUNET_MQ_msg (msg,
663  msg->event_type = htonl (GNUNET_TESTBED_ET_CONNECT);
664  msg->peer1 = htonl (occ->peer->id);
665  msg->peer2 = htonl (occ->other_peer_id);
666  msg->operation_id = GNUNET_htonll (occ->op_id);
668  env);
669 }
670 
671 
679 static void
681  const struct GNUNET_PeerIdentity *new_peer)
682 {
683  struct OverlayConnectContext *occ = cls;
684  char *new_peer_str;
685  char *other_peer_str;
686 
687  LOG_DEBUG ("Overlay connect notify\n");
688  if (0 ==
689  GNUNET_memcmp (new_peer,
690  &occ->peer_identity))
691  return;
692  new_peer_str = GNUNET_strdup (GNUNET_i2s (new_peer));
693  other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
694  if (0 !=
695  GNUNET_memcmp (new_peer,
696  &occ->other_peer_identity))
697  {
698  LOG_DEBUG ("Unexpected peer %s connected when expecting peer %s\n",
699  new_peer_str,
700  other_peer_str);
701  GNUNET_free (new_peer_str);
702  GNUNET_free (other_peer_str);
703  return;
704  }
705  GNUNET_free (new_peer_str);
706  LOG_DEBUG ("0x%llx: Peer %s connected to peer %s\n",
707  (unsigned long long) occ->op_id,
708  other_peer_str,
709  GNUNET_i2s (&occ->peer_identity));
710  GNUNET_free (other_peer_str);
711  if (NULL != occ->send_hello_task)
712  {
714  occ->send_hello_task = NULL;
715  }
716  GNUNET_assert (NULL != occ->timeout_task);
718  occ->timeout_task = NULL;
719  switch (occ->type)
720  {
721  case OCC_TYPE_LOCAL:
722  cleanup_occ_lp2c (&occ->p2ctx.local);
723  break;
724 
727  cleanup_occ_rp2c (&occ->p2ctx.remote);
728  break;
729  }
730  GNUNET_free (occ->emsg);
731  occ->emsg = NULL;
734  occ);
735 }
736 
737 
748 static void
750  struct GNUNET_CORE_Handle *ch,
751  struct GNUNET_TRANSPORT_CoreHandle *th,
753  const struct GNUNET_PeerIdentity *my_identity,
754  const struct GNUNET_CONFIGURATION_Handle *cfg)
755 {
756  struct OverlayConnectContext *occ = cls;
757  struct LocalPeer2Context *lp2c;
758 
760  GNUNET_assert (NULL != occ->timeout_task);
761  GNUNET_free (occ->emsg);
762  if (NULL == ac)
763  {
764  GNUNET_asprintf (&occ->emsg,
765  "0x%llx: Failed to connect to ATS of peer with id: %u",
766  (unsigned long long) occ->op_id,
767  occ->peer->id);
769  occ->timeout_task =
771  occ);
772  return;
773  }
774  occ->emsg = NULL;
775 
776  GNUNET_asprintf (&occ->emsg,
777  "0x%llx: Timeout during GNUNET_ATS_connectivity_suggest() at peer %s",
778  (unsigned long long) occ->op_id,
780 
781  lp2c = &occ->p2ctx.local;
782  lp2c->tcc.csh =
784  &occ->peer_identity,
785  1);
786 }
787 
788 
798 static void
800  struct GNUNET_CORE_Handle *ch,
801  struct GNUNET_TRANSPORT_CoreHandle *th,
803  const struct GNUNET_PeerIdentity *my_identity,
804  const struct GNUNET_CONFIGURATION_Handle *cfg)
805 {
806  struct RemoteOverlayConnectCtx *rocc = cls;
807 
808  rocc->tcc.csh =
810  &rocc->a_id,
811  1);
812 }
813 
814 
821 static void
822 send_hello (void *cls);
823 
824 
832 static void
833 occ_hello_sent_cb (void *cls)
834 {
835  struct OverlayConnectContext *occ = cls;
836  struct LocalPeer2Context *lp2c;
837  struct Peer *peer2;
838 
840  GNUNET_assert (NULL != occ->timeout_task);
841  lp2c = &occ->p2ctx.local;
842  lp2c->ohh = NULL;
843 
844  GNUNET_assert (NULL == occ->send_hello_task);
845  GNUNET_free (occ->emsg);
846 
847  GNUNET_asprintf (&occ->emsg,
848  "0x%llx: Timeout while acquiring ATS of %s from cache",
849  (unsigned long long) occ->op_id,
851  GNUNET_assert (NULL != (peer2 = GST_peer_list[occ->other_peer_id]));
852  lp2c->tcc.cgh_p2_ats =
854  peer2->details.local.cfg,
857  occ, NULL, NULL, NULL);
858 }
859 
860 
868 static void
870 {
872  char *other_peer_str;
873  uint16_t msize;
874  uint16_t hello_size;
875 
877  GNUNET_assert (NULL != occ->hello);
878  other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
879  LOG_DEBUG (
880  "0x%llx: Offering HELLO of %s (size: %u) to %s via Remote Overlay Request\n",
881  (unsigned long long) occ->op_id,
882  GNUNET_i2s (&occ->peer_identity),
883  ntohs (occ->hello->size),
884  other_peer_str);
885  GNUNET_free (other_peer_str);
886  hello_size = ntohs (occ->hello->size);
887  msize = sizeof(struct GNUNET_TESTBED_RemoteOverlayConnectMessage)
888  + hello_size;
889  msg = GNUNET_malloc (msize);
890  msg->header.type =
892  msg->header.size = htons (msize);
893  msg->peer = htonl (occ->other_peer_id);
894  msg->operation_id = GNUNET_htonll (occ->op_id);
895  msg->peer_identity = occ->peer_identity;
896  GNUNET_memcpy (msg->hello,
897  occ->hello,
898  hello_size);
900  &msg->header);
901 }
902 
903 
911 static void
912 send_hello (void *cls)
913 {
914  struct OverlayConnectContext *occ = cls;
915  struct LocalPeer2Context *lp2c;
916  char *other_peer_str;
917 
918  occ->send_hello_task = NULL;
919  GNUNET_assert (NULL != occ->timeout_task);
920  GNUNET_assert (NULL != occ->hello);
921  if (OCC_TYPE_LOCAL != occ->type)
922  {
923  send_hello_thru_rocc (occ);
924  return;
925  }
926  lp2c = &occ->p2ctx.local;
927  other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
928  LOG_DEBUG ("0x%llx: Offering HELLO of %s to %s\n",
929  (unsigned long long) occ->op_id,
930  GNUNET_i2s (&occ->peer_identity),
931  other_peer_str);
932  GNUNET_free (other_peer_str);
933  lp2c->ohh =
935  occ->hello,
937  occ);
938  if (NULL == lp2c->ohh)
939  {
940  GNUNET_break (0);
941  occ->send_hello_task =
944  100
947  &send_hello, occ);
948  }
949 }
950 
951 
962 static void
964  struct GNUNET_CORE_Handle *ch,
965  struct GNUNET_TRANSPORT_CoreHandle *th,
967  const struct GNUNET_PeerIdentity *ignore_,
968  const struct
970 {
971  struct OverlayConnectContext *occ = cls;
972 
974  if (NULL == th)
975  {
976  GNUNET_asprintf (&occ->emsg,
977  "0x%llx: Cannot connect to TRANSPORT of %s",
978  (unsigned long long) occ->op_id,
981  occ->timeout_task =
983  return;
984  }
985  occ->p2ctx.local.tcc.th_ = th;
986  occ->p2ctx.local.tcc.cfg = cfg;
987  GNUNET_asprintf (&occ->emsg,
988  "0x%llx: Timeout while offering HELLO to %s",
989  (unsigned long long) occ->op_id,
992 }
993 
994 
1001 static void
1003 {
1004  struct Peer *peer2;
1005 
1006  /* HUH? Why to *obtain* HELLO? Seems we use this to *SEND* the
1007  HELLO! */
1009  "Connecting to transport of peer %s to obtain HELLO\n",
1011  GNUNET_assert (NULL == occ->emsg);
1012  GNUNET_assert (NULL != occ->hello);
1013  GNUNET_assert (NULL == occ->ghh);
1014  GNUNET_assert (NULL == occ->p1th_);
1015  GNUNET_assert (NULL == occ->cgh_p1th);
1016  if (OCC_TYPE_LOCAL == occ->type)
1017  {
1018  GNUNET_assert (NULL != (peer2 = GST_peer_list[occ->other_peer_id]));
1019  occ->p2ctx.local.tcc.cgh_p2_th =
1021  peer2->details.local.cfg,
1024  occ, NULL, NULL, NULL);
1025  return;
1026  }
1027  GNUNET_asprintf (&occ->emsg,
1028  "0x%llx: Timeout while offering HELLO to %s",
1029  (unsigned long long) occ->op_id,
1032 }
1033 
1034 
1043 static int
1044 test_address (void *cls,
1045  const struct GNUNET_HELLO_Address *address,
1047 {
1048  int *empty = cls;
1049 
1050  *empty = GNUNET_NO;
1051  return GNUNET_OK;
1052 }
1053 
1054 
1063 static void
1064 hello_update_cb (void *cls,
1065  const struct GNUNET_MessageHeader *hello)
1066 {
1067  struct OverlayConnectContext *occ = cls;
1068  int empty;
1069  uint16_t msize;
1070 
1071  msize = ntohs (hello->size);
1072  empty = GNUNET_YES;
1073  (void) GNUNET_HELLO_iterate_addresses ((const struct GNUNET_HELLO_Message *)
1074  hello, GNUNET_NO,
1075  &test_address,
1076  &empty);
1077  if (GNUNET_YES == empty)
1078  {
1079  LOG_DEBUG ("0x%llx: HELLO of %s is empty\n",
1080  (unsigned long long) occ->op_id,
1081  GNUNET_i2s (&occ->peer_identity));
1082  return;
1083  }
1084  LOG_DEBUG ("0x%llx: Received HELLO of %s\n",
1085  (unsigned long long) occ->op_id,
1086  GNUNET_i2s (&occ->peer_identity));
1087  occ->hello = GNUNET_malloc (msize);
1088  GST_cache_add_hello (occ->peer->id, hello);
1089  GNUNET_memcpy (occ->hello, hello, msize);
1091  occ->ghh = NULL;
1093  occ->cgh_p1th = NULL;
1094  occ->p1th_ = NULL;
1095  GNUNET_free (occ->emsg);
1096  occ->emsg = NULL;
1097  p2_transport_connect (occ);
1098 }
1099 
1100 
1110 static void
1112  struct GNUNET_CORE_Handle *ch,
1113  struct GNUNET_TRANSPORT_CoreHandle *th,
1115  const struct GNUNET_PeerIdentity *ignore_,
1116  const struct
1118 {
1119  struct OverlayConnectContext *occ = cls;
1120 
1121  GNUNET_free (occ->emsg);
1122  occ->emsg = NULL;
1123  if (NULL == th)
1124  {
1125  GNUNET_asprintf (&occ->emsg,
1126  "0x%llx: Cannot connect to TRANSPORT of %s",
1127  (unsigned long long) occ->op_id,
1128  GNUNET_i2s (&occ->peer_identity));
1130  occ->timeout_task =
1132  return;
1133  }
1134  GNUNET_assert (NULL == occ->p1th_);
1135  GNUNET_assert (NULL != occ->cgh_p1th);
1136  occ->p1th_ = th;
1137  GNUNET_asprintf (&occ->emsg,
1138  "0x%llx: Timeout while acquiring HELLO of peer %s",
1139  (unsigned long long) occ->op_id,
1140  GNUNET_i2s (&occ->peer_identity));
1143  &hello_update_cb,
1144  occ);
1145 }
1146 
1147 
1157 static void
1159  struct GNUNET_CORE_Handle *ch,
1160  struct GNUNET_TRANSPORT_CoreHandle *th,
1162  const struct GNUNET_PeerIdentity *my_identity,
1163  const struct GNUNET_CONFIGURATION_Handle *cfg)
1164 {
1165  struct OverlayConnectContext *occ = cls;
1166  const struct GNUNET_MessageHeader *hello;
1167 
1168  GNUNET_assert (NULL != occ->timeout_task);
1169  GNUNET_free (occ->emsg);
1170  if ((NULL == ch) || (NULL == my_identity))
1171  {
1172  GNUNET_asprintf (&occ->emsg,
1173  "0x%llx: Failed to connect to CORE of peer with "
1174  "id: %u",
1175  (unsigned long long) occ->op_id,
1176  occ->peer->id);
1178  occ->timeout_task =
1180  return;
1181  }
1182  occ->emsg = NULL;
1183  occ->peer_identity = *my_identity;
1184  if (NULL !=
1186  &occ->other_peer_identity))
1187  {
1188  LOG_DEBUG ("0x%llx: Target peer %s already connected\n",
1189  (unsigned long long) occ->op_id,
1191  LOG_DEBUG ("0x%llx: Target peer %s connected\n",
1192  (unsigned long long) occ->op_id,
1193  GNUNET_i2s (&occ->peer_identity));
1195  occ->timeout_task = NULL;
1198  return;
1199  }
1200  LOG_DEBUG ("0x%llx: Acquiring HELLO of peer %s\n",
1201  (unsigned long long) occ->op_id,
1202  GNUNET_i2s (&occ->peer_identity));
1203  /* Lookup for HELLO in hello cache */
1204  if (NULL != (hello = GST_cache_lookup_hello (occ->peer->id)))
1205  {
1206  LOG_DEBUG ("0x%llx: HELLO of peer %s found in cache\n",
1207  (unsigned long long) occ->op_id,
1208  GNUNET_i2s (&occ->peer_identity));
1209  occ->hello = GNUNET_copy_message (hello);
1210  p2_transport_connect (occ);
1211  return;
1212  }
1213  GNUNET_asprintf (&occ->emsg,
1214  "0x%llx: Timeout while acquiring TRANSPORT of %s from cache",
1215  (unsigned long long) occ->op_id,
1216  GNUNET_i2s (&occ->peer_identity));
1217  occ->cgh_p1th =
1219  occ->peer->details.local.cfg,
1222  occ,
1223  NULL, NULL, NULL);
1224 }
1225 
1226 
1235 static void
1237  const struct GNUNET_MessageHeader *msg)
1238 {
1239  struct OverlayConnectContext *occ = cls;
1240  struct RemotePeer2Context *rp2c;
1242 
1243  GNUNET_assert (OCC_TYPE_LOCAL != occ->type);
1244  rp2c = &occ->p2ctx.remote;
1245  rp2c->opc = NULL;
1246  GNUNET_assert (NULL != occ->timeout_task);
1248  {
1250  occ->timeout_task =
1252  }
1253  cmsg =
1255  occ->other_peer_identity = cmsg->peer_identity;
1256  GNUNET_free (occ->emsg);
1257  GNUNET_asprintf (&occ->emsg,
1258  "0x%llx: Timeout while connecting to CORE of peer with "
1259  "id: %u",
1260  (unsigned long long) occ->op_id,
1261  occ->peer->id);
1262  occ->cgh_ch =
1264  occ->peer->details.local.cfg,
1267  occ,
1268  &occ->other_peer_identity,
1270  occ);
1271 }
1272 
1273 
1280 static void
1281 host_registration_comp (void *cls, const char *emsg)
1282 {
1283  struct RegisteredHostContext *rhc = cls;
1284 
1285  rhc->state = RHC_DONE;
1286  GST_process_next_focc (rhc);
1287 }
1288 
1289 
1300 static int
1302  const struct GNUNET_HashCode *key,
1303  void *value)
1304 {
1305  struct RegisteredHostContext **rh = cls;
1306  struct RegisteredHostContext *rh_val = value;
1307 
1308  if ((rh_val->host == (*rh)->host) && (rh_val->reg_host == (*rh)->reg_host))
1309  {
1310  GNUNET_free (*rh);
1311  *rh = rh_val;
1312  return GNUNET_NO;
1313  }
1314  return GNUNET_YES;
1315 }
1316 
1317 
1325 static struct GNUNET_HashCode
1326 hash_hosts (struct GNUNET_TESTBED_Host *reg_host,
1327  struct GNUNET_TESTBED_Host *host)
1328 {
1329  struct GNUNET_HashCode hash;
1330  uint32_t host_ids[2];
1331 
1332  host_ids[0] = GNUNET_TESTBED_host_get_id_ (reg_host);
1333  host_ids[1] = GNUNET_TESTBED_host_get_id_ (host);
1334  GNUNET_CRYPTO_hash (host_ids, sizeof(host_ids), &hash);
1335  return hash;
1336 }
1337 
1338 
1352 static struct RegisteredHostContext *
1353 register_host (struct Slave *slave,
1354  struct GNUNET_TESTBED_Host *host)
1355 {
1356  struct GNUNET_HashCode hash;
1357  struct RegisteredHostContext *rhc;
1358 
1359  rhc = GNUNET_new (struct RegisteredHostContext);
1360  rhc->reg_host = host;
1361  rhc->host = GST_host_list[slave->host_id];
1362  GNUNET_assert (NULL != rhc->reg_host);
1363  GNUNET_assert (NULL != rhc->host);
1364  rhc->state = RHC_INIT;
1365  hash = hash_hosts (rhc->reg_host, rhc->host);
1366  if ((GNUNET_NO ==
1368  &hash)) ||
1369  (GNUNET_SYSERR !=
1371  &hash,
1373  &rhc)))
1374  {
1375  /* create and add a new registered host context */
1376  /* add the focc to its queue */
1378  &hash,
1379  rhc,
1383  rhc,
1384  rhc->reg_host);
1385  }
1386  else
1387  {
1388  /* rhc is now set to the existing one from the hash map by
1389  * reghost_match_iterator() */
1390  /* if queue is empty then ignore creating focc and proceed with normal
1391  * forwarding */
1392  if (RHC_DONE == rhc->state)
1393  return NULL;
1394  }
1395  return rhc;
1396 }
1397 
1398 
1408 static void
1410  struct GNUNET_SERVICE_Client *client)
1411 {
1412  struct ForwardedOperationContext *fopc;
1413  struct Route *route_to_peer2_host;
1414  struct Route *route_to_peer1_host;
1415  struct Peer *peer;
1416  struct RegisteredHostContext *rhc;
1417  struct ForwardedOverlayConnectContext *focc;
1418  uint64_t op_id;
1419  uint32_t peer2_host_id;
1420  uint32_t p1;
1421  uint32_t p2;
1422 
1423  p1 = ntohl (msg->peer1);
1424  p2 = ntohl (msg->peer2);
1425  op_id = GNUNET_ntohll (msg->operation_id);
1426  peer2_host_id = ntohl (msg->peer2_host_id);
1429  peer = GST_peer_list[p1];
1430  GNUNET_assert (GNUNET_YES == peer->is_remote);
1431  LOG_DEBUG ("0x%llx: Forwarding overlay connect\n",
1432  (unsigned long long) op_id);
1433  route_to_peer2_host = GST_find_dest_route (peer2_host_id);
1434  route_to_peer1_host = GST_find_dest_route
1435  (peer->details.remote.remote_host_id);
1436  GNUNET_assert (NULL != route_to_peer1_host);
1437  if ((NULL != route_to_peer2_host) &&
1438  (route_to_peer1_host->dest == route_to_peer2_host->dest))
1439  goto forward;
1440  /* Peer2 is either with us OR peer1 and peer2 can be reached through
1441  different subtrees OR peer2 is on a subtree unknown to us */
1442  if (NULL != (rhc = register_host (peer->details.remote.slave,
1444  {
1445  LOG_DEBUG ("Queueing forwarding FOCC for connecting peers %u and %u\n", p1,
1446  p2);
1448  focc->rhc = rhc;
1449  focc->peer1 = p1;
1450  focc->peer2 = p2;
1451  focc->peer2_host_id = peer2_host_id;
1452  focc->orig_msg = GNUNET_copy_message (&msg->header);
1453  focc->operation_id = op_id;
1454  focc->client = client;
1456  rhc->focc_dll_tail,
1457  focc);
1458  return;
1459  }
1460 
1461 forward:
1462  LOG_DEBUG ("Forwarding without FOCC for connecting peers %u and %u\n", p1,
1463  p2);
1464  fopc = GNUNET_new (struct ForwardedOperationContext);
1465  fopc->client = client;
1466  fopc->operation_id = op_id;
1467  fopc->type = OP_OVERLAY_CONNECT;
1468  fopc->opc =
1470  slave->controller, op_id,
1471  &msg->header,
1473  fopc);
1474  fopc->timeout_task =
1477  fopc);
1479  fopcq_tail,
1480  fopc);
1481 }
1482 
1483 
1491 static void
1493  struct GNUNET_TESTBED_Controller *c)
1494 {
1495  struct OverlayConnectContext *occ = cls;
1496  struct RemotePeer2Context *rp2c;
1498 
1499  GNUNET_assert (OCC_TYPE_LOCAL != occ->type);
1500  rp2c = &occ->p2ctx.remote;
1501  rp2c->ncn = NULL;
1502  rp2c->p2c = c;
1503  cmsg.header.size =
1504  htons (sizeof(struct GNUNET_TESTBED_PeerGetConfigurationMessage));
1505  cmsg.header.type =
1507  cmsg.peer_id = htonl (occ->other_peer_id);
1508  cmsg.operation_id = GNUNET_htonll (occ->op_id);
1509  rp2c->opc =
1511  occ->op_id,
1512  &cmsg.header,
1514  occ);
1515  GNUNET_free (occ->emsg);
1516  GNUNET_asprintf (&occ->emsg,
1517  "0x%llx: Timeout while getting peer identity of peer "
1518  "with id: %u",
1519  (unsigned long long) occ->op_id,
1520  occ->other_peer_id);
1521 }
1522 
1523 
1530 void
1533 {
1534  struct GNUNET_SERVICE_Client *client = cls;
1535  struct Peer *peer;
1536  struct Peer *peer2;
1537  struct OverlayConnectContext *occ;
1538  struct Neighbour *p2n;
1539  uint64_t operation_id;
1540  uint32_t p1;
1541  uint32_t p2;
1542  uint32_t peer2_host_id;
1543 
1544  p1 = ntohl (msg->peer1);
1545  p2 = ntohl (msg->peer2);
1546  if (p1 == p2)
1547  {
1548  GNUNET_break (0);
1549  GNUNET_SERVICE_client_drop (client);
1550  return;
1551  }
1552  if (! VALID_PEER_ID (p1))
1553  {
1554  GNUNET_break (0);
1555  GNUNET_SERVICE_client_drop (client);
1556  return;
1557  }
1558  peer = GST_peer_list[p1];
1559  operation_id = GNUNET_ntohll (msg->operation_id);
1560  LOG_DEBUG
1561  ("Received overlay connect for peers %u and %u with op id: 0x%llx\n",
1562  p1,
1563  p2,
1564  (unsigned long long) operation_id);
1565  peer2_host_id = ntohl (msg->peer2_host_id);
1566  if (GNUNET_YES == peer->is_remote)
1567  {
1568  if (! VALID_HOST_ID (peer2_host_id))
1569  {
1570  GNUNET_break (0);
1571  GNUNET_SERVICE_client_drop (client);
1572  return;
1573  }
1574  forward_overlay_connect (msg, client);
1576  return;
1577  }
1578  p2n = NULL;
1579  occ = GNUNET_new (struct OverlayConnectContext);
1580  occ->type = OCC_TYPE_LOCAL;
1581  if (! VALID_PEER_ID (p2)) /* May be peer2 is on a another controller */
1582  {
1583  if (NULL == (p2n = GST_get_neighbour (peer2_host_id)))
1584  {
1585  if (! VALID_HOST_ID (peer2_host_id))
1586  {
1587  GNUNET_break (0);
1589  "0x%llx: Peer %u's host not in our neighbours list\n",
1590  (unsigned long long) operation_id, p2);
1591  GNUNET_SERVICE_client_drop (client);
1592  GNUNET_free (occ);
1593  return;
1594  }
1595  p2n = GST_create_neighbour (GST_host_list[peer2_host_id]);
1596  }
1598  occ->p2ctx.remote.p2n = p2n;
1599  }
1600  else if (GNUNET_YES == GST_peer_list[p2]->is_remote)
1601  {
1602  occ->type = OCC_TYPE_REMOTE_SLAVE;
1603  occ->p2ctx.remote.p2c = GST_peer_list[p2]->details.remote.slave->controller;
1604  }
1606  occq_tail,
1607  occ);
1608  occ->client = client;
1609  occ->other_peer_id = p2;
1611  occ->peer = GST_peer_list[p1];
1612  occ->op_id = operation_id;
1613  GNUNET_assert (NULL == occ->timeout_task);
1614  occ->timeout_task =
1617  occ);
1618  switch (occ->type)
1619  {
1621  GNUNET_asprintf (&occ->emsg,
1622  "0x%llx: Timeout while acquiring connection to peer %u's "
1623  "host: %u\n",
1624  (unsigned long long) occ->op_id,
1625  occ->other_peer_id,
1626  peer2_host_id);
1627  occ->p2ctx.remote.ncn
1630  occ);
1631  break;
1632  case OCC_TYPE_REMOTE_SLAVE:
1634  occ->p2ctx.remote.p2c);
1635  break;
1636  case OCC_TYPE_LOCAL:
1637  peer2 = GST_peer_list[occ->other_peer_id];
1638  peer2->reference_cnt++;
1640  &occ->other_peer_identity);
1641  GNUNET_asprintf (&occ->emsg,
1642  "0x%llx: Timeout while connecting to CORE of peer with "
1643  "id: %u",
1644  (unsigned long long) occ->op_id,
1645  occ->peer->id);
1646  LOG_DEBUG ("Peer %u has PID %s\n",
1647  occ->other_peer_id,
1649  {
1650  struct GNUNET_PeerIdentity lpid;
1651 
1652  GNUNET_TESTING_peer_get_identity (peer->details.local.peer,
1653  &lpid);
1654  LOG_DEBUG ("Peer %u has PID %s\n",
1655  p1,
1656  GNUNET_i2s (&lpid));
1657  }
1658  occ->cgh_ch =
1660  occ->peer->details.local.cfg,
1663  &occ->other_peer_identity,
1664  &overlay_connect_notify, occ);
1665  break;
1666  }
1668 }
1669 
1670 
1677 static void
1679 {
1680  LOG_DEBUG ("0x%llx: Cleaning up rocc\n",
1681  (unsigned long long) rocc->op_id);
1682  if (NULL != rocc->attempt_connect_task_id)
1684  if (NULL != rocc->timeout_rocc_task_id)
1686  if (NULL != rocc->ohh)
1688  if (NULL != rocc->tcc.csh)
1692  GNUNET_assert (rocc->peer->reference_cnt > 0);
1693  rocc->peer->reference_cnt--;
1694  if ((GNUNET_YES == rocc->peer->destroy_flag) &&
1695  (0 == rocc->peer->reference_cnt))
1696  GST_destroy_peer (rocc->peer);
1697  GNUNET_free (rocc->hello);
1699  roccq_tail,
1700  rocc);
1701  GNUNET_free (rocc);
1702 }
1703 
1704 
1710 static void
1712 {
1713  struct RemoteOverlayConnectCtx *rocc = cls;
1714 
1715  GNUNET_assert (rocc->timeout_rocc_task_id != NULL);
1716  rocc->timeout_rocc_task_id = NULL;
1717  LOG_DEBUG ("0x%llx: rocc timed out\n",
1718  (unsigned long long) rocc->op_id);
1719  cleanup_rocc (rocc);
1720 }
1721 
1722 
1730 static void
1732  const struct GNUNET_PeerIdentity *new_peer)
1733 {
1734  struct RemoteOverlayConnectCtx *rocc = cls;
1735 
1736  LOG_DEBUG ("0x%llx: Request Overlay connect notify\n",
1737  (unsigned long long) rocc->op_id);
1738  GNUNET_assert (0 ==
1739  memcmp (new_peer, &rocc->a_id,
1740  sizeof(struct GNUNET_PeerIdentity)));
1741  LOG_DEBUG ("0x%llx: Peer %s connected\n",
1742  (unsigned long long) rocc->op_id,
1743  GNUNET_i2s (&rocc->a_id));
1744  cleanup_rocc (rocc);
1745 }
1746 
1747 
1754 static void
1755 attempt_connect_task (void *cls);
1756 
1757 
1765 static void
1767 {
1768  struct RemoteOverlayConnectCtx *rocc = cls;
1769 
1770  rocc->ohh = NULL;
1771  GNUNET_assert (NULL == rocc->attempt_connect_task_id);
1772  LOG_DEBUG ("0x%llx: HELLO of peer %s delivered to local peer with id: %u\n",
1773  (unsigned long long) rocc->op_id,
1774  GNUNET_i2s (&rocc->a_id),
1775  rocc->peer->id);
1776  rocc->tcc.cgh_p2_ats =
1778  rocc->peer->details.local.cfg,
1781  rocc, NULL, NULL, NULL);
1782 }
1783 
1784 
1791 static void
1793 {
1794  struct RemoteOverlayConnectCtx *rocc = cls;
1795 
1796  GNUNET_assert (NULL != rocc->attempt_connect_task_id);
1797  rocc->attempt_connect_task_id = NULL;
1798  LOG_DEBUG ("0x%llx: Offering HELLO of peer %s to remote peer with id: %u\n",
1799  (unsigned long long) rocc->op_id,
1800  GNUNET_i2s (&rocc->a_id),
1801  rocc->peer->id);
1802  rocc->ohh =
1804  rocc->hello,
1806  rocc);
1807  if (NULL == rocc->ohh)
1808  rocc->attempt_connect_task_id =
1811  100
1814  &attempt_connect_task, rocc);
1815 }
1816 
1817 
1827 static void
1829  struct GNUNET_CORE_Handle *ch,
1830  struct GNUNET_TRANSPORT_CoreHandle *th,
1832  const struct GNUNET_PeerIdentity *ignore_,
1833  const struct
1835 {
1836  struct RemoteOverlayConnectCtx *rocc = cls;
1837 
1838  if (NULL == th)
1839  {
1840  rocc->timeout_rocc_task_id =
1842  return;
1843  }
1844  rocc->tcc.th_ = th;
1845  rocc->tcc.cfg = cfg;
1846  if (NULL !=
1848  &rocc->a_id))
1849  {
1850  LOG_DEBUG ("0x%llx: Target peer %s already connected to local peer: %u\n",
1851  (unsigned long long) rocc->op_id,
1852  GNUNET_i2s (&rocc->a_id),
1853  rocc->peer->id);
1854  cleanup_rocc (rocc);
1855  return;
1856  }
1857  rocc->attempt_connect_task_id =
1859 }
1860 
1861 
1869 int
1871  const struct
1873 {
1874  uint32_t peer_id;
1875  uint16_t msize;
1876  uint16_t hsize;
1877 
1878  msize = ntohs (msg->header.size);
1879  if (GNUNET_MESSAGE_TYPE_HELLO != ntohs (msg->hello->type))
1880  {
1881  GNUNET_break (0);
1882  return GNUNET_SYSERR;
1883  }
1884  hsize = ntohs (msg->hello->size);
1885  if ((sizeof(struct GNUNET_TESTBED_RemoteOverlayConnectMessage) + hsize) !=
1886  msize)
1887  {
1888  GNUNET_break (0);
1889  return GNUNET_SYSERR;
1890  }
1891  peer_id = ntohl (msg->peer);
1892  if ((peer_id >= GST_peer_list_size) ||
1893  (NULL == GST_peer_list[peer_id]))
1894  {
1895  GNUNET_break_op (0);
1896  return GNUNET_SYSERR;
1897  }
1898  return GNUNET_OK;
1899 }
1900 
1901 
1908 void
1910  const struct
1912 {
1913  struct GNUNET_SERVICE_Client *client = cls;
1914  struct RemoteOverlayConnectCtx *rocc;
1915  struct Peer *peer;
1916  struct GNUNET_PeerIdentity pid;
1917  static char pid_str[16];
1918  uint32_t peer_id;
1919  uint16_t hsize;
1920 
1921  hsize = ntohs (msg->hello->size);
1922  peer_id = ntohl (msg->peer);
1924  if (GNUNET_YES == peer->is_remote)
1925  {
1926  struct GNUNET_MessageHeader *msg2;
1927 
1928  msg2 = GNUNET_copy_message (&msg->header);
1929  GNUNET_TESTBED_queue_message_ (peer->details.remote.slave->controller,
1930  msg2);
1932  return;
1933  }
1934  rocc = GNUNET_new (struct RemoteOverlayConnectCtx);
1935  rocc->op_id = GNUNET_ntohll (msg->operation_id);
1937  roccq_tail,
1938  rocc);
1939  rocc->a_id = msg->peer_identity;
1940  GNUNET_TESTING_peer_get_identity (peer->details.local.peer,
1941  &pid);
1942  (void) GNUNET_strlcpy (pid_str,
1943  GNUNET_i2s (&pid),
1944  sizeof(pid_str));
1945  LOG_DEBUG (
1946  "0x%llx: Remote overlay connect %s to peer %s with hello size: %u\n",
1947  (unsigned long long) rocc->op_id,
1948  pid_str,
1949  GNUNET_i2s (&rocc->a_id),
1950  hsize);
1951  rocc->peer = peer;
1952  rocc->peer->reference_cnt++;
1953  rocc->hello = GNUNET_malloc (hsize);
1954  GNUNET_memcpy (rocc->hello,
1955  msg->hello,
1956  hsize);
1957  rocc->tcc.cgh_p2_th =
1959  rocc->peer->details.local.cfg,
1962  rocc,
1963  &rocc->a_id,
1965  rocc);
1966  rocc->timeout_rocc_task_id =
1969  rocc);
1971 }
1972 
1973 
1977 void
1979 {
1980  struct OverlayConnectContext *occ;
1981 
1982  while (NULL != (occ = occq_head))
1983  cleanup_occ (occ);
1984 }
1985 
1986 
1990 void
1992 {
1993  struct RemoteOverlayConnectCtx *rocc;
1994 
1995  while (NULL != (rocc = roccq_head))
1996  cleanup_rocc (rocc);
1997 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static int forward
Search direction: forward.
Definition: gnunet-abd.c:162
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
static char * address
GNS address for this phone.
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
#define LOG_DEBUG(...)
Debug logging shorthand.
static struct GNUNET_MQ_Envelope * ac
Handle to current GNUNET_PEERINFO_add_peer() operation.
static struct GNUNET_PeerIdentity my_identity
Identity of this peer.
void GST_forwarded_operation_reply_relay(void *cls, const struct GNUNET_MessageHeader *msg)
Callback to relay the reply msg of a forwarded operation back to the client.
struct ForwardedOperationContext * fopcq_head
DLL head for forwarded operation contexts.
struct GNUNET_TESTBED_Host ** GST_host_list
Array of hosts.
struct GNUNET_TIME_Relative GST_timeout
Timeout for operations which may take some time.
void GST_send_operation_fail_msg(struct GNUNET_SERVICE_Client *client, uint64_t operation_id, const char *emsg)
Send operation failure message to client.
unsigned int GST_peer_list_size
The size of the peer list.
void GST_queue_host_registration(struct Slave *slave, GNUNET_TESTBED_HostRegistrationCompletion cb, void *cb_cls, struct GNUNET_TESTBED_Host *host)
Adds a host registration's request to a slave's registration queue.
struct ForwardedOperationContext * fopcq_tail
DLL tail for forwarded operation contexts.
void GST_forwarded_operation_timeout(void *cls)
Task to free resources when forwarded operation has been timed out.
data structures shared amongst components of TESTBED service
const struct GNUNET_MessageHeader * GST_cache_lookup_hello(const unsigned int peer_id)
Looks up in the hello cache and returns the HELLO of the given peer.
#define VALID_PEER_ID(id)
Condition to check if peer id is valid.
struct Route * GST_find_dest_route(uint32_t host_id)
Finds the route with directly connected host as destination through which the destination host can be...
void GST_destroy_peer(struct Peer *peer)
Function to destroy a peer.
struct Peer ** GST_peer_list
A list of peers we know about.
#define VALID_HOST_ID(id)
Condition to check if host id is valid.
void GST_cache_add_hello(const unsigned int peer_id, const struct GNUNET_MessageHeader *hello)
Caches the HELLO of the given peer.
struct GST_ConnectionPool_GetHandle * GST_connection_pool_get_handle(unsigned int peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg, enum GST_ConnectionPool_Service service, GST_connection_pool_connection_ready_cb cb, void *cb_cls, const struct GNUNET_PeerIdentity *target, GST_connection_pool_peer_connect_notify connect_notify_cb, void *connect_notify_cb_cls)
Get a connection handle to service.
void GST_connection_pool_get_handle_done(struct GST_ConnectionPool_GetHandle *gh)
Relinquish a GST_ConnectionPool_GetHandle object.
Interface for connection pooling subroutines.
@ GST_CONNECTIONPOOL_SERVICE_TRANSPORT
Transport service.
@ GST_CONNECTIONPOOL_SERVICE_CORE
Core service.
@ GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY
ATS service.
void handle_overlay_connect(void *cls, const struct GNUNET_TESTBED_OverlayConnectMessage *msg)
Handler for GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT messages.
static void cleanup_occ_lp2c(struct LocalPeer2Context *lp2c)
Cleans up any used handles in local peer2 context.
static void send_overlay_connect_success_msg(struct OverlayConnectContext *occ)
FIXME.
static void forward_overlay_connect(const struct GNUNET_TESTBED_OverlayConnectMessage *msg, struct GNUNET_SERVICE_Client *client)
Forwards the overlay connect request to a slave controller.
static void rocc_hello_sent_cb(void *cls)
Task that is run when hello has been sent If tc->reason = GNUNET_SCHEDULER_REASON_TIMEOUT then sendin...
static void rocc_cache_get_handle_transport_cb(void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *ignore_, const struct GNUNET_CONFIGURATION_Handle *cfg)
Callback from cache with needed handles set.
int check_remote_overlay_connect(void *cls, const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg)
Check GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages.
static void overlay_connect_get_config(void *cls, const struct GNUNET_MessageHeader *msg)
Callback to be called when forwarded get peer config operation as part of overlay connect is successf...
static void occ_cache_get_handle_core_cb(void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *my_identity, const struct GNUNET_CONFIGURATION_Handle *cfg)
Callback from cache with needed CORE handle set.
static void cache_transport_peer_connect_notify(void *cls, const struct GNUNET_PeerIdentity *new_peer)
Function called to notify transport users that another peer connected to us.
static void do_cleanup_occ(void *cls)
Task for cleaning up overlay connect context structure.
static void occ_cache_get_handle_ats_rocc_cb(void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *my_identity, const struct GNUNET_CONFIGURATION_Handle *cfg)
Callback from cache with needed ATS handle set.
static struct OverlayConnectContext * occq_tail
DLL tail for OverlayConnectContext DLL.
static void attempt_connect_task(void *cls)
Task to offer the HELLO message to the peer and ask it to connect to the peer whose identity is in Re...
static void p1_transport_connect_cache_callback(void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *ignore_, const struct GNUNET_CONFIGURATION_Handle *cfg)
Callback from cache with needed handles set.
static void p2_transport_connect(struct OverlayConnectContext *occ)
Connects to the transport of the other peer if it is a local peer and schedules the send hello task.
static struct GNUNET_HashCode hash_hosts(struct GNUNET_TESTBED_Host *reg_host, struct GNUNET_TESTBED_Host *host)
Function to generate the hashcode corresponding to a RegisteredHostContext.
static struct OverlayConnectContext * occq_head
DLL head for OverlayConnectContext DLL - to be used to clean up during shutdown.
void GST_free_occq()
Clears all pending overlay connect contexts in queue.
static struct RegisteredHostContext * register_host(struct Slave *slave, struct GNUNET_TESTBED_Host *host)
Checks if the given host is registered at the given slave.
static void timeout_rocc_task(void *cls)
Task to timeout rocc and cleanit up.
void handle_remote_overlay_connect(void *cls, const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg)
Handler for GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages.
static int reghost_match_iterator(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator to match a registered host context.
static void forwarded_overlay_connect_listener(void *cls, const struct GNUNET_MessageHeader *msg)
Callback to be called when forwarded overlay connection operation has a reply from the sub-controller...
static void occ_cache_get_handle_ats_occ_cb(void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *my_identity, const struct GNUNET_CONFIGURATION_Handle *cfg)
Callback from cache with needed ATS handle set.
static void hello_update_cb(void *cls, const struct GNUNET_MessageHeader *hello)
Function called whenever there is an update to the HELLO of peers in the OverlayConnectClosure.
static void host_registration_comp(void *cls, const char *emsg)
Callback which will be called after a host registration succeeded or failed.
void GST_cleanup_focc(struct ForwardedOverlayConnectContext *focc)
Cleans up ForwardedOverlayConnectContext.
static void p2_controller_connect_cb(void *cls, struct GNUNET_TESTBED_Controller *c)
Callback called when a connection to the controller of peer2 has been established.
static void send_hello(void *cls)
Task to offer HELLO of peer 1 to peer 2 and try to make peer 2 to connect to peer 1.
static void send_hello_thru_rocc(struct OverlayConnectContext *occ)
Sends the HELLO of peer1 to peer2's controller through remote overlay connect request.
static void timeout_overlay_connect(void *cls)
Task which will be run when overlay connect request has been timed out.
static struct RemoteOverlayConnectCtx * roccq_tail
DLL tail for RequectOverlayConnectContext DLL.
void GST_free_roccq()
Clears all pending remote overlay connect contexts in queue.
static struct RemoteOverlayConnectCtx * roccq_head
DLL head for RequectOverlayConnectContext DLL - to be used to clean up during shutdown.
#define PEER_EXPIRED(peer)
Condition for checking if given peer is ready to be destroyed.
static void p2_transport_connect_cache_callback(void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *ignore_, const struct GNUNET_CONFIGURATION_Handle *cfg)
Callback from cache with needed handles set.
void GST_process_next_focc(struct RegisteredHostContext *rhc)
Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext.
static int test_address(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
Test for checking whether HELLO message is empty.
static void cleanup_rocc(struct RemoteOverlayConnectCtx *rocc)
Function to cleanup RemoteOverlayConnectCtx and any associated tasks with it.
OverlayConnectContextType
Types for context information we create for overlay connect requests.
@ OCC_TYPE_LOCAL
This type is used if the overlay connection is local i.e.
@ OCC_TYPE_REMOTE_LATERAL
Type to be used when the first peer is local and the other peer is on a controller which is not start...
@ OCC_TYPE_REMOTE_SLAVE
Type to be used when the first peer is local and the other peer is on a slave controller started by u...
#define LOG(kind,...)
Redefine LOG with a changed log component string.
void GST_notify_client_disconnect_oc(struct GNUNET_SERVICE_Client *client)
Notify OC subsystem that client disconnected.
static void cleanup_occ(struct OverlayConnectContext *occ)
Cleanup overlay connect context structure.
static void overlay_connect_notify(void *cls, const struct GNUNET_PeerIdentity *new_peer)
Function called to notify transport users that another peer connected to us.
static void forwarded_overlay_connect_timeout(void *cls)
Timeout task for cancelling a forwarded overlay connect connect.
static void occ_hello_sent_cb(void *cls)
Task that is run when hello has been sent If tc->reason = GNUNET_SCHEDULER_REASON_TIMEOUT then sendin...
static void cleanup_occ_rp2c(struct RemotePeer2Context *rp2c)
Cleans up any used handles in remote peer2 context.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
obtain information about our current address
struct GNUNET_ATS_ConnectivitySuggestHandle * GNUNET_ATS_connectivity_suggest(struct GNUNET_ATS_ConnectivityHandle *ch, const struct GNUNET_PeerIdentity *peer, uint32_t strength)
We would like to receive address suggestions for a peer.
void GNUNET_ATS_connectivity_suggest_cancel(struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
We no longer care about being connected to a peer.
struct GNUNET_MQ_Handle * GNUNET_CORE_get_mq(const struct GNUNET_CORE_Handle *h, const struct GNUNET_PeerIdentity *pid)
Obtain the message queue for a connected peer.
Definition: core_api.c:760
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL).
enum GNUNET_GenericReturnValue 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.
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
struct GNUNET_HELLO_Message * GNUNET_HELLO_iterate_addresses(const struct GNUNET_HELLO_Message *msg, int return_modified, GNUNET_HELLO_AddressIterator it, void *it_cls)
Iterate over all of the addresses in the HELLO.
Definition: hello.c:254
#define GNUNET_log(kind,...)
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:37
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
#define GNUNET_free(ptr)
Wrapper around free.
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:304
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
#define GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION
Message to get a peer's information.
#define GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT
Message to request a controller to make one of its peer to connect to another peer using the containe...
#define GNUNET_MESSAGE_TYPE_HELLO
HELLO message with friend only flag used for communicating peer addresses.
#define GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION
Message containing the peer's information.
#define GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT
Message for peer connect events.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1299
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
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:1272
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2330
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2443
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2249
size_t GNUNET_strlcpy(char *dst, const char *src, size_t n)
Like strlcpy but portable.
Definition: strings.c:138
@ GNUNET_TESTBED_ET_CONNECT
A connection between two peers was established.
void GNUNET_TESTING_peer_get_identity(struct GNUNET_TESTING_Peer *peer, struct GNUNET_PeerIdentity *id)
Obtain the peer identity from a peer handle.
Definition: testing.c:1359
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
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:484
struct GNUNET_TRANSPORT_HelloGetHandle * GNUNET_TRANSPORT_hello_get(const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_TRANSPORT_AddressClass ac, GNUNET_TRANSPORT_HelloUpdateCallback rec, void *rec_cls)
Obtain updates on changes to the HELLO message for this peer.
struct GNUNET_MQ_Handle * GNUNET_TRANSPORT_core_get_mq(struct GNUNET_TRANSPORT_CoreHandle *handle, const struct GNUNET_PeerIdentity *peer)
Checks if a given peer is connected to us and get the message queue.
void GNUNET_TRANSPORT_offer_hello_cancel(struct GNUNET_TRANSPORT_OfferHelloHandle *ohh)
Cancel the request to transport to offer the HELLO message.
struct GNUNET_TRANSPORT_OfferHelloHandle * GNUNET_TRANSPORT_offer_hello(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_MessageHeader *hello, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Offer the transport service the HELLO of another peer.
void GNUNET_TRANSPORT_hello_get_cancel(struct GNUNET_TRANSPORT_HelloGetHandle *ghh)
Stop receiving updates about changes to our HELLO message.
@ GNUNET_TRANSPORT_AC_ANY
Bitmask for "any" address.
Context information for requesting ATS to connect to a peer.
struct GST_ConnectionPool_GetHandle * cgh_p2_ats
The GetCacheHandle for the peer2's ATS handle.
struct GST_ConnectionPool_GetHandle * cgh_p2_th
The GetCacheHandle for the peer2's transport handle (used to offer the HELLO to the peer).
struct GNUNET_TRANSPORT_CoreHandle * th_
The transport handle obtained from cache.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration of the peer from cache.
struct GNUNET_ATS_ConnectivitySuggestHandle * csh
The ATS handle for the connectivity suggestion.
Context information for operations forwarded to subcontrollers.
struct GNUNET_SCHEDULER_Task * timeout_task
Task ID for the timeout task.
enum OperationType type
The type of the operation which is forwarded.
struct OperationContext * opc
The generated operation context.
struct GNUNET_SERVICE_Client * client
The client to which we have to reply.
struct ForwardedOperationContext * next
The next pointer for DLL.
uint64_t operation_id
The id of the operation that has been forwarded.
Context information to used during operations which forward the overlay connect message.
struct RegisteredHostContext * rhc
Which host does this FOCC belong to?
uint64_t operation_id
The id of the operation which created this context information.
struct GNUNET_SERVICE_Client * client
The client handle.
uint32_t peer2_host_id
Id of the host where peer2 is running.
struct GNUNET_MessageHeader * orig_msg
A copy of the original overlay connect message.
Handle to the ATS subsystem for connectivity management.
Handle for ATS address suggestion requests.
Context for the core service connection.
Definition: core_api.c:78
An address for communicating with a peer.
A HELLO message is used to exchange information about transports with other peers.
A 512-bit hashcode.
Header for all communications.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:136
Handle to a client that is connected to a service.
Definition: service.c:252
Event notification from a controller to a client.
Definition: testbed.h:476
Handle to interact with a GNUnet testbed controller.
Definition: testbed_api.h:194
Opaque handle to a host running experiments managed by the testing framework.
Message sent from client to testing service to connect two peers.
Definition: testbed.h:376
Peer configuration and identity reply from controller to a client.
Definition: testbed.h:604
struct GNUNET_PeerIdentity peer_identity
Identity of the peer.
Definition: testbed.h:623
Message sent from client to testing service to obtain the configuration of a peer.
Definition: testbed.h:582
uint64_t operation_id
Operation ID that is used to identify this operation.
Definition: testbed.h:596
uint32_t peer_id
Unique ID for the peer.
Definition: testbed.h:591
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION.
Definition: testbed.h:586
struct GNUNET_TESTBED_Controller * controller
Our controller context (not necessarily the controller that is responsible for starting/running the p...
Message sent from host controller of a peer(A) to the host controller of another peer(B) to request B...
Definition: testbed.h:409
Time for absolute times used by GNUnet, in microseconds.
Handle for the transport service (includes all of the state for the transport service).
Functions to call with this peer's HELLO.
Entry in linked list for all offer-HELLO requests.
The request handle for obtaining a pooled connection.
Context data for operations on second peer in local overlay connection contexts.
struct ConnectivitySuggestContext tcc
The transport ConnectivitySuggestContext.
struct GNUNET_TRANSPORT_OfferHelloHandle * ohh
The handle for offering the HELLO of the first peer to the second peer.
Notification context to be used to notify when connection to the neighbour's controller is opened.
A connected controller which is not our child.
Context information for GNUNET_TESTBED_Operation.
Definition: testbed_api.h:137
Context information for connecting 2 peers in overlay.
struct GNUNET_MessageHeader * hello
HELLO of the first peer.
struct GNUNET_TRANSPORT_CoreHandle * p1th_
Transport handle of the first peer obtained from cache to get its HELLO.
struct RemotePeer2Context remote
Context information to be used if the second peer is remote.
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
struct GNUNET_SERVICE_Client * client
The client which has requested for overlay connection.
struct LocalPeer2Context local
Context information to be used if the second peer is local.
uint64_t op_id
The id of the operation responsible for creating this context.
struct GNUNET_SCHEDULER_Task * send_hello_task
The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to connect to peer 2.
struct GNUNET_PeerIdentity peer_identity
The peer identity of the first peer.
struct GST_ConnectionPool_GetHandle * cgh_ch
The GST_ConnectionPool_GetHandle for registering callback to notify CORE level peer connects and to g...
union OverlayConnectContext::@60 p2ctx
Context information for operations on the second peer.
struct GNUNET_SCHEDULER_Task * cleanup_task
The id of the cleanup task.
enum OverlayConnectContextType type
The type of this context information.
struct Peer * peer
the first peer which is to expect an overlay connection from the second peer.
uint32_t other_peer_id
The id of the second peer which has to connect to the first peer.
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
struct OverlayConnectContext * next
The next pointer for maintaining a DLL of all OverlayConnectContexts.
char * emsg
The error message we send if this overlay connect operation has timed out.
struct GNUNET_TRANSPORT_HelloGetHandle * ghh
Get GetHelloHandle to acquire a HELLO of the first peer.
struct OverlayConnectContext * prev
The prev pointer for maintaining a DLL of all OverlayConnectContexts.
struct GST_ConnectionPool_GetHandle * cgh_p1th
The GST_ConnectionPool_GetHandle for the peer1's transport handle.
uint32_t destroy_flag
While destroying a peer, due to the fact that there could be references to this peer,...
union Peer::@57 details
uint32_t reference_cnt
References to peers are using in forwarded overlay contexts and remote overlay connect contexts.
uint32_t id
Our local reference id for this peer.
struct GNUNET_HELLO_Message * hello
Pointer to the HELLO message of this peer; can be NULL.
struct Peer::@57::@58 local
struct Peer::@57::@59 remote
This context information will be created for each host that is registered at slave controllers during...
enum RegisteredHostContext::RHCState state
struct GNUNET_TESTBED_Host * host
The host of the controller which has to connect to the above rhost.
struct ForwardedOverlayConnectContext * focc_dll_tail
Tail of the ForwardedOverlayConnectContext DLL.
struct ForwardedOverlayConnectContext * focc_dll_head
Head of the ForwardedOverlayConnectContext DLL.
struct GNUNET_TESTBED_Host * reg_host
The host which is being registered.
@ RHC_DONE
State where we attempt to do the overlay connection again.
@ RHC_INIT
The initial state.
Context information for remote overlay connect operations.
struct GNUNET_SCHEDULER_Task * attempt_connect_task_id
Task for offering HELLO of A to B and doing try_connect.
struct RemoteOverlayConnectCtx * prev
the prev pointer for DLL
struct RemoteOverlayConnectCtx * next
the next pointer for DLL
struct GNUNET_TRANSPORT_OfferHelloHandle * ohh
The handle for offering HELLO.
struct ConnectivitySuggestContext tcc
The transport try connect context.
struct GNUNET_SCHEDULER_Task * timeout_rocc_task_id
Task to timeout RequestOverlayConnect.
struct Peer * peer
The peer handle of peer B.
uint64_t op_id
The id of the operation responsible for creating this context.
struct GNUNET_PeerIdentity a_id
The peer identity of peer A.
struct GNUNET_MessageHeader * hello
Peer A's HELLO.
Context data for operations on second peer in remote overlay connection contexts.
struct Neighbour * p2n
The neighbour handle.
struct NeighbourConnectNotification * ncn
Notification handle acquire to connect to a remote controller.
struct OperationContext * opc
Operation context for the suboperation we start to get the identity of the second peer.
struct GNUNET_TESTBED_Controller * p2c
Controller of peer 2; If OCC_TYPE_REMOTE_LATERAL is the type of overlay connection then this can be N...
A routing entry.
uint32_t dest
destination host
Structure representing a connected(directly-linked) controller.
uint32_t host_id
The id of the host this controller is running on.
struct GNUNET_TESTBED_Controller * controller
The controller handle.
struct GNUNET_CONTAINER_MultiHashMap * reghost_map
Hashmap to hold Registered host contexts.
void GNUNET_TESTBED_queue_message_(struct GNUNET_TESTBED_Controller *controller, struct GNUNET_MessageHeader *msg)
Queues a message in send queue for sending to the service.
Definition: testbed_api.c:1336
void GNUNET_TESTBED_forward_operation_msg_cancel_(struct OperationContext *opc)
Function to cancel an operation created by simply forwarding an operation message.
Definition: testbed_api.c:1407
struct OperationContext * GNUNET_TESTBED_forward_operation_msg_(struct GNUNET_TESTBED_Controller *controller, uint64_t operation_id, const struct GNUNET_MessageHeader *msg, GNUNET_MQ_MessageCallback cc, void *cc_cls)
Sends the given message as an operation.
Definition: testbed_api.c:1370
@ OP_OVERLAY_CONNECT
Overlay connection operation.
Definition: testbed_api.h:79
uint32_t GNUNET_TESTBED_host_get_id_(const struct GNUNET_TESTBED_Host *host)
Obtain a host's unique global ID.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.