/** * Main run function. * * @param cls NULL * @param args arguments passed to GNUNET_PROGRAM_run * @param cfgfile the path to configuration file * @param cfg the configuration file handle */ static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *config) { host = GNUNET_TESTBED_host_create (NULL, NULL, 0); GNUNET_assert (NULL != host); if (GNUNET_YES != GNUNET_TESTBED_is_host_habitable (host, config)) { GNUNET_TESTBED_host_destroy (host); host = NULL; (void) PRINTF ("%s", "Unable to run the test as this system is not configured " "to use password less SSH logins to localhost.\n" "Marking test as successful\n"); result = SUCCESS; return; } cfg = GNUNET_CONFIGURATION_dup (config); cp = GNUNET_TESTBED_controller_start ("127.0.0.1", host, cfg, status_cb, NULL); abort_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5), &do_abort, NULL); }
/** * Main function that will be run by the scheduler. * * @param cls closure * @param args remaining command-line arguments * @param cfgfile name of the configuration file used (for saving, can be NULL!) * @param config configuration */ static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *config) { unsigned int nhost; if (NULL == args[0]) { fprintf (stderr, _("No hosts-file specified on command line\n")); return; } if (0 == num_peers) { result = GNUNET_OK; return; } num_hosts = GNUNET_TESTBED_hosts_load_from_file (args[0], &hosts); if (0 == num_hosts) { fprintf (stderr, _("No hosts loaded. Need at least one host\n")); return; } for (nhost = 0; nhost < num_hosts; nhost++) { if (GNUNET_YES != GNUNET_TESTBED_is_host_habitable (hosts[nhost], config)) { fprintf (stderr, _("Host %s cannot start testbed\n"), GNUNET_TESTBED_host_get_hostname_ (hosts[nhost])); break; } } if (num_hosts != nhost) { fprintf (stderr, _("Exiting\n")); shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); return; } cfg = GNUNET_CONFIGURATION_dup (config); mc_proc = GNUNET_TESTBED_controller_start (GNUNET_TESTBED_host_get_hostname_ (hosts[0]), hosts[0], cfg, status_cb, NULL); abort_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5), &do_abort, NULL); }
/** * Callbacks of this type are called by GNUNET_TESTBED_is_host_habitable to * inform whether the given host is habitable or not. The Handle returned by * GNUNET_TESTBED_is_host_habitable() is invalid after this callback is called * * @param cls NULL * @param host the host whose status is being reported; will be NULL if the host * given to GNUNET_TESTBED_is_host_habitable() is NULL * @param status GNUNET_YES if it is habitable; GNUNET_NO if not */ static void host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *_host, int status) { hc_handle = NULL; if (GNUNET_NO == status) { (void) PRINTF ("%s", "Unable to run the test as this system is not configured " "to use password less SSH logins to localhost.\n" "Skipping test\n"); GNUNET_SCHEDULER_cancel (abort_task); abort_task = NULL; (void) GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); result = SKIP; return; } cp = GNUNET_TESTBED_controller_start ("127.0.0.1", host, status_cb, NULL); }
/** * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_LCONTROLLERS message * * @param cls identification of the client * @param msg the actual message */ void handle_link_controllers (void *cls, const struct GNUNET_TESTBED_ControllerLinkRequest *msg) { struct GNUNET_SERVICE_Client *client = cls; struct LCFContext *lcf; struct Route *route; struct Route *new_route; uint64_t op_id; uint32_t delegated_host_id; uint32_t slave_host_id; if (NULL == GST_context) { GNUNET_break (0); GNUNET_SERVICE_client_drop (client); return; } delegated_host_id = ntohl (msg->delegated_host_id); if (delegated_host_id == GST_context->host_id) { GNUNET_break (0); LOG (GNUNET_ERROR_TYPE_WARNING, "Trying to link ourselves\n"); GNUNET_SERVICE_client_drop (client); return; } if ((delegated_host_id >= GST_host_list_size) || (NULL == GST_host_list[delegated_host_id])) { LOG (GNUNET_ERROR_TYPE_WARNING, "Delegated host %u not registered with us\n", delegated_host_id); GNUNET_SERVICE_client_drop (client); return; } slave_host_id = ntohl (msg->slave_host_id); if ((slave_host_id >= GST_host_list_size) || (NULL == GST_host_list[slave_host_id])) { LOG (GNUNET_ERROR_TYPE_WARNING, "Slave host %u not registered with us\n", slave_host_id); GNUNET_SERVICE_client_drop (client); return; } if (slave_host_id == delegated_host_id) { LOG (GNUNET_ERROR_TYPE_WARNING, "Slave and delegated host are same\n"); GNUNET_SERVICE_client_drop (client); return; } op_id = GNUNET_ntohll (msg->operation_id); if (slave_host_id == GST_context->host_id) /* Link from us */ { struct Slave *slave; struct LinkControllersContext *lcc; if (1 != msg->is_subordinate) { struct Neighbour *n; struct NeighbourConnectCtxt *ncc; if ((delegated_host_id < neighbour_list_size) && (NULL != neighbour_list[delegated_host_id])) { GNUNET_break (0); GNUNET_SERVICE_client_drop (client); return; } LOG_DEBUG ("Received request to establish a link to host %u\n", delegated_host_id); n = GST_create_neighbour (GST_host_list[delegated_host_id]); ncc = GNUNET_new (struct NeighbourConnectCtxt); ncc->n = n; ncc->op_id = op_id; ncc->client = client; ncc->nh = GST_neighbour_get_connection (n, &neighbour_connect_cb, ncc); ncc->timeout_task = GNUNET_SCHEDULER_add_delayed (GST_timeout, &timeout_neighbour_connect, ncc); GNUNET_CONTAINER_DLL_insert_tail (ncc_head, ncc_tail, ncc); GNUNET_SERVICE_client_continue (client); return; } if ( (delegated_host_id < GST_slave_list_size) && (NULL != GST_slave_list[delegated_host_id]) ) { GNUNET_break (0); GNUNET_SERVICE_client_drop (client); return; } LOG_DEBUG ("Received request to start and establish a link to host %u\n", delegated_host_id); slave = GNUNET_new (struct Slave); slave->host_id = delegated_host_id; slave->reghost_map = GNUNET_CONTAINER_multihashmap_create (100, GNUNET_NO); slave_list_add (slave); lcc = GNUNET_new (struct LinkControllersContext); lcc->operation_id = op_id; lcc->client = client; slave->lcc = lcc; slave->controller_proc = GNUNET_TESTBED_controller_start (GST_context->master_ip, GST_host_list[slave->host_id], &slave_status_cb, slave); new_route = GNUNET_new (struct Route); new_route->dest = delegated_host_id; new_route->thru = GST_context->host_id; route_list_add (new_route); return; } /* Route the request */ if (slave_host_id >= route_list_size) { LOG (GNUNET_ERROR_TYPE_WARNING, "No route towards slave host"); GNUNET_SERVICE_client_drop (client); return; } lcf = GNUNET_new (struct LCFContext); lcf->delegated_host_id = delegated_host_id; lcf->slave_host_id = slave_host_id; route = GST_find_dest_route (slave_host_id); GNUNET_assert (NULL != route); /* because we add routes carefully */ GNUNET_assert (route->dest < GST_slave_list_size); GNUNET_assert (NULL != GST_slave_list[route->dest]); lcf->is_subordinate = msg->is_subordinate; lcf->state = INIT; lcf->operation_id = op_id; lcf->gateway = GST_slave_list[route->dest]; lcf->client = client; if (NULL == lcf_head) { GNUNET_assert (NULL == lcf_proc_task_id); GNUNET_CONTAINER_DLL_insert_tail (lcf_head, lcf_tail, lcf); lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf); } else { GNUNET_CONTAINER_DLL_insert_tail (lcf_head, lcf_tail, lcf); } /* FIXME: Adding a new route should happen after the controllers are linked * successfully */ if (1 != msg->is_subordinate) { GNUNET_SERVICE_client_continue (client); return; } if ( (delegated_host_id < route_list_size) && (NULL != route_list[delegated_host_id]) ) { GNUNET_break_op (0); /* Are you trying to link delegated host twice * with is subordinate flag set to GNUNET_YES? */ GNUNET_SERVICE_client_drop (client); return; } new_route = GNUNET_new (struct Route); new_route->dest = delegated_host_id; new_route->thru = route->dest; route_list_add (new_route); GNUNET_SERVICE_client_continue (client); }