int
main (int argc, char **argv)
{
struct GNUNET_OS_Process *openssl;
if (argc != 3)
return 1;
removecerts (argv[1], argv[2]);
close (2); /* eliminate stderr */
/* Create RSA Private Key */
/* openssl genrsa -out $1 1024 2> /dev/null */
openssl =
GNUNET_OS_start_process (GNUNET_NO, NULL, NULL, "openssl", "openssl", "genrsa",
"-out", argv[1], "1024", NULL);
if (openssl == NULL)
return 2;
GNUNET_assert (GNUNET_OS_process_wait (openssl) == GNUNET_OK);
GNUNET_OS_process_destroy (openssl);
/* Create a self-signed certificate in batch mode using rsa key */
/* openssl req -batch -days 365 -out $2 -new -x509 -key $1 2> /dev/null */
openssl =
GNUNET_OS_start_process (GNUNET_NO, NULL, NULL, "openssl", "openssl", "req",
"-batch", "-days", "365", "-out", argv[2],
"-new", "-x509", "-key", argv[1], NULL);
if (openssl == NULL)
return 3;
GNUNET_assert (GNUNET_OS_process_wait (openssl) == GNUNET_OK);
GNUNET_OS_process_destroy (openssl);
CHMOD (argv[1], S_IRUSR);
CHMOD (argv[2], S_IRUSR);
return 0;
}
/**
* Test our plugin's configuration (NAT traversal, etc.).
*
* @param cfg configuration to test
*/
static void
do_test_configuration (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
char *plugins;
char *tok;
unsigned long long bnd_port;
unsigned long long adv_port;
struct TestContext *tc;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg, "transport", "plugins",
&plugins))
{
FPRINTF (stderr,
"%s",
_
("No transport plugins configured, peer will never communicate\n"));
ret = 4;
return;
}
for (tok = strtok (plugins, " "); tok != NULL; tok = strtok (NULL, " "))
{
char section[12 + strlen (tok)];
GNUNET_snprintf (section, sizeof (section), "transport-%s", tok);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg, section, "PORT", &bnd_port))
{
FPRINTF (stderr,
_("No port configured for plugin `%s', cannot test it\n"), tok);
continue;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg, section, "ADVERTISED_PORT",
&adv_port))
adv_port = bnd_port;
if (NULL == resolver)
resolver =
GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, "gnunet-service-resolver",
"gnunet-service-resolver", NULL);
resolver_users++;
GNUNET_RESOLVER_connect (cfg);
tc = GNUNET_malloc (sizeof (struct TestContext));
tc->name = GNUNET_strdup (tok);
tc->tst =
GNUNET_NAT_test_start (cfg,
(0 ==
strcasecmp (tok,
"udp")) ? GNUNET_NO : GNUNET_YES,
(uint16_t) bnd_port, (uint16_t) adv_port,
&result_callback, tc);
if (NULL == tc->tst)
{
display_test_result (tc, GNUNET_SYSERR);
continue;
}
tc->tsk = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &fail_timeout, tc);
}
GNUNET_free (plugins);
}
static void
run_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
char *fn;
const struct GNUNET_DISK_FileHandle *stdout_read_handle;
const struct GNUNET_DISK_FileHandle *wh;
#if !WINDOWS
GNUNET_asprintf (&fn, "cat");
#else
GNUNET_asprintf (&fn, "w32cat");
#endif
hello_pipe_stdin = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
hello_pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
if ((hello_pipe_stdout == NULL) || (hello_pipe_stdin == NULL))
{
GNUNET_break (0);
ok = 1;
GNUNET_free (fn);
return;
}
proc =
GNUNET_OS_start_process (GNUNET_NO, GNUNET_OS_INHERIT_STD_ERR, hello_pipe_stdin, hello_pipe_stdout, fn,
"test_gnunet_echo_hello", "-", NULL);
GNUNET_free (fn);
/* Close the write end of the read pipe */
GNUNET_DISK_pipe_close_end (hello_pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
/* Close the read end of the write pipe */
GNUNET_DISK_pipe_close_end (hello_pipe_stdin, GNUNET_DISK_PIPE_END_READ);
wh = GNUNET_DISK_pipe_handle (hello_pipe_stdin, GNUNET_DISK_PIPE_END_WRITE);
/* Write the test_phrase to the cat process */
if (GNUNET_DISK_file_write (wh, test_phrase, strlen (test_phrase) + 1) !=
strlen (test_phrase) + 1)
{
GNUNET_break (0);
ok = 1;
return;
}
/* Close the write end to end the cycle! */
GNUNET_DISK_pipe_close_end (hello_pipe_stdin, GNUNET_DISK_PIPE_END_WRITE);
stdout_read_handle =
GNUNET_DISK_pipe_handle (hello_pipe_stdout, GNUNET_DISK_PIPE_END_READ);
die_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 1), &end_task,
NULL);
GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
stdout_read_handle, &read_call,
(void *) stdout_read_handle);
}
static void
setup_peer (struct PeerContext *p,
const char *cfgname)
{
char *binary;
binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
p->cfg = GNUNET_CONFIGURATION_create ();
p->arm_proc =
GNUNET_OS_start_process (GNUNET_YES,
GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
NULL, NULL, NULL,
binary,
"gnunet-service-arm",
"-c",
cfgname,
NULL);
GNUNET_assert (GNUNET_OK ==
GNUNET_CONFIGURATION_load (p->cfg,
cfgname));
p->ats = GNUNET_ATS_connectivity_init (p->cfg);
GNUNET_assert (NULL != p->ats);
p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg,
GNUNET_TRANSPORT_AC_ANY,
&process_hello,
p);
GNUNET_free (binary);
}
static int
check ()
{
char *const argv[] = { "test-sensor-api", NULL };
struct GNUNET_GETOPT_CommandLineOption options[] = {
GNUNET_GETOPT_OPTION_END
};
struct GNUNET_OS_Process *proc;
char *path = GNUNET_OS_get_libexec_binary_path ("gnunet-service-sensor");
if (NULL == path)
{
fprintf (stderr, "Service executable not found `%s'\n",
"gnunet-service-sensor");
return -1;
}
proc =
GNUNET_OS_start_process (GNUNET_NO, GNUNET_OS_INHERIT_STD_ALL, NULL, NULL,
NULL, path, "gnunet-service-sensor", NULL);
GNUNET_free (path);
GNUNET_assert (NULL != proc);
GNUNET_PROGRAM_run (1, argv, "test-sensor-api", "nohelp", options, &run, &ok);
if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
ok = 1;
}
GNUNET_OS_process_wait (proc);
GNUNET_OS_process_destroy (proc);
return ok;
}
/**
* Test killing via pipe.
*/
static int
check_instant_kill ()
{
char *fn;
#if !WINDOWS
GNUNET_asprintf (&fn, "cat");
#else
GNUNET_asprintf (&fn, "w32cat");
#endif
hello_pipe_stdin = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
hello_pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
if ((hello_pipe_stdout == NULL) || (hello_pipe_stdin == NULL))
{
GNUNET_free (fn);
return 1;
}
proc =
GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_ERR, hello_pipe_stdin, hello_pipe_stdout, fn,
"gnunet-service-resolver", "-", NULL);
if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
}
GNUNET_free (fn);
GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (proc));
GNUNET_OS_process_destroy (proc);
proc = NULL;
GNUNET_DISK_pipe_close (hello_pipe_stdout);
GNUNET_DISK_pipe_close (hello_pipe_stdin);
return 0;
}
/**
* Test killing via pipe.
*/
static int
check_instant_kill ()
{
char *fn;
hello_pipe_stdin = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
hello_pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
if ((hello_pipe_stdout == NULL) || (hello_pipe_stdin == NULL))
{
return 1;
}
fn = GNUNET_OS_get_libexec_binary_path ("gnunet-service-resolver");
proc =
GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_ERR,
hello_pipe_stdin, hello_pipe_stdout, NULL,
fn,
"gnunet-service-resolver", "-", NULL);
if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG))
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
}
GNUNET_free (fn);
GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (proc));
GNUNET_OS_process_destroy (proc);
proc = NULL;
GNUNET_DISK_pipe_close (hello_pipe_stdout);
GNUNET_DISK_pipe_close (hello_pipe_stdin);
return 0;
}
/**
* Initialize framework and start test
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_log_setup ("test_mesh_local",
#if VERBOSE
"DEBUG",
#else
"WARNING",
#endif
NULL);
arm_pid =
GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
"gnunet-service-arm",
#if VERBOSE_ARM
"-L", "DEBUG",
#endif
"-c", "test_mesh.conf", NULL);
abort_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 20), &do_abort,
NULL);
test_task = GNUNET_SCHEDULER_add_now (&test, (void *) cfg);
}
/**
* 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)
{
const char *uri;
const char *slash;
char *subsystem;
char *program;
struct GNUNET_SCHEDULER_Task * rt;
if (NULL == (uri = args[0]))
{
fprintf (stderr,
_("No URI specified on command line\n"));
return;
}
if (0 != strncasecmp ("gnunet://", uri, strlen ("gnunet://")))
{
fprintf (stderr,
_("Invalid URI: does not start with `%s'\n"),
"gnunet://");
return;
}
uri += strlen ("gnunet://");
if (NULL == (slash = strchr (uri, '/')))
{
fprintf (stderr, _("Invalid URI: fails to specify subsystem\n"));
return;
}
subsystem = GNUNET_strndup (uri, slash - uri);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg,
"uri",
subsystem,
&program))
{
fprintf (stderr, _("No handler known for subsystem `%s'\n"), subsystem);
GNUNET_free (subsystem);
return;
}
GNUNET_free (subsystem);
rt = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
GNUNET_DISK_pipe_handle (sigpipe,
GNUNET_DISK_PIPE_END_READ),
&maint_child_death, NULL);
p = GNUNET_OS_start_process (GNUNET_NO, 0,
NULL, NULL, NULL,
program,
program,
args[0],
NULL);
GNUNET_free (program);
if (NULL == p)
GNUNET_SCHEDULER_cancel (rt);
}
static void
start_arm (const char *cfgname)
{
arm = GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
"gnunet-service-arm", "-c", cfgname,
#if VERBOSE_PEERS
"-L", "DEBUG",
#else
"-L", "ERROR",
#endif
NULL);
}
static void
setup_peer (struct PeerContext *p, const char *cfgname)
{
p->cfg = GNUNET_CONFIGURATION_create ();
#if START_ARM
p->arm_proc =
GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
"gnunet-service-arm",
"-c", cfgname, NULL);
#endif
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
}
int
main (int argc, char *const argv[])
{
struct GNUNET_GETOPT_CommandLineOption options[] = {
GNUNET_GETOPT_OPTION_END
};
char *const argv_prog[] = {
"test-stun",
"-c",
"test_stun.conf",
NULL
};
char *fn;
struct GNUNET_OS_Process *proc;
GNUNET_log_setup ("test-stun",
"WARNING",
NULL);
/* Lets start resolver */
fn = GNUNET_OS_get_libexec_binary_path ("gnunet-service-resolver");
proc = GNUNET_OS_start_process (GNUNET_YES,
GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
NULL, NULL, NULL,
fn,
"gnunet-service-resolver",
"-c", "test_stun.conf", NULL);
if (NULL == proc)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"This test was unable to start gnunet-service-resolver, and it is required to run ...\n");
exit(1);
}
GNUNET_PROGRAM_run (3, argv_prog,
"test-stun", "nohelp",
options,
&run, NULL);
/* Now kill the resolver */
if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG))
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
}
GNUNET_OS_process_wait (proc);
GNUNET_OS_process_destroy (proc);
proc = NULL;
GNUNET_free (fn);
return ret;
}
static void
setup_peer (struct PeerContext *p, const char *cfgname)
{
char *binary;
binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
p->cfg = GNUNET_CONFIGURATION_create ();
p->arm_proc =
GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
NULL, NULL,
binary,
"gnunet-service-arm",
"-c", cfgname, NULL);
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
GNUNET_free (binary);
}
static void
gather_log_data ()
{
char *peer_number;
char *connect_number;
struct GNUNET_OS_Process *mem_process;
GNUNET_asprintf (&peer_number, "%llu", num_peers);
GNUNET_asprintf (&connect_number, "%llu", expected_connections);
mem_process =
GNUNET_OS_start_process (NULL, NULL, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, "./memsize.pl", "memsize.pl",
"totals.txt", peer_number, connect_number, NULL);
GNUNET_OS_process_wait (mem_process);
GNUNET_OS_process_destroy (mem_process);
mem_process = NULL;
}
static int
check ()
{
struct GNUNET_OS_Process *proc;
char cfg_name[128];
char *const argv[] = {
"test-datastore-api-management",
"-c",
cfg_name,
#if VERBOSE
"-L", "DEBUG",
#endif
NULL
};
struct GNUNET_GETOPT_CommandLineOption options[] = {
GNUNET_GETOPT_OPTION_END
};
GNUNET_snprintf (cfg_name, sizeof (cfg_name),
"test_datastore_api_data_%s.conf", plugin_name);
proc =
GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
"gnunet-service-arm",
#if VERBOSE
"-L", "DEBUG",
#endif
"-c", cfg_name, NULL);
GNUNET_assert (NULL != proc);
GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
"test-datastore-api-management", "nohelp", options, &run,
NULL);
sleep (1); /* give datastore chance to process 'DROP' request */
if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
ok = 1;
}
GNUNET_OS_process_wait (proc);
GNUNET_OS_process_destroy (proc);
proc = NULL;
if (ok != 0)
FPRINTF (stderr, "Missed some testcases: %u\n", ok);
return ok;
}
static void
setup_peer (struct PeerContext *p, const char *cfgname)
{
p->cfg = GNUNET_CONFIGURATION_create ();
#if START_ARM
p->arm_proc =
GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
"gnunet-service-arm",
#if VERBOSE
"-L", "DEBUG",
#endif
"-c", cfgname, NULL);
#endif
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
p->th =
GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL, ¬ify_connect, NULL);
GNUNET_assert (p->th != NULL);
p->ghh = GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
}
/**
* Main point of test execution
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting test...\n");
config = GNUNET_CONFIGURATION_dup (cfg);
arm_pid =
GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
"gnunet-service-arm",
#if VERBOSE_ARM
"-L", "DEBUG",
#endif
"-c", "test_lockmanager_api.conf", NULL);
GNUNET_assert (NULL != arm_pid);
GNUNET_SCHEDULER_add_delayed (TIME_REL_SECONDS (3),
&test,
NULL);
}
int
main (int argc, char *argv_ign[])
{
char *const argv[] = { "test-statistics-api",
"-c",
"test_statistics_api_data.conf",
NULL
};
struct GNUNET_GETOPT_CommandLineOption options[] = {
GNUNET_GETOPT_OPTION_END
};
struct GNUNET_OS_Process *proc;
char *binary;
binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-statistics");
proc =
GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL,
binary,
"gnunet-service-statistics",
"-c", "test_statistics_api_data.conf", NULL);
GNUNET_assert (NULL != proc);
ok = 3;
ok2 = 1;
GNUNET_PROGRAM_run (3, argv, "test-statistics-api", "nohelp", options, &run,
NULL);
if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
ok = 1;
}
GNUNET_OS_process_wait (proc);
GNUNET_OS_process_destroy (proc);
proc = NULL;
GNUNET_free (binary);
if ((0 == ok) && (0 == ok2))
return 0;
return 1;
}
/**
* Test killing via pipe.
*/
static int
check_instant_kill ()
{
hello_pipe_stdin = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
hello_pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
if ((hello_pipe_stdout == NULL) || (hello_pipe_stdin == NULL))
{
return 1;
}
proc =
GNUNET_OS_start_process (GNUNET_YES, hello_pipe_stdin, hello_pipe_stdout, "cat",
"gnunet-service-resolver", "-", NULL);
if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
}
GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (proc));
GNUNET_OS_process_destroy (proc);
proc = NULL;
GNUNET_DISK_pipe_close (hello_pipe_stdout);
GNUNET_DISK_pipe_close (hello_pipe_stdin);
return 0;
}
static void
setup_learn_peer (struct PeerContext *p, const char *cfgname)
{
char *filename;
unsigned int result;
char *binary;
binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
p->cfg = GNUNET_CONFIGURATION_create ();
p->arm_proc =
GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
NULL, NULL, NULL,
binary,
"gnunet-service-arm",
"-c", cfgname, NULL);
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_string (p->cfg, "HOSTLIST", "HOSTLISTFILE",
&filename))
{
if (GNUNET_YES == GNUNET_DISK_file_test (filename))
{
result = UNLINK (filename);
if (result == 0)
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Hostlist file `%s' was removed\n"), filename);
}
GNUNET_free (filename);
}
p->core =
GNUNET_CORE_connect (p->cfg, NULL, NULL, NULL, NULL, NULL, GNUNET_NO,
NULL, GNUNET_NO, learn_handlers);
GNUNET_assert (NULL != p->core);
p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
GNUNET_assert (NULL != p->stats);
GNUNET_free (binary);
}
static void
runone ()
{
const struct GNUNET_DISK_FileHandle *stdout_read_handle;
pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
if (pipe_stdout == NULL)
{
GNUNET_break (0);
ok = 2;
return;
}
putenv ("GNUNET_LOG=");
putenv ("GNUNET_FORCE_LOG=");
putenv ("GNUNET_FORCE_LOGFILE=");
switch (phase)
{
case 0:
putenv ("GNUNET_LOG=;;;;ERROR");
break;
case 1:
putenv ("GNUNET_LOG=;;;;WARNING");
break;
case 2:
putenv ("GNUNET_LOG=;;;;INFO");
break;
case 3:
putenv ("GNUNET_LOG=;;;;DEBUG");
break;
case 4:
putenv ("GNUNET_FORCE_LOG=;;;;ERROR");
break;
case 5:
putenv ("GNUNET_FORCE_LOG=;;;;WARNING");
break;
case 6:
putenv ("GNUNET_FORCE_LOG=;;;;INFO");
break;
case 7:
putenv ("GNUNET_FORCE_LOG=;;;;DEBUG");
break;
case 8:
putenv ("GNUNET_LOG=blah;;;;ERROR");
break;
case 9:
putenv ("GNUNET_FORCE_LOG=blah;;;;ERROR");
break;
}
proc = GNUNET_OS_start_process (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
NULL, pipe_stdout, NULL,
#if MINGW
"test_common_logging_dummy",
#else
"./test_common_logging_dummy",
#endif
"test_common_logging_dummy", NULL);
GNUNET_assert (NULL != proc);
putenv ("GNUNET_FORCE_LOG=");
putenv ("GNUNET_LOG=");
/* Close the write end of the read pipe */
GNUNET_DISK_pipe_close_end (pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
stdout_read_handle =
GNUNET_DISK_pipe_handle (pipe_stdout, GNUNET_DISK_PIPE_END_READ);
die_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 10), &end_task,
NULL);
bytes = 0;
buf_ptr = buf;
memset (&buf, 0, sizeof (buf));
read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
stdout_read_handle, &read_call,
(void*) stdout_read_handle);
}
int
main (int argc, char *argv_ign[])
{
int ok = 1;
char *const argv[] = { "test-statistics-api",
"-c",
"test_statistics_api_data.conf",
"-L", "WARNING",
NULL
};
struct GNUNET_GETOPT_CommandLineOption options[] = {
GNUNET_GETOPT_OPTION_END
};
struct GNUNET_OS_Process *proc;
char *binary;
GNUNET_log_setup ("test_statistics_api",
"WARNING",
NULL);
binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-statistics");
proc =
GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL,
binary,
"gnunet-service-statistics",
"-c", "test_statistics_api_data.conf", NULL);
GNUNET_assert (NULL != proc);
GNUNET_PROGRAM_run (5, argv, "test-statistics-api", "nohelp", options, &run,
&ok);
if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
ok = 1;
}
GNUNET_OS_process_wait (proc);
GNUNET_OS_process_destroy (proc);
proc = NULL;
if (ok != 0)
{
GNUNET_free (binary);
return ok;
}
ok = 1;
/* restart to check persistence! */
proc =
GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL,
binary,
"gnunet-service-statistics",
"-c", "test_statistics_api_data.conf", NULL);
GNUNET_PROGRAM_run (5, argv, "test-statistics-api", "nohelp", options,
&run_more, &ok);
if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
ok = 1;
}
GNUNET_OS_process_wait (proc);
GNUNET_OS_process_destroy (proc);
proc = NULL;
GNUNET_free (binary);
return ok;
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
enum MHD_FLAG flags;
struct GNUNET_CRYPTO_EcdsaPrivateKey *host_key;
struct GNUNET_GNSRECORD_Data rd;
char *zone_keyfile;
namestore = GNUNET_NAMESTORE_connect (cfg);
GNUNET_assert (NULL != namestore);
flags = MHD_USE_DEBUG;
mhd = MHD_start_daemon (flags,
PORT,
NULL, NULL,
&mhd_ahc, NULL,
MHD_OPTION_END);
GNUNET_assert (NULL != mhd);
mhd_main ();
tmp_cfgfile = GNUNET_DISK_mktemp ("test_gns_proxy_tmp.conf");
if (NULL == tmp_cfgfile)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to create tmp cfg!\n");
do_shutdown ();
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_write ((struct GNUNET_CONFIGURATION_Handle *)cfg,
tmp_cfgfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to write tmp cfg\n");
do_shutdown ();
return;
}
proxy_proc = GNUNET_OS_start_process (GNUNET_NO,
GNUNET_OS_INHERIT_STD_ALL,
NULL,
NULL,
NULL,
"gnunet-gns-proxy",
"gnunet-gns-proxy",
"-c", tmp_cfgfile, NULL);
if (NULL == proxy_proc)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Unable to start proxy\n");
do_shutdown ();
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&zone_keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
return;
}
host_key = GNUNET_CRYPTO_ecdsa_key_create_from_file (zone_keyfile);
rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_string_to_value (GNUNET_DNSPARSER_TYPE_A,
"127.0.0.1",
(void**)&rd.data,
&rd.data_size));
rd.record_type = GNUNET_DNSPARSER_TYPE_A;
GNUNET_NAMESTORE_record_create (namestore,
host_key,
"www",
&rd,
&commence_testing,
NULL);
GNUNET_free ((void**)rd.data);
GNUNET_free (zone_keyfile);
GNUNET_free (host_key);
}
/**
* Try to get the external IPv4 address of this peer.
*
* @param cb function to call with result
* @param cb_cls closure for @a cb
* @return handle for cancellation (can only be used until @a cb is called), never NULL
*/
struct GNUNET_NAT_ExternalHandle *
GNUNET_NAT_mini_get_external_ipv4_ (GNUNET_NAT_IPCallback cb,
void *cb_cls)
{
struct GNUNET_NAT_ExternalHandle *eh;
eh = GNUNET_new (struct GNUNET_NAT_ExternalHandle);
eh->cb = cb;
eh->cb_cls = cb_cls;
eh->ret = GNUNET_NAT_ERROR_SUCCESS;
if (GNUNET_SYSERR ==
GNUNET_OS_check_helper_binary ("external-ip",
GNUNET_NO,
NULL))
{
LOG (GNUNET_ERROR_TYPE_INFO,
_("`external-ip' command not found\n"));
eh->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND;
eh->task = GNUNET_SCHEDULER_add_now (&signal_external_ip_error,
eh);
return eh;
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Running `external-ip' to determine our external IP\n");
eh->opipe = GNUNET_DISK_pipe (GNUNET_YES,
GNUNET_YES,
GNUNET_NO,
GNUNET_YES);
if (NULL == eh->opipe)
{
eh->ret = GNUNET_NAT_ERROR_IPC_FAILURE;
eh->task = GNUNET_SCHEDULER_add_now (&signal_external_ip_error,
eh);
return eh;
}
eh->eip =
GNUNET_OS_start_process (GNUNET_NO,
0,
NULL,
eh->opipe,
NULL,
"external-ip",
"external-ip",
NULL);
if (NULL == eh->eip)
{
GNUNET_DISK_pipe_close (eh->opipe);
eh->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED;
eh->task = GNUNET_SCHEDULER_add_now (&signal_external_ip_error,
eh);
return eh;
}
GNUNET_DISK_pipe_close_end (eh->opipe,
GNUNET_DISK_PIPE_END_WRITE);
eh->r = GNUNET_DISK_pipe_handle (eh->opipe,
GNUNET_DISK_PIPE_END_READ);
eh->task
= GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
eh->r,
&read_external_ipv4,
eh);
return eh;
}