GNUnet  0.10.x
gnunet-service-testbed_links.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2008--2013 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 
28 #include "gnunet-service-testbed.h"
29 
33 #ifdef LOG
34 #undef LOG
35 #endif
36 #define LOG(kind,...) \
37  GNUNET_log_from (kind, "testbed-links", __VA_ARGS__)
38 
42 #define EVENT_MASK (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED)
43 
44 
49 {
54 
59 
64 
69 };
70 
71 
75 struct LCFContext
76 {
80  struct LCFContext *next;
81 
85  struct LCFContext *prev;
86 
90  struct Slave *gateway;
91 
96 
101 
106 
110  uint64_t operation_id;
111 
116 
121 
126 
130  uint32_t slave_host_id;
131 
132 };
133 
134 
140 {
145 
150 
154  struct Neighbour *n;
155 
160 
164  void *cb_cls;
165 };
166 
167 
171 struct Neighbour
172 {
177 
183 
188 
193 
198 
202  unsigned int reference_cnt;
203 
207  unsigned int inactive;
208 
212  uint32_t host_id;
213 };
214 
215 
219 static struct Neighbour **neighbour_list;
220 
224 static unsigned int neighbour_list_size;
225 
226 
232 {
237 
242 
246  struct Neighbour *n;
247 
252 
257 
262 
267  uint64_t op_id;
268 };
269 
274 
279 
284 
288 unsigned int GST_slave_list_size;
289 
293 static struct Route **route_list;
294 
298 static struct LCFContext *lcf_head;
299 
303 static struct LCFContext *lcf_tail;
304 
309 
313 static unsigned int route_list_size;
314 
315 
321 static void
322 slave_list_add (struct Slave *slave)
323 {
324  if (slave->host_id >= GST_slave_list_size)
325  GST_array_grow_large_enough (GST_slave_list,
327  slave->host_id);
328  GNUNET_assert (NULL == GST_slave_list[slave->host_id]);
329  GST_slave_list[slave->host_id] = slave;
330 }
331 
332 
342 static int
344  const struct GNUNET_HashCode *key,
345  void *value)
346 {
347  struct GNUNET_SERVICE_Client *client = cls;
348  struct RegisteredHostContext *rhc = value;
349  struct ForwardedOverlayConnectContext *focc;
350  struct ForwardedOverlayConnectContext *foccn;
351 
352  for (focc = rhc->focc_dll_head; NULL != focc; focc = foccn)
353  {
354  foccn = focc->next;
355  if (focc->client == client)
356  GST_cleanup_focc (focc);
357  }
358  return GNUNET_OK;
359 }
360 
361 
367 static void
368 route_list_add (struct Route *route)
369 {
370  if (route->dest >= route_list_size)
371  GST_array_grow_large_enough (route_list, route_list_size, route->dest);
372  GNUNET_assert (NULL == route_list[route->dest]);
373  route_list[route->dest] = route;
374 }
375 
376 
383 static void
385 {
386  if (n->host_id >= neighbour_list_size)
388  GNUNET_assert (NULL == neighbour_list[n->host_id]);
389  neighbour_list[n->host_id] = n;
390 }
391 
392 
396 void
398 {
399  unsigned int id;
400 
401  for (id = 0; id < route_list_size; id++)
402  if (NULL != route_list[id])
403  GNUNET_free (route_list[id]);
404  GNUNET_free_non_null (route_list);
405  route_list = NULL;
406 }
407 
408 
418 static int
420  const struct GNUNET_HashCode *key,
421  void *value)
422 {
423  struct Slave *slave = cls;
424  struct RegisteredHostContext *rhc = value;
425  struct ForwardedOverlayConnectContext *focc;
426 
429  value));
430  while (NULL != (focc = rhc->focc_dll_head))
431  GST_cleanup_focc (focc);
432  GNUNET_free (value);
433  return GNUNET_YES;
434 }
435 
436 
442 static void
443 kill_slave (struct Slave *slave)
444 {
445  struct HostRegistration *hr_entry;
446 
447  while (NULL != (hr_entry = slave->hr_dll_head))
448  {
450  hr_entry);
451  GNUNET_free (hr_entry);
452  }
453  if (NULL != slave->rhandle)
458  slave));
460  if (NULL != slave->controller)
462  if (NULL != slave->controller_proc)
463  {
464  LOG_DEBUG ("Stopping a slave\n");
466  }
467 }
468 
469 
475 static void
476 destroy_slave (struct Slave *slave)
477 {
478  if (NULL != slave->controller_proc)
479  {
481  LOG_DEBUG ("Slave stopped\n");
482  }
483  GST_slave_list[slave->host_id] = NULL;
484  GNUNET_free (slave);
485 }
486 
487 
491 void
493 {
494  struct Slave *slave;
495  unsigned int id;
496 
497  for (id = 0; id < GST_slave_list_size; id++)
498  {
499  slave = GST_slave_list[id];
500  if (NULL == slave)
501  continue;
502  kill_slave (slave);
503  }
504  for (id = 0; id < GST_slave_list_size; id++)
505  {
506  slave = GST_slave_list[id];
507  if (NULL == slave)
508  continue;
509  destroy_slave (slave);
510  }
511  GNUNET_free_non_null (GST_slave_list);
512  GST_slave_list = NULL;
513 }
514 
515 
524 struct Route *
525 GST_find_dest_route (uint32_t host_id)
526 {
527  struct Route *route;
528 
529  if (route_list_size <= host_id)
530  return NULL;
531  while (NULL != (route = route_list[host_id]))
532  {
533  if (route->thru == GST_context->host_id)
534  break;
535  host_id = route->thru;
536  }
537  return route;
538 }
539 
540 
553 static void
555  uint64_t operation_id,
556  const struct GNUNET_CONFIGURATION_Handle *cfg,
557  const char *emsg)
558 {
559  struct GNUNET_MQ_Envelope *env;
561  char *xconfig;
562  size_t config_size;
563  size_t xconfig_size;
564  uint16_t msize;
565 
566  GNUNET_assert ((NULL == cfg) || (NULL == emsg));
567  xconfig = NULL;
568  xconfig_size = 0;
569  config_size = 0;
570  msize = 0;
571  if (NULL != cfg)
572  {
573  xconfig = GNUNET_TESTBED_compress_cfg_ (cfg,
574  &config_size,
575  &xconfig_size);
576  msize += xconfig_size;
577  }
578  if (NULL != emsg)
579  msize += strlen (emsg);
580  env = GNUNET_MQ_msg_extra (msg,
581  msize,
583  if (NULL == emsg)
584  msg->success = htons (GNUNET_YES);
585  msg->operation_id = GNUNET_htonll (operation_id);
586  msg->config_size = htons ((uint16_t) config_size);
587  if (NULL != xconfig)
588  {
589  GNUNET_memcpy (&msg[1],
590  xconfig,
591  xconfig_size);
592  GNUNET_free (xconfig);
593  }
594  if (NULL != emsg)
595  GNUNET_memcpy (&msg[1],
596  emsg,
597  strlen (emsg));
599  env);
600 }
601 
602 
608 static void
609 lcf_proc_task (void *cls);
610 
611 
618 static void
619 lcf_proc_cc (void *cls,
620  const char *emsg)
621 {
622  struct LCFContext *lcf = cls;
623 
624  GNUNET_assert (NULL == lcf_proc_task_id);
625  switch (lcf->state)
626  {
627  case INIT:
628  if (NULL != emsg)
629  goto registration_error;
631  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
632  break;
634  if (NULL != emsg)
635  goto registration_error;
637  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
638  break;
639  default:
640  GNUNET_assert (0); /* Shouldn't reach here */
641  }
642  return;
643 
644 registration_error:
646  "Host registration failed with message: %s\n",
647  emsg);
648  lcf->state = FINISHED;
649  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task,
650  lcf);
651 }
652 
653 
659 static void
660 lcf_proc_task (void *cls);
661 
662 
668 static void
670 {
671  struct LCFContext *lcf = cls;
672 
673  lcf->timeout_task = NULL;
674  // GST_forwarded_operation_timeout (lcf->fopc, tc);
676  "A forwarded controller link operation has timed out\n");
678  lcf->operation_id,
679  NULL,
680  "A forwarded controller link operation has timed out\n");
681  GNUNET_assert (NULL == lcf_proc_task_id);
682  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task,
683  lcf);
684 }
685 
686 
692 static void
693 lcf_proc_task (void *cls)
694 {
695  struct LCFContext *lcf = cls;
696 
697  lcf_proc_task_id = NULL;
698  switch (lcf->state)
699  {
700  case INIT:
701  if (GNUNET_NO ==
703  [lcf->delegated_host_id],
704  lcf->gateway->controller))
705  {
708  }
709  else
710  {
712  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
713  }
714  break;
716  if (GNUNET_NO ==
718  lcf->gateway->controller))
719  {
722  }
723  else
724  {
726  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
727  }
728  break;
731  lcf->gateway->controller,
734  lcf->is_subordinate);
735  lcf->timeout_task =
738  lcf);
739  lcf->state = FINISHED;
740  break;
741  case FINISHED:
742  if (NULL != lcf->op)
744  GNUNET_CONTAINER_DLL_remove (lcf_head,
745  lcf_tail,
746  lcf);
747  GNUNET_free (lcf);
748  if (NULL != lcf_head)
749  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task,
750  lcf_head);
751  }
752 }
753 
754 
761 static void
762 slave_event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
763 {
764  struct LCFContext *lcf;
765 
766  /* We currently only get here when working on LCFContexts */
768  lcf = event->op_cls;
769  GNUNET_assert (lcf->op == event->op);
771  lcf->op = NULL;
772  GNUNET_assert (FINISHED == lcf->state);
773  GNUNET_assert (NULL != lcf->timeout_task);
775  if (NULL == event->details.operation_finished.emsg)
779  NULL);
780  else
782  NULL,
783  event->details.operation_finished.emsg);
784  GNUNET_assert (NULL == lcf_proc_task_id);
785  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
786  return;
787 }
788 
789 
799 static void
800 slave_status_cb (void *cls,
801  const struct GNUNET_CONFIGURATION_Handle *cfg,
802  int status)
803 {
804  struct Slave *slave = cls;
805  struct LinkControllersContext *lcc;
806 
807  lcc = slave->lcc;
808  if (GNUNET_SYSERR == status)
809  {
810  slave->controller_proc = NULL;
811  /* Stop all link controller forwarding tasks since we shutdown here anyway
812  and as these tasks they depend on the operation queues which are created
813  through GNUNET_TESTBED_controller_connect() and in kill_slave() we call
814  the destructor function GNUNET_TESTBED_controller_disconnect() */
815  GST_free_lcf ();
816  kill_slave (slave);
817  destroy_slave (slave);
818  slave = NULL;
819  LOG (GNUNET_ERROR_TYPE_WARNING, "Unexpected slave shutdown\n");
820  GNUNET_SCHEDULER_shutdown (); /* We too shutdown */
821  goto clean_lcc;
822  }
823  slave->controller =
826  slave);
827  if (NULL != slave->controller)
828  {
829  send_controller_link_response (lcc->client, lcc->operation_id, cfg, NULL);
830  }
831  else
832  {
834  "Could not connect to delegated controller");
835  kill_slave (slave);
836  destroy_slave (slave);
837  slave = NULL;
838  }
839 
840  clean_lcc:
841  if (NULL != lcc)
842  {
843  if (NULL != lcc->client)
844  {
846  lcc->client = NULL;
847  }
848  GNUNET_free (lcc);
849  }
850  if (NULL != slave)
851  slave->lcc = NULL;
852 }
853 
854 
863 static void
864 trigger_notifications (struct Neighbour *n);
865 
866 
873 static void
875 {
876  struct Neighbour *n = cls;
878 
879  GNUNET_assert (NULL != (h = n->nl_head));
880  GNUNET_assert (NULL != n->notify_task);
881  n->notify_task = NULL;
882  GNUNET_assert (NULL != n->controller);
885  h->cb (h->cb_cls, n->controller);
886  GNUNET_free (h);
887 }
888 
889 
898 static void
900 {
901  GNUNET_assert (NULL != n->conn_op);
902  if (NULL == n->nl_head)
903  return;
904  if (NULL == n->controller)
905  return;
906  if (NULL != n->notify_task)
907  return;
908  if (1 == n->inactive)
909  {
910  GNUNET_assert (0 == n->reference_cnt);
912  n->inactive = 0;
913  }
914  n->reference_cnt++;
915  n->notify_task =
917 }
918 
919 
927 static void
929 {
930  struct Neighbour *n = cls;
931 
932  GNUNET_assert (NULL != n->conn_op);
933  GNUNET_assert (NULL == n->controller);
934  LOG_DEBUG ("Opening connection to controller on host %u\n", n->host_id);
936  EVENT_MASK,
938  NULL);
940 }
941 
942 
948 static void
950 {
951  struct Neighbour *n = cls;
952 
953  GNUNET_assert (0 == n->reference_cnt);
954  GNUNET_assert (NULL == n->notify_task);
955  GNUNET_assert (NULL == n->nl_head);
956  if (NULL != n->controller)
957  {
958  LOG_DEBUG ("Closing connection to controller on host %u\n", n->host_id);
960  n->controller = NULL;
961  }
962  n->conn_op = NULL;
963  n->inactive = 0;
964 }
965 
966 
981  void *cb_cls)
982 {
984 
985  GNUNET_assert (NULL != cb);
986  LOG_DEBUG ("Attempting to get connection to controller on host %u\n",
987  n->host_id);
989  h->n = n;
990  h->cb = cb;
991  h->cb_cls = cb_cls;
993  if (NULL == n->conn_op)
994  {
995  GNUNET_assert (NULL == n->controller);
1000  return h;
1001  }
1003  return h;
1004 }
1005 
1006 
1012 void
1014 {
1015  struct Neighbour *n;
1016  int cleanup_task;
1017 
1018  n = h->n;
1019  cleanup_task = (h == n->nl_head) ? GNUNET_YES : GNUNET_NO;
1021  GNUNET_free (h);
1022  if (GNUNET_NO == cleanup_task)
1023  return;
1024  if (NULL == n->notify_task)
1025  return;
1026  GNUNET_assert (0 < n->reference_cnt);
1027  n->reference_cnt--;
1029  n->notify_task = NULL;
1030  if (NULL == n->nl_head)
1031  {
1032  if ( (0 == n->reference_cnt) && (0 == n->inactive) )
1033  {
1034  n->inactive = 1;
1036  }
1037  return;
1038  }
1040 }
1041 
1042 
1050 void
1052 {
1053  GNUNET_assert (0 == n->inactive);
1054  GNUNET_assert (0 < n->reference_cnt);
1055  n->reference_cnt--;
1056  if (0 == n->reference_cnt)
1057  {
1058  n->inactive = 1;
1060  }
1061 }
1062 
1063 
1069 static void
1071 {
1072  if (NULL != ncc->nh)
1074  if (NULL != ncc->timeout_task)
1076  GNUNET_CONTAINER_DLL_remove (ncc_head,
1077  ncc_tail,
1078  ncc);
1079  GNUNET_free (ncc);
1080 }
1081 
1082 
1086 void
1088 {
1089  struct Neighbour *n;
1090  unsigned int id;
1091 
1092  for (id = 0; id < neighbour_list_size; id++)
1093  {
1094  if (NULL == (n = neighbour_list[id]))
1095  continue;
1096  if (NULL != n->conn_op)
1098  GNUNET_free (n);
1099  neighbour_list[id] = NULL;
1100  }
1101  GNUNET_free_non_null (neighbour_list);
1102 }
1103 
1104 
1112 struct Neighbour *
1113 GST_get_neighbour (uint32_t id)
1114 {
1115  if (neighbour_list_size <= id)
1116  return NULL;
1117  return neighbour_list[id];
1118 }
1119 
1120 
1124 void
1126 {
1127  while (NULL != ncc_head)
1128  cleanup_ncc (ncc_head);
1129 }
1130 
1131 
1137 static void
1139 {
1140  struct NeighbourConnectCtxt *ncc = cls;
1141 
1142  ncc->timeout_task = NULL;
1144  ncc->op_id,
1145  NULL,
1146  "Could not connect to delegated controller");
1147  cleanup_ncc (ncc);
1148 }
1149 
1150 
1157 static void
1159  struct GNUNET_TESTBED_Controller *c)
1160 {
1161  struct NeighbourConnectCtxt *ncc = cls;
1162 
1164  ncc->timeout_task = NULL;
1165  ncc->nh = NULL;
1168  ncc->op_id,
1169  NULL,
1170  NULL);
1171  cleanup_ncc (ncc);
1172 }
1173 
1174 
1180 struct Neighbour *
1182 {
1183  struct Neighbour *n;
1184 
1185  n = GNUNET_new (struct Neighbour);
1187  neighbour_list_add (n); /* just add; connect on-demand */
1188  return n;
1189 }
1190 
1191 
1198 void
1201 {
1202  struct GNUNET_SERVICE_Client *client = cls;
1203  struct LCFContext *lcf;
1204  struct Route *route;
1205  struct Route *new_route;
1206  uint64_t op_id;
1207  uint32_t delegated_host_id;
1208  uint32_t slave_host_id;
1209 
1210  if (NULL == GST_context)
1211  {
1212  GNUNET_break (0);
1213  GNUNET_SERVICE_client_drop (client);
1214  return;
1215  }
1216  delegated_host_id = ntohl (msg->delegated_host_id);
1217  if (delegated_host_id == GST_context->host_id)
1218  {
1219  GNUNET_break (0);
1221  "Trying to link ourselves\n");
1222  GNUNET_SERVICE_client_drop (client);
1223  return;
1224  }
1225  if ((delegated_host_id >= GST_host_list_size) ||
1226  (NULL == GST_host_list[delegated_host_id]))
1227  {
1229  "Delegated host %u not registered with us\n",
1230  delegated_host_id);
1231  GNUNET_SERVICE_client_drop (client);
1232  return;
1233  }
1234  slave_host_id = ntohl (msg->slave_host_id);
1235  if ((slave_host_id >= GST_host_list_size) ||
1236  (NULL == GST_host_list[slave_host_id]))
1237  {
1239  "Slave host %u not registered with us\n",
1240  slave_host_id);
1241  GNUNET_SERVICE_client_drop (client);
1242  return;
1243  }
1244  if (slave_host_id == delegated_host_id)
1245  {
1247  "Slave and delegated host are same\n");
1248  GNUNET_SERVICE_client_drop (client);
1249  return;
1250  }
1251  op_id = GNUNET_ntohll (msg->operation_id);
1252  if (slave_host_id == GST_context->host_id) /* Link from us */
1253  {
1254  struct Slave *slave;
1255  struct LinkControllersContext *lcc;
1256 
1257  if (1 != msg->is_subordinate)
1258  {
1259  struct Neighbour *n;
1260  struct NeighbourConnectCtxt *ncc;
1261 
1262  if ((delegated_host_id < neighbour_list_size) &&
1263  (NULL != neighbour_list[delegated_host_id]))
1264  {
1265  GNUNET_break (0);
1266  GNUNET_SERVICE_client_drop (client);
1267  return;
1268  }
1269  LOG_DEBUG ("Received request to establish a link to host %u\n",
1270  delegated_host_id);
1271  n = GST_create_neighbour (GST_host_list[delegated_host_id]);
1272  ncc = GNUNET_new (struct NeighbourConnectCtxt);
1273  ncc->n = n;
1274  ncc->op_id = op_id;
1275  ncc->client = client;
1276  ncc->nh = GST_neighbour_get_connection (n,
1278  ncc);
1279  ncc->timeout_task
1282  ncc);
1284  ncc_tail,
1285  ncc);
1287  return;
1288  }
1289  if ( (delegated_host_id < GST_slave_list_size) &&
1290  (NULL != GST_slave_list[delegated_host_id]) )
1291  {
1292  GNUNET_break (0);
1293  GNUNET_SERVICE_client_drop (client);
1294  return;
1295  }
1296  LOG_DEBUG ("Received request to start and establish a link to host %u\n",
1297  delegated_host_id);
1298  slave = GNUNET_new (struct Slave);
1299  slave->host_id = delegated_host_id;
1301  GNUNET_NO);
1302  slave_list_add (slave);
1303  lcc = GNUNET_new (struct LinkControllersContext);
1304  lcc->operation_id = op_id;
1305  lcc->client = client;
1306  slave->lcc = lcc;
1307  slave->controller_proc
1309  GST_host_list[slave->host_id],
1310  &slave_status_cb,
1311  slave);
1312  new_route = GNUNET_new (struct Route);
1313  new_route->dest = delegated_host_id;
1314  new_route->thru = GST_context->host_id;
1315  route_list_add (new_route);
1316  return;
1317  }
1318 
1319  /* Route the request */
1320  if (slave_host_id >= route_list_size)
1321  {
1323  "No route towards slave host");
1324  GNUNET_SERVICE_client_drop (client);
1325  return;
1326  }
1327  lcf = GNUNET_new (struct LCFContext);
1330  route = GST_find_dest_route (slave_host_id);
1331  GNUNET_assert (NULL != route); /* because we add routes carefully */
1333  GNUNET_assert (NULL != GST_slave_list[route->dest]);
1334  lcf->is_subordinate = msg->is_subordinate;
1335  lcf->state = INIT;
1336  lcf->operation_id = op_id;
1337  lcf->gateway = GST_slave_list[route->dest];
1338  lcf->client = client;
1339  if (NULL == lcf_head)
1340  {
1341  GNUNET_assert (NULL == lcf_proc_task_id);
1343  lcf_tail,
1344  lcf);
1345  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task,
1346  lcf);
1347  }
1348  else
1349  {
1351  lcf_tail,
1352  lcf);
1353  }
1354  /* FIXME: Adding a new route should happen after the controllers are linked
1355  * successfully */
1356  if (1 != msg->is_subordinate)
1357  {
1359  return;
1360  }
1361  if ( (delegated_host_id < route_list_size) &&
1362  (NULL != route_list[delegated_host_id]) )
1363  {
1364  GNUNET_break_op (0); /* Are you trying to link delegated host twice
1365  * with is subordinate flag set to GNUNET_YES? */
1366  GNUNET_SERVICE_client_drop (client);
1367  return;
1368  }
1369  new_route = GNUNET_new (struct Route);
1370  new_route->dest = delegated_host_id;
1371  new_route->thru = route->dest;
1372  route_list_add (new_route);
1374 }
1375 
1376 
1383 void
1385 {
1386  struct NeighbourConnectCtxt *ncc;
1387  struct NeighbourConnectCtxt *nccn;
1388  struct LCFContext *lcf;
1389  struct LCFContext *lcfn;
1390 
1391  for (ncc = ncc_head; NULL != ncc; ncc = nccn)
1392  {
1393  nccn = ncc->next;
1394  if (ncc->client == client)
1395  cleanup_ncc (ncc);
1396  }
1397  for (unsigned int i=0;i<GST_slave_list_size;i++)
1398  {
1399  struct Slave *slave = GST_slave_list[i];
1400  struct LinkControllersContext *lcc;
1401 
1402  if (NULL == slave)
1403  continue;
1406  client);
1407  lcc = slave->lcc;
1408  if (NULL == lcc)
1409  continue;
1410  if (lcc->client == client)
1411  {
1412  slave->lcc = NULL;
1413  GNUNET_free (lcc);
1414  }
1415  }
1416  for (lcf = lcf_head; NULL != lcf; lcf = lcfn)
1417  {
1418  lcfn = lcf->next;
1419  if ( (NULL != lcf) &&
1420  (client == lcf->client) )
1421  {
1422  if (NULL != lcf->op)
1424  GNUNET_CONTAINER_DLL_remove (lcf_head,
1425  lcf_tail,
1426  lcf);
1427  GNUNET_free (lcf);
1428  }
1429  }
1430 }
1431 
1432 
1436 void
1438 {
1439  struct LCFContext *lcf;
1440 
1441  if (NULL != lcf_head)
1442  {
1443  if (NULL != lcf_proc_task_id)
1444  {
1445  GNUNET_SCHEDULER_cancel (lcf_proc_task_id);
1446  lcf_proc_task_id = NULL;
1447  }
1448  }
1449  GNUNET_assert (NULL == lcf_proc_task_id);
1450  for (lcf = lcf_head; NULL != lcf; lcf = lcf_head)
1451  {
1452  if (NULL != lcf->op)
1454  if (NULL != lcf->timeout_task)
1456  GNUNET_CONTAINER_DLL_remove (lcf_head,
1457  lcf_tail,
1458  lcf);
1459  GNUNET_free (lcf);
1460  }
1461 }
struct ForwardedOverlayConnectContext * focc_dll_head
Head of the ForwardedOverlayConnectContext DLL.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_CONTAINER_MultiHashMap * reghost_map
Hashmap to hold Registered host contexts.
struct GNUNET_SCHEDULER_Task * timeout_task
Task to be run upon timeout.
A connected controller which is not our child.
void GNUNET_TESTBED_cancel_registration(struct GNUNET_TESTBED_HostRegistrationHandle *handle)
Cancel the pending registration.
uint64_t operation_id
The id of the operation which created this context.
Context information for establishing a link to neighbour (Used is GST_handle_link_controllers() ...
This context information will be created for each host that is registered at slave controllers during...
uint32_t host_id
The id of the host this controller is running on.
unsigned int GST_host_list_size
The size of the host list.
struct Neighbour * n
The neighbour to whom connection should be made.
void GNUNET_TESTBED_controller_disconnect(struct GNUNET_TESTBED_Controller *c)
Stop the given controller (also will terminate all peers and controllers dependent on this controller...
Definition: testbed_api.c:1723
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint64_t operation_id
The id of the operation which created this message.
Definition: testbed.h:198
Link controllers request forwarding context.
unsigned int inactive
Is the conn_op inactivated?
uint32_t thru
The destination host is reachable thru.
Handle to interact with a GNUnet testbed controller.
Definition: testbed_api.h:194
struct NeighbourConnectNotification * nh
The notification handle associated with the neighbour&#39;s connection request.
struct NeighbourConnectNotification * next
DLL next for inclusion in neighbour&#39;s list of notification requests.
data structures shared amongst components of TESTBED service
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2734
struct GNUNET_SERVICE_Client * client
The client handle.
struct LCFContext * prev
The LCFContext.
void GNUNET_TESTBED_controller_kill_(struct GNUNET_TESTBED_ControllerProc *cproc)
Sends termination signal to the controller&#39;s helper process.
static struct GNUNET_SCHEDULER_Task * cleanup_task
Cleanup task.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Notification context to be used to notify when connection to the neighbour&#39;s controller is opened...
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_controller_link(void *op_cls, struct GNUNET_TESTBED_Controller *master, struct GNUNET_TESTBED_Host *delegated_host, struct GNUNET_TESTBED_Host *slave_host, int is_subordinate)
Create a link from slave controller to delegated controller.
Definition: testbed_api.c:1833
char * master_ip
The network address of the master controller.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_operation_create_(void *cls, OperationStart start, OperationRelease release)
Create an &#39;operation&#39; to be performed.
void GNUNET_TESTBED_operation_release_(struct GNUNET_TESTBED_Operation *op)
An operation is &#39;done&#39; (was cancelled or finished); remove it from the queues and release associated ...
int is_subordinate
should the slave controller start the delegated controller?
void GST_queue_host_registration(struct Slave *slave, GNUNET_TESTBED_HostRegistrationCompletion cb, void *cb_cls, struct GNUNET_TESTBED_Host *host)
Adds a host registration&#39;s request to a slave&#39;s registration queue.
Argument to GNUNET_TESTBED_ControllerCallback with details about the event.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_HashMapIterator it, void *it_cls)
Iterate over all entries in the map.
#define GNUNET_NO
Definition: gnunet_common.h:81
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
enum GNUNET_TESTBED_EventType type
Type of the event.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct GNUNET_TESTBED_Operation * op
Handle for operations which are forwarded while linking controllers.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Structure representing a connected(directly-linked) controller.
struct GNUNET_TESTBED_HostRegistrationHandle * rhandle
The current host registration handle.
Opaque handle to a host running experiments managed by the testing framework.
enum LCFContextState state
The state of this context.
void GNUNET_TESTBED_operation_queue_insert_(struct OperationQueue *queue, struct GNUNET_TESTBED_Operation *op)
Add an operation to a queue.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
Context information used while linking controllers.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct Slave * gateway
The gateway which will pass the link message to delegated host.
struct NeighbourConnectNotification * nl_tail
DLL tail for the list of notification requests.
struct OperationQueue * GST_opq_openfds
Operation queue for open file descriptors.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
#define GST_array_grow_large_enough(ptr, size, accommodate_size)
Similar to GNUNET_array_grow(); however instead of calling GNUNET_array_grow() several times we call ...
Opaque handle to an abstract operation to be executed by the testing framework.
Response message for ControllerLinkRequest message.
Definition: testbed.h:176
Handle to a client that is connected to a service.
Definition: service.c:249
uint32_t delegated_host_id
For which host should requests be delegated? NBO.
Definition: testbed.h:152
const struct GNUNET_TIME_Relative GST_timeout
Timeout for operations which may take some time.
void GST_cleanup_focc(struct ForwardedOverlayConnectContext *focc)
Cleans up ForwardedOverlayConnectContext.
#define GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT
Message to signal the result of GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS request.
GST_NeigbourConnectNotifyCallback cb
The notification callback to call when we are connect to neighbour.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
struct GNUNET_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:1246
char * GNUNET_TESTBED_compress_cfg_(const struct GNUNET_CONFIGURATION_Handle *cfg, size_t *size, size_t *xsize)
Function to serialize and compress using zlib a configuration through a configuration handle...
Definition: testbed_api.c:1787
#define GNUNET_memcpy(dst, src, n)
uint32_t host_id
Our host id according to this context.
struct GNUNET_SERVICE_Client * client
The client which has asked to perform this operation.
static char * value
Value of the record to add/remove.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void * cb_cls
The closure for the above callback.
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:1273
struct GNUNET_TESTBED_Host ** GST_host_list
Array of hosts.
Context information to used during operations which forward the overlay connect message.
A DLL of host registrations to be made.
A requested testbed operation has been completed.
uint16_t status
See PRISM_STATUS_*-constants.
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
A routing entry.
uint32_t GNUNET_TESTBED_host_get_id_(const struct GNUNET_TESTBED_Host *host)
Obtain the host&#39;s unique global ID.
struct HostRegistration * hr_dll_tail
Tail of the host registration DLL.
struct GNUNET_TESTBED_Controller * controller
The controller handle.
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2046
uint32_t delegated_host_id
The delegated host.
const struct GNUNET_CONFIGURATION_Handle * GNUNET_TESTBED_host_get_cfg_(const struct GNUNET_TESTBED_Host *host)
Obtain the host&#39;s configuration template.
struct GNUNET_TESTBED_Operation * conn_op
Operation handle for opening a lateral connection to another controller.
A 512-bit hashcode.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2618
void GNUNET_TESTBED_controller_destroy_(struct GNUNET_TESTBED_ControllerProc *cproc)
Cleans-up the controller&#39;s helper process handle.
struct HostRegistration * hr_dll_head
Head of the host registration DLL.
struct GNUNET_TESTBED_EventInformation::@58::@63 operation_finished
Details about an operation finished event.
void GNUNET_TESTBED_operation_activate_(struct GNUNET_TESTBED_Operation *op)
Marks and inactive operation as active.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
int GNUNET_TESTBED_is_host_registered_(const struct GNUNET_TESTBED_Host *host, const struct GNUNET_TESTBED_Controller *const controller)
Checks whether a host has been registered.
struct GNUNET_HashCode key
The key used in the DHT.
struct GNUNET_TESTBED_ControllerProc * controller_proc
The controller process handle if we had started the controller.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
uint16_t success
Set to GNUNET_YES to signify SUCCESS; GNUNET_NO to signify failure.
Definition: testbed.h:193
GUID host
struct NeighbourConnectCtxt * prev
DLL tail.
uint64_t operation_id
The ID of the operation.
struct Neighbour * n
The neighbour.
uint32_t slave_host_id
The slave host.
union GNUNET_TESTBED_EventInformation::@58 details
Details about the event.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
unsigned int reference_cnt
How many references are present currently to this neighbour&#39;s connection.
struct LinkControllersContext * lcc
handle to lcc which is associated with this slave startup.
struct GNUNET_TESTBED_Controller * GNUNET_TESTBED_controller_connect(struct GNUNET_TESTBED_Host *host, uint64_t event_mask, GNUNET_TESTBED_ControllerCallback cc, void *cc_cls)
Connect to a controller process.
Definition: testbed_api.c:1558
uint16_t config_size
The size of the compressed configuration.
Definition: testbed.h:188
uint64_t op_id
The id of the link-controllers operation responsible for creating this context.
struct NeighbourConnectCtxt * next
DLL next for inclusion in the corresponding context list.
struct NeighbourConnectNotification * prev
DLL prev.
struct ForwardedOverlayConnectContext * next
next ForwardedOverlayConnectContext in the DLL
uint32_t slave_host_id
Which host is responsible for managing the delegation? NBO.
Definition: testbed.h:162
uint32_t host_id
The id of the host this controller is running on.
void GNUNET_TESTBED_operation_begin_wait_(struct GNUNET_TESTBED_Operation *op)
Marks the given operation as waiting on the queues.
configuration data
Definition: configuration.c:85
struct Context * GST_context
The master context; generated with the first INIT message.
struct GNUNET_SERVICE_Client * client
The client requesting the connection.
uint8_t is_subordinate
Set to 1 if the receiving controller is the master controller for the slave host (and thus responsibl...
Definition: testbed.h:168
struct NeighbourConnectNotification * nl_head
DLL head for the list of notification requests.
Entry in list of pending tasks.
Definition: scheduler.c:134
struct GNUNET_SCHEDULER_Task * timeout_task
The timeout task.
struct GNUNET_TESTBED_Controller * controller
The controller handle.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
uint64_t operation_id
The id of the operation which created this message.
Definition: testbed.h:157
#define GNUNET_YES
Definition: gnunet_common.h:80
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
#define LOG_DEBUG(msg)
void GNUNET_TESTBED_operation_inactivate_(struct GNUNET_TESTBED_Operation *op)
Marks an active operation as inactive - the operation will be kept in a ready-to-be-released state an...
struct LCFContext * next
The LCFContext.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
uint32_t dest
destination host
struct GNUNET_TESTBED_ControllerProc * GNUNET_TESTBED_controller_start(const char *trusted_ip, struct GNUNET_TESTBED_Host *host, GNUNET_TESTBED_ControllerStatusCallback cb, void *cls)
Starts a controller process at the given host.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_SERVICE_Client * client
The client which initiated the link controller operation.
struct GNUNET_SCHEDULER_Task * notify_task
Task id for the task to call notifications from the notification list.
Client notifies controller that it should delegate requests for a particular client to a particular s...
Definition: testbed.h:141
struct GNUNET_TESTBED_Operation * op
Handle for the corresponding operation that generated this event.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965