Program library

Start command-line programs. More...

Collaboration diagram for Program library:

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 64 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 111 of file program.c.

{
  struct CommandContext cc;
 
#if ENABLE_NLS
  char *path;
#endif
  char *loglev;
  char *logfile;
  char *cfg_fn;
  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 ();
  const 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)
  };
  unsigned int deflen = sizeof(defoptions) / sizeof(defoptions[0]);
  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_new_array (cnt + deflen + 1,
                              struct GNUNET_GETOPT_CommandLineOption);
  GNUNET_memcpy (allopts,
                 options,
                 cnt * sizeof(struct GNUNET_GETOPT_CommandLineOption));
  {
    unsigned int xtra = 0;
 
    for (unsigned int i = 0;
         i<sizeof (defoptions) / sizeof(struct GNUNET_GETOPT_CommandLineOption);
         i++)
    {
      bool found = false;
 
      for (unsigned int j = 0; j<cnt; j++)
      {
        found |= ( (options[j].shortName == defoptions[i].shortName) &&
                   (0 != options[j].shortName) );
        found |= ( (NULL != options[j].name) &&
                   (NULL != defoptions[i].name) &&
                   (0 == strcmp (options[j].name,
                                 defoptions[i].name)) );
        if (found)
          break;
      }
      if (found)
        continue;
      GNUNET_memcpy (&allopts[cnt + xtra],
                     &defoptions[i],
                     sizeof (struct GNUNET_GETOPT_CommandLineOption));
      xtra++;
    }
    cnt += xtra;
  }
  qsort (allopts,
         cnt,
         sizeof(struct GNUNET_GETOPT_CommandLineOption),
         &cmd_sorter);
  loglev = NULL;
  if ((NULL != pd->config_file) && (NULL != pd->user_config_file))
    cfg_fn = GNUNET_CONFIGURATION_default_filename ();
  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)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Loading configuration from entry point specified as option (%s)\n",
                cc.cfgfile);
    if (GNUNET_YES !=
        GNUNET_DISK_file_test (cc.cfgfile))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Unreadable configuration file `%s', exiting ...\n"),
                  cc.cfgfile);
      ret = GNUNET_SYSERR;
      GNUNET_free (allopts);
      GNUNET_free (lpfx);
      goto cleanup;
    }
    if (GNUNET_SYSERR ==
        GNUNET_CONFIGURATION_load (cfg,
                                   cc.cfgfile))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Malformed configuration file `%s', exiting ...\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)) )
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Unreadable configuration file `%s'. Exiting ...\n"),
                  cfg_fn);
      ret = GNUNET_SYSERR;
      GNUNET_free (allopts);
      GNUNET_free (lpfx);
      goto cleanup;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Loading configuration from entry point `%s'\n",
                cc.cfgfile);
    if (GNUNET_SYSERR ==
        GNUNET_CONFIGURATION_load (cfg,
                                   cfg_fn))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Malformed configuration. Exiting ...\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;
}

Referenced by main().

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 111 of file program.c.

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

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

Here is the caller graph for this function: