Program library

Start command-line programs. More...

Typedefs
typedef void(*	GNUNET_PROGRAM_Main) (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Main function that will be run. More...

Functions
enum GNUNET_GenericReturnValue	GNUNET_PROGRAM_run2 (int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls, int run_without_scheduler)
	Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options). More...
enum GNUNET_GenericReturnValue	GNUNET_PROGRAM_run (int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
	Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options). More...

Detailed Description

Start command-line programs.

Typedef Documentation

GNUNET_PROGRAM_Main

typedef void(* GNUNET_PROGRAM_Main) (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)

Main function that will be run.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
cfg	configuration

Definition at line 56 of file gnunet_program_lib.h.

Function Documentation

GNUNET_PROGRAM_run2()

enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run2	(	int	argc,
		char *const *	argv,
		const char *	binaryName,
		const char *	binaryHelp,
		const struct GNUNET_GETOPT_CommandLineOption *	options,
		GNUNET_PROGRAM_Main	task,
		void *	task_cls,
		int	run_without_scheduler
	)

Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).

Parameters

argc	number of command line arguments in argv
argv	command line arguments
binaryName	our expected name
binaryHelp	help text for the program
options	command line options
task	main function to run
task_cls	closure for task
run_without_scheduler	GNUNET_NO start the scheduler, GNUNET_YES do not start the scheduler just run the main task

Returns

