Program library

Start command-line programs. More...

Collaboration diagram for Program library:

Macros
#define	GNUNET_DAEMON_MAIN(daemon_name, daemon_help, init_cb)

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 (const struct GNUNET_OS_ProjectData *pd, 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 (const struct GNUNET_OS_ProjectData *pd, 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...
enum GNUNET_GenericReturnValue	GNUNET_DAEMON_register (const char *daemon_name, const char *daemon_desc, GNUNET_PROGRAM_Main task)
void	GNUNET_PROGRAM_monolith_main (const struct GNUNET_OS_ProjectData *pd, int argc, char *const *argv, struct GNUNET_CONFIGURATION_Handle *cfg)
	Start all services and daemons in a single process. More...
enum GNUNET_GenericReturnValue	GNUNET_PROGRAM_conf_and_options (const struct GNUNET_OS_ProjectData *pd, int argc, char *const *argv, struct GNUNET_CONFIGURATION_Handle *cfg)
	Create configuration handle from options and configuration file. More...
void	GNUNET_DAEMON_main (const struct GNUNET_OS_ProjectData *pd, int argc, char *const *argv, struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_GenericReturnValue with_scheduler)
	Run the mainloop in a monolithic libgnunet. More...

Detailed Description

Start command-line programs.

Macro Definition Documentation

GNUNET_DAEMON_MAIN

#define GNUNET_DAEMON_MAIN	(		daemon_name,
			daemon_help,
			init_cb
	)

Value:

        int \
        main (int argc, \
              char *const *argv) \
        { \
          int ret; \
          struct GNUNET_GETOPT_CommandLineOption options[] = { \
            GNUNET_GETOPT_OPTION_END \
          }; \
          ret =  GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (), \
                                     argc,                             \
                                     argv, \
                                     daemon_name, \
                                     daemon_help, \
                                     options, \
                                     init_cb, \
                                     NULL); \
          return ret; \
        }

Definition at line 150 of file gnunet_program_lib.h.

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	(	const struct GNUNET_OS_ProjectData *	pd,
		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

pd	project data for the project the program belongs to
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 132 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_GETOPT_CommandLineOption defoptions[] = {
    GNUNET_GETOPT_option_cfgfile (&cc.cfgfile),
    GNUNET_GETOPT_option_help (pd,
                               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 (pd);
  /* prepare */
#if ENABLE_NLS
  if (NULL != pd->gettext_domain)
  {
    setlocale (LC_ALL, "");
    path = (NULL == pd->gettext_path)
      ? GNUNET_OS_installation_get_path (pd,
                                         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 (pd);
  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;
}

References _, CommandContext::args, bindtextdomain, cfg, CommandContext::cfg, CommandContext::cfgfile, cleanup(), cmd_sorter(), GNUNET_OS_ProjectData::config_file, getenv(), GNUNET_OS_ProjectData::gettext_domain, GNUNET_OS_ProjectData::gettext_path, GNUNET_array_append, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_default_filename(), 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_DEBUG, 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_memcpy, GNUNET_new_array, GNUNET_NO, GNUNET_OK, GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_LOCALEDIR, GNUNET_RESOLVER_connect(), GNUNET_SCHEDULER_run(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_TIME_set_offset(), GNUNET_YES, name, GNUNET_GETOPT_CommandLineOption::name, options, program_main(), ret, GNUNET_GETOPT_CommandLineOption::shortName, CommandContext::task, CommandContext::task_cls, textdomain, GNUNET_OS_ProjectData::user_config_file, and GNUNET_OS_ProjectData::version.

Referenced by GNUNET_PROGRAM_run(), and main().

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	(	const struct GNUNET_OS_ProjectData *	pd,
		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

pd	project data for the project the program belongs to
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 407 of file program.c.

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

References GNUNET_NO, GNUNET_PROGRAM_run2(), and options.

Referenced by GNUNET_TRANSPORT_TESTING_connect_check(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DAEMON_register()

enum GNUNET_GenericReturnValue GNUNET_DAEMON_register	(	const char *	daemon_name,
		const char *	daemon_desc,
		GNUNET_PROGRAM_Main	task
	)

Definition at line 683 of file program.c.

{
  struct DaemonHandleList *hle;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "registering daemon %s\n",
       daemon_name);
  hle = GNUNET_new (struct DaemonHandleList);
  hle->d = task;
  hle->daemon_name = daemon_name;
  GNUNET_CONTAINER_DLL_insert (hll_head,
                               hll_tail,
                               hle);
  return GNUNET_OK;
}

References DaemonHandleList::d, DaemonHandleList::daemon_name, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_OK, hll_head, hll_tail, and LOG.

GNUNET_PROGRAM_monolith_main()

void GNUNET_PROGRAM_monolith_main	(	const struct GNUNET_OS_ProjectData *	pd,
		int	argc,
		char *const *	argv,
		struct GNUNET_CONFIGURATION_Handle *	cfg
	)

Start all services and daemons in a single process.

Parameters

pd	project data for the project the program belongs to
argc	number of command line arguments
argv	command line arguments

Definition at line 582 of file program.c.

{
  struct MonoContext mc = {
    .cfg = cfg,
    .pd = pd
  };
 
  if (GNUNET_YES !=
      GNUNET_PROGRAM_conf_and_options (pd,
                                       argc,
                                       argv,
                                       cfg))
    return;
  GNUNET_SCHEDULER_run (&monolith_main,
                        &mc);
}

References cfg, GNUNET_PROGRAM_conf_and_options(), GNUNET_SCHEDULER_run(), GNUNET_YES, mc, monolith_main(), GNUNET_CONFIGURATION_Handle::pd, and MonoContext::pd.

Here is the call graph for this function:

GNUNET_PROGRAM_conf_and_options()

enum GNUNET_GenericReturnValue GNUNET_PROGRAM_conf_and_options	(	const struct GNUNET_OS_ProjectData *	pd,
		int	argc,
		char *const *	argv,
		struct GNUNET_CONFIGURATION_Handle *	cfg
	)

Create configuration handle from options and configuration file.

Parameters

pd	project data for the project the program belongs to
argc	number of command line arguments
argv	command line arguments

Definition at line 429 of file program.c.

{
  char *cfg_filename;
  char *opt_cfg_filename;
  char *logfile;
  char *loglev;
  const char *xdg;
  int do_daemonize;
  int ret;
  struct GNUNET_GETOPT_CommandLineOption service_options[] = {
    GNUNET_GETOPT_option_cfgfile (&opt_cfg_filename),
    GNUNET_GETOPT_option_flag ('d',
                               "daemonize",
                               gettext_noop (
                                 "do daemonize (detach from terminal)"),
                               &do_daemonize),
    GNUNET_GETOPT_option_help (pd,
                               NULL),
    GNUNET_GETOPT_option_loglevel (&loglev),
    GNUNET_GETOPT_option_logfile (&logfile),
    GNUNET_GETOPT_option_version (pd->version),
    GNUNET_GETOPT_OPTION_END
  };
 
  xdg = getenv ("XDG_CONFIG_HOME");
  if (NULL != xdg)
    GNUNET_asprintf (&cfg_filename,
                     "%s%s%s",
                     xdg,
                     DIR_SEPARATOR_STR,
                     pd->config_file);
  else
    cfg_filename = GNUNET_strdup (pd->user_config_file);
 
  loglev = NULL;
  logfile = NULL;
  opt_cfg_filename = NULL;
  // FIXME we need to set this up for each service!
  ret = GNUNET_GETOPT_run ("libgnunet",
                           service_options,
                           argc,
                           argv);
  if (GNUNET_SYSERR == ret)
    goto error;
  if (GNUNET_NO == ret)
  {
    goto error;
  }
  // FIXME we need to set this up for each service!
  // NOTE: that was not the idea. What are you proposing? -CG
  if (GNUNET_OK !=
      GNUNET_log_setup ("libgnunet",
                        "DEBUG",// loglev,
                        logfile))
  {
    GNUNET_break (0);
    goto error;
  }
  if (NULL == cfg)
  {
    cfg = GNUNET_CONFIGURATION_create (pd);
    if (NULL != opt_cfg_filename)
    {
      if ( (GNUNET_YES !=
            GNUNET_DISK_file_test (opt_cfg_filename)) ||
           (GNUNET_SYSERR ==
            GNUNET_CONFIGURATION_load (cfg,
                                       opt_cfg_filename)) )
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    _ ("Malformed configuration file `%s', exit ...\n"),
                    opt_cfg_filename);
        goto error;
      }
    }
    else
    {
      if (GNUNET_YES ==
          GNUNET_DISK_file_test (cfg_filename))
      {
        if (GNUNET_SYSERR ==
            GNUNET_CONFIGURATION_load (cfg,
                                       cfg_filename))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                      _ ("Malformed configuration file `%s', exit ...\n"),
                      cfg_filename);
          GNUNET_free (cfg_filename);
          goto error;;
        }
      }
      else
      {
        if (GNUNET_SYSERR ==
            GNUNET_CONFIGURATION_load (cfg,
                                       NULL))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                      _ ("Malformed configuration, exit ...\n"));
          GNUNET_free (cfg_filename);
          goto error;
        }
      }
    }
  }
 
  GNUNET_free (logfile);
  GNUNET_free (loglev);
  GNUNET_free (cfg_filename);
  GNUNET_free (opt_cfg_filename);
 
  return GNUNET_OK;
 
error:
  GNUNET_SPEEDUP_stop_ ();
  GNUNET_CONFIGURATION_destroy (cfg);
  GNUNET_free (logfile);
  GNUNET_free (loglev);
  GNUNET_free (cfg_filename);
  GNUNET_free (opt_cfg_filename);
 
  return GNUNET_SYSERR;
}

