/**
* 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);
}