GNUNET_SYSERR on error, GNUNET_NO if successful option processing called for the program to terminate, GNUNET_OK on success (#a task was invoked)

Definition at line 126 of file program.c.

References _, CommandContext::args, bindtextdomain, CommandContext::cfg, CommandContext::cfgfile, cleanup(), cmd_sorter(), GNUNET_OS_ProjectData::config_file, DIR_SEPARATOR_STR, getenv(), GNUNET_OS_ProjectData::gettext_domain, GNUNET_OS_ProjectData::gettext_path, GNUNET_array_append, GNUNET_asprintf(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_have_value(), GNUNET_CONFIGURATION_load(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GETOPT_option_cfgfile(), GNUNET_GETOPT_option_help(), GNUNET_GETOPT_option_logfile(), GNUNET_GETOPT_option_loglevel(), GNUNET_GETOPT_option_version(), GNUNET_GETOPT_run(), GNUNET_log, GNUNET_log_setup(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_LOCALEDIR, GNUNET_OS_project_data_get(), GNUNET_RESOLVER_connect(), GNUNET_SCHEDULER_run(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_TIME_set_offset(), GNUNET_YES, name, program_main(), ret, CommandContext::task, CommandContext::task_cls, textdomain, GNUNET_OS_ProjectData::user_config_file, and GNUNET_OS_ProjectData::version.

Referenced by GNUNET_PROGRAM_run(), and main().

{
  struct CommandContext cc;

#if ENABLE_NLS
  char *path;
#endif
  char *loglev;
  char *logfile;
  char *cfg_fn;
  const char *xdg;
  enum GNUNET_GenericReturnValue ret;
  int iret;
  unsigned int cnt;
  unsigned long long skew_offset;
  unsigned long long skew_variance;
  long long clock_offset;
  struct GNUNET_CONFIGURATION_Handle *cfg;
  const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get ();
  struct GNUNET_GETOPT_CommandLineOption defoptions[] =
  { GNUNET_GETOPT_option_cfgfile (&cc.cfgfile),
    GNUNET_GETOPT_option_help (binaryHelp),
    GNUNET_GETOPT_option_loglevel (&loglev),
    GNUNET_GETOPT_option_logfile (&logfile),
    GNUNET_GETOPT_option_version (pd->version) };
  struct GNUNET_GETOPT_CommandLineOption *allopts;
  const char *gargs;
  char *lpfx;
  char *spc;

  logfile = NULL;
  gargs = getenv ("GNUNET_ARGS");
  if (NULL != gargs)
  {
    char **gargv;
    unsigned int gargc;
    char *cargs;

    gargv = NULL;
    gargc = 0;
    for (int i = 0; i < argc; i++)
      GNUNET_array_append (gargv, gargc, GNUNET_strdup (argv[i]));
    cargs = GNUNET_strdup (gargs);
    for (char *tok = strtok (cargs, " "); NULL != tok; tok = strtok (NULL, " "))
      GNUNET_array_append (gargv, gargc, GNUNET_strdup (tok));
    GNUNET_free (cargs);
    GNUNET_array_append (gargv, gargc, NULL);
    argv = (char *const *) gargv;
    argc = gargc - 1;
  }
  memset (&cc, 0, sizeof(cc));
  loglev = NULL;
  cc.task = task;
  cc.task_cls = task_cls;
  cc.cfg = cfg = GNUNET_CONFIGURATION_create ();
  /* prepare */
#if ENABLE_NLS
  if (NULL != pd->gettext_domain)
  {
    setlocale (LC_ALL, "");
    path = (NULL == pd->gettext_path)
           ? GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR)
           : GNUNET_strdup (pd->gettext_path);
    if (NULL != path)
    {
      bindtextdomain (pd->gettext_domain, path);
      GNUNET_free (path);
    }
    textdomain (pd->gettext_domain);
  }
#endif
  cnt = 0;
  while (NULL != options[cnt].name)
    cnt++;
  allopts =
    GNUNET_malloc ((cnt + 1) * sizeof(struct GNUNET_GETOPT_CommandLineOption)
                   + sizeof(defoptions));
  GNUNET_memcpy (allopts, defoptions, sizeof(defoptions));
  GNUNET_memcpy (&allopts[sizeof(defoptions)
                          / sizeof(struct GNUNET_GETOPT_CommandLineOption)],
                 options,
                 (cnt + 1) * sizeof(struct GNUNET_GETOPT_CommandLineOption));
  cnt += sizeof(defoptions) / sizeof(struct GNUNET_GETOPT_CommandLineOption);
  qsort (allopts,
         cnt,
         sizeof(struct GNUNET_GETOPT_CommandLineOption),
         &cmd_sorter);
  loglev = NULL;
  if ((NULL != pd->config_file) && (NULL != pd->user_config_file))
  {
    xdg = getenv ("XDG_CONFIG_HOME");
    if (NULL != xdg)
      GNUNET_asprintf (&cfg_fn,
                       "%s%s%s",
                       xdg,
                       DIR_SEPARATOR_STR,
                       pd->config_file);
    else
      cfg_fn = GNUNET_strdup (pd->user_config_file);
  }
  else
    cfg_fn = NULL;
  lpfx = GNUNET_strdup (binaryName);
  if (NULL != (spc = strstr (lpfx, " ")))
    *spc = '\0';
  iret = GNUNET_GETOPT_run (binaryName,
                            allopts,
                            (unsigned int) argc,
                            argv);
  if ((GNUNET_OK > iret) ||
      (GNUNET_OK != GNUNET_log_setup (lpfx,
                                      loglev,
                                      logfile)))
  {
    GNUNET_free (allopts);
    GNUNET_free (lpfx);
    ret = (enum GNUNET_GenericReturnValue) iret;
    goto cleanup;
  }
  if (NULL != cc.cfgfile)
  {
    if ((GNUNET_YES != GNUNET_DISK_file_test (cc.cfgfile)) ||
        (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, cc.cfgfile)))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ (
                    "Unreadable or malformed configuration file `%s', exit ...\n"),
                  cc.cfgfile);
      ret = GNUNET_SYSERR;
      GNUNET_free (allopts);
      GNUNET_free (lpfx);
      goto cleanup;
    }
  }
  else
  {
    if ((NULL != cfg_fn) && (GNUNET_YES == GNUNET_DISK_file_test (cfg_fn)))
    {
      if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, cfg_fn))
      {
        GNUNET_log (
          GNUNET_ERROR_TYPE_ERROR,
          _ (
            "Unreadable or malformed default configuration file `%s', exit ...\n"),
          cfg_fn);
        ret = GNUNET_SYSERR;
        GNUNET_free (allopts);
        GNUNET_free (lpfx);
        goto cleanup;
      }
    }
    else if (NULL != cfg_fn)
    {
      GNUNET_free (cfg_fn);
      cfg_fn = NULL;
      if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, NULL))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    _ ("Unreadable or malformed configuration, exit ...\n"));
        ret = GNUNET_SYSERR;
        GNUNET_free (allopts);
        GNUNET_free (lpfx);
        goto cleanup;
      }
    }
  }
  GNUNET_free (allopts);
  GNUNET_free (lpfx);
  if ((GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_number (cc.cfg,
                                              "testing",
                                              "skew_offset",
                                              &skew_offset)) &&
      (GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_number (cc.cfg,
                                              "testing",
                                              "skew_variance",
                                              &skew_variance)))
  {
    clock_offset = skew_offset - skew_variance;
    GNUNET_TIME_set_offset (clock_offset);
  }
  /* ARM needs to know which configuration file to use when starting
     services.  If we got a command-line option *and* if nothing is
     specified in the configuration, remember the command-line option
     in "cfg".  This is typically really only having an effect if we
     are running code in src/arm/, as obviously the rest of the code
     has little business with ARM-specific options. */
  if (GNUNET_YES !=
      GNUNET_CONFIGURATION_have_value (cfg,
                                       "arm",
                                       "CONFIG"))
  {
    if (NULL != cc.cfgfile)
      GNUNET_CONFIGURATION_set_value_string (cfg,
                                             "arm",
                                             "CONFIG",
                                             cc.cfgfile);
    else if (NULL != cfg_fn)
      GNUNET_CONFIGURATION_set_value_string (cfg,
                                             "arm",
                                             "CONFIG",
                                             cfg_fn);
  }

  /* run */
  cc.args = &argv[iret];
  if ((NULL == cc.cfgfile) && (NULL != cfg_fn))
    cc.cfgfile = GNUNET_strdup (cfg_fn);
  if (GNUNET_NO == run_without_scheduler)
  {
    GNUNET_SCHEDULER_run (&program_main, &cc);
  }
  else
  {
    GNUNET_RESOLVER_connect (cc.cfg);
    cc.task (cc.task_cls, cc.args, cc.cfgfile, cc.cfg);
  }
  ret = GNUNET_OK;