References _, cfg, cfg_filename, GNUNET_OS_ProjectData::config_file, DIR_SEPARATOR_STR, getenv(), gettext_noop, GNUNET_asprintf(), GNUNET_break, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_load(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GETOPT_option_cfgfile(), GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), 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_NO, GNUNET_OK, GNUNET_SPEEDUP_stop_(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_YES, ret, GNUNET_OS_ProjectData::user_config_file, and GNUNET_OS_ProjectData::version.

Referenced by GNUNET_DAEMON_main(), GNUNET_PROGRAM_monolith_main(), and GNUNET_SERVICE_main().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DAEMON_main()

void GNUNET_DAEMON_main	(	const struct GNUNET_OS_ProjectData *	pd,
		int	argc,
		char *const *	argv,
		struct GNUNET_CONFIGURATION_Handle *	cfg,
		enum GNUNET_GenericReturnValue	with_scheduler
	)

Run the mainloop in a monolithic libgnunet.

Must be called such that services are actually launched.

Parameters

pd	project data for the project the program belongs to
argc	number of command line arguments
argv	command line arguments

Definition at line 658 of file program.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Entering GNUNET_DAEMON_main\n");
  if (GNUNET_YES == with_scheduler)
  {
    if (GNUNET_YES !=
        GNUNET_PROGRAM_conf_and_options (pd,
                                         argc,
                                         argv,
                                         cfg))
      return;
    GNUNET_SCHEDULER_run (&launch_daemons,
                          cfg);
  }
  else
    launch_daemons (cfg);
}

References cfg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_PROGRAM_conf_and_options(), GNUNET_SCHEDULER_run(), GNUNET_YES, launch_daemons(), LOG, and GNUNET_CONFIGURATION_Handle::pd.

Referenced by monolith_main().

Here is the call graph for this function:

Here is the caller graph for this function: