自学教程：C++ GNUNET_PROGRAM_run函数代码示例

intmain (int argcx,      char *argvx[]){  static char *const argv[] = {    "test-gnunet-daemon-hostlist",    "-c", "test_gnunet_daemon_hostlist_data.conf",    NULL  };  static struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-3");  GNUNET_log_setup ("test-gnunet-daemon-hostlist",                    "WARNING",                    NULL);  ok = 1;  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,		      argv,                      "test-gnunet-daemon-hostlist",		      "nohelp",		      options,		      &run,                      &ok);  if (0 == ok)  {    FPRINTF (stderr, "%s",  ".");    /* now do it again */    ok = 1;    GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,			argv,			"test-gnunet-daemon-hostlist",			"nohelp",			options,			&run,			&ok);    FPRINTF (stderr,	     "%s",	     "./n");  }  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-3");  return ok;}

intmain (int argc, char *argv0[]){  ok = 1;  GNUNET_TRANSPORT_TESTING_get_test_name (argv0[0], &test_name);  GNUNET_log_setup ("test-transport-api-blacklisting",                    "WARNING",                    NULL);  static char *const argv[] = { "date",    "-c",    "test_transport_api_data.conf",    NULL  };  static struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  tth = GNUNET_TRANSPORT_TESTING_init ();  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,  										"test-transport-api-blacklisting",                      "nohelp", options, &run, NULL);  GNUNET_TRANSPORT_TESTING_done (tth);  return ok;}

static intcheck (){  int ret;  char *const argv[] = { "test-testing-topology-churn",    "-c",    "test_testing_data_topology_churn.conf",    NULL  };  struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  ret =      GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,                          "test-testing-topology-churn", "nohelp", options,                          &run, &ok);  if (ret != GNUNET_OK)  {    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,                "`test-testing-topology-churn': Failed with error code %d/n",                ret);  }  return ok;}

/** * The main function to obtain peer information. * * @param argc number of arguments from the command line * @param argv command line arguments * @return 0 ok, 1 on error */intmain (int argc, char *const *argv){  static const struct GNUNET_GETOPT_CommandLineOption options[] = {    {'n', "numeric", NULL,     gettext_noop ("don't resolve host names"),     0, &GNUNET_GETOPT_set_one, &no_resolve},    {'q', "quiet", NULL,     gettext_noop ("output only the identity strings"),     0, &GNUNET_GETOPT_set_one, &be_quiet},    {'s', "self", NULL,     gettext_noop ("output our own identity only"),     0, &GNUNET_GETOPT_set_one, &get_self},    {'i', "info", NULL,     gettext_noop ("list all known peers"),     0, &GNUNET_GETOPT_set_one, &get_info},    {'g', "get-hello", NULL,     gettext_noop ("also output HELLO uri(s)"),     0, &GNUNET_GETOPT_set_one, &get_uri},    {'p', "put-hello", "HELLO",     gettext_noop ("add given HELLO uri to the database"),     1, &GNUNET_GETOPT_set_string, &put_uri},    GNUNET_GETOPT_OPTION_END  };  return (GNUNET_OK ==          GNUNET_PROGRAM_run (argc, argv, "gnunet-peerinfo",                              gettext_noop ("Print information about peers."),                              options, &run, NULL)) ? 0 : 1;}

intmain (int argc, char *argv[]){  char cfg_name[128];  char *const xargv[] = {    "test-plugin-namestore",    "-c",    cfg_name,    NULL  };  struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  //GNUNET_DISK_directory_remove ("/tmp/gnunet-test-plugin-namestore-sqlite");  GNUNET_log_setup ("test-plugin-namestore",                    "WARNING",                    NULL);  plugin_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]);  GNUNET_snprintf (cfg_name, sizeof (cfg_name), "test_plugin_namestore_%s.conf",                   plugin_name);  GNUNET_PROGRAM_run ((sizeof (xargv) / sizeof (char *)) - 1, xargv,                      "test-plugin-namestore", "nohelp", options, &run, NULL);  if (ok != 0)    FPRINTF (stderr, "Missed some testcases: %d/n", ok);  //GNUNET_DISK_directory_remove ("/tmp/gnunet-test-plugin-namestore-sqlite");  return ok;}

/** * Main: start test */intmain (int argc, char *argv[]){  char *const argv2[] = {    argv[0],    "-c",    "test_testing_2dtorus.conf",#if VERBOSE    "-L",    "DEBUG",#endif    NULL  };  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Start/n");  GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,                      "test_testing_2dtorus",                      gettext_noop ("Test testing 2d torus."), options, &run,                      NULL);#if REMOVE_DIR  GNUNET_DISK_directory_remove ("/tmp/test_testing_2dtorus");#endif  if (GNUNET_OK != ok)  {    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "test: FAILED!/n");    return 1;  }  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: success/n");  return 0;}

/** * Main function */intmain (int argc, char **argv){  int ret;  char *const argv2[] =      { "test_testbed_api_operations", "-c", "test_testbed_api.conf", NULL };  struct GNUNET_GETOPT_CommandLineOption options[] =      { GNUNET_GETOPT_OPTION_END };  ret =      GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,                          "test_testbed_api_operations", "nohelp", options,                          &run, NULL);  if ((GNUNET_OK != ret) || (TEST_OP9_RELEASED != result))    return 1;  op1 = NULL;  op2 = NULL;  op3 = NULL;  op4 = NULL;  op5 = NULL;  op6 = NULL;  op7 = NULL;  op8 = NULL;  op9 = NULL;  q1 = NULL;  q2 = NULL;  return 0;}

intmain (int argc, char *argv[]){  char cfg_name[128];  char *const xargv[] = {    "perf-datacache",    "-c",    cfg_name,    NULL  };  struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  GNUNET_log_setup ("perf-datacache",                    "WARNING",                    NULL);  plugin_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]);  GNUNET_snprintf (cfg_name, sizeof (cfg_name), "perf_datacache_data_%s.conf",                   plugin_name);  GNUNET_PROGRAM_run ((sizeof (xargv) / sizeof (char *)) - 1, xargv,                      "perf-datacache", "nohelp", options, &run, NULL);  if ( (0 != ok) && (77 != ok) )    FPRINTF (stderr, "Missed some perfcases: %d/n", ok);  return ok;}

intmain (int argc,      char *argv1[]){  char *const argv[] = {    "test-core-api",    "-c",    "test_core_api_data.conf",    NULL  };  struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  ok = 1;  GNUNET_log_setup ("test-core-api",                    "WARNING",                    NULL);  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,		      argv,                      "test-core-api",		      "nohelp",		      options,		      &run,		      &ok);  stop_arm (&p1);  stop_arm (&p2);  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1");  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2");  return ok;}

/** * The main function to obtain peer information. * * @param argc number of arguments from the command line * @param argv command line arguments * @return 0 ok, 1 on error */intmain (int argc, char *const *argv){  int res;  static const struct GNUNET_GETOPT_CommandLineOption options[] = {    {'m', "monitor", NULL,     gettext_noop ("provide information about all tunnels (continuously) NOT IMPLEMENTED"), /* FIXME */     GNUNET_NO, &GNUNET_GETOPT_set_one, &monitor_connections},    {'t', "tunnel", "OWNER_ID:TUNNEL_ID",     gettext_noop ("provide information about a particular tunnel"),     GNUNET_YES, &GNUNET_GETOPT_set_string, &tunnel_id},    GNUNET_GETOPT_OPTION_END  };  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))    return 2;  res = GNUNET_PROGRAM_run (argc, argv, "gnunet-mesh",                      gettext_noop                      ("Print information about mesh tunnels and peers."),                      options, &run, NULL);  GNUNET_free ((void *) argv);  if (GNUNET_OK == res)    return 0;  else    return 1;}

static intcheck (){  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;}

intmain (int argc, char *const argv[]){  struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  char *const argv_prog[] = {    "test-nat-mini",    "-c",    "test_nat_data.conf",    "-L",    "WARNING",    NULL  };  GNUNET_log_setup ("test-nat-mini",                    "WARNING",                    NULL);  GNUNET_log (GNUNET_ERROR_TYPE_INFO,              "UPnP test for NAT library, timeout set to %s/n",              GNUNET_STRINGS_relative_time_to_string (TIMEOUT,                                                      GNUNET_YES));  GNUNET_PROGRAM_run (5, argv_prog, "test-nat-mini", "nohelp", options, &run,                      NULL);  return 0;}

static intcheck (){  char *binary_name;  char *config_file_name;  GNUNET_asprintf (&binary_name, "test-testing-topology-%s", topology_string);  GNUNET_asprintf (&config_file_name, "test_testing_data_topology_%s.conf",                   topology_string);  int ret;  char *const argv[] = { binary_name,    "-c",    config_file_name,    NULL  };  struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  ret =      GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,                          binary_name, "nohelp", options, &run, &ok);  if (ret != GNUNET_OK)  {    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,                "`test-testing-topology-%s': Failed with error code %d/n",                topology_string, ret);  }  GNUNET_free (binary_name);  GNUNET_free (config_file_name);  return ok;}

/** * Program to manipulate RSA key files. * * @param argc number of arguments from the command line * @param argv command line arguments * @return 0 ok, 1 on error */intmain (int argc, char *const*argv){  static const struct GNUNET_GETOPT_CommandLineOption options[] = {    { 'g', "generate-keys", "COUNT",      gettext_noop ("create COUNT public-private key pairs (for testing)"),      1, &GNUNET_GETOPT_set_uint, &make_keys },    { 'p', "print-public-key", NULL,      gettext_noop ("print the public key in ASCII format"),      0, &GNUNET_GETOPT_set_one, &print_public_key },    { 'P', "print-peer-identity", NULL,      gettext_noop ("print the hash of the public key in ASCII format"),      0, &GNUNET_GETOPT_set_one, &print_peer_identity },    { 's', "print-short-identity", NULL,      gettext_noop ("print the short hash of the public key in ASCII format"),      0, &GNUNET_GETOPT_set_one, &print_short_identity },    { 'w', "weak-random", NULL,      gettext_noop ("use insecure, weak random number generator for key generation (for testing only)"),      0, &GNUNET_GETOPT_set_one, &weak_random },    GNUNET_GETOPT_OPTION_END  };  int ret;  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))    return 2;  ret = (GNUNET_OK ==	 GNUNET_PROGRAM_run (argc, argv, "gnunet-rsa [OPTIONS] keyfile",			     gettext_noop ("Manipulate GNUnet private RSA key files"),			     options, &run, NULL)) ? 0 : 1;  GNUNET_free ((void*) argv);  return ret;}

intmain (int argc, char *const *argv){  static const struct GNUNET_GETOPT_CommandLineOption options[] = {    {'4', "ipv4", "IPV4",     gettext_noop ("set A records"),     1, &GNUNET_GETOPT_set_string, &n4},    {'6', "ipv4", "IPV6",     gettext_noop ("set AAAA records"),     1, &GNUNET_GETOPT_set_string, &n6},    GNUNET_GETOPT_OPTION_VERBOSE (&verbosity),    GNUNET_GETOPT_OPTION_END  };  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))    return 2;  ret = (GNUNET_OK ==	 GNUNET_PROGRAM_run (argc, argv, "gnunet-dns-redirector",			     gettext_noop			     ("Change DNS replies to point elsewhere."), options,			     &run, NULL)) ? ret : 1;  GNUNET_free ((void*) argv);  return ret;}

/** * Main */intmain (int argc, char *argv[]){  int ret;  char *const argv2[] = { "test-mesh-local",    "-c", "test_mesh.conf",#if VERBOSE    "-L", "DEBUG",#endif    NULL  };  struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  ret =      GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,                          "test-mesh-local", "nohelp", options, &run, NULL);  if (GNUNET_OK != ret)  {    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "run failed with error code %d/n",                ret);    return 1;  }  if (GNUNET_SYSERR == result)  {    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "test failed/n");    return 1;  }  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test ok/n");  return 0;}

/** * Main function */intmain (int argc, char **argv){  char *const argv2[] = { "test_testbed_api_controllerlink",    "-c", "test_testbed_api.conf",    NULL  };  struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  int ret;  result = INIT;  ret =      GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,                          "test_testbed_api_controllerlink", "nohelp", options,                          &run, NULL);  if (GNUNET_OK != ret)    return 1;  switch (result)  {  case SUCCESS:    return 0;  case SKIP:    return 77;                  /* Mark test as skipped */  default:    return 1;  }}

/** * Program to manipulate ECC key files. * * @param argc number of arguments from the command line * @param argv command line arguments * @return 0 ok, 1 on error */intmain (int argc, char *const *argv){  static const struct GNUNET_GETOPT_CommandLineOption options[] = {    { 'b', "bits", "BITS",      gettext_noop ("number of bits to require for the proof of work"),      1, &GNUNET_GETOPT_set_ulong, &nse_work_required },    { 'k', "keyfile", "FILE",      gettext_noop ("file with private key, otherwise default is used"),      1, &GNUNET_GETOPT_set_filename, &pkfn },    { 'o', "outfile", "FILE",      gettext_noop ("file with proof of work, otherwise default is used"),      1, &GNUNET_GETOPT_set_filename, &pwfn },    { 't', "timeout", "TIME",      gettext_noop ("time to wait between calculations"),      1, &GNUNET_GETOPT_set_relative_time, &proof_find_delay },    GNUNET_GETOPT_OPTION_END  };  int ret;  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))    return 2;  ret = (GNUNET_OK ==         GNUNET_PROGRAM_run (argc, argv,                             "gnunet-scrypt [OPTIONS] prooffile",                             gettext_noop ("Manipulate GNUnet proof of work files"),                             options, &run, NULL)) ? 0 : 1;  GNUNET_free ((void*) argv);  GNUNET_free_non_null (pwfn);  return ret;}

/** * The main function. * * @param argc number of arguments from the command line * @param argv command line arguments * @return 0 ok, 1 on error */intmain (int argc, char *const *argv){  int res;  static const struct GNUNET_GETOPT_CommandLineOption options[] = {    {'V', "verbose", NULL,     gettext_noop ("verbose output"),     0, &GNUNET_GETOPT_set_one, &verbose},    GNUNET_GETOPT_OPTION_END  };  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))    return 2;  res = GNUNET_PROGRAM_run (argc, argv, "gnunet-dv",			    gettext_noop ("Print information about DV state"),			    options, &run,			    NULL);  GNUNET_free ((void *) argv);  if (GNUNET_OK != res)    return 1;  return 0;}

intmain (int argc, char *argv[]){    char *const argvx[] = {        "test-fs-start-stop",        "-c",        "test_fs_data.conf",#if VERBOSE        "-L", "DEBUG",#endif        NULL    };    struct GNUNET_GETOPT_CommandLineOption options[] = {        GNUNET_GETOPT_OPTION_END    };    GNUNET_log_setup ("test_fs_start_stop",#if VERBOSE                      "DEBUG",#else                      "WARNING",#endif                      NULL);    GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, argvx,                        "test-fs-start-stop", "nohelp", options, &run, NULL);    stop_arm (&p1);    GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs/");    return 0;}

/** * The main function to handle gnunet://-URIs. * * @param argc number of arguments from the command line * @param argv command line arguments * @return 0 ok, 1 on error */intmain (int argc, char *const *argv){  static const struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  struct GNUNET_SIGNAL_Context *shc_chld;  int ret;  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))    return 2;  sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);  GNUNET_assert (sigpipe != NULL);  shc_chld =    GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, &sighandler_child_death);  ret = GNUNET_PROGRAM_run (argc, argv, "gnunet-uri URI",			    gettext_noop ("Perform default-actions for GNUnet URIs"),			    options, &run, NULL);  GNUNET_SIGNAL_handler_uninstall (shc_chld);  shc_chld = NULL;  GNUNET_DISK_pipe_close (sigpipe);  sigpipe = NULL;  GNUNET_free ((void *) argv);  return ((GNUNET_OK == ret) && (0 == exit_code)) ? 0 : 1;}

static intcheck (){  int ret;  /* Arguments for GNUNET_PROGRAM_run */  char *const argv[] = { "test-gns-simple-delegated-lookup", /* Name to give running binary */    "-c",    "test_gns_simple_lookup.conf",       /* Config file to use */#if VERBOSE    "-L", "DEBUG",#endif    NULL  };  struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  /* Run the run function as a new program */  ret =      GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,                          "test-gns-simple-delegated-lookup", "nohelp", options, &run,                          &ok);  if (ret != GNUNET_OK)  {    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,                "`test-gns-simple-delegated-lookup': Failed with error code %d/n", ret);  }  return ok;}

intmain (int argc, char *argv[]){  char *const argvx[] = {    "test-fs-file_information",    "-c",    "test_fs_file_information_data.conf",#if VERBOSE    "-L", "DEBUG",#endif    NULL  };  struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  GNUNET_log_setup ("test_fs_file_information",#if VERBOSE                    "DEBUG",#else                    "WARNING",#endif                    NULL);  GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, argvx,                      "test-fs-file_information", "nohelp", options, &run,                      NULL);  return 0;}

/** * Program to run a file-sharing testbed. * * @param argc number of arguments from the command line * @param argv command line arguments * @return 0 ok, 1 on error */intmain (int argc, char *const *argv){  static const struct GNUNET_GETOPT_CommandLineOption options[] = {    {'n', "num-peers", "COUNT",     gettext_noop ("run the experiment with COUNT peers"),     1, &GNUNET_GETOPT_set_uint, &num_peers},    {'H', "hosts", "HOSTFILE",     gettext_noop ("specifies name of a file with the HOSTS the testbed should use"),     1, &GNUNET_GETOPT_set_string, &host_filename},    {'t', "timeout", "DELAY",     gettext_noop ("automatically terminate experiment after DELAY"),     1, &GNUNET_GETOPT_set_relative_time, &timeout},    GNUNET_GETOPT_OPTION_END  };  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))    return 2;  ret = (GNUNET_OK ==	 GNUNET_PROGRAM_run (argc, argv, "gnunet-fs-profiler",			     gettext_noop ("run a testbed to measure file-sharing performance"), options, &run,			     NULL)) ? ret : 1;  GNUNET_free ((void*) argv);  return ret;}

/** * The main function. * * @param argc number of arguments from the command line * @param argv command line arguments * @return 0 ok, 1 on error */intmain (int argc, char *const *argv){  int res;  resolve_addresses_numeric = GNUNET_NO;  op_monitor = GNUNET_NO;  op_list_all = GNUNET_NO;  op_list_used = GNUNET_NO;  op_set_pref = GNUNET_NO;  pending = 0;  receive_done = GNUNET_NO;  static const struct GNUNET_GETOPT_CommandLineOption options[] = {      {'u', "used", NULL,       gettext_noop ("get list of active addresses currently used"),       0, &GNUNET_GETOPT_set_one, &op_list_used},       {'a', "all", NULL,        gettext_noop ("get list of all active addresses"),        0, &GNUNET_GETOPT_set_one, &op_list_all},      {'n', "numeric", NULL,       gettext_noop ("do not resolve IP addresses to hostnames"),       0, &GNUNET_GETOPT_set_one, &resolve_addresses_numeric},       {'m', "monitor", NULL,        gettext_noop ("monitor mode"),        0, &GNUNET_GETOPT_set_one, &op_monitor},       {'p', "preference", NULL,         gettext_noop ("set preference for the given peer"),         0, &GNUNET_GETOPT_set_one, &op_set_pref},       {'i', "id", "TYPE",         gettext_noop ("peer id"),         1, &GNUNET_GETOPT_set_string, &pid_str},       {'t', "type", "TYPE",         gettext_noop ("preference type to set: latency | bandwidth"),         1, &GNUNET_GETOPT_set_string, &type_str},       {'k', "value", "VALUE",         gettext_noop ("preference value"),         1, &GNUNET_GETOPT_set_uint, &value},       {'V', "verbose", NULL,        gettext_noop ("verbose output (include ATS address properties)"),        0, &GNUNET_GETOPT_set_one, &verbose},    GNUNET_GETOPT_OPTION_END  };  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))    return 2;  res = GNUNET_PROGRAM_run (argc, argv, "gnunet-ats",                              gettext_noop ("Print information about ATS state"), options, &run,                              NULL);  GNUNET_free_non_null (pid_str);  GNUNET_free_non_null (type_str);  GNUNET_free ((void *) argv);  if (GNUNET_OK == res)    return ret;  else    return 1;}

/** * Entry point for gnunet-dht-put * * @param argc number of arguments from the command line * @param argv command line arguments * @return 0 ok, 1 on error */intmain (int argc, char *const *argv){  return (GNUNET_OK ==          GNUNET_PROGRAM_run (argc, argv, "gnunet-dht-put",                              gettext_noop                              ("Issue a PUT request to the GNUnet DHT insert DATA under KEY."),                              options, &run, NULL)) ? ret : 1;}

intmain (int argc, char *argv[]){  char *test_source;  int ret;  static char *const argv_new[] = {    "test-transport-api-reliability",    "-c",    "test_transport_api_data.conf",    NULL  };  static struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  GNUNET_TRANSPORT_TESTING_get_test_name (argv[0],                                          &test_name);  GNUNET_log_setup (test_name,                    "WARNING",                    NULL);  GNUNET_TRANSPORT_TESTING_get_test_source_name (__FILE__,                                                 &test_source);  GNUNET_TRANSPORT_TESTING_get_test_plugin_name (argv[0],                                                 test_source,                                                 &test_plugin);  tth = GNUNET_TRANSPORT_TESTING_init ();  GNUNET_TRANSPORT_TESTING_get_config_name (argv[0], &cfg_file_p1, 1);  GNUNET_TRANSPORT_TESTING_get_config_name (argv[0], &cfg_file_p2, 2);#if WRITECONFIG  setTransportOptions ("test_transport_api_data.conf");#endif  ok = GNUNET_SYSERR;  ret = GNUNET_PROGRAM_run ((sizeof (argv_new) / sizeof (char *)) - 1,                            argv_new, test_name,                            "nohelp", options,                            &run, &ok);  if (GNUNET_SYSERR == ret)  {    fprintf (stderr,             "Test failed: %d/n",             ok);    ok = -1;  }  GNUNET_free (cfg_file_p1);  GNUNET_free (cfg_file_p2);  GNUNET_free (test_source);  GNUNET_free (test_plugin);  GNUNET_free (test_name);  return ok;}

/** * Main function */intmain (int argc, char **argv){  char *argv2[] = {    "test_testbed_api_testbed_run",    "-c", NULL,    NULL  };  struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  char *testname;  char *config_filename;  int ret;  if (NULL == (testname = strrchr (argv[0], (int) '_')))  {    GNUNET_break (0);    return 1;  }  testname++;  testname = GNUNET_strdup (testname);#ifdef MINGW  {    char *period;    /* check and remove .exe extension */    period = strrchr (testname, (int) '.');    if (NULL != period)      *period = '/0';    else      GNUNET_break (0);         /* Windows with no .exe? */  }#endif  if (0 == strcmp ("waitforever", testname))    wait_forever = GNUNET_YES;  if ( (GNUNET_YES != wait_forever) && (0 != strcmp ("run", testname)) )  {    GNUNET_asprintf (&config_filename, "test_testbed_api_testbed_run_%s.conf",                     testname);  }  else    config_filename = GNUNET_strdup ("test_testbed_api.conf");  GNUNET_free (testname);  argv2[2] = config_filename;  result = GNUNET_SYSERR;  ret =      GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,                          "test_testbed_api_testbed_run", "nohelp", options,                          &run, NULL);  GNUNET_free (config_filename);  if ((GNUNET_OK != ret) || (GNUNET_OK != result))    return 1;  return 0;}

intmain (int argc, char **argv){   static const struct GNUNET_GETOPT_CommandLineOption options[] = {        GNUNET_GETOPT_OPTION_END   };  GNUNET_PROGRAM_run (argc, argv, "gnunet-consensus",		      "help",		      options, &run, NULL);  return 0;}

/** * The main function to obtain peer information. * * @param argc number of arguments from the command line * @param argv command line arguments * @return 0 ok, 1 on error */intmain (int argc, char *const *argv){  static const struct GNUNET_GETOPT_CommandLineOption options[] = {    GNUNET_GETOPT_OPTION_END  };  return (GNUNET_OK ==          GNUNET_PROGRAM_run (argc, argv, "gnunet-core",                              gettext_noop                              ("Print information about connected peers."),                              options, &run, NULL)) ? 0 : 1;}