static void task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct sockaddr_in sa; struct sockaddr *sap[2]; socklen_t slens[2]; sap[0] = (struct sockaddr *) &sa; slens[0] = sizeof (sa); sap[1] = NULL; slens[1] = 0; memset (&sa, 0, sizeof (sa)); #if HAVE_SOCKADDR_IN_SIN_LEN sa.sin_len = sizeof (sa); #endif sa.sin_family = AF_INET; sa.sin_port = htons (PORT); server = GNUNET_SERVER_create (NULL, NULL, sap, slens, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250), GNUNET_NO); GNUNET_assert (server != NULL); handlers[0].callback_cls = cls; GNUNET_SERVER_add_handlers (server, handlers); GNUNET_SERVER_disconnect_notify (server, ¬ify_disconnect, cls); cfg = GNUNET_CONFIGURATION_create (); GNUNET_CONFIGURATION_set_value_number (cfg, "test", "PORT", PORT); GNUNET_CONFIGURATION_set_value_string (cfg, "test", "HOSTNAME", "localhost"); GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME", "localhost"); client = GNUNET_CLIENT_connect ("test", cfg); GNUNET_assert (client != NULL); test_mq (client); }
/** * First task run by the scheduler. Initializes the server and * a client and asks for a transmission from the client to the * server. * * @param cls NULL */ static void task (void *cls) { struct sockaddr_in sa; struct sockaddr *sap[2]; socklen_t slens[2]; struct GNUNET_MQ_Envelope *env; struct GNUNET_MessageHeader *msg; struct GNUNET_MQ_MessageHandler chandlers[] = { GNUNET_MQ_hd_fixed_size (reply, MY_TYPE, struct GNUNET_MessageHeader, cls), GNUNET_MQ_handler_end () }; sap[0] = (struct sockaddr *) &sa; slens[0] = sizeof (sa); sap[1] = NULL; slens[1] = 0; memset (&sa, 0, sizeof (sa)); #if HAVE_SOCKADDR_IN_SIN_LEN sa.sin_len = sizeof (sa); #endif sa.sin_family = AF_INET; sa.sin_port = htons (PORT); server = GNUNET_SERVER_create (NULL, NULL, sap, slens, TIMEOUT, GNUNET_NO); GNUNET_assert (server != NULL); GNUNET_SERVER_add_handlers (server, handlers); cfg = GNUNET_CONFIGURATION_create (); GNUNET_CONFIGURATION_set_value_number (cfg, "test-server", "PORT", PORT); GNUNET_CONFIGURATION_set_value_string (cfg, "test-server", "HOSTNAME", "localhost"); GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME", "localhost"); mq = GNUNET_CLIENT_connect (cfg, "test-server", chandlers, &mq_error_handler, NULL); GNUNET_assert (NULL != mq); ok = 2; env = GNUNET_MQ_msg (msg, MY_TYPE); GNUNET_MQ_send (mq, env); }
/** * Main function */ int main (int argc, char **argv) { struct GNUNET_CONFIGURATION_Handle *cfg; char pwd[PATH_MAX]; char *binary; uint64_t event_mask; result = GNUNET_SYSERR; event_mask = 0; cfg = GNUNET_CONFIGURATION_create (); GNUNET_assert (GNUNET_YES == GNUNET_CONFIGURATION_parse (cfg, "test_testbed_api_barriers.conf.in")); if (NULL == getcwd (pwd, PATH_MAX)) return 1; GNUNET_assert (0 < GNUNET_asprintf (&binary, "%s/%s", pwd, "gnunet-service-test-barriers")); GNUNET_CONFIGURATION_set_value_string (cfg, "test-barriers","BINARY", binary); GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_write (cfg, "test_testbed_api_barriers.conf")); GNUNET_CONFIGURATION_destroy (cfg); cfg = NULL; GNUNET_free (binary); binary = NULL; (void) GNUNET_TESTBED_test_run ("test_testbed_api_barriers", "test_testbed_api_barriers.conf", NUM_PEERS, event_mask, NULL, NULL, &test_master, NULL); (void) unlink ("test_testbed_api_barriers.conf"); if (GNUNET_OK != result) return 1; return 0; }
static char * generate_config (char *cfg_file, unsigned long long quota_in, unsigned long long quota_out) { char *networks[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString; char *in_name; char *out_name; char *fname = NULL; struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create (); int c; GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (cfg, cfg_file)); GNUNET_asprintf (&fname, "q_in_%llu_q_out_%llu_%s", quota_in, quota_out, cfg_file); GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG", fname); for (c = 0; c < GNUNET_ATS_NetworkTypeCount; c++) { GNUNET_asprintf (&in_name, "%s_QUOTA_IN", networks[c]); GNUNET_asprintf (&out_name, "%s_QUOTA_OUT", networks[c]); GNUNET_CONFIGURATION_set_value_number (cfg, "ats", in_name, quota_in); GNUNET_CONFIGURATION_set_value_number (cfg, "ats", out_name, quota_out); GNUNET_free (in_name); GNUNET_free (out_name); } GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_write (cfg, fname)); GNUNET_CONFIGURATION_destroy (cfg); return fname; }
/** * Handler for SET_DEFAULT message from client, updates * default identity for some service. * * @param cls unused * @param client who sent the message * @param message the message received */ static void handle_set_default_message (void *cls, const struct SetDefaultMessage *sdm) { struct Ego *ego; struct GNUNET_SERVICE_Client *client = cls; const char *str; str = (const char *) &sdm[1]; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received SET_DEFAULT for service `%s' from client\n", str); for (ego = ego_head; NULL != ego; ego = ego->next) { if (0 == key_cmp (ego->pk, &sdm->private_key)) { GNUNET_CONFIGURATION_set_value_string (subsystem_cfg, str, "DEFAULT_IDENTIFIER", ego->identifier); if (GNUNET_OK != GNUNET_CONFIGURATION_write (subsystem_cfg, subsystem_cfg_file)) GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Failed to write subsystem default identifier map to `%s'.\n"), subsystem_cfg_file); send_result_code (client, 0, NULL); GNUNET_SERVICE_client_continue (client); return; } } send_result_code (client, 1, _("Unknown ego specified for service (internal error)")); GNUNET_SERVICE_client_continue (client); }
/** * Process list of local IP addresses. Find and set the * one of the default interface. * * @param cls our `struct GNUNET_NAT_AutoHandle` * @param name name of the interface (can be NULL for unknown) * @param isDefault is this presumably the default interface * @param addr address of this interface (can be NULL for unknown or unassigned) * @param broadcast_addr the broadcast address (can be NULL for unknown or unassigned) * @param netmask the network mask (can be NULL for unknown or unassigned)) * @param addrlen length of the @a addr and @a broadcast_addr * @return GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort */ static int process_if (void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen) { struct GNUNET_NAT_AutoHandle *ah = cls; const struct sockaddr_in *in; char buf[INET_ADDRSTRLEN]; if ( (sizeof (struct sockaddr_in6) == addrlen) && (0 != memcmp (&in6addr_loopback, &((const struct sockaddr_in6 *) addr)->sin6_addr, sizeof (struct in6_addr))) && (! IN6_IS_ADDR_LINKLOCAL(&((const struct sockaddr_in6 *) addr)->sin6_addr)) ) { ah->have_v6 = GNUNET_YES; GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("This system has a global IPv6 address, setting IPv6 to supported.\n")); return GNUNET_OK; } if (addrlen != sizeof (struct sockaddr_in)) return GNUNET_OK; in = (const struct sockaddr_in *) addr; /* set internal IP address */ if (NULL == inet_ntop (AF_INET, &in->sin_addr, buf, sizeof (buf))) { GNUNET_break (0); return GNUNET_OK; } GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "INTERNAL_ADDRESS", buf); GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Detected internal network address `%s'.\n"), buf); ah->ret = GNUNET_NAT_ERROR_SUCCESS; /* Check if our internal IP is the same as the External detect by STUN*/ if(ah->stun_ip && (strcmp(buf, ah->stun_ip) == 0) ) { ah->internal_ip_is_public = GNUNET_YES; GNUNET_log (GNUNET_ERROR_TYPE_INFO,"A internal IP is the sameas the external"); /* No need to continue*/ return GNUNET_SYSERR; } /* no need to continue iteration if we found the default */ if (!isDefault) return GNUNET_OK; else return GNUNET_SYSERR; }
/** * Handler for SET_DEFAULT message from client, updates * default identity for some service. * * @param cls unused * @param client who sent the message * @param message the message received */ static void handle_set_default_message (void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message) { const struct GNUNET_IDENTITY_SetDefaultMessage *sdm; uint16_t size; uint16_t name_len; struct Ego *ego; const char *str; size = ntohs (message->size); if (size <= sizeof (struct GNUNET_IDENTITY_SetDefaultMessage)) { GNUNET_break (0); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } sdm = (const struct GNUNET_IDENTITY_SetDefaultMessage *) message; name_len = ntohs (sdm->name_len); GNUNET_break (0 == ntohs (sdm->reserved)); if (name_len + sizeof (struct GNUNET_IDENTITY_SetDefaultMessage) != size) { GNUNET_break (0); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } str = (const char *) &sdm[1]; if ('\0' != str[name_len - 1]) { GNUNET_break (0); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received SET_DEFAULT for service `%s' from client\n", str); for (ego = ego_head; NULL != ego; ego = ego->next) { if (0 == key_cmp (ego->pk, &sdm->private_key)) { GNUNET_CONFIGURATION_set_value_string (subsystem_cfg, str, "DEFAULT_IDENTIFIER", ego->identifier); if (GNUNET_OK != GNUNET_CONFIGURATION_write (subsystem_cfg, subsystem_cfg_file)) GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Failed to write subsystem default identifier map to `%s'.\n"), subsystem_cfg_file); send_result_code (client, 0, NULL); GNUNET_SERVER_receive_done (client, GNUNET_OK); return; } } send_result_code (client, 1, _("Unknown ego specified for service (internal error)")); GNUNET_SERVER_receive_done (client, GNUNET_OK); }
static struct GNUNET_CONFIGURATION_Handle * editConfiguration (struct GNUNET_CONFIGURATION_Handle *cfg, int option) { struct DiffsCBData diffsCB; initDiffsCBData (&diffsCB); diffsCB.cfgDiffs = GNUNET_CONFIGURATION_create (); switch (option) { case EDIT_SECTION: case EDIT_ALL: case ADD_NEW_ENTRY: diffsCB.callBackOption = option; diffsCB.cfg = cfg; GNUNET_CONFIGURATION_iterate (cfg, diffsCallBack, &diffsCB); break; case EDIT_NOTHING: /* Do nothing */ break; case ADD_NEW_SECTION: { int i; char *key; for (i = 0; i < 5; i++) { GNUNET_asprintf (&key, "key%d", i); GNUNET_CONFIGURATION_set_value_string (cfg, "new-section", key, "new-value"); GNUNET_CONFIGURATION_set_value_string (diffsCB.cfgDiffs, "new-section", key, "new-value"); GNUNET_free (key); } break; } case REMOVE_SECTION: break; case REMOVE_ENTRY: break; default: break; } return diffsCB.cfgDiffs; }
static void task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct sockaddr_un un; const char *unixpath = "/tmp/testsock"; size_t slen = strlen (unixpath); struct sockaddr *sap[2]; socklen_t slens[2]; memset (&un, 0, sizeof (un)); un.sun_family = AF_UNIX; memcpy (un.sun_path, unixpath, slen); un.sun_path[slen] = '\0'; #if HAVE_SOCKADDR_IN_SIN_LEN un.sun_len = (u_char) sizeof (un); #endif #if LINUX un.sun_path[0] = '\0'; #endif sap[0] = (struct sockaddr *) &un; slens[0] = sizeof (un); sap[1] = NULL; slens[1] = 0; server = GNUNET_SERVER_create (NULL, NULL, sap, slens, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250), GNUNET_NO); GNUNET_assert (server != NULL); handlers[0].callback_cls = cls; GNUNET_SERVER_add_handlers (server, handlers); GNUNET_SERVER_disconnect_notify (server, ¬ify_disconnect, cls); cfg = GNUNET_CONFIGURATION_create (); GNUNET_CONFIGURATION_set_value_string (cfg, "test", "UNIXPATH", unixpath); GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME", "localhost"); client = GNUNET_CLIENT_connect ("test", cfg); GNUNET_assert (client != NULL); GNUNET_CLIENT_notify_transmit_ready (client, 256, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250), GNUNET_NO, ¬ify_ready, NULL); }
int main (int argc, char *argv[]) { int ok; GNUNET_log_setup ("test_client", "WARNING", NULL); cfg = GNUNET_CONFIGURATION_create (); GNUNET_CONFIGURATION_set_value_number (cfg, MYNAME, "PORT", PORT); GNUNET_CONFIGURATION_set_value_string (cfg, MYNAME, "HOSTNAME", "localhost"); GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME", "localhost"); ok = 1; GNUNET_SCHEDULER_run (&task, &ok); GNUNET_CONFIGURATION_destroy (cfg); return ok; }
/** * Determine our local IP addresses; detect internal IP & IPv6-support * * @param ah auto setup context */ static void test_local_ip (struct GNUNET_NAT_AutoHandle *ah) { ah->have_v6 = GNUNET_NO; ah->ret = GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO; // reset to success if any of the IFs in below iterator has a valid IP GNUNET_OS_network_interfaces_list (&process_if, ah); GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "DISABLEV6", (GNUNET_YES == ah->have_v6) ? "NO" : "YES"); next_phase (ah); }
/** * Change the state of the sensor. * Write the change to file to make it persistent. * * @param sensor sensor info struct * @param state new enabled state: #GNUNET_YES / #GNUNET_NO */ static void set_sensor_enabled (struct GNUNET_SENSOR_SensorInfo *sensor, int state) { LOG (GNUNET_ERROR_TYPE_DEBUG, "Sensor `%s': Setting enabled to %d.\n", sensor->name, state); sensor->enabled = GNUNET_NO; GNUNET_assert (NULL != sensor->cfg); GNUNET_CONFIGURATION_set_value_string (sensor->cfg, sensor->name, "ENABLED", (GNUNET_YES == state) ? "YES" : "NO"); GNUNET_CONFIGURATION_write (sensor->cfg, sensor->def_file); }
/** * Set our external IPv4 address based on the UPnP. * * * @param cls closure with our setup context * @param addr the address, NULL on errors * @param emsg NULL on success, otherwise an error message */ static void set_external_ipv4 (void *cls, const struct in_addr *addr, enum GNUNET_NAT_StatusCode ret) { struct GNUNET_NAT_AutoHandle *ah = cls; char buf[INET_ADDRSTRLEN]; ah->eh = NULL; ah->ret = ret; if (GNUNET_NAT_ERROR_SUCCESS != ret) { next_phase (ah); return; } /* enable 'behind nat' */ GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Detected external IP `%s'\n"), inet_ntop (AF_INET, addr, buf, sizeof (buf))); GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "YES"); /* set external IP address */ if (NULL == inet_ntop (AF_INET, addr, buf, sizeof (buf))) { GNUNET_break (0); /* actually, this should never happen, as the caller already executed just * this check, but for consistency (eg: future changes in the caller) * we still need to report this error... */ ah->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID; next_phase (ah); return; } GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS", buf); ah->upnp_set_external_address = GNUNET_YES; next_phase (ah); }
/** * Function called with th test result to see if the resolver is * running. * * @param cls closure with our configuration * @param result #GNUNET_YES if the resolver is running */ static void resolver_test_task (void *cls, int result) { struct GNUNET_CONFIGURATION_Handle *cfg = cls; if (GNUNET_YES != result) { FPRINTF (stderr, _("Trying to connect to remote host, but service `%s' is not running\n"), "resolver"); return; } /* connect to a remote host */ if (0 == remote_port) { if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, "statistics", "PORT", &remote_port)) { FPRINTF (stderr, _("A port is required to connect to host `%s'\n"), remote_host); return; } } else if (65535 <= remote_port) { FPRINTF (stderr, _("A port has to be between 1 and 65535 to connect to host `%s'\n"), remote_host); return; } /* Manipulate configuration */ GNUNET_CONFIGURATION_set_value_string (cfg, "statistics", "UNIXPATH", ""); GNUNET_CONFIGURATION_set_value_string (cfg, "statistics", "HOSTNAME", remote_host); GNUNET_CONFIGURATION_set_value_number (cfg, "statistics", "PORT", remote_port); GNUNET_SCHEDULER_add_now (&main_task, cfg); }
static void task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct sockaddr_in sa; struct sockaddr *sap[2]; socklen_t slens[2]; sap[0] = (struct sockaddr *) &sa; slens[0] = sizeof (sa); sap[1] = NULL; slens[1] = 0; memset (&sa, 0, sizeof (sa)); #if HAVE_SOCKADDR_IN_SIN_LEN sa.sin_len = sizeof (sa); #endif sa.sin_family = AF_INET; sa.sin_port = htons (PORT); server = GNUNET_SERVER_create (NULL, NULL, sap, slens, TIMEOUT, GNUNET_NO); GNUNET_assert (server != NULL); GNUNET_SERVER_add_handlers (server, handlers); GNUNET_SERVER_disconnect_notify (server, ¬ify_disconnect, NULL); cfg = GNUNET_CONFIGURATION_create (); GNUNET_CONFIGURATION_set_value_number (cfg, "test-server", "PORT", PORT); GNUNET_CONFIGURATION_set_value_string (cfg, "test-server", "HOSTNAME", "localhost"); GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME", "localhost"); cc = GNUNET_CLIENT_connect ("test-server", cfg); GNUNET_assert (cc != NULL); GNUNET_assert (NULL != GNUNET_CLIENT_notify_transmit_ready (cc, sizeof (struct GNUNET_MessageHeader), TIMEOUT, GNUNET_YES, &transmit_initial_message, NULL)); }
int main (int argc, char *argv[]) { int ok; GNUNET_log_setup ("test_connection_timeout_no_connect", "WARNING", NULL); ok = 1; cfg = GNUNET_CONFIGURATION_create (); GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME", "localhost"); GNUNET_SCHEDULER_run (&task_timeout, &ok); GNUNET_CONFIGURATION_destroy (cfg); return ok; }
/** * Function to iterate over sugested changes options * * @param cls closure * @param section name of the section * @param option name of the option * @param value value of the option */ static void auto_conf_iter (void *cls, const char *section, const char *option, const char *value) { struct GNUNET_CONFIGURATION_Handle *new_cfg = cls; PRINTF ("%s: %s\n", option, value); if (NULL != new_cfg) GNUNET_CONFIGURATION_set_value_string (new_cfg, section, option, value); }
/** * Load configuration (starts with defaults, then loads * system-specific configuration). * * @param cfg configuration to update * @param filename name of the configuration file, NULL to load defaults * @return #GNUNET_OK on success, #GNUNET_SYSERR on error */ int GNUNET_CONFIGURATION_load (struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename) { char *baseconfig; const char *base_config_varname; base_config_varname = GNUNET_OS_project_data_get ()->base_config_varname; if (NULL != (baseconfig = getenv (base_config_varname))) { baseconfig = GNUNET_strdup (baseconfig); } else { char *ipath; ipath = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR); if (NULL == ipath) return GNUNET_SYSERR; GNUNET_asprintf (&baseconfig, "%s%s", ipath, "config.d"); GNUNET_free (ipath); } if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load_from (cfg, baseconfig)) { GNUNET_free (baseconfig); return GNUNET_SYSERR; /* no configuration at all found */ } GNUNET_free (baseconfig); if ((NULL != filename) && (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg, filename))) { /* specified configuration not found */ return GNUNET_SYSERR; } if (((GNUNET_YES != GNUNET_CONFIGURATION_have_value (cfg, "PATHS", "DEFAULTCONFIG"))) && (filename != NULL)) GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG", filename); return GNUNET_OK; }
static char * generate_config (char *cfg_file, unsigned long long quota_in, unsigned long long quota_out) { char *fname = NULL; struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create (); GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (cfg, cfg_file)); GNUNET_asprintf (&fname, "q_in_%llu_q_out_%llu_%s", quota_in, quota_out, cfg_file); GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG", fname); GNUNET_CONFIGURATION_set_value_number (cfg, "ats", "WAN_QUOTA_IN", quota_in); GNUNET_CONFIGURATION_set_value_number (cfg, "ats", "WAN_QUOTA_OUT", quota_out); GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_write (cfg, fname)); GNUNET_CONFIGURATION_destroy (cfg); return fname; }
/** * Function called by NAT to report the outcome of the nat-test. * Clean up and update GUI. * * @param cls the auto handle * @param success currently always #GNUNET_OK * @param emsg NULL on success, otherwise an error message */ static void result_callback (void *cls, enum GNUNET_NAT_StatusCode ret) { struct GNUNET_NAT_AutoHandle *ah = cls; if (GNUNET_NAT_ERROR_SUCCESS == ret) GNUNET_NAT_test_stop (ah->tst); ah->tst = NULL; ah->ret = ret; GNUNET_log (GNUNET_ERROR_TYPE_INFO, GNUNET_NAT_ERROR_SUCCESS == ret ? _("NAT traversal with ICMP Server succeeded.\n") : _("NAT traversal with ICMP Server failed.\n")); GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_ICMP_SERVER", GNUNET_NAT_ERROR_SUCCESS == ret ? "NO" : "YES"); next_phase (ah); }
static int init () { struct GNUNET_CONFIGURATION_Handle *cfg; char pwd[PATH_MAX]; char *binary; cfg = GNUNET_CONFIGURATION_create (); if (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg, "test_arm_api_data.conf")) return GNUNET_SYSERR; if (NULL == getcwd (pwd, PATH_MAX)) return GNUNET_SYSERR; GNUNET_assert (0 < GNUNET_asprintf (&binary, "%s/%s", pwd, BINARY)); GNUNET_CONFIGURATION_set_value_string (cfg, SERVICE, "BINARY", binary); GNUNET_free (binary); if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg, CFGFILENAME)) { GNUNET_CONFIGURATION_destroy (cfg); return GNUNET_SYSERR; } GNUNET_CONFIGURATION_destroy (cfg); #if LOG_BACKOFF killLogFileName = GNUNET_DISK_mktemp ("exponential-backoff-waiting.log"); if (NULL == (killLogFilePtr = FOPEN (killLogFileName, "w"))) { GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fopen", killLogFileName); GNUNET_free (killLogFileName); return GNUNET_SYSERR; } #endif return GNUNET_OK; }
/** * run: load configuration options and schedule test to run (start peergroup) * @param cls closure * @param args argv * @param cfgfile configuration file name (can be NULL) * @param cfg configuration handle */ static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg) { struct GNUNET_TESTING_Host *hosts; ok = GNUNET_NO; total_connections = 0; failed_connections = 0; testing_cfg = GNUNET_CONFIGURATION_dup (cfg); GNUNET_log_setup ("test_testing_2dtorus", #if VERBOSE "DEBUG", #else "WARNING", #endif NULL); #if VERBOSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Starting daemons.\n"); GNUNET_CONFIGURATION_set_value_string (testing_cfg, "testing", "use_progressbars", "YES"); #endif if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (testing_cfg, "testing", "num_peers", &num_peers)) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Option TESTING:NUM_PEERS is required!\n"); return; } hosts = GNUNET_TESTING_hosts_load (testing_cfg); pg = GNUNET_TESTING_peergroup_start (testing_cfg, num_peers, TIMEOUT, &connect_cb, &peergroup_ready, NULL, hosts); GNUNET_assert (pg != NULL); shutdown_handle = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task, NULL); }
static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg) { struct GNUNET_CONFIGURATION_Handle *testing_cfg; ok = 1; testing_cfg = GNUNET_CONFIGURATION_create (); GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (testing_cfg, cfgfile)); #if VERBOSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemons.\n"); GNUNET_CONFIGURATION_set_value_string (testing_cfg, "testing", "use_progressbars", "YES"); #endif peers_left = NUM_PEERS; pg = GNUNET_TESTING_peergroup_start (testing_cfg, peers_left, TIMEOUT, NULL, &my_cb, NULL, NULL); GNUNET_assert (pg != NULL); }
/** * Functions with this signature are called whenever a * complete message is received by the tokenizer. * * Do not call GNUNET_SERVER_mst_destroy in callback * * @param cls closure * @param client identification of the client * @param message the actual message * * @return GNUNET_OK on success, GNUNET_SYSERR to stop further processing */ static int helper_mst (void *cls, void *client, const struct GNUNET_MessageHeader *message) { struct GNUNET_TESTBED_ControllerProc *cp = cls; const struct GNUNET_TESTBED_HelperReply *msg; const char *hostname; char *config; uLongf config_size; uLongf xconfig_size; msg = (const struct GNUNET_TESTBED_HelperReply *) message; GNUNET_assert (sizeof (struct GNUNET_TESTBED_HelperReply) < ntohs (msg->header.size)); GNUNET_assert (GNUNET_MESSAGE_TYPE_TESTBED_HELPER_REPLY == ntohs (msg->header.type)); config_size = (uLongf) ntohs (msg->config_size); xconfig_size = (uLongf) (ntohs (msg->header.size) - sizeof (struct GNUNET_TESTBED_HelperReply)); config = GNUNET_malloc (config_size); GNUNET_assert (Z_OK == uncompress ((Bytef *) config, &config_size, (const Bytef *) &msg[1], xconfig_size)); /* Replace the configuration template present in the host with the controller's running configuration */ GNUNET_CONFIGURATION_destroy (cp->host->cfg); cp->host->cfg = GNUNET_CONFIGURATION_create (); GNUNET_assert (GNUNET_CONFIGURATION_deserialize (cp->host->cfg, config, config_size, GNUNET_NO)); GNUNET_free (config); if (NULL == (hostname = GNUNET_TESTBED_host_get_hostname (cp->host))) hostname = "localhost"; /* Change the hostname so that we can connect to it */ GNUNET_CONFIGURATION_set_value_string (cp->host->cfg, "testbed", "hostname", hostname); cp->host->locked = GNUNET_NO; cp->host->controller_started = GNUNET_YES; cp->cb (cp->cls, cp->host->cfg, GNUNET_OK); return GNUNET_OK; }
/** * Start auto-configuration routine. The resolver service should * be available when this function is called. * * @param cfg initial configuration * @param cb function to call with autoconfiguration result * @param cb_cls closure for @a cb * @return handle to cancel operation */ struct GNUNET_NAT_AutoHandle * GNUNET_NAT_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_NAT_AutoResultCallback cb, void *cb_cls) { struct GNUNET_NAT_AutoHandle *ah; ah = GNUNET_new (struct GNUNET_NAT_AutoHandle); ah->fin_cb = cb; ah->fin_cb_cls = cb_cls; ah->ret = GNUNET_NAT_ERROR_SUCCESS; ah->cfg = GNUNET_CONFIGURATION_dup (cfg); ah->initial_cfg = GNUNET_CONFIGURATION_dup (cfg); /* never use loopback addresses if user wanted autoconfiguration */ GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "USE_LOCALADDR", "NO"); next_phase (ah); return ah; }
/** * Test if UPnPC works. * * @param ah auto setup context */ static void test_upnpc (struct GNUNET_NAT_AutoHandle *ah) { int have_upnpc; if (GNUNET_NAT_ERROR_SUCCESS != ah->ret) next_phase (ah); // test if upnpc is available have_upnpc = (GNUNET_SYSERR != GNUNET_OS_check_helper_binary ("upnpc", GNUNET_NO, NULL)); //FIXME: test if upnpc is actually working, that is, if transports start to work once we use UPnP GNUNET_log (GNUNET_ERROR_TYPE_INFO, (have_upnpc) ? _("upnpc found, enabling its use\n") : _("upnpc not found\n")); GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_UPNP", (GNUNET_YES == have_upnpc) ? "YES" : "NO"); next_phase (ah); }
/** * An ego was removed, remove it from all subsystems where it is * currently set as the default. * * @param cls name of the removed ego (const char *) * @param section a section in the configuration to process */ static void handle_ego_delete (void *cls, const char *section) { const char *identifier = cls; char *id; if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (subsystem_cfg, section, "DEFAULT_IDENTIFIER", &id)) return; if (0 != strcmp (id, identifier)) { GNUNET_free (id); return; } GNUNET_CONFIGURATION_set_value_string (subsystem_cfg, section, "DEFAULT_IDENTIFIER", NULL); GNUNET_free (id); }
/** * An ego was renamed; rename it in all subsystems where it is * currently set as the default. * * @param cls the 'struct RenameContext' * @param section a section in the configuration to process */ static void handle_ego_rename (void *cls, const char *section) { struct RenameContext *rc = cls; char *id; if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (subsystem_cfg, section, "DEFAULT_IDENTIFIER", &id)) return; if (0 != strcmp (id, rc->old_name)) { GNUNET_free (id); return; } GNUNET_CONFIGURATION_set_value_string (subsystem_cfg, section, "DEFAULT_IDENTIFIER", rc->new_name); GNUNET_free (id); }
int main (int argc, char *argv[]) { int ok; int status; const char *socksport = "1081"; GNUNET_log_setup ("test_client", "WARNING", NULL); pid_t pid = fork(); GNUNET_assert (pid >= 0); if (pid == 0) { execlp ("ssh", "ssh","-D",socksport, "-o","BatchMode yes", "-o","UserKnownHostsFile /tmp/gnunet_test_socks_ssh_garbage", "-o","StrictHostKeyChecking no", "127.0.0.1","-N",(char*)NULL); perror ("execlp (\"ssh\",\"ssh\",...,\"-D\",\"1081\",\"127.0.0.1\",\"-N\") "); printf ("" "Please ensure you have ssh installed and have sshd installed and running :\n" "\tsudo apt-get install openssh-client openssh-server\n" "If you run Tor as a network proxy then Tor might prevent ssh from connecting\n" "to localhost. Please either run make check from an unproxied user, or else\n" "add these lines to the beginning of your ~/.ssh/config file :" "\tHost 127.0.0.1 localhost\n" "\t CheckHostIP no\n" "\t Protocol 2\n" "\t ProxyCommand nc 127.0.0.1 22\n"); kill (getppid(), SIGALRM); return 1; } if (0 != sleep (1)) { /* sleep interrupted, likely SIGALRM, failure to launch child, terminate */ printf ("" "Please ensure you have ssh installed and have sshd installed and running :\n" "\tsudo apt-get install openssh-client openssh-server\n" "If you run Tor as a network proxy then Tor might prevent ssh from connecting\n" "to localhost. Please either run make check from an unproxied user, or else\n" "add these lines to the beginning of your ~/.ssh/config file :" "\tHost 127.0.0.1 localhost\n" "\t CheckHostIP no\n" "\t Protocol 2\n" "\t ProxyCommand nc 127.0.0.1 22\n"); return 77; } /* check if child exec()ed but died */ if (0 != waitpid (pid, &status, WNOHANG)) { printf ("" "If you run Tor as a network proxy then Tor might prevent ssh from connecting\n" "to localhost. Please either run make check from an unproxied user, or else\n" "add these lines to the beginning of your ~/.ssh/config file :" "\tHost 127.0.0.1 localhost\n" "\t CheckHostIP no\n" "\t Protocol 2\n" "\t ProxyCommand nc 127.0.0.1 22\n"); return 77; } cfg = GNUNET_CONFIGURATION_create (); GNUNET_CONFIGURATION_set_value_string (cfg, MYNAME, "SOCKSHOST", "127.0.0.1"); GNUNET_CONFIGURATION_set_value_string (cfg, MYNAME, "SOCKSPORT", socksport); GNUNET_CONFIGURATION_set_value_number (cfg, MYNAME, "PORT", PORT); GNUNET_CONFIGURATION_set_value_string (cfg, MYNAME, "HOSTNAME", "127.0.0.1"); ok = 1; GNUNET_SCHEDULER_run (&task, &ok); GNUNET_CONFIGURATION_destroy (cfg); GNUNET_break (0 == kill (pid, SIGTERM)); GNUNET_break (pid == waitpid (pid, &status, 0)); return ok; }
/** * Function called with the result from the autoconfiguration. * * @param cls closure * @param diff minimal suggested changes to the original configuration * to make it work (as best as we can) * @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code * @param type what the situation of the NAT */ static void auto_config_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *diff, enum GNUNET_NAT_StatusCode result, enum GNUNET_NAT_Type type) { const char *nat_type; char unknown_type[64]; struct GNUNET_CONFIGURATION_Handle *new_cfg; ah = NULL; switch (type) { case GNUNET_NAT_TYPE_NO_NAT: nat_type = "NO NAT"; break; case GNUNET_NAT_TYPE_UNREACHABLE_NAT: nat_type = "NAT but we can traverse"; break; case GNUNET_NAT_TYPE_STUN_PUNCHED_NAT: nat_type = "NAT but STUN is able to identify the correct information"; break; case GNUNET_NAT_TYPE_UPNP_NAT: nat_type = "NAT but UPNP opened the ports"; break; default: SPRINTF (unknown_type, "NAT unknown, type %u", type); nat_type = unknown_type; break; } GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "NAT status: %s/%s\n", GNUNET_NAT_AUTO_status2string (result), nat_type); /* Shortcut: if there are no changes suggested, bail out early. */ if (GNUNET_NO == GNUNET_CONFIGURATION_is_dirty (diff)) { test_finished (); return; } /* Apply diff to original configuration and show changes to the user */ new_cfg = write_cfg ? GNUNET_CONFIGURATION_dup (cfg) : NULL; if (NULL != diff) { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, _("Suggested configuration changes:\n")); GNUNET_CONFIGURATION_iterate_section_values (diff, "nat", &auto_conf_iter, new_cfg); } /* If desired, write configuration to file; we write only the changes to the defaults to keep things compact. */ if ( (write_cfg) && (NULL != diff) ) { struct GNUNET_CONFIGURATION_Handle *def_cfg; GNUNET_CONFIGURATION_set_value_string (new_cfg, "ARM", "CONFIG", NULL); def_cfg = GNUNET_CONFIGURATION_create (); GNUNET_break (GNUNET_OK == GNUNET_CONFIGURATION_load (def_cfg, NULL)); if (GNUNET_OK != GNUNET_CONFIGURATION_write_diffs (def_cfg, new_cfg, cfg_file)) { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, _("Failed to write configuration to `%s'\n"), cfg_file); global_ret = 1; } else { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, _("Wrote updated configuration to `%s'\n"), cfg_file); } GNUNET_CONFIGURATION_destroy (def_cfg); } if (NULL != new_cfg) GNUNET_CONFIGURATION_destroy (new_cfg); test_finished (); }