/** * 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 cfg configuration */ static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg) { if ( (NULL == set_subsystem) ^ (NULL == set_ego) ) { fprintf (stderr, "Options -e and -s must always be specified together\n"); return; } sh = GNUNET_IDENTITY_connect (cfg, &print_ego, NULL); if (NULL != delete_ego) delete_op = GNUNET_IDENTITY_delete (sh, delete_ego, &delete_finished, &delete_op); if (NULL != create_ego) create_op = GNUNET_IDENTITY_create (sh, create_ego, &create_finished, &create_op); GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); test_finished (); }
void Service::start() { auto& eth0 = net::Super_stack::get<net::IP4>(0); auto& eth1 = net::Super_stack::get<net::IP4>(1); net::setup_vlans(); auto& vlan0_2 = net::Super_stack::get<net::IP4>(0,2); auto& vlan0_42 = net::Super_stack::get<net::IP4>(0,42); auto& vlan1_2 = net::Super_stack::get<net::IP4>(1,2); auto& vlan1_42 = net::Super_stack::get<net::IP4>(1,42); eth0.tcp().listen(80, [](auto conn) { printf("Received connection %s\n", conn->to_string().c_str()); test_finished(); }); vlan0_2.tcp().listen(80, [](auto conn) { printf("Received connection %s\n", conn->to_string().c_str()); test_finished(); }); vlan1_42.tcp().listen(80, [](auto conn) { printf("Received connection %s\n", conn->to_string().c_str()); test_finished(); }); eth1.tcp().connect({eth0.ip_addr(), 80}, [](auto conn) { CHECKSERT(conn != nullptr, "eth0 can connect to eth1"); printf("Connected to %s\n", conn->to_string().c_str()); }); vlan1_2.tcp().connect({vlan0_2.ip_addr(), 80}, [](auto conn) { CHECKSERT(conn != nullptr, "VLAN 2 can connect to peer inside the same VLAN"); printf("Connected to %s\n", conn->to_string().c_str()); }); vlan0_42.tcp().connect({vlan1_42.ip_addr(), 80}, [](auto conn) { CHECKSERT(conn != nullptr, "VLAN 42 can connect to to peer inside the same VLAN"); printf("Connected to %s\n", conn->to_string().c_str()); }); }
/** * Function called to report success or failure for * NAT configuration test. * * @param cls closure * @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code */ static void test_report_cb (void *cls, enum GNUNET_NAT_StatusCode result) { nt = NULL; PRINTF ("NAT test result: %s\n", GNUNET_NAT_AUTO_status2string (result)); test_finished (); }
/** * Function called by #GNUNET_IDENTITY_set up on completion. * * @param cls NULL * @param emsg error message (NULL on success) */ static void set_done (void *cls, const char *emsg) { set_op = NULL; if (NULL != emsg) fprintf (stderr, _("Failed to set default ego: %s\n"), emsg); test_finished (); }
/** * Creation operation finished. * * @param cls pointer to operation handle * @param emsg error message, NULL on success */ static void create_finished (void *cls, const char *emsg) { struct GNUNET_IDENTITY_Operation **op = cls; *op = NULL; if (NULL != emsg) fprintf (stderr, _("Failed to create ego: %s\n"), emsg); test_finished (); }
/** * Deletion operation finished. * * @param cls pointer to operation handle * @param emsg NULL on success, otherwise an error message */ static void delete_finished (void *cls, const char *emsg) { struct GNUNET_IDENTITY_Operation **op = cls; *op = NULL; if (NULL != emsg) fprintf (stderr, "%s\n", gettext (emsg)); test_finished (); }
/*************************************************************************************************** * * * PRE-TEST SETUP OF EXPECTED RESULTS * * * ***************************************************************************************************/ int do_test() { int i; init_testevents(); DEFINE_TESTEVENT("Before StartOS"); #ifdef USESTARTUPHOOK DEFINE_TESTEVENT("StartupHook"); #endif /* TaskA and TaskB are autostarted. TaskB is higher priority than TaskB so should run first */ #ifdef USEPRETASKHOOK DEFINE_TESTEVENT("PreTaskHook"); DEFINE_TESTEVENT("Main"); #endif DEFINE_TESTEVENT("Start Main"); #ifdef USESTACKMONITORING #ifdef TEST_BASIC_STACKOVERFLOW define_task_switch(Main, TaskBasic); DEFINE_TESTEVENT("Start TaskBasic"); #endif #ifdef TEST_EXTENDED_STACKOVERFLOW define_task_switch(Main, TaskExtended); DEFINE_TESTEVENT("Start TaskExtended"); #endif #ifdef TEST_ISR_STACKOVERFLOW DEFINE_TESTEVENT("Start ISRX"); #endif #endif #ifdef USESHUTDOWNHOOK DEFINE_TESTEVENT("ShutdownHook"); #endif /************************************************************************************************ *************************BEGIN TEST AND CHECK AGAINST EXPECTED RESULTS************************** ************************************************************************************************ */ SET_TESTEVENT("Before StartOS"); StartOS(OSDEFAULTAPPMODE); test_finished(); return 0; }
/** * Function called with the result of our attempt to obtain a name for a given * public key. * * @param cls NULL * @param zone private key of the zone; NULL on disconnect * @param label label of the records; NULL on disconnect * @param rd_count number of entries in @a rd array, 0 if label was deleted * @param rd array of records with data to store */ static void handle_reverse_lookup (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd) { reverse_qe = NULL; if (NULL == label) FPRINTF (stdout, "%s.zkey\n", reverse_pkey); else FPRINTF (stdout, "%s.gnu\n", label); test_finished (); }
/** * Main function that will be run. * * @param cls closure * @param args remaining command-line arguments * @param cfgfile name of the configuration file used (for saving, can be NULL!) * @param c configuration */ static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c) { cfg_file = cfgfile; cfg = c; GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); if (do_auto) { ah = GNUNET_NAT_AUTO_autoconfig_start (c, &auto_config_cb, NULL); } if (use_tcp && use_udp) { if (do_auto) return; GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Cannot use TCP and UDP\n"); global_ret = 1; return; } proto = 0; if (use_tcp) proto = IPPROTO_TCP; if (use_udp) proto = IPPROTO_UDP; if (NULL != section_name) { nt = GNUNET_NAT_AUTO_test_start (c, proto, section_name, &test_report_cb, NULL); } test_finished (); }
/** * Continuation called to notify client about result of the * operation. * * @param cls closure, location of the QueueEntry pointer to NULL out * @param success #GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate) * #GNUNET_NO if content was already there * #GNUNET_YES (or other positive value) on success * @param emsg NULL on success, otherwise an error message */ static void add_continuation (void *cls, int32_t success, const char *emsg) { struct GNUNET_NAMESTORE_QueueEntry **qe = cls; *qe = NULL; if (GNUNET_YES != success) { fprintf (stderr, _("Adding record failed: %s\n"), (GNUNET_NO == success) ? "record exists" : emsg); if (GNUNET_NO != success) ret = 1; } ret = 0; test_finished (); }
/** * Continuation called to notify client about result of the * operation. * * @param cls closure, unused * @param success #GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate) * #GNUNET_NO if content was already there * #GNUNET_YES (or other positive value) on success * @param emsg NULL on success, otherwise an error message */ static void del_continuation (void *cls, int32_t success, const char *emsg) { del_qe = NULL; if (GNUNET_NO == success) { fprintf (stderr, _("Deleting record failed, record does not exist%s%s\n"), (NULL != emsg) ? ": " : "", (NULL != emsg) ? emsg : ""); } if (GNUNET_SYSERR == success) { fprintf (stderr, _("Deleting record failed%s%s\n"), (NULL != emsg) ? ": " : "", (NULL != emsg) ? emsg : ""); } test_finished (); }
// check if test with one specific delay is finished int Responder::test_step_finished(uint64_t trigger_count, uint64_t num_total_samps_test, STATS statsCurrent, size_t success_count) { if ( ((_opt.test_iterations_is_sample_count == false) && (trigger_count >= _opt.test_iterations)) || ((_opt.test_iterations_is_sample_count) && (num_total_samps_test > _opt.test_iterations)) ) { add_stats_to_results(statsCurrent, _delay); if (statsCurrent.missed == 0) // == NO late bursts ++success_count; else success_count = 0; if(test_finished(success_count) ) return -2; // test is completely finished _delay += _delay_step; // increase delay by one step update_and_print_parameters(statsCurrent, _delay); return success_count; // test is finished for one delay step } return -1; // == continue test }
/* Standard shutdown hook * * $Req: artf1227 $ */ void ShutdownHook(StatusType error) { #ifdef USESHUTDOWNHOOK SET_TESTEVENT("ShutdownHook"); /* Check that the status passed to ShutdownOS() gets passed to this hook. * * $Req: artf1218 $ */ if(test_shutdown_code && error != shutdown_code) { test_failed(OS_HERE); } /* Check that the system shuts down if a stack overflow detected (when expected). * * $Req: artf1040 $ */ if(test_shutdown_code && error == shutdown_code && error == E_OS_STACKFAULT) { test_finished(); test_passed(); } #else test_failed(OS_HERE); #endif }
/*************************************************************************************************** * * * PRE-TEST SETUP OF EXPECTED RESULTS * * * ***************************************************************************************************/ int do_test() { int i; init_testevents(); first_run_TaskJ = 1; DEFINE_TESTEVENT("Before StartOS"); #ifdef USESTARTUPHOOK DEFINE_TESTEVENT("StartupHook"); #endif /* TaskA and TaskB are autostarted. TaskB is higher priority than TaskB so should run first */ #ifdef USEPRETASKHOOK DEFINE_TESTEVENT("PreTaskHook"); DEFINE_TESTEVENT("TaskB"); #endif DEFINE_TESTEVENT("Start B"); DEFINE_TESTEVENT("Unlock resource to switch to C"); define_task_switch(TaskB, TaskC); DEFINE_TESTEVENT("Start C"); DEFINE_TESTEVENT("End C"); define_task_switch(TaskC, TaskB); DEFINE_TESTEVENT("Back in B (1)"); DEFINE_TESTEVENT("Still in B (1)"); define_task_switch(TaskB, TaskC); DEFINE_TESTEVENT("Start C"); DEFINE_TESTEVENT("End C"); define_task_switch(TaskC, TaskB); DEFINE_TESTEVENT("Back in B (2)"); DEFINE_TESTEVENT("Still in B (2)"); define_task_switch(TaskB, TaskC); DEFINE_TESTEVENT("Start C"); DEFINE_TESTEVENT("End C"); define_task_switch(TaskC, TaskB); DEFINE_TESTEVENT("Back in B (3)"); DEFINE_TESTEVENT("Still in B (3)"); DEFINE_TESTEVENT("Start X"); DEFINE_TESTEVENT("End X"); define_task_switch(TaskB, TaskC); DEFINE_TESTEVENT("Start C"); DEFINE_TESTEVENT("End C"); define_task_switch(TaskC, TaskB); DEFINE_TESTEVENT("Back in B (4)"); DEFINE_TESTEVENT("Still in B (4)"); if(cat1_interrupts_cat2()) { DEFINE_TESTEVENT("Running cat1"); } DEFINE_TESTEVENT("Still in B (4a)"); if(!cat1_interrupts_cat2()) { DEFINE_TESTEVENT("Running cat1"); } DEFINE_TESTEVENT("Start X"); DEFINE_TESTEVENT("End X"); define_task_switch(TaskB, TaskC); DEFINE_TESTEVENT("Start C"); DEFINE_TESTEVENT("End C"); define_task_switch(TaskC, TaskB); DEFINE_TESTEVENT("Back in B (5)"); DEFINE_TESTEVENT("Still in B (5)"); DEFINE_TESTEVENT("Resuming OS interrupts"); DEFINE_TESTEVENT("Resuming all interrupts"); if(cat1_interrupts_cat2() || cat1_precedes_cat2()) { DEFINE_TESTEVENT("Running cat1"); DEFINE_TESTEVENT("Start X"); DEFINE_TESTEVENT("End X"); define_task_switch(TaskB, TaskC); } else { DEFINE_TESTEVENT("Start X"); DEFINE_TESTEVENT("End X"); define_task_switch(TaskB, TaskC); DEFINE_TESTEVENT("Running cat1"); } DEFINE_TESTEVENT("Start C"); DEFINE_TESTEVENT("End C"); define_task_switch(TaskC, TaskB); DEFINE_TESTEVENT("Back in B (6)"); DEFINE_TESTEVENT("Still in B (6)"); DEFINE_TESTEVENT("Resuming OS interrupts"); DEFINE_TESTEVENT("Enabling all interrupts"); if(cat1_interrupts_cat2() || cat1_precedes_cat2()) { DEFINE_TESTEVENT("Running cat1"); DEFINE_TESTEVENT("Start X"); DEFINE_TESTEVENT("End X"); define_task_switch(TaskB, TaskC); } else { DEFINE_TESTEVENT("Start X"); DEFINE_TESTEVENT("End X"); define_task_switch(TaskB, TaskC); DEFINE_TESTEVENT("Running cat1"); } define_task_switch(TaskB, TaskC); DEFINE_TESTEVENT("Start C"); DEFINE_TESTEVENT("End C"); define_task_switch(TaskC, TaskB); DEFINE_TESTEVENT("Back in B (7)"); DEFINE_TESTEVENT("End B"); define_task_switch(TaskB, TaskJ); DEFINE_TESTEVENT("Start J"); DEFINE_TESTEVENT("Chain J"); define_task_switch(TaskJ, TaskI); DEFINE_TESTEVENT("Start I"); DEFINE_TESTEVENT("End I"); define_task_switch(TaskI, TaskJ); define_task_switch(TaskJ, TaskJ); DEFINE_TESTEVENT("Start J"); DEFINE_TESTEVENT("End J"); define_task_switch(TaskJ, TaskA); DEFINE_TESTEVENT("Start A"); DEFINE_TESTEVENT("Activating D"); define_task_switch(TaskA, TaskD); DEFINE_TESTEVENT("Start D"); DEFINE_TESTEVENT("Activate E"); DEFINE_TESTEVENT("D continues"); define_task_switch(TaskD, TaskE); DEFINE_TESTEVENT("Start E"); DEFINE_TESTEVENT("End E"); define_task_switch(TaskE, TaskD); DEFINE_TESTEVENT("Back in D"); DEFINE_TESTEVENT("End D"); define_task_switch(TaskD, TaskE); DEFINE_TESTEVENT("Start E"); DEFINE_TESTEVENT("End E"); define_task_switch(TaskE, TaskA); DEFINE_TESTEVENT("Activating F"); define_task_switch(TaskA, TaskF); DEFINE_TESTEVENT("Start F"); DEFINE_TESTEVENT("F continues"); define_task_switch(TaskF, TaskE); DEFINE_TESTEVENT("Start E"); DEFINE_TESTEVENT("End E"); define_task_switch(TaskE, TaskF); DEFINE_TESTEVENT("End F"); define_task_switch(TaskF, TaskA); DEFINE_TESTEVENT("Back in A (1)"); #ifndef OPTIMIZED_QUEUEING DEFINE_TESTEVENT("Activating G and H"); #endif DEFINE_TESTEVENT("Activating I"); DEFINE_TESTEVENT("Letting go of scheduler"); define_task_switch(TaskA, TaskI); DEFINE_TESTEVENT("Start I"); DEFINE_TESTEVENT("End I"); define_task_switch(TaskI, TaskI); DEFINE_TESTEVENT("Start I"); DEFINE_TESTEVENT("End I"); define_task_switch(TaskI, TaskI); DEFINE_TESTEVENT("Start I"); DEFINE_TESTEVENT("End I"); define_task_switch(TaskI, TaskI); DEFINE_TESTEVENT("Start I"); DEFINE_TESTEVENT("End I"); define_task_switch(TaskI, TaskI); /* 5th run of TaskI */ DEFINE_TESTEVENT("Start I"); DEFINE_TESTEVENT("End I"); #ifndef OPTIMIZED_QUEUEING define_task_switch(TaskI, TaskG); /* 1st run of TaskG */ DEFINE_TESTEVENT("Start G"); DEFINE_TESTEVENT("End G"); define_task_switch(TaskG, TaskH); DEFINE_TESTEVENT("Start H"); DEFINE_TESTEVENT("End H"); define_task_switch(TaskH, TaskG); /* 2nd run of TaskG */ DEFINE_TESTEVENT("Start G"); DEFINE_TESTEVENT("End G"); define_task_switch(TaskG, TaskH); DEFINE_TESTEVENT("Start H"); DEFINE_TESTEVENT("End H"); define_task_switch(TaskH, TaskH); DEFINE_TESTEVENT("Start H"); DEFINE_TESTEVENT("End H"); define_task_switch(TaskH, TaskH); DEFINE_TESTEVENT("Start H"); DEFINE_TESTEVENT("End H"); define_task_switch(TaskH, TaskH); DEFINE_TESTEVENT("Start H"); DEFINE_TESTEVENT("End H"); define_task_switch(TaskH, TaskH); DEFINE_TESTEVENT("Start H"); DEFINE_TESTEVENT("End H"); define_task_switch(TaskH, TaskH); /* 7th run of TaskH */ DEFINE_TESTEVENT("Start H"); DEFINE_TESTEVENT("End H"); define_task_switch(TaskH, TaskG); /* 3rd run of TaskG */ DEFINE_TESTEVENT("Start G"); DEFINE_TESTEVENT("End G"); define_task_switch(TaskG, TaskA); #else /* non-optimized queueing */ define_task_switch(TaskI, TaskA); #endif DEFINE_TESTEVENT("Back in A (2)"); #ifndef OPTIMIZED_QUEUEING DEFINE_TESTEVENT("Bulk activations"); for(i = 0; i < 7; i++) { DEFINE_TESTEVENT("Phase start"); DEFINE_TESTEVENT("Activating G and H"); DEFINE_TESTEVENT("Activating I"); DEFINE_TESTEVENT("Activating C"); define_task_switch(TaskA, TaskI); DEFINE_TESTEVENT("Start I"); DEFINE_TESTEVENT("End I"); define_task_switch(TaskI, TaskI); DEFINE_TESTEVENT("Start I"); DEFINE_TESTEVENT("End I"); define_task_switch(TaskI, TaskG); DEFINE_TESTEVENT("Start G"); DEFINE_TESTEVENT("End G"); define_task_switch(TaskG, TaskH); DEFINE_TESTEVENT("Start H"); DEFINE_TESTEVENT("End H"); define_task_switch(TaskH, TaskG); DEFINE_TESTEVENT("Start G"); DEFINE_TESTEVENT("End G"); define_task_switch(TaskG, TaskC); DEFINE_TESTEVENT("Start C"); DEFINE_TESTEVENT("End C"); define_task_switch(TaskC, TaskA); DEFINE_TESTEVENT("Phase end"); } #endif DEFINE_TESTEVENT("End A"); DEFINE_TESTEVENT("Calling ShutdownOS"); #ifdef USESHUTDOWNHOOK DEFINE_TESTEVENT("ShutdownHook"); #endif DEFINE_TESTEVENT("After StartOS"); #undef DEFINE_TESTEVENT /************************************************************************************************ *************************BEGIN TEST AND CHECK AGAINST EXPECTED RESULTS************************** ************************************************************************************************ */ SET_TESTEVENT("Before StartOS"); StartOS(OSDEFAULTAPPMODE); /* Call returns after ShutDownOS() called. * * $Req: artf1219 $ * $Req: artf1217 $ */ SET_TESTEVENT("After StartOS"); test_finished(); return 0; }
/** * 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 (); }
/** * We were asked to delete something; this function is called with * the existing records. Now we should determine what should be * deleted and then issue the deletion operation. * * @param cls NULL * @param zone private key of the zone we are deleting from * @param label name of the records we are editing * @param rd_count size of the @a rd array * @param rd existing records */ static void del_monitor (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd) { struct GNUNET_GNSRECORD_Data rdx[rd_count]; unsigned int rd_left; unsigned int i; uint32_t type; char *vs; del_qe = NULL; if (0 == rd_count) { FPRINTF (stderr, _("There are no records under label `%s' that could be deleted.\n"), label); test_finished (); return; } if ( (NULL == value) && (NULL == typestring) ) { /* delete everything */ del_qe = GNUNET_NAMESTORE_records_store (ns, &zone_pkey, name, 0, NULL, &del_continuation, NULL); return; } rd_left = 0; if (NULL != typestring) type = GNUNET_GNSRECORD_typename_to_number (typestring); else type = GNUNET_GNSRECORD_TYPE_ANY; for (i=0;i<rd_count;i++) { vs = NULL; if (! ( ( (GNUNET_GNSRECORD_TYPE_ANY == type) || (rd[i].record_type == type) ) && ( (NULL == value) || (NULL == (vs = (GNUNET_GNSRECORD_value_to_string (rd[i].record_type, rd[i].data, rd[i].data_size)))) || (0 == strcmp (vs, value)) ) ) ) rdx[rd_left++] = rd[i]; GNUNET_free_non_null (vs); } if (rd_count == rd_left) { /* nothing got deleted */ FPRINTF (stderr, _("There are no records under label `%s' that match the request for deletion.\n"), label); test_finished (); return; } /* delete everything but what we copied to 'rdx' */ del_qe = GNUNET_NAMESTORE_records_store (ns, &zone_pkey, name, rd_left, rdx, &del_continuation, NULL); }
/** * Main function that will be run. * * @param cls closure * @param args remaining command-line arguments * @param cfgfile name of the configuration file used (for saving, can be NULL!) * @param c configuration */ static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c) { uint8_t af; struct sockaddr *local_sa; struct sockaddr *remote_sa; socklen_t local_len; size_t remote_len; if (use_tcp && use_udp) { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Cannot use TCP and UDP\n"); global_ret = 1; return; } proto = 0; if (use_tcp) proto = IPPROTO_TCP; if (use_udp) proto = IPPROTO_UDP; GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); if (0 == proto) { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Must specify either TCP or UDP\n"); global_ret = 1; return; } if (NULL != local_addr) { local_len = (socklen_t) GNUNET_STRINGS_parse_socket_addr (local_addr, &af, &local_sa); if (0 == local_len) { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Invalid socket address `%s'\n", local_addr); global_ret = 1; return; } } if (NULL != remote_addr) { remote_len = GNUNET_STRINGS_parse_socket_addr (remote_addr, &af, &remote_sa); if (0 == remote_len) { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Invalid socket address `%s'\n", remote_addr); global_ret = 1; return; } } if (NULL != local_addr) { if (NULL == section_name) section_name = GNUNET_strdup ("undefined"); nh = GNUNET_NAT_register (c, section_name, proto, 1, (const struct sockaddr **) &local_sa, &local_len, &address_cb, (listen_reversal) ? &reversal_cb : NULL, NULL); } else if (listen_reversal) { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Use of `-W` only effective in combination with `-i`\n"); global_ret = 1; GNUNET_SCHEDULER_shutdown (); return; } if (NULL != remote_addr) { int ret; if ( (NULL == nh) || (sizeof (struct sockaddr_in) != local_len) ) { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Require IPv4 local address to initiate connection reversal\n"); global_ret = 1; GNUNET_SCHEDULER_shutdown (); return; } if (sizeof (struct sockaddr_in) != remote_len) { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Require IPv4 reversal target address\n"); global_ret = 1; GNUNET_SCHEDULER_shutdown (); return; } GNUNET_assert (AF_INET == local_sa->sa_family); GNUNET_assert (AF_INET == remote_sa->sa_family); ret = GNUNET_NAT_request_reversal (nh, (const struct sockaddr_in *) local_sa, (const struct sockaddr_in *) remote_sa); switch (ret) { case GNUNET_SYSERR: GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Connection reversal internal error\n"); break; case GNUNET_NO: GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Connection reversal unavailable\n"); break; case GNUNET_OK: /* operation in progress */ break; } } if (do_stun) { if (NULL == local_addr) { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Require local address to support STUN requests\n"); global_ret = 1; GNUNET_SCHEDULER_shutdown (); return; } if (IPPROTO_UDP != proto) { GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "STUN only supported over UDP\n"); global_ret = 1; GNUNET_SCHEDULER_shutdown (); return; } ls = GNUNET_NETWORK_socket_create (af, SOCK_DGRAM, IPPROTO_UDP); if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ls, local_sa, local_len)) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to bind to %s: %s\n", GNUNET_a2s (local_sa, local_len), STRERROR (errno)); global_ret = 1; GNUNET_SCHEDULER_shutdown (); return; } rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, ls, &stun_read_task, NULL); } test_finished (); }
/** * We're storing a record; this function is given the existing record * so that we can merge the information. * * @param cls closure, unused * @param zone_key private key of the zone * @param rec_name name that is being mapped (at most 255 characters long) * @param rd_count number of entries in @a rd array * @param rd array of records with data to store */ static void get_existing_record (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *rec_name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd) { struct GNUNET_GNSRECORD_Data rdn[rd_count + 1]; struct GNUNET_GNSRECORD_Data *rde; unsigned int i; add_qe = NULL; if ( (NULL != zone_key) && (0 != strcmp (rec_name, name)) ) { GNUNET_break (0); ret = 1; test_finished (); return; } GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received %u records for name `%s'\n", rd_count, rec_name); for (i=0;i<rd_count;i++) { switch (rd[i].record_type) { case GNUNET_DNSPARSER_TYPE_CNAME: fprintf (stderr, _("A %s record exists already under `%s', no other records can be added.\n"), "CNAME", rec_name); ret = 1; test_finished (); return; case GNUNET_GNSRECORD_TYPE_PKEY: fprintf (stderr, _("A %s record exists already under `%s', no other records can be added.\n"), "PKEY", rec_name); ret = 1; test_finished (); return; case GNUNET_GNSRECORD_TYPE_GNS2DNS: fprintf (stderr, _("A %s record exists already under `%s', no other records can be added.\n"), "GNS2DNS", rec_name); ret = 1; test_finished (); return; } } switch (type) { case GNUNET_DNSPARSER_TYPE_CNAME: if (0 != rd_count) { fprintf (stderr, _("Records already exist under `%s', cannot add `%s' record.\n"), rec_name, "CNAME"); ret = 1; test_finished (); return; } break; case GNUNET_GNSRECORD_TYPE_PKEY: if (0 != rd_count) { fprintf (stderr, _("Records already exist under `%s', cannot add `%s' record.\n"), rec_name, "PKEY"); ret = 1; test_finished (); return; } break; case GNUNET_GNSRECORD_TYPE_GNS2DNS: if (0 != rd_count) { fprintf (stderr, _("Records already exist under `%s', cannot add `%s' record.\n"), rec_name, "GNS2DNS"); ret = 1; test_finished (); return; } break; } memset (rdn, 0, sizeof (struct GNUNET_GNSRECORD_Data)); memcpy (&rdn[1], rd, rd_count * sizeof (struct GNUNET_GNSRECORD_Data)); rde = &rdn[0]; rde->data = data; rde->data_size = data_size; rde->record_type = type; if (1 == is_shadow) rde->flags |= GNUNET_GNSRECORD_RF_SHADOW_RECORD; if (1 != is_public) rde->flags |= GNUNET_GNSRECORD_RF_PRIVATE; if (GNUNET_YES == etime_is_rel) { rde->expiration_time = etime_rel.rel_value_us; rde->flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION; } else if (GNUNET_NO == etime_is_rel) rde->expiration_time = etime_abs.abs_value_us; else rde->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us; GNUNET_assert (NULL != name); add_qe = GNUNET_NAMESTORE_records_store (ns, &zone_pkey, name, rd_count + 1, rde, &add_continuation, &add_qe); }
/** * Process a record that was stored in the namestore. * * @param cls closure * @param zone_key private key of the zone * @param rname name that is being mapped (at most 255 characters long) * @param rd_len number of entries in @a rd array * @param rd array of records with data to store */ static void display_record (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd) { const char *typestring; char *s; unsigned int i; const char *ets; struct GNUNET_TIME_Absolute at; struct GNUNET_TIME_Relative rt; if (NULL == rname) { list_it = NULL; test_finished (); return; } if ( (NULL != name) && (0 != strcmp (name, rname)) ) { GNUNET_NAMESTORE_zone_iterator_next (list_it); return; } FPRINTF (stdout, "%s:\n", rname); for (i=0;i<rd_len;i++) { if ( (GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) && (0 != strcmp (rname, "+")) ) continue; typestring = GNUNET_GNSRECORD_number_to_typename (rd[i].record_type); s = GNUNET_GNSRECORD_value_to_string (rd[i].record_type, rd[i].data, rd[i].data_size); if (NULL == s) { FPRINTF (stdout, _("\tCorrupt or unsupported record of type %u\n"), (unsigned int) rd[i].record_type); continue; } if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION)) { rt.rel_value_us = rd[i].expiration_time; ets = GNUNET_STRINGS_relative_time_to_string (rt, GNUNET_YES); } else { at.abs_value_us = rd[i].expiration_time; ets = GNUNET_STRINGS_absolute_time_to_string (at); } FPRINTF (stdout, "\t%s: %s (%s)\t%s\t%s\n", typestring, s, ets, (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE)) ? "PRIVATE" : "PUBLIC", (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW_RECORD)) ? "SHADOW" : ""); GNUNET_free (s); } FPRINTF (stdout, "%s", "\n"); GNUNET_NAMESTORE_zone_iterator_next (list_it); }