cleanup:
  GNUNET_CONFIGURATION_destroy (cfg);
  GNUNET_free (cc.cfgfile);
  GNUNET_free (cfg_fn);
  GNUNET_free (loglev);
  GNUNET_free (logfile);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PROGRAM_run()

enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run	(	int	argc,
		char *const *	argv,
		const char *	binaryName,
		const char *	binaryHelp,
		const struct GNUNET_GETOPT_CommandLineOption *	options,
		GNUNET_PROGRAM_Main	task,
		void *	task_cls
	)

Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).

Parameters

argc	number of command line arguments
argv	command line arguments
binaryName	our expected name
binaryHelp	helptext for "-h" option (about the app)
options	command line options
task	main function to run
task_cls	closure for task

Returns

GNUNET_SYSERR on error, GNUNET_NO if successful option processing called for the program to terminate, GNUNET_OK on success (#a task was invoked)

Definition at line 363 of file program.c.

References GNUNET_NO, and GNUNET_PROGRAM_run2().

Referenced by GNUNET_TESTBED_test_run(), GNUNET_TRANSPORT_TESTING_connect_check(), and main().

{
  return GNUNET_PROGRAM_run2 (argc,
                              argv,
                              binaryName,
                              binaryHelp,
                              options,
                              task,
                              task_cls,
                              GNUNET_NO);
}

Here is the call graph for this function:

Here is the caller graph for this function: