Configuration library

Configuration management. More...

Collaboration diagram for Configuration library:

Data Structures
struct	GNUNET_CONFIGURATION_ConfigSettings
	Closure for GNUNET_CONFIGURATION_config_tool_run() with settings for what should be done with the configuration. More...

Macros
#define	GNUNET_CONFIGURATION_CONFIG_OPTIONS(cs)
	Macro that expands to a set of GNUNET-getopt directives to initialize a struct GNUNET_CONFIGURATION_ConfigSettings from the command line.

Typedefs
typedef void(*	GNUNET_CONFIGURATION_CleanCallback) (void *cls, const char *section, const char *option, unsigned int line)
	Function called for each duplicate definition removed by GNUNET_CONFIGURATION_clean_file().
typedef enum GNUNET_GenericReturnValue(*	GNUNET_CONFIGURATION_Callback) (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Signature of a function to be run with a configuration.
typedef void(*	GNUNET_CONFIGURATION_Iterator) (void *cls, const char *section, const char *option, const char *value)
	Function to iterate over options.
typedef void(*	GNUNET_CONFIGURATION_SectionIterator) (void *cls, const char *section)
	Function to iterate over all configuration sections.

Functions
struct GNUNET_CONFIGURATION_Handle *	GNUNET_CONFIGURATION_create (const struct GNUNET_OS_ProjectData *pd)
	Create a new configuration object.
struct GNUNET_CONFIGURATION_Handle *	GNUNET_CONFIGURATION_dup (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Duplicate an existing configuration object.
void	GNUNET_CONFIGURATION_destroy (struct GNUNET_CONFIGURATION_Handle *cfg)
	Destroy configuration object.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_load (struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
	Load configuration.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_load_from (struct GNUNET_CONFIGURATION_Handle *cfg, const char *defaults_d)
	Load default configuration.
char *	GNUNET_CONFIGURATION_default_filename (const struct GNUNET_OS_ProjectData *pd)
	Return the filename of the default configuration filename that is used when no explicit configuration entry point has been specified.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_parse (struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
	Parse a configuration file, add all of the options in the file to the configuration environment.
char *	GNUNET_CONFIGURATION_serialize (const struct GNUNET_CONFIGURATION_Handle *cfg, size_t *size)
	Serializes the given configuration.
char *	GNUNET_CONFIGURATION_serialize_diagnostics (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Serializes the given configuration with diagnostics information.
char *	GNUNET_CONFIGURATION_serialize_diagnostics_verbose (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Serializes the given configuration with verbose diagnostics information, including all source definitions of each value.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_clean_file (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename, GNUNET_CONFIGURATION_CleanCallback cb, void *cb_cls, unsigned int *removed)
	Remove redundant option definitions from a parsed configuration file.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_deserialize (struct GNUNET_CONFIGURATION_Handle *cfg, const char *mem, size_t size, const char *source_filename)
	De-serializes configuration.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_write (struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
	Write configuration file.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_write_diffs (const struct GNUNET_CONFIGURATION_Handle *cfg_default, const struct GNUNET_CONFIGURATION_Handle *cfg_new, const char *filename)
	Write only configuration entries that have been changed to configuration file.
struct GNUNET_CONFIGURATION_Handle *	GNUNET_CONFIGURATION_get_diff (const struct GNUNET_CONFIGURATION_Handle *cfg_default, const struct GNUNET_CONFIGURATION_Handle *cfg_new)
	Compute configuration with only entries that have been changed.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_is_dirty (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Test if there are configuration options that were changed since the last save.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_parse_and_run (const struct GNUNET_OS_ProjectData *pd, const char *filename, GNUNET_CONFIGURATION_Callback cb, void *cb_cls)
	Parse a configuration file filename and run the function cb with the resulting configuration object.
void	GNUNET_CONFIGURATION_enable_diagnostics (struct GNUNET_CONFIGURATION_Handle *cfg)
	Enable extra diagnostics.
const struct GNUNET_OS_ProjectData *	GNUNET_CONFIGURATION_get_project_data (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Return the project data associated with this configuration.
void	GNUNET_CONFIGURATION_iterate (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CONFIGURATION_Iterator iter, void *iter_cls)
	Iterate over all options in the configuration.
void	GNUNET_CONFIGURATION_iterate_sections (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CONFIGURATION_SectionIterator iter, void *iter_cls)
	Iterate over all sections in the configuration.
void	GNUNET_CONFIGURATION_remove_section (struct GNUNET_CONFIGURATION_Handle *cfg, const char *section)
	Remove the given section and all options in it.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_get_value_number (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
	Get a configuration value that should be a number.
void	GNUNET_CONFIGURATION_set_value_float (struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, float number)
	Set a configuration value that should be a float.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_get_value_float (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, float *number)
	Get a configuration value that should be a floating point number.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_get_value_time (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
	Get a configuration value that should be a relative time.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_get_value_size (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *size)
	Get a configuration value that should be a size in bytes.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_have_value (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
	Test if we have a value for a particular option.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_get_value_string (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
	Get a configuration value that should be a string.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_get_value_filename (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
	Get a configuration value that should be the name of a file or directory.
int	GNUNET_CONFIGURATION_iterate_value_filenames (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, GNUNET_FileNameCallback cb, void *cb_cls)
	Iterate over the set of filenames stored in a configuration value.
void	GNUNET_CONFIGURATION_iterate_section_values (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, GNUNET_CONFIGURATION_Iterator iter, void *iter_cls)
	Iterate over values of a section in the configuration.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_get_value_choice (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *const *choices, const char **value)
	Get a configuration value that should be in a set of predefined strings.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_get_value_yesno (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
	Get a configuration value that should be in a set of "YES" or "NO".
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_get_data (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, void *buf, size_t buf_size)
	Get Crockford32-encoded fixed-size binary data from a configuration.
char *	GNUNET_CONFIGURATION_expand_dollar (const struct GNUNET_CONFIGURATION_Handle *cfg, char *orig)
	Expand an expression of the form "$FOO/BAR" to "DIRECTORY/BAR" where either in the "PATHS" section or the environment "FOO" is set to "DIRECTORY".
void	GNUNET_CONFIGURATION_set_value_number (struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long number)
	Set a configuration value that should be a number.
void	GNUNET_CONFIGURATION_set_value_string (struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
	Set a configuration value that should be a string.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_remove_value_filename (struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
	Remove a filename from a configuration value that represents a list of filenames.
enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_append_value_filename (struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
	Append a filename to a configuration value that represents a list of filenames.
void	GNUNET_CONFIGURATION_config_settings_free (struct GNUNET_CONFIGURATION_ConfigSettings *cs)
	Free resources associated with cs.
void	GNUNET_CONFIGURATION_config_tool_run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Main task to run to perform operations typical for gnunet-config as per the configuration settings given in cls.
char *	GNUNET_CONFIGURATION_get_suid_binary_path (const struct GNUNET_OS_ProjectData *pd, const struct GNUNET_CONFIGURATION_Handle *cfg, const char *progname)
	Given the name of a helper, service or daemon binary construct the full path to the binary using the SUID_BINARY_PATH in the PATHS section of the configuration.

Detailed Description

Configuration management.

Macro Definition Documentation

GNUNET_CONFIGURATION_CONFIG_OPTIONS

#define GNUNET_CONFIGURATION_CONFIG_OPTIONS

(

cs

)

Macro that expands to a set of GNUNET-getopt directives to initialize a struct GNUNET_CONFIGURATION_ConfigSettings from the command line.

Parameters

cs	configuration settings to initialize

Definition at line 818 of file gnunet_configuration_lib.h.

{
#endif
#ifdef __cplusplus
}
#endif
 
#endif
 
 

Typedef Documentation

GNUNET_CONFIGURATION_CleanCallback

typedef void(* GNUNET_CONFIGURATION_CleanCallback) (void *cls, const char *section, const char *option, unsigned int line)

Function called for each duplicate definition removed by GNUNET_CONFIGURATION_clean_file().

Parameters

cls	closure
section	configuration section
option	configuration option
line	line removed from the target file

Definition at line 193 of file gnunet_configuration_lib.h.

GNUNET_CONFIGURATION_Callback

typedef enum GNUNET_GenericReturnValue(* GNUNET_CONFIGURATION_Callback) (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)

Signature of a function to be run with a configuration.

Parameters

cls	closure
cfg	the configuration

Returns

status code

Definition at line 290 of file gnunet_configuration_lib.h.

GNUNET_CONFIGURATION_Iterator

typedef void(* GNUNET_CONFIGURATION_Iterator) (void *cls, const char *section, const char *option, const char *value)

Function to iterate over options.

Parameters

cls	closure
section	name of the section
option	name of the option
value	value of the option

Definition at line 356 of file gnunet_configuration_lib.h.

GNUNET_CONFIGURATION_SectionIterator

typedef void(* GNUNET_CONFIGURATION_SectionIterator) (void *cls, const char *section)

Function to iterate over all configuration sections.

Parameters

cls	closure
section	name of the section

Definition at line 369 of file gnunet_configuration_lib.h.

Function Documentation

GNUNET_CONFIGURATION_create()

struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create

(

const struct GNUNET_OS_ProjectData *

pd

)

Create a new configuration object.

Parameters

pd	project data to use to determine paths

Returns

fresh configuration object

Definition at line 259 of file configuration.c.

{
  struct GNUNET_CONFIGURATION_Handle *cfg;
  char *p;
 
  cfg = GNUNET_new (struct GNUNET_CONFIGURATION_Handle);
  cfg->pd = pd;
  /* make certain values from the project data available
     as PATHS */
  p = GNUNET_OS_installation_get_path (pd,
                                       GNUNET_OS_IPK_DATADIR);
  if (NULL != p)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg,
                                           "PATHS",
                                           "DATADIR",
                                           p);
    GNUNET_free (p);
  }
  p = GNUNET_OS_installation_get_path (pd,
                                       GNUNET_OS_IPK_LIBDIR);
  if (NULL != p)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg,
                                           "PATHS",
                                           "LIBDIR",
                                           p);
    GNUNET_free (p);
  }
  p = GNUNET_OS_installation_get_path (pd,
                                       GNUNET_OS_IPK_BINDIR);
  if (NULL != p)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg,
                                           "PATHS",
                                           "BINDIR",
                                           p);
    GNUNET_free (p);
  }
  p = GNUNET_OS_installation_get_path (pd,
                                       GNUNET_OS_IPK_PREFIX);
  if (NULL != p)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg,
                                           "PATHS",
                                           "PREFIX",
                                           p);
    GNUNET_free (p);
  }
  p = GNUNET_OS_installation_get_path (pd,
                                       GNUNET_OS_IPK_LOCALEDIR);
  if (NULL != p)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg,
                                           "PATHS",
                                           "LOCALEDIR",
                                           p);
    GNUNET_free (p);
  }
  p = GNUNET_OS_installation_get_path (pd,
                                       GNUNET_OS_IPK_ICONDIR);
  if (NULL != p)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg,
                                           "PATHS",
                                           "ICONDIR",
                                           p);
    GNUNET_free (p);
  }
  p = GNUNET_OS_installation_get_path (pd,
                                       GNUNET_OS_IPK_DOCDIR);
  if (NULL != p)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg,
                                           "PATHS",
                                           "DOCDIR",
                                           p);
    GNUNET_free (p);
  }
  p = GNUNET_OS_installation_get_path (pd,
                                       GNUNET_OS_IPK_LIBEXECDIR);
  if (NULL != p)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg,
                                           "PATHS",
                                           "LIBEXECDIR",
                                           p);
    GNUNET_free (p);
  }
  return cfg;
}

References cfg, GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_new, GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_BINDIR, GNUNET_OS_IPK_DATADIR, GNUNET_OS_IPK_DOCDIR, GNUNET_OS_IPK_ICONDIR, GNUNET_OS_IPK_LIBDIR, GNUNET_OS_IPK_LIBEXECDIR, GNUNET_OS_IPK_LOCALEDIR, GNUNET_OS_IPK_PREFIX, p, and GNUNET_CONFIGURATION_Handle::pd.

Referenced by auto_config_cb(), create_unique_cfgs(), gg_load_configuration(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_get_diff(), GNUNET_CONFIGURATION_parse_and_run(), GNUNET_PROGRAM_conf_and_options(), GNUNET_PROGRAM_run2(), GNUNET_SERVICE_run_(), GNUNET_TESTING_get_topo_from_string_(), GNUNET_TRANSPORT_TESTING_start_peer(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), handle_auto_result(), handle_autoconfig_request(), handle_inline(), iter_check_config(), load_member(), load_member_session(), load_member_session_next(), load_operation(), main(), main(), run(), run(), save_member(), save_member_session(), save_operation(), start_peer_run(), and start_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_dup()

struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Duplicate an existing configuration object.

Parameters

cfg	configuration to duplicate

Returns

duplicate configuration

Definition at line 2295 of file configuration.c.

{
  struct GNUNET_CONFIGURATION_Handle *ret;
 
  ret = GNUNET_CONFIGURATION_create (cfg->pd);
  GNUNET_CONFIGURATION_iterate (cfg,
                                &copy_entry,
                                ret);
  return ret;
}

References cfg, copy_entry(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_iterate(), GNUNET_CONFIGURATION_Handle::pd, and ret.

Referenced by auto_config_cb(), create_unique_cfgs(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_NAT_autoconfig_start(), handle_autoconfig_request(), run(), run(), run(), and set_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_destroy()

void GNUNET_CONFIGURATION_destroy

(

struct GNUNET_CONFIGURATION_Handle *

cfg

)

Destroy configuration object.

Parameters

cfg	configuration to destroy

Definition at line 353 of file configuration.c.

{
  struct ConfigSection *sec;
  struct ConfigFile *cf;
 
  while (NULL != (sec = cfg->sections))
    GNUNET_CONFIGURATION_remove_section (cfg, sec->name);
  while (NULL != (cf = cfg->loaded_files_head))
  {
    GNUNET_free (cf->hint_restrict_section);
    GNUNET_free (cf->source_filename);
    GNUNET_CONTAINER_DLL_remove (cfg->loaded_files_head,
                                 cfg->loaded_files_tail,
                                 cf);
    GNUNET_free (cf);
  }
  GNUNET_free (cfg->main_filename);
  GNUNET_free (cfg);
}

References cfg, GNUNET_CONFIGURATION_remove_section(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, ConfigFile::hint_restrict_section, GNUNET_CONFIGURATION_Handle::loaded_files_head, GNUNET_CONFIGURATION_Handle::loaded_files_tail, GNUNET_CONFIGURATION_Handle::main_filename, ConfigSection::name, GNUNET_CONFIGURATION_Handle::sections, and ConfigFile::source_filename.

Referenced by auto_config_cb(), clean_node(), conclude_autoconfig_request(), create_unique_cfgs(), do_shutdown(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_parse_and_run(), GNUNET_CONFIGURATION_write_diffs(), GNUNET_NAT_autoconfig_cancel(), GNUNET_PROGRAM_conf_and_options(), GNUNET_PROGRAM_run2(), GNUNET_SERVICE_run_(), GNUNET_TESTING_get_topo_from_string_(), GNUNET_TRANSPORT_TESTING_start_peer(), GNUNET_TRANSPORT_TESTING_stop_peer(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_stop(), handle_auto_result(), handle_autoconfig_request(), handle_inline(), load_member(), load_member_session(), load_member_session_next(), load_operation(), main(), next_phase(), save_member(), save_member_session(), save_operation(), shutdown_task(), shutdown_task(), shutdown_task(), start_peer_cleanup(), and start_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_load()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	filename
	)

Load configuration.

This function will first parse the defaults and then parse the specific configuration file to overwrite the defaults.

Parameters

[in,out]	cfg	configuration to update
	filename	name of the configuration file, NULL to load defaults

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 3288 of file configuration.c.

{
  char *baseconfig;
  const char *base_config_varname;
 
  if (cfg->load_called)
  {
    /* FIXME:  Make this a GNUNET_assert later */
    GNUNET_break (0);
    GNUNET_free (cfg->main_filename);
  }
  cfg->load_called = true;
  if (NULL != filename)
  {
    GNUNET_free (cfg->main_filename);
    cfg->main_filename = GNUNET_strdup (filename);
  }
 
  base_config_varname = cfg->pd->base_config_varname;
 
  if ((NULL != base_config_varname)
      && (NULL != (baseconfig = getenv (base_config_varname))))
  {
    baseconfig = GNUNET_strdup (baseconfig);
  }
  else
  {
    char *ipath;
 
    ipath = GNUNET_OS_installation_get_path (cfg->pd,
                                             GNUNET_OS_IPK_DATADIR);
    if (NULL == ipath)
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    GNUNET_asprintf (&baseconfig,
                     "%s%s",
                     ipath,
                     "config.d");
    GNUNET_free (ipath);
  }
 
  {
    char *dname = GNUNET_STRINGS_filename_expand (baseconfig);
 
    GNUNET_free (baseconfig);
 
    if ((GNUNET_YES ==
         GNUNET_DISK_directory_test (dname,
                                     GNUNET_YES)) &&
        (GNUNET_SYSERR ==
         GNUNET_CONFIGURATION_load_from (cfg,
                                         dname)))
    {
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "Failed to load base configuration from '%s'\n",
           filename);
      GNUNET_free (dname);
      return GNUNET_SYSERR;     /* no configuration at all found */
    }
    GNUNET_free (dname);
  }
  if ((NULL != filename) &&
      (GNUNET_OK !=
       GNUNET_CONFIGURATION_parse (cfg,
                                   filename)))
  {
    /* specified configuration not found */
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Failed to load configuration from file '%s'\n",
         filename);
    return GNUNET_SYSERR;
  }
  if (((GNUNET_YES !=
        GNUNET_CONFIGURATION_have_value (cfg,
                                         "PATHS",
                                         "DEFAULTCONFIG"))) &&
      (filename != NULL))
    GNUNET_CONFIGURATION_set_value_string (cfg,
                                           "PATHS",
                                           "DEFAULTCONFIG",
                                           filename);
  return GNUNET_OK;
}

References GNUNET_OS_ProjectData::base_config_varname, cfg, filename, getenv(), GNUNET_asprintf(), GNUNET_break, GNUNET_CONFIGURATION_have_value(), GNUNET_CONFIGURATION_load_from(), GNUNET_CONFIGURATION_parse(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_DISK_directory_test(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_OK, GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_DATADIR, GNUNET_strdup, GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, GNUNET_YES, GNUNET_CONFIGURATION_Handle::load_called, LOG, GNUNET_CONFIGURATION_Handle::main_filename, and GNUNET_CONFIGURATION_Handle::pd.

Referenced by auto_config_cb(), create_unique_cfgs(), gg_load_configuration(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_parse_and_run(), GNUNET_PROGRAM_conf_and_options(), GNUNET_PROGRAM_run2(), GNUNET_SERVICE_run_(), GNUNET_TRANSPORT_TESTING_start_peer(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), iter_check_config(), main(), main(), start_peer_run(), and start_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_load_from()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load_from	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	defaults_d
	)

Load default configuration.

This function will parse the defaults from the given defaults_d directory.

Parameters

cfg	configuration to update
defaults_d	directory with the defaults

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 3190 of file configuration.c.

{
  struct CollectFilesContext files_context = {
    .files = NULL,
    .files_length = 0,
  };
  enum GNUNET_GenericReturnValue fun_ret = GNUNET_NO;
 
  if (GNUNET_SYSERR ==
      GNUNET_DISK_directory_scan (defaults_d,
                                  &collect_files_cb,
                                  &files_context))
    return GNUNET_SYSERR; /* no configuration at all found */
  qsort (files_context.files,
         files_context.files_length,
         sizeof (char *),
         &pstrcmp);
  for (unsigned int i = 0; i < files_context.files_length; i++)
  {
    const char *ext;
    const char *filename = files_context.files[i];
 
    /* Examine file extension */
    ext = strrchr (filename, '.');
    if ( (NULL == ext) ||
         (0 != strcmp (ext,
                       ".conf")) )
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Skipping file `%s'\n",
                  filename);
      fun_ret = GNUNET_OK;
      continue;
    }
    fun_ret = GNUNET_CONFIGURATION_parse (cfg,
                                          filename);
    if (fun_ret != GNUNET_OK)
      break;
  }
  if (files_context.files_length > 0)
  {
    for (size_t i = 0; i < files_context.files_length; i++)
      GNUNET_free (files_context.files[i]);
    GNUNET_array_grow (files_context.files,
                       files_context.files_length,
                       0);
  }
  return fun_ret;
}

References cfg, collect_files_cb(), filename, CollectFilesContext::files, CollectFilesContext::files_length, GNUNET_array_grow, GNUNET_CONFIGURATION_parse(), GNUNET_DISK_directory_scan(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, and pstrcmp().

Referenced by GNUNET_CONFIGURATION_load().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_default_filename()

char * GNUNET_CONFIGURATION_default_filename

(

const struct GNUNET_OS_ProjectData *

pd

)

Return the filename of the default configuration filename that is used when no explicit configuration entry point has been specified.

Parameters

pd	project data to use to determine paths

Returns

NULL if no default configuration file can be located, a newly allocated string otherwise

Definition at line 3244 of file configuration.c.

{
  char *cfg_fn;
  const char *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);
 
  if (GNUNET_OK == GNUNET_DISK_file_test_read (cfg_fn))
    return cfg_fn;
  GNUNET_free (cfg_fn);
 
  /* Fall back to /etc/ for the default configuration.
     Should be okay to use forward slashes here. */
 
  GNUNET_asprintf (&cfg_fn,
                   "/etc/%s",
                   pd->config_file);
  if (GNUNET_OK ==
      GNUNET_DISK_file_test_read (cfg_fn))
    return cfg_fn;
  GNUNET_free (cfg_fn);
 
  GNUNET_asprintf (&cfg_fn,
                   "/etc/%s/%s",
                   pd->project_dirname,
                   pd->config_file);
  if (GNUNET_OK ==
      GNUNET_DISK_file_test_read (cfg_fn))
    return cfg_fn;
 
  GNUNET_free (cfg_fn);
  return NULL;
}

References GNUNET_OS_ProjectData::config_file, DIR_SEPARATOR_STR, getenv(), GNUNET_asprintf(), GNUNET_DISK_file_test_read(), GNUNET_free, GNUNET_OK, GNUNET_strdup, GNUNET_OS_ProjectData::project_dirname, and GNUNET_OS_ProjectData::user_config_file.

Referenced by GNUNET_PROGRAM_run2(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_parse()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_parse	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	filename
	)

Parse a configuration file, add all of the options in the file to the configuration environment.

Parameters

cfg	configuration to update
filename	name of the configuration file

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1097 of file configuration.c.

{
  struct ConfigFile *loaded_file;
  uint64_t fs64;
  size_t fs;
  char *fn;
  char *mem;
  int dirty;
  enum GNUNET_GenericReturnValue ret;
  ssize_t sret;
 
  fn = GNUNET_STRINGS_filename_expand (filename);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Asked to parse config file `%s'\n",
       fn);
  if (NULL == fn)
    return GNUNET_SYSERR;
 
 
  /* Check for cycles */
  {
    unsigned int lvl = cfg->current_nest_level;
    struct ConfigFile *cf = cfg->loaded_files_tail;
    struct ConfigFile *parent = NULL;
 
 
    for (; NULL != cf; parent = cf, cf = cf->prev)
    {
      /* Check parents based on level, skipping children of siblings. */
      if (cf->level >= lvl)
        continue;
      lvl = cf->level;
      if ( (NULL == cf->source_filename) ||
           (NULL == filename) )
        continue;
      if (0 == strcmp (cf->source_filename,
                       filename))
      {
        if (NULL == parent)
        {
          LOG (GNUNET_ERROR_TYPE_ERROR,
               "Forbidden direct cyclic configuration import (%s -> %s)\n",
               cf->source_filename,
               filename);
        }
        else
          LOG (GNUNET_ERROR_TYPE_ERROR,
               "Forbidden indirect cyclic configuration import (%s -> ... -> %s -> %s)\n",
               cf->source_filename,
               parent->source_filename,
               filename);
        GNUNET_free (fn);
        return GNUNET_SYSERR;
      }
    }
 
  }
 
  /* Keep track of loaded files.*/
  {
    loaded_file = GNUNET_new (struct ConfigFile);
 
    loaded_file->level = cfg->current_nest_level;
    loaded_file->source_filename = GNUNET_strdup (filename
                                                   ? filename
                                                   : "<input>");
    GNUNET_CONTAINER_DLL_insert_tail (cfg->loaded_files_head,
                                      cfg->loaded_files_tail,
                                      loaded_file);
  }
 
  dirty = cfg->dirty; /* back up value! */
  if (GNUNET_SYSERR ==
      GNUNET_DISK_file_size (fn,
                             &fs64,
                             GNUNET_NO,
                             GNUNET_YES))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Error while determining the file size of `%s'\n",
         fn);
    GNUNET_free (fn);
    return GNUNET_SYSERR;
  }
  if (fs64 > SIZE_MAX)
  {
    GNUNET_break (0);  /* File size is more than the heap size */
    GNUNET_free (fn);
    return GNUNET_SYSERR;
  }
  fs = fs64;
  mem = GNUNET_malloc (fs);
  sret = GNUNET_DISK_fn_read (fn,
                              mem,
                              fs);
  if ((sret < 0) || (fs != (size_t) sret))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Error while reading file `%s'\n",
         fn);
    GNUNET_free (fn);
    GNUNET_free (mem);
    return GNUNET_SYSERR;
  }
  if (cfg->diagnostics)
  {
    GNUNET_CRYPTO_hash (mem,
                        fs,
                        &loaded_file->content_hash);
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Deserializing contents of file `%s'\n",
       fn);
  ret = GNUNET_CONFIGURATION_deserialize (cfg,
                                          mem,
                                          fs,
                                          fn);
  if (GNUNET_SYSERR == ret)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to parse configuration file `%s'\n"),
                fn);
  }
  else if (cfg->diagnostics)
  {
    loaded_file->have_content_hash = true;
  }
  GNUNET_free (fn);
  GNUNET_free (mem);
  /* restore dirty flag - anything we set in the meantime
   * came from disk */
  cfg->dirty = dirty;
  return ret;
}

References _, cfg, ConfigFile::content_hash, GNUNET_CONFIGURATION_Handle::current_nest_level, GNUNET_CONFIGURATION_Handle::diagnostics, GNUNET_CONFIGURATION_Handle::dirty, filename, fs, GNUNET_break, GNUNET_CONFIGURATION_deserialize(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_hash(), GNUNET_DISK_file_size(), GNUNET_DISK_fn_read(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_new, GNUNET_NO, GNUNET_strdup, GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, GNUNET_YES, ConfigFile::have_content_hash, ConfigFile::level, GNUNET_CONFIGURATION_Handle::loaded_files_head, GNUNET_CONFIGURATION_Handle::loaded_files_tail, LOG, ConfigFile::prev, ret, SIZE_MAX, and ConfigFile::source_filename.

Referenced by GNUNET_CONFIGURATION_load(), GNUNET_CONFIGURATION_load_from(), handle_inline(), load_member(), load_member_session(), load_member_session_next(), load_operation(), main(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_serialize()

char * GNUNET_CONFIGURATION_serialize	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		size_t *	size
	)

Serializes the given configuration.

Parameters

cfg	configuration to serialize
size	will be set to the size of the serialized memory block

Returns

the memory block where the serialized configuration is present. This memory should be freed by the caller

Definition at line 1277 of file configuration.c.

{
  char *mem;
  char *cbuf;
  char *val;
  char *pos;
  size_t m_size;
  size_t c_size;
 
  /* Pass1 : calculate the buffer size required */
  m_size = 0;
  for (struct ConfigSection *sec = cfg->sections;
       NULL != sec;
       sec = sec->next)
  {
    if (sec->inaccessible && (NULL == sec->entries))
      continue;
    /* For each section we need to add 3 characters: {'[',']','\n'} */
    m_size += strlen (sec->name) + 3;
    for (struct ConfigEntry *ent = sec->entries;
         NULL != ent;
         ent = ent->next)
    {
      if (do_skip (sec->name,
                   ent->key))
        continue;
      if (NULL != ent->val)
      {
        /* if val has any '\n' then they occupy +1 character as '\n'->'\\','n' */
        pos = ent->val;
        while (NULL != (pos = strstr (pos, "\n")))
        {
          m_size++;
          pos++;
        }
        /* For each key = value pair we need to add 4 characters (2
           spaces and 1 equal-to character and 1 new line) */
        m_size += strlen (ent->key) + strlen (ent->val) + 4;
      }
    }
    /* A new line after section end */
    m_size++;
  }
 
  /* Pass2: Allocate memory and write the configuration to it */
  mem = GNUNET_malloc (m_size);
  c_size = 0;
  *size = c_size;
  for (struct ConfigSection *sec = cfg->sections;
       NULL != sec;
       sec = sec->next)
  {
    int len;
 
    len = GNUNET_asprintf (&cbuf,
                           "[%s]\n",
                           sec->name);
    GNUNET_assert (0 < len);
    GNUNET_memcpy (mem + c_size,
                   cbuf,
                   len);
    c_size += len;
    GNUNET_free (cbuf);
    for (struct ConfigEntry *ent = sec->entries;
         NULL != ent;
         ent = ent->next)
    {
      if (do_skip (sec->name,
                   ent->key))
        continue;
      if (NULL != ent->val)
      {
        val = GNUNET_malloc (strlen (ent->val) * 2 + 1);
        strcpy (val, ent->val);
        while (NULL != (pos = strstr (val, "\n")))
        {
          memmove (&pos[2], &pos[1], strlen (&pos[1]));
          pos[0] = '\\';
          pos[1] = 'n';
        }
        len = GNUNET_asprintf (&cbuf, "%s = %s\n", ent->key, val);
        GNUNET_free (val);
        GNUNET_memcpy (mem + c_size, cbuf, len);
        c_size += len;
        GNUNET_free (cbuf);
      }
    }
    GNUNET_memcpy (mem + c_size, "\n", 1);
    c_size++;
  }
  GNUNET_assert (c_size == m_size);
  *size = c_size;
  return mem;
}

References cfg, do_skip(), GNUNET_asprintf(), GNUNET_assert, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_CONFIGURATION_Handle::sections, and size.

Referenced by conclude_autoconfig_request(), GNUNET_CONFIGURATION_write(), and GNUNET_NAT_AUTO_autoconfig_start().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_serialize_diagnostics()

char * GNUNET_CONFIGURATION_serialize_diagnostics

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Serializes the given configuration with diagnostics information.

Diagnostics information will only be available if diagnostics have been enabled before parsing.

Parameters

cfg	configuration to serialize

Returns

the memory block where the serialized configuration is present. This memory should be freed by the caller

Definition at line 1600 of file configuration.c.

{
  return serialize_diagnostics (cfg,
                                false);
}

References cfg, and serialize_diagnostics().

Referenced by GNUNET_CONFIGURATION_config_tool_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_serialize_diagnostics_verbose()

char * GNUNET_CONFIGURATION_serialize_diagnostics_verbose

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Serializes the given configuration with verbose diagnostics information, including all source definitions of each value.

Diagnostics information will only be available if diagnostics have been enabled before parsing.

Parameters

cfg	configuration to serialize

Returns

the memory block where the serialized configuration is present. This memory should be freed by the caller

Definition at line 1609 of file configuration.c.

{
  return serialize_diagnostics (cfg,
                                true);
}

References cfg, and serialize_diagnostics().

Referenced by GNUNET_CONFIGURATION_config_tool_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_clean_file()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_clean_file	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	filename,
		GNUNET_CONFIGURATION_CleanCallback	cb,
		void *	cb_cls,
		unsigned int *	removed
	)

Remove redundant option definitions from a parsed configuration file.

Only complete assignment lines in filename are removed; formatting, comments and directives otherwise remain byte-for-byte unchanged. The configuration must have had diagnostics enabled before it was loaded. The operation fails if the file changed since it was parsed.

Parameters

cfg	parsed configuration
filename	target configuration file
cb	callback invoked after a successful update, may be NULL
cb_cls	closure for cb
removed	set to the number of removed definitions, may be NULL

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1909 of file configuration.c.

{
  struct CleanLine *lines = NULL;
  unsigned int lines_length = 0;
  const struct ConfigFile *parsed_file = NULL;
  char *target;
  char *contents = NULL;
  char *cleaned = NULL;
  size_t size;
  size_t cleaned_size = 0;
  enum GNUNET_GenericReturnValue ret = GNUNET_SYSERR;
 
  if (NULL != removed)
    *removed = 0;
  if ( (! cfg->diagnostics) ||
       (NULL == filename) )
    return GNUNET_SYSERR;
  target = GNUNET_STRINGS_filename_expand (filename);
  if (NULL == target)
    return GNUNET_SYSERR;
 
  for (const struct ConfigFile *cf = cfg->loaded_files_head;
       NULL != cf;
       cf = cf->next)
  {
    char *source;
 
    if (! cf->have_content_hash)
      continue;
    source = GNUNET_STRINGS_filename_expand (cf->source_filename);
    if ( (NULL != source) &&
         (0 == strcmp (source,
                       target)) )
      parsed_file = cf;
    GNUNET_free (source);
  }
  if (NULL == parsed_file)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Configuration file `%s' was not parsed with diagnostics enabled\n",
         target);
    goto cleanup;
  }
  if (GNUNET_OK != read_file (target,
                              &contents,
                              &size))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Configuration file `%s' changed since it was parsed\n",
         target);
    goto cleanup;
  }
  {
    struct GNUNET_HashCode actual;
 
    GNUNET_CRYPTO_hash (contents,
                        size,
                        &actual);
    if (0 != GNUNET_memcmp (&actual,
                            &parsed_file->content_hash))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Configuration file `%s' changed since it was parsed\n",
           target);
      goto cleanup;
    }
  }
 
  /* First mark every target definition that has an exact duplicate at a
     distinct source location. */
  for (const struct ConfigSection *sec = cfg->sections;
       NULL != sec;
       sec = sec->next)
    for (const struct ConfigEntry *ent = sec->entries;
         NULL != ent;
         ent = ent->next)
      for (const struct ConfigSource *source = ent->sources;
           NULL != source;
           source = source->next)
      {
        bool duplicate = false;
        struct CleanLine line;
 
        if (0 != strcmp (source->filename,
                         target))
          continue;
        for (const struct ConfigSource *other = ent->sources;
             NULL != other;
             other = other->next)
        {
          if ( (0 == strcmp (source->value,
                             other->value)) &&
               ( (source->lineno != other->lineno) ||
                 (0 != strcmp (source->filename,
                               other->filename)) ) )
          {
            duplicate = true;
            break;
          }
        }
        if ( (! duplicate) ||
             (NULL != find_clean_line (lines,
                                       lines_length,
                                       source->lineno)) )
          continue;
        line.section = sec->name;
        line.option = ent->key;
        line.line = source->lineno;
        line.remove = true;
        GNUNET_array_append (lines,
                             lines_length,
                             line);
      }
 
  /* Keep the highest-precedence target duplicate needed to preserve every
     effective value after all of the tentative removals. */
  for (const struct ConfigSection *sec = cfg->sections;
       NULL != sec;
       sec = sec->next)
    for (const struct ConfigEntry *ent = sec->entries;
         NULL != ent;
         ent = ent->next)
    {
      const struct ConfigSource *survivor = NULL;
 
      for (const struct ConfigSource *source = ent->sources;
           NULL != source;
           source = source->next)
        if (! source_is_removed (source,
                                 target,
                                 lines,
                                 lines_length))
        {
          survivor = source;
          break;
        }
      if ( (NULL != survivor) &&
           (0 == strcmp (survivor->value,
                         ent->val)) )
        continue;
      for (const struct ConfigSource *source = ent->sources;
           NULL != source;
           source = source->next)
      {
        struct CleanLine *line;
 
        if ( (0 != strcmp (source->filename,
                           target)) ||
             (0 != strcmp (source->value,
                           ent->val)) )
          continue;
        line = find_clean_line (lines,
                                lines_length,
                                source->lineno);
        if ( (NULL != line) && line->remove)
        {
          line->remove = false;
          break;
        }
      }
    }
 
  if (lines_length > 1)
    qsort (lines,
           lines_length,
           sizeof (*lines),
           &clean_line_cmp);
  {
    unsigned int remove_count = 0;
 
    for (unsigned int i = 0; i < lines_length; i++)
      if (lines[i].remove)
        remove_count++;
    if (0 == remove_count)
    {
      if (NULL != removed)
        *removed = 0;
      ret = GNUNET_OK;
      goto cleanup;
    }
 
    cleaned = GNUNET_malloc (size);
    for (size_t offset = 0, line_number = 1; offset < size; line_number++)
    {
      size_t end = offset;
      struct CleanLine *line;
 
      while ( (end < size) && ('\n' != contents[end]) )
        end++;
      if (end < size)
        end++;
      line = find_clean_line (lines,
                              lines_length,
                              (unsigned int) line_number);
      if ( (NULL == line) || (! line->remove) )
      {
        GNUNET_memcpy (&cleaned[cleaned_size],
                       &contents[offset],
                       end - offset);
        cleaned_size += end - offset;
      }
      offset = end;
    }
    if (GNUNET_OK !=
        write_buffer_atomic (target,
                             cleaned,
                             cleaned_size,
                             &parsed_file->content_hash))
      goto cleanup;
    if (NULL != removed)
      *removed = remove_count;
    if (NULL != cb)
      for (unsigned int i = 0; i < lines_length; i++)
        if (lines[i].remove)
          cb (cb_cls,
              lines[i].section,
              lines[i].option,
              lines[i].line);
    ret = GNUNET_OK;
  }
 
cleanup:
  GNUNET_free (cleaned);
  GNUNET_free (contents);
  GNUNET_array_grow (lines,
                     lines_length,
                     0);
  GNUNET_free (target);
  return ret;
}

References cfg, clean_line_cmp(), cleanup(), ConfigFile::content_hash, GNUNET_CONFIGURATION_Handle::diagnostics, end, filename, find_clean_line(), GNUNET_array_append, GNUNET_array_grow, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_malloc, GNUNET_memcmp, GNUNET_memcpy, GNUNET_OK, GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, line, GNUNET_CONFIGURATION_Handle::loaded_files_head, LOG, CleanLine::option, read_file(), CleanLine::remove, ret, CleanLine::section, GNUNET_CONFIGURATION_Handle::sections, size, source, source_is_removed(), ConfigSource::value, and write_buffer_atomic().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_deserialize()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_deserialize	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	mem,
		size_t	size,
		const char *	source_filename
	)

De-serializes configuration.

Parameters

cfg	configuration to update
mem	the memory block of serialized configuration
size	the size of the memory block
source_filename	source filename, will be used to resolve relative @INLINE@ statements

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 831 of file configuration.c.

{
  size_t line_size;
  unsigned int nr;
  size_t r_bytes;
  size_t to_read;
  enum GNUNET_GenericReturnValue ret;
  char *section;
  char *eq;
  char *tag;
  char *value;
  char *line_orig = NULL;
 
  ret = GNUNET_OK;
  section = NULL;
  nr = 0;
  r_bytes = 0;
  while (r_bytes < size)
  {
    const char *pos;
    char *line;
    bool emptyline;
 
    GNUNET_free (line_orig);
    /* fgets-like behaviour on buffer */
    to_read = size - r_bytes;
    pos = memchr (&mem[r_bytes], '\n', to_read);
    if (NULL == pos)
    {
      line_orig = GNUNET_strndup (&mem[r_bytes],
                                  line_size = to_read);
      r_bytes += line_size;
    }
    else
    {
      line_orig = GNUNET_strndup (&mem[r_bytes],
                                  line_size = (pos - &mem[r_bytes]));
      r_bytes += line_size + 1;
    }
    line = line_orig;
    /* increment line number */
    nr++;
    /* tabs and '\r' are whitespace */
    emptyline = GNUNET_YES;
    for (size_t i = 0; i < line_size; i++)
    {
      if (line[i] == '\t')
        line[i] = ' ';
      if (line[i] == '\r')
        line[i] = ' ';
      if (' ' != line[i])
        emptyline = GNUNET_NO;
    }
    /* ignore empty lines */
    if (GNUNET_YES == emptyline)
      continue;
 
    /* remove tailing whitespace */
    for (size_t i = line_size - 1;
         (i >= 1) && (isspace ((unsigned char) line[i]));
         i--)
      line[i] = '\0';
 
    /* remove leading whitespace */
    for (; line[0] != '\0' && (isspace ((unsigned char) line[0])); line++)
      ;
 
    /* ignore comments */
    if ( ('#' == line[0]) ||
         ('%' == line[0]) )
      continue;
 
    /* Handle special directives. */
    if ('@' == line[0])
    {
      char *end = strchr (line + 1, '@');
      char *directive;
      enum GNUNET_GenericReturnValue directive_ret;
 
      if (NULL != cfg->restrict_section)
      {
        LOG (GNUNET_ERROR_TYPE_WARNING,
             "Illegal directive in line %u (parsing restricted section %s)\n",
             nr,
             cfg->restrict_section);
        ret = GNUNET_SYSERR;
        break;
      }
 
      if (NULL == end)
      {
        LOG (GNUNET_ERROR_TYPE_WARNING,
             "Bad directive in line %u\n",
             nr);
        ret = GNUNET_SYSERR;
        break;
      }
      *end = '\0';
      directive = line + 1;
 
      if (0 == strcasecmp (directive,
                           "INLINE"))
      {
        const char *path = end + 1;
 
        /* Skip space before path */
        for (; isspace (*path); path++)
          ;
 
        directive_ret = handle_inline (cfg,
                                       path,
                                       false,
                                       NULL,
                                       source_filename,
                                       nr);
      }
      else if (0 == strcasecmp (directive,
                                "INLINE-MATCHING"))
      {
        const char *path = end + 1;
 
        /* Skip space before path */
        for (; isspace (*path); path++)
          ;
 
        directive_ret = handle_inline (cfg,
                                       path,
                                       true,
                                       NULL,
                                       source_filename,
                                       nr);
      }
      else if (0 == strcasecmp (directive,
                                "INLINE-SECRET"))
      {
        char *secname = end + 1;
        char *secname_end;
        const char *path;
 
        /* Skip space before secname */
        for (; isspace (*secname); secname++)
          ;
 
        secname_end = strchr (secname, ' ');
 
        if (NULL == secname_end)
        {
          LOG (GNUNET_ERROR_TYPE_WARNING,
               "Bad inline-secret directive in line %u\n",
               nr);
          ret = GNUNET_SYSERR;
          break;
        }
        *secname_end = '\0';
        path = secname_end + 1;
 
        /* Skip space before path */
        for (; isspace (*path); path++)
          ;
 
        directive_ret = handle_inline (cfg,
                                       path,
                                       false,
                                       secname,
                                       source_filename,
                                       nr);
      }
      else
      {
        LOG (GNUNET_ERROR_TYPE_WARNING,
             "Unknown or malformed directive '%s' in line %u\n",
             directive,
             nr);
        ret = GNUNET_SYSERR;
        break;
      }
      if (GNUNET_OK != directive_ret)
      {
        ret = directive_ret;
        break;
      }
      continue;
    }
    if ( ('[' == line[0]) &&
         (']' == line[line_size - 1]) )
    {
      /* [value] */
      line[line_size - 1] = '\0';
      value = &line[1];
      GNUNET_free (section);
      section = GNUNET_strdup (value);
      continue;
    }
    if (NULL != (eq = strchr (line, '=')))
    {
 
      if (NULL == section)
      {
        LOG (GNUNET_ERROR_TYPE_WARNING,
             "Syntax error while deserializing in line %u (option without section)\n",
             nr);
        ret = GNUNET_SYSERR;
        break;
      }
 
      /* tag = value */
      tag = GNUNET_strndup (line, eq - line);
      /* remove tailing whitespace */
      for (int i = strlen (tag) - 1;
           (i >= 1) && (isspace ((unsigned char) tag[i]));
           i--)
        tag[i] = '\0';
 
      /* Strip whitespace */
      value = eq + 1;
      while (isspace ((unsigned char) value[0]))
        value++;
      for (int i = strlen (value) - 1;
           (i >= 1) && (isspace ((unsigned char) value[i]));
           i--)
        value[i] = '\0';
 
      /* remove quotes */
      if ( ('"' == value[0]) &&
           ('"' == value[strlen (value) - 1]) )
      {
        value[strlen (value) - 1] = '\0';
        value++;
      }
      GNUNET_CONFIGURATION_set_value_string (cfg,
                                             section,
                                             tag,
                                             value);
      if (cfg->diagnostics)
      {
        add_entry_source (cfg,
                          section,
                          tag,
                          value,
                          source_filename
                          ? source_filename
                          : "<input>",
                          nr);
      }
      GNUNET_free (tag);
      continue;
    }
    /* parse error */
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Syntax error while deserializing in line %u\n",
         nr);
    ret = GNUNET_SYSERR;
    break;
  }
  GNUNET_free (line_orig);
  GNUNET_free (section);
  GNUNET_assert ( (GNUNET_OK != ret) ||
                  (r_bytes == size) );
  return ret;
}

References add_entry_source(), cfg, GNUNET_CONFIGURATION_Handle::diagnostics, end, GNUNET_assert, GNUNET_CONFIGURATION_set_value_string(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_strndup, GNUNET_SYSERR, GNUNET_YES, handle_inline(), line, LOG, GNUNET_CONFIGURATION_Handle::restrict_section, ret, size, and value.

Referenced by GNUNET_CONFIGURATION_parse(), GNUNET_TESTING_get_topo_from_string_(), handle_auto_result(), handle_autoconfig_request(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_write()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_write	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	filename
	)

Write configuration file.

Parameters

cfg	configuration to write
filename	where to write the configuration

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1822 of file configuration.c.

{
  enum GNUNET_GenericReturnValue ret;
  char *cfg_buf;
  size_t size;
 
  cfg_buf = GNUNET_CONFIGURATION_serialize (cfg,
                                            &size);
  ret = write_buffer_atomic (filename,
                             cfg_buf,
                             size,
                             NULL);
  GNUNET_free (cfg_buf);
  cfg->dirty = (GNUNET_OK == ret) ? GNUNET_NO : GNUNET_SYSERR;
  return ret;
}

References cfg, GNUNET_CONFIGURATION_Handle::dirty, filename, GNUNET_CONFIGURATION_serialize(), GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, ret, size, and write_buffer_atomic().

Referenced by create_unique_cfgs(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_write_diffs(), handle_delete_message(), handle_rename_message(), save_member(), save_member_session(), save_operation(), set_cont(), and start_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_write_diffs()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_write_diffs	(	const struct GNUNET_CONFIGURATION_Handle *	cfg_default,
		const struct GNUNET_CONFIGURATION_Handle *	cfg_new,
		const char *	filename
	)

Write only configuration entries that have been changed to configuration file.

Parameters

cfg_default	default configuration
cfg_new	new configuration
filename	where to write the configuration diff between default and new

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 2356 of file configuration.c.

{
  int ret;
  struct GNUNET_CONFIGURATION_Handle *diff;
 
  diff = GNUNET_CONFIGURATION_get_diff (cfg_default, cfg_new);
  ret = GNUNET_CONFIGURATION_write (diff, filename);
  GNUNET_CONFIGURATION_destroy (diff);
  return ret;
}

References filename, GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_diff(), GNUNET_CONFIGURATION_write(), and ret.

Referenced by auto_config_cb(), GNUNET_CONFIGURATION_config_tool_run(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_get_diff()

struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_get_diff	(	const struct GNUNET_CONFIGURATION_Handle *	cfg_default,
		const struct GNUNET_CONFIGURATION_Handle *	cfg_new
	)

Compute configuration with only entries that have been changed.

Parameters

cfg_default	original configuration
cfg_new	new configuration

Returns

configuration with only the differences, never NULL

Definition at line 2339 of file configuration.c.

{
  struct DiffHandle diffHandle;
 
  GNUNET_break (cfg_default->pd == cfg_new->pd);
  diffHandle.cfgDiff = GNUNET_CONFIGURATION_create (cfg_new->pd);
  diffHandle.cfg_default = cfg_default;
  GNUNET_CONFIGURATION_iterate (cfg_new,
                                &compare_entries,
                                &diffHandle);
  return diffHandle.cfgDiff;
}

References DiffHandle::cfg_default, DiffHandle::cfgDiff, compare_entries(), GNUNET_break, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_iterate(), and GNUNET_CONFIGURATION_Handle::pd.

Referenced by conclude_autoconfig_request(), GNUNET_CONFIGURATION_write_diffs(), and next_phase().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_is_dirty()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_is_dirty

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Test if there are configuration options that were changed since the last save.

Parameters

cfg	configuration to inspect

Returns

GNUNET_NO if clean, GNUNET_YES if dirty, GNUNET_SYSERR on error (i.e. last save failed)

Definition at line 1235 of file configuration.c.

{
  return cfg->dirty;
}

References cfg, and GNUNET_CONFIGURATION_Handle::dirty.

Referenced by auto_config_cb().

Here is the caller graph for this function:

GNUNET_CONFIGURATION_parse_and_run()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_parse_and_run	(	const struct GNUNET_OS_ProjectData *	pd,
		const char *	filename,
		GNUNET_CONFIGURATION_Callback	cb,
		void *	cb_cls
	)

Parse a configuration file filename and run the function cb with the resulting configuration object.

Then free the configuration object and return the status value from cb.

Parameters

pd	project data to use to determine paths
filename	configuration to parse, NULL for "default"
cb	function to run
cb_cls	closure for cb

Returns

GNUNET_SYSERR if parsing the configuration failed, otherwise return value from cb.

Definition at line 375 of file configuration.c.

{
  struct GNUNET_CONFIGURATION_Handle *cfg;
  enum GNUNET_GenericReturnValue ret;
 
  cfg = GNUNET_CONFIGURATION_create (pd);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_load (cfg,
                                 filename))
  {
    GNUNET_break (0);
    GNUNET_CONFIGURATION_destroy (cfg);
    return GNUNET_SYSERR;
  }
  ret = cb (cb_cls,
            cfg);
  GNUNET_CONFIGURATION_destroy (cfg);
  return ret;
}

References cfg, filename, GNUNET_break, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_load(), GNUNET_OK, GNUNET_SYSERR, GNUNET_CONFIGURATION_Handle::pd, and ret.

Referenced by GNUNET_OS_purge_cfg_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_enable_diagnostics()

void GNUNET_CONFIGURATION_enable_diagnostics

(

struct GNUNET_CONFIGURATION_Handle *

cfg

)

Enable extra diagnostics.

Will produce more log output and allocate more memory.

Parameters

cfg	configuration handle

Definition at line 251 of file configuration.c.

{
  cfg->diagnostics = true;
}

References cfg, and GNUNET_CONFIGURATION_Handle::diagnostics.

Referenced by GNUNET_CONFIGURATION_config_tool_run(), handle_inline(), and main().

Here is the caller graph for this function:

GNUNET_CONFIGURATION_get_project_data()

const struct GNUNET_OS_ProjectData * GNUNET_CONFIGURATION_get_project_data

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Return the project data associated with this configuration.

Parameters

cfg	a configuration

Returns

associated project data, never NULL

Definition at line 3661 of file configuration.c.

{
  return cfg->pd;
}

References cfg, and GNUNET_CONFIGURATION_Handle::pd.

Referenced by GNUNET_BLOCK_context_create(), and GNUNET_DATACACHE_create().

Here is the caller graph for this function:

GNUNET_CONFIGURATION_iterate()

void GNUNET_CONFIGURATION_iterate	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_CONFIGURATION_Iterator	iter,
		void *	iter_cls
	)

Iterate over all options in the configuration.

Parameters

cfg	configuration to inspect
iter	function to call on each option
iter_cls	closure for iter

Definition at line 2147 of file configuration.c.

{
  for (struct ConfigSection *spos = cfg->sections;
       NULL != spos;
       spos = spos->next)
    for (struct ConfigEntry *epos = spos->entries;
         NULL != epos;
         epos = epos->next)
      if (NULL != epos->val)
        iter (iter_cls,
              spos->name,
              epos->key,
              epos->val);
}

References cfg, and GNUNET_CONFIGURATION_Handle::sections.

Referenced by get_cont(), GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_get_diff(), and GNUNET_TESTBED_configuration_create().

Here is the caller graph for this function:

GNUNET_CONFIGURATION_iterate_sections()

void GNUNET_CONFIGURATION_iterate_sections	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_CONFIGURATION_SectionIterator	iter,
		void *	iter_cls
	)

Iterate over all sections in the configuration.

Parameters

cfg	configuration to inspect
iter	function to call on each section
iter_cls	closure for iter

Definition at line 2200 of file configuration.c.

{
  struct ConfigSection *spos;
  struct ConfigSection *next;
 
  next = cfg->sections;
  while (NULL != next)
  {
    spos = next;
    next = spos->next;
    if (spos->inaccessible && (NULL == spos->entries))
      continue;
    iter (iter_cls,
          spos->name);
  }
}

References cfg, ConfigSection::entries, ConfigSection::inaccessible, ConfigSection::name, ConfigSection::next, and GNUNET_CONFIGURATION_Handle::sections.

Referenced by GNUNET_CONFIGURATION_config_tool_run(), GNUNET_TESTBED_configuration_create(), handle_delete_message(), handle_rename_message(), pid_change_cb(), run(), and run().

Here is the caller graph for this function:

GNUNET_CONFIGURATION_remove_section()

void GNUNET_CONFIGURATION_remove_section	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section
	)

Remove the given section and all options in it.

Parameters

cfg	configuration to inspect
section	name of the section to remove

Definition at line 2222 of file configuration.c.

{
  struct ConfigSection *spos;
  struct ConfigSection *prev;
  struct ConfigEntry *ent;
 
  prev = NULL;
  spos = cfg->sections;
  while (NULL != spos)
  {
    if (0 == strcasecmp (section,
                         spos->name))
    {
      if (NULL == prev)
        cfg->sections = spos->next;
      else
        prev->next = spos->next;
      while (NULL != (ent = spos->entries))
      {
        struct ConfigSource *source;
 
        spos->entries = ent->next;
        GNUNET_free (ent->key);
        GNUNET_free (ent->val);
        while (NULL != (source = ent->sources))
        {
          ent->sources = source->next;
          GNUNET_free (source->value);
          GNUNET_free (source->filename);
          GNUNET_free (source);
        }
        GNUNET_free (ent);
        cfg->dirty = GNUNET_YES;
      }
      GNUNET_free (spos->name);
      GNUNET_free (spos->hint_secret_filename);
      GNUNET_free (spos->hint_secret_stat);
      GNUNET_free (spos->hint_inlined_from_filename);
      GNUNET_free (spos);
      return;
    }
    prev = spos;
    spos = spos->next;
  }
}

References cfg, GNUNET_CONFIGURATION_Handle::dirty, ConfigSection::entries, GNUNET_free, GNUNET_YES, ConfigSection::hint_inlined_from_filename, ConfigSection::hint_secret_filename, ConfigSection::hint_secret_stat, ConfigEntry::key, ConfigSection::name, ConfigSource::next, ConfigEntry::next, ConfigSection::next, GNUNET_CONFIGURATION_Handle::sections, source, ConfigEntry::sources, and ConfigEntry::val.

Referenced by GNUNET_CONFIGURATION_destroy().

Here is the caller graph for this function:

GNUNET_CONFIGURATION_get_value_number()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		unsigned long long *	number
	)

Get a configuration value that should be a number.

Parameters

cfg	configuration to inspect
section	section of interest
option	option of interest
number	where to store the numeric value of the option

Returns

GNUNET_OK on success, GNUNET_NO if option is not set GNUNET_SYSERR on error (value is malformed)

Definition at line 2434 of file configuration.c.

{
  struct ConfigEntry *e;
  char dummy[2];
 
  if (NULL == (e = find_entry (cfg,
                               section,
                               option)))
    return GNUNET_NO;
  if (NULL == e->val)
    return GNUNET_NO;
  if (1 != sscanf (e->val,
                   "%llu%1s",
                   number,
                   dummy))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References cfg, dummy, find_entry(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, number, and ConfigEntry::val.

Referenced by create_service(), create_subnets(), DHTU_ip_init(), GCD_init(), GCO_init(), GDS_NEIGHBOURS_init(), get_server_addresses(), get_server_addresses(), GNUNET_CLIENT_connect(), GNUNET_CLIENT_test(), GNUNET_HOSTLIST_server_start(), GNUNET_NAT_AUTO_test_start(), GNUNET_PROGRAM_run2(), GNUNET_REVOCATION_revoke(), GNUNET_SERVICE_run_(), GNUNET_SOCKS_do_connect(), GNUNET_TESTING_get_topo_from_string_(), GNUNET_TRANSPORT_communicator_connect(), GSF_cadet_start_server(), GSF_pending_request_init_(), libgnunet_plugin_block_revocation_init(), libgnunet_plugin_datastore_heap_init(), load_member_session(), load_operation(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), setup_exit_helper_args(), test_service_configuration(), test_stun(), and update_config().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_set_value_float()

void GNUNET_CONFIGURATION_set_value_float	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		float	number
	)

Set a configuration value that should be a float.

Note that this possibly truncates your float value.

Parameters

cfg	configuration to update
section	section of interest
option	option of interest
number	value to set

Definition at line 2459 of file configuration.c.

{
  char s[64];
 
  /* See: #9369 */
  const locale_t cl = newlocale (LC_NUMERIC_MASK,
                                 "C",
                                 (locale_t) 0);
  locale_t old_locale = uselocale (cl);
  GNUNET_snprintf (s,
                   64,
                   "%f",
                   (double) number);
  uselocale (old_locale);
  GNUNET_CONFIGURATION_set_value_string (cfg,
                                         section,
                                         option,
                                         s);
}

References cfg, GNUNET_CONFIGURATION_set_value_string(), GNUNET_snprintf(), and number.

Here is the call graph for this function:

GNUNET_CONFIGURATION_get_value_float()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_float	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		float *	number
	)

Get a configuration value that should be a floating point number.

Parameters

cfg	configuration to inspect
section	section of interest
option	option of interest
number	where to store the floating value of the option

Returns

GNUNET_OK on success, GNUNET_NO if option is not set GNUNET_SYSERR on error (value is malformed)

Definition at line 2484 of file configuration.c.

{
  struct ConfigEntry *e;
  char dummy[2];
 
  if (NULL == (e = find_entry (cfg,
                               section,
                               option)))
    return GNUNET_NO;
  if (NULL == e->val)
    return GNUNET_NO;
  /* See #9369 */
  {
    const locale_t cl = newlocale (LC_NUMERIC_MASK,
                                   "C",
                                   (locale_t) 0);
    locale_t old_locale = uselocale (cl);
 
    if (1 != sscanf (e->val,
                     "%f%1s",
                     number,
                     dummy))
      return GNUNET_SYSERR;
    uselocale (old_locale);
  }
  return GNUNET_OK;
}

References cfg, dummy, find_entry(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, number, and ConfigEntry::val.

Referenced by GNUNET_RPS_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_get_value_time()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		struct GNUNET_TIME_Relative *	time
	)

Get a configuration value that should be a relative time.

Parameters

cfg	configuration to inspect
section	section of interest
option	option of interest
time	set to the time value stored in the configuration

Returns

GNUNET_OK on success, GNUNET_NO if option is not set GNUNET_SYSERR on error (value is malformed)

Definition at line 2518 of file configuration.c.

{
  struct ConfigEntry *e;
  int ret;
 
  if (NULL == (e = find_entry (cfg,
                               section,
                               option)))
    return GNUNET_NO;
  if (NULL == e->val)
    return GNUNET_NO;
  ret = GNUNET_STRINGS_fancy_time_to_relative (e->val,
                                               time);
  if (GNUNET_OK != ret)
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                               section,
                               option,
                               _ ("Not a valid relative time specification"));
  return ret;
}

References _, cfg, find_entry(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log_config_invalid(), GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_fancy_time_to_relative(), ret, and ConfigEntry::val.

Referenced by GCD_init(), GNUNET_REVOCATION_revoke(), GNUNET_SPEEDUP_start_(), GSF_push_init_(), libgnunet_plugin_block_revocation_init(), RECLAIM_TICKETS_init(), REST_openid_init(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), and token_endpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_get_value_size()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_size	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		unsigned long long *	size
	)

Get a configuration value that should be a size in bytes.

Parameters

cfg	configuration to inspect
section	section of interest
option	option of interest
size	set to the size in bytes as stored in the configuration

Returns

GNUNET_OK on success, GNUNET_NO if option is not set GNUNET_SYSERR on error (value is malformed)

Definition at line 2545 of file configuration.c.

{
  struct ConfigEntry *e;
 
  if (NULL == (e = find_entry (cfg,
                               section,
                               option)))
    return GNUNET_NO;
  if (NULL == e->val)
    return GNUNET_NO;
  return GNUNET_STRINGS_fancy_size_to_bytes (e->val,
                                             size);
}

References cfg, find_entry(), GNUNET_NO, GNUNET_STRINGS_fancy_size_to_bytes(), size, and ConfigEntry::val.

Referenced by GNUNET_DATACACHE_create(), run(), run(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_have_value()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_have_value	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option
	)

Test if we have a value for a particular option.

Parameters

cfg	configuration to inspect
section	section of interest
option	option of interest

Returns

GNUNET_YES if so, GNUNET_NO if not.

Definition at line 2668 of file configuration.c.

{
  struct ConfigEntry *e;
 
  if ( (NULL == (e = find_entry (cfg,
                                 section,
                                 option))) ||
       (NULL == e->val) )
    return GNUNET_NO;
  return GNUNET_YES;
}

References cfg, find_entry(), GNUNET_NO, GNUNET_YES, and ConfigEntry::val.

Referenced by check_config(), get_server_addresses(), GNUNET_CLIENT_connect(), GNUNET_CLIENT_test(), GNUNET_CONFIGURATION_load(), GNUNET_HOSTLIST_server_start(), GNUNET_PROGRAM_run2(), GNUNET_SOCKS_check_service(), process_acl4(), process_acl6(), run(), setup_service(), start_arm_service(), test_service_configuration(), and update_config_sections().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_get_value_string()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		char **	value
	)

Get a configuration value that should be a string.

Parameters

cfg	configuration to inspect
section	section of interest
option	option of interest
value	will be set to a freshly allocated configuration value, or NULL if option is not specified

Returns

GNUNET_OK on success, GNUNET_NO if option is not set GNUNET_SYSERR on error (value is malformed)

Parameters

cfg	configuration to inspect
section	section of interest
option	option of interest
value	will be set to a freshly allocated configuration value, or NULL if option is not specified

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 2575 of file configuration.c.

{
  struct ConfigEntry *e;
 
  if ( (NULL == (e = find_entry (cfg,
                                 section,
                                 option))) ||
       (NULL == e->val) )
  {
    *value = NULL;
    return GNUNET_NO;
  }
  *value = GNUNET_strdup (e->val);
  return GNUNET_OK;
}

References cfg, find_entry(), GNUNET_NO, GNUNET_OK, GNUNET_strdup, ConfigEntry::val, and value.

Referenced by advertise_dns_exit(), check_authorization(), check_config(), client_connect_cb(), communicator_start(), DHTU_ip_init(), expand_dollar(), get_bootstrap_server(), get_server_addresses(), get_server_addresses(), gg_load_configuration(), GNUNET_CLIENT_connect(), GNUNET_CLIENT_test(), GNUNET_CONFIGURATION_append_value_filename(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_get_data(), GNUNET_CONFIGURATION_get_suid_binary_path(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_iterate_value_filenames(), GNUNET_CONFIGURATION_remove_value_filename(), GNUNET_CONVERSATION_phone_create(), GNUNET_DATACACHE_create(), GNUNET_FS_unindex_do_extract_keywords_(), GNUNET_GNS_lookup_with_tld(), GNUNET_HOSTLIST_client_start(), GNUNET_HOSTLIST_server_start(), GNUNET_PQ_init(), GNUNET_SOCKS_do_connect(), GNUNET_TESTING_get_topo_from_string_(), handle_ego_delete(), handle_ego_rename(), handle_register(), handle_uri(), identity_continuation(), load_member_session(), load_member_session_next(), login_redirect(), mq_init(), mq_init(), process_acl4(), process_acl6(), read_service_conf(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), setup_exit_helper_args(), setup_service(), sock_read(), sock_read(), start_arm_service(), start_peer_run(), start_process(), test_icmp_client(), test_icmp_server(), test_service_configuration(), token_endpoint(), and update_config_sections().

Here is the call graph for this function:

GNUNET_CONFIGURATION_get_value_filename()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		char **	value
	)

Get a configuration value that should be the name of a file or directory.

Parameters

cfg	configuration to inspect
section	section of interest
option	option of interest
value	will be set to a freshly allocated configuration value, or NULL if option is not specified

Returns

GNUNET_OK on success, GNUNET_NO if option is not set GNUNET_SYSERR on error (value is malformed)

Definition at line 2879 of file configuration.c.

{
  char *tmp;
  enum GNUNET_GenericReturnValue ret;
 
  ret = GNUNET_CONFIGURATION_get_value_string (cfg,
                                               section,
                                               option,
                                               &tmp);
  if (GNUNET_OK != ret)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Failed to retrieve filename\n");
    *value = NULL;
    return ret;
  }
  tmp = GNUNET_CONFIGURATION_expand_dollar (cfg,
                                            tmp);
  *value = GNUNET_STRINGS_filename_expand (tmp);
  GNUNET_free (tmp);
  if (*value == NULL)
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References cfg, GNUNET_CONFIGURATION_expand_dollar(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_OK, GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, LOG, ret, and value.

Referenced by create_service(), database_connect(), database_setup(), database_setup(), database_setup(), database_setup(), database_setup(), get_oidc_dir_path(), get_pid_file_name(), get_serialization_file_name(), get_serialization_file_name_in_dir(), get_server_addresses(), get_server_addresses(), get_update_information_directory(), get_user_name(), GNUNET_CLIENT_test(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_HOSTLIST_client_start(), GNUNET_PILS_create_key_ring(), GNUNET_PILS_enable_private_key(), GNUNET_PQ_init(), GNUNET_TIME_absolute_get_monotonic(), load(), load_hostlist_file(), load_ikm(), load_ikm(), new_sub(), print_filename_option(), purge_cfg_dir(), read_index_list(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), save(), save_hostlist_file(), setup_service(), start_arm_service(), start_peer_run(), test_service_configuration(), try_unixpath(), write_index_list(), and write_proof().

Here is the call graph for this function:

GNUNET_CONFIGURATION_iterate_value_filenames()

int GNUNET_CONFIGURATION_iterate_value_filenames	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		GNUNET_FileNameCallback	cb,
		void *	cb_cls
	)

Iterate over the set of filenames stored in a configuration value.

Parameters

cfg	configuration to inspect
section	section of interest
option	option of interest
cb	function to call on each filename
cb_cls	closure for cb

Returns

number of filenames iterated over, -1 on error

Definition at line 2938 of file configuration.c.

{
  char *list;
  char *pos;
  char *end;
  char old;
  int ret;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             section,
                                             option,
                                             &list))
    return 0;
  GNUNET_assert (list != NULL);
  ret = 0;
  pos = list;
  while (1)
  {
    while (pos[0] == ' ')
      pos++;
    if (strlen (pos) == 0)
      break;
    end = pos + 1;
    while ((end[0] != ' ') && (end[0] != '\0'))
    {
      if (end[0] == '\\')
      {
        switch (end[1])
        {
        case '\\':
        case ' ':
          memmove (end, &end[1], strlen (&end[1]) + 1);
 
        case '\0':
          /* illegal, but just keep it */
          break;
 
        default:
          /* illegal, but just ignore that there was a '/' */
          break;
        }
      }
      end++;
    }
    old = end[0];
    end[0] = '\0';
    if (strlen (pos) > 0)
    {
      ret++;
      if ( (NULL != cb) &&
           (GNUNET_OK != cb (cb_cls,
                             pos)))
      {
        ret = GNUNET_SYSERR;
        break;
      }
    }
    if (old == '\0')
      break;
    pos = end + 1;
  }
  GNUNET_free (list);
  return ret;
}

References cfg, end, GNUNET_assert, GNUNET_CONFIGURATION_get_value_string(), GNUNET_free, GNUNET_OK, GNUNET_SYSERR, list, and ret.

Referenced by GNUNET_CONFIGURATION_append_value_filename().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_iterate_section_values()

void GNUNET_CONFIGURATION_iterate_section_values	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		GNUNET_CONFIGURATION_Iterator	iter,
		void *	iter_cls
	)

Iterate over values of a section in the configuration.

Parameters

cfg	configuration to inspect
section	the section
iter	function to call on each option
iter_cls	closure for iter

Definition at line 2167 of file configuration.c.

{
  struct ConfigSection *spos;
 
  spos = cfg->sections;
  while ((spos != NULL) && (0 != strcasecmp (spos->name, section)))
    spos = spos->next;
  if (NULL == spos)
    return;
  for (struct ConfigEntry *epos = spos->entries;
       NULL != epos;
       epos = epos->next)
    if (NULL != epos->val)
      iter (iter_cls,
            spos->name,
            epos->key,
            epos->val);
  if (spos->inaccessible)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Section '%s' is marked as inaccessible, because a configuration "
         "file that contains the section can't be read.\n",
         section);
    return;
  }
}

References cfg, ConfigSection::entries, GNUNET_ERROR_TYPE_WARNING, ConfigSection::inaccessible, LOG, ConfigSection::name, ConfigSection::next, and GNUNET_CONFIGURATION_Handle::sections.

Referenced by authorize_endpoint(), auto_config_cb(), get_cont(), GNUNET_CONFIGURATION_config_tool_run(), and run().

Here is the caller graph for this function:

GNUNET_CONFIGURATION_get_value_choice()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_choice	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		const char *const *	choices,
		const char **	value
	)

Get a configuration value that should be in a set of predefined strings.

Parameters

cfg	configuration to inspect
section	section of interest
option	option of interest
choices	NULL-terminated list of legal values
value	will be set to an entry in the legal list, or NULL if option is not specified and no default given

Returns

GNUNET_OK on success, GNUNET_NO if option is not set GNUNET_SYSERR on error (value not in choices)

Definition at line 2597 of file configuration.c.

{
  struct ConfigEntry *e;
  unsigned int i;
 
  if (NULL == (e = find_entry (cfg,
                               section,
                               option)))
    return GNUNET_NO;
  for (i = 0; NULL != choices[i]; i++)
    if (0 == strcasecmp (choices[i], e->val))
      break;
  if (NULL == choices[i])
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Configuration value '%s' for '%s'"
            " in section '%s' is not in set of legal choices\n"),
         e->val,
         option,
         section);
    return GNUNET_SYSERR;
  }
  *value = choices[i];
  return GNUNET_OK;
}

References _, cfg, find_entry(), GNUNET_ERROR_TYPE_ERROR, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, LOG, ConfigEntry::val, and value.

Referenced by GNUNET_CONFIGURATION_get_value_yesno(), run(), and start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_get_value_yesno()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_yesno	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option
	)

Get a configuration value that should be in a set of "YES" or "NO".

Parameters

cfg	configuration to inspect
section	section of interest
option	option of interest

Returns

GNUNET_OK if option is set to "YES" GNUNET_NO if option is not set or "NO" GNUNET_SYSERR on error (neither YES nor NO)

Definition at line 2910 of file configuration.c.

{
  static const char *yesno[] = {
    "YES",
    "NO",
    NULL
  };
  const char *val;
  enum GNUNET_GenericReturnValue ret;
 
  ret =
    GNUNET_CONFIGURATION_get_value_choice (cfg,
                                           section,
                                           option,
                                           yesno,
                                           &val);
  if (GNUNET_OK != ret)
    return ret;
  if (val == yesno[0])
    return GNUNET_YES;
  return GNUNET_NO;
}

References cfg, GNUNET_CONFIGURATION_get_value_choice(), GNUNET_NO, GNUNET_OK, GNUNET_YES, ret, and ConfigEntry::val.

Referenced by advertise_dns_exit(), create_handle(), create_listen_socket(), create_service(), database_connect(), GDS_NEIGHBOURS_init(), get_server_addresses(), get_server_addresses(), gg_load_configuration(), GNS_resolver_init(), GNUNET_DATACACHE_create(), GNUNET_STATISTICS_create(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), GSF_pending_request_init_(), GSF_push_init_(), libgnunet_plugin_datacache_sqlite_init(), load_underlay(), main_init(), parse_ip_options(), reconnect_setup(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), setup_service(), setup_service(), start_arm_service(), start_process(), test_icmp_client(), test_icmp_server(), test_master(), udp_address_to_sockaddr(), and update_config().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_get_data()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_data	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		void *	buf,
		size_t	buf_size
	)

Get Crockford32-encoded fixed-size binary data from a configuration.

Parameters

cfg	configuration to access
section	section to access
option	option to access
buf	where to store the decoded binary result
buf_size	exact number of bytes to store in buf

Returns

GNUNET_OK on success GNUNET_NO is the value does not exist GNUNET_SYSERR on decoding error

Definition at line 2630 of file configuration.c.

{
  char *enc;
  int res;
  size_t data_size;
 
  if (GNUNET_OK !=
      (res =
         GNUNET_CONFIGURATION_get_value_string (cfg,
                                                section,
                                                option,
                                                &enc)))
    return res;
  data_size = (strlen (enc) * 5) / 8;
  if (data_size != buf_size)
  {
    GNUNET_free (enc);
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (enc,
                                     strlen (enc),
                                     buf,
                                     buf_size))
  {
    GNUNET_free (enc);
    return GNUNET_SYSERR;
  }
  GNUNET_free (enc);
  return GNUNET_OK;
}

References cfg, data_size, enc, GNUNET_CONFIGURATION_get_value_string(), GNUNET_free, GNUNET_OK, GNUNET_STRINGS_string_to_data(), GNUNET_SYSERR, and res.

Referenced by load_member(), load_member_session_next(), and load_operation().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_expand_dollar()

char * GNUNET_CONFIGURATION_expand_dollar	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		char *	orig
	)

Expand an expression of the form "$FOO/BAR" to "DIRECTORY/BAR" where either in the "PATHS" section or the environment "FOO" is set to "DIRECTORY".

We also support default expansion, i.e. ${VARIABLE:-default} will expand to $VARIABLE if VARIABLE is set in PATHS or the environment, and otherwise to "default". Note that "default" itself can also be a $-expression, thus "${VAR1:-{$VAR2}}" will expand to VAR1 and if that is not defined to VAR2.

Parameters

cfg	configuration to use for path expansion
orig	string to $-expand (will be freed!) Note that multiple $-expressions can be present in this string. They will all be $-expanded.

Returns

$-expanded string

Definition at line 2854 of file configuration.c.

{
  char *dup;
  size_t i;
  size_t len;
 
  for (i = 0; '\0' != orig[i]; i++)
  {
    if ('$' != orig[i])
      continue;
    dup = GNUNET_strdup (orig + i);
    dup = expand_dollar (cfg, dup, 0);
    GNUNET_assert (NULL != dup); /* make compiler happy */
    len = strlen (dup) + 1;
    orig = GNUNET_realloc (orig, i + len);
    GNUNET_memcpy (orig + i, dup, len);
    GNUNET_free (dup);
  }
  return orig;
}

References cfg, expand_dollar(), GNUNET_assert, GNUNET_free, GNUNET_memcpy, GNUNET_realloc, and GNUNET_strdup.

Referenced by expand_dollar(), GNUNET_CONFIGURATION_get_value_filename(), run(), start_arm_service(), and start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_set_value_number()

void GNUNET_CONFIGURATION_set_value_number	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		unsigned long long	number
	)

Set a configuration value that should be a number.

Parameters

cfg	configuration to update
section	section of interest
option	option of interest
number	value to set

Definition at line 2415 of file configuration.c.

{
  char s[64];
 
  GNUNET_snprintf (s,
                   64,
                   "%llu",
                   number);
  GNUNET_CONFIGURATION_set_value_string (cfg,
                                         section,
                                         option,
                                         s);
}

References cfg, GNUNET_CONFIGURATION_set_value_string(), GNUNET_snprintf(), and number.

Referenced by next_phase(), run(), run(), save_member_session(), save_operation(), and set_value().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_set_value_string()

void GNUNET_CONFIGURATION_set_value_string	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		const char *	value
	)

Set a configuration value that should be a string.

Parameters

cfg	configuration to update
section	section of interest
option	option of interest
value	value to set

Definition at line 2372 of file configuration.c.

{
  struct ConfigSection *sec;
  struct ConfigEntry *e;
  char *nv;
 
  e = find_entry (cfg, section, option);
  if (NULL != e)
  {
    if (NULL == value)
    {
      GNUNET_free (e->val);
      e->val = NULL;
    }
    else
    {
      nv = GNUNET_strdup (value);
      GNUNET_free (e->val);
      e->val = nv;
    }
    return;
  }
  sec = find_section (cfg, section);
  if (sec == NULL)
  {
    sec = GNUNET_new (struct ConfigSection);
    sec->name = GNUNET_strdup (section);
    sec->next = cfg->sections;
    cfg->sections = sec;
  }
  e = GNUNET_new (struct ConfigEntry);
  e->key = GNUNET_strdup (option);
  e->val = GNUNET_strdup (value);
  e->next = sec->entries;
  sec->entries = e;
}

References cfg, ConfigSection::entries, find_entry(), find_section(), GNUNET_free, GNUNET_new, GNUNET_strdup, ConfigEntry::key, ConfigSection::name, ConfigEntry::next, ConfigSection::next, GNUNET_CONFIGURATION_Handle::sections, ConfigEntry::val, and value.

Referenced by auto_conf_iter(), auto_config_cb(), compare_entries(), copy_entry(), copy_entry_with_sources(), GNUNET_CONFIGURATION_append_value_filename(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_deserialize(), GNUNET_CONFIGURATION_load(), GNUNET_CONFIGURATION_remove_value_filename(), GNUNET_CONFIGURATION_set_value_float(), GNUNET_CONFIGURATION_set_value_number(), GNUNET_NAT_autoconfig_start(), GNUNET_PROGRAM_run2(), GNUNET_TESTBED_configuration_create(), handle_ego_delete(), handle_ego_rename(), identity_cb(), next_phase(), process_if(), result_callback(), run(), run(), save_member(), save_member_session(), save_operation(), set_external_ipv4(), set_value(), start_peer_run(), test_local_ip(), test_upnpc(), update_config(), update_config_sections(), and update_enable_upnpc_option().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_remove_value_filename()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_remove_value_filename	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		const char *	value
	)

Remove a filename from a configuration value that represents a list of filenames.

Parameters

cfg	configuration to update
section	section of interest
option	option of interest
value	filename to remove

Returns

GNUNET_OK on success, GNUNET_SYSERR if the filename is not in the list

Definition at line 3106 of file configuration.c.

{
  char *list;
  char *pos;
  char *end;
  char *match;
  char old;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             section,
                                             option,
                                             &list))
    return GNUNET_NO;
  match = escape_name (value);
  pos = list;
  while (1)
  {
    while (pos[0] == ' ')
      pos++;
    if (strlen (pos) == 0)
      break;
    end = pos + 1;
    while ((end[0] != ' ') && (end[0] != '\0'))
    {
      if (end[0] == '\\')
      {
        switch (end[1])
        {
        case '\\':
        case ' ':
          end++;
          break;
 
        case '\0':
          /* illegal, but just keep it */
          break;
 
        default:
          /* illegal, but just ignore that there was a '/' */
          break;
        }
      }
      end++;
    }
    old = end[0];
    end[0] = '\0';
    if (0 == strcmp (pos, match))
    {
      if (old != '\0')
        memmove (pos,
                 &end[1],
                 strlen (&end[1]) + 1);
      else
      {
        if (pos != list)
          pos[-1] = '\0';
        else
          pos[0] = '\0';
      }
      GNUNET_CONFIGURATION_set_value_string (cfg,
                                             section,
                                             option,
                                             list);
      GNUNET_free (list);
      GNUNET_free (match);
      return GNUNET_OK;
    }
    if (old == '\0')
      break;
    end[0] = old;
    pos = end + 1;
  }
  GNUNET_free (list);
  GNUNET_free (match);
  return GNUNET_NO;
}

References cfg, end, escape_name(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_NO, GNUNET_OK, list, and value.

Here is the call graph for this function:

GNUNET_CONFIGURATION_append_value_filename()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_append_value_filename	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		const char *	value
	)

Append a filename to a configuration value that represents a list of filenames.

Parameters

cfg	configuration to update
section	section of interest
option	option of interest
value	filename to append

Returns

GNUNET_OK on success, GNUNET_SYSERR if the filename already in the list

Definition at line 3068 of file configuration.c.

{
  char *escaped;
  char *old;
  char *nw;
 
  if (GNUNET_SYSERR ==
      GNUNET_CONFIGURATION_iterate_value_filenames (cfg,
                                                    section,
                                                    option,
                                                    &test_match,
                                                    (void *) value))
    return GNUNET_NO; /* already exists */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &old))
    old = GNUNET_strdup ("");
  escaped = escape_name (value);
  nw = GNUNET_malloc (strlen (old) + strlen (escaped) + 2);
  strcpy (nw, old);
  if (strlen (old) > 0)
    strcat (nw, " ");
  strcat (nw, escaped);
  GNUNET_CONFIGURATION_set_value_string (cfg,
                                         section,
                                         option,
                                         nw);
  GNUNET_free (old);
  GNUNET_free (nw);
  GNUNET_free (escaped);
  return GNUNET_OK;
}

References cfg, escape_name(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_iterate_value_filenames(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_malloc, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, test_match(), and value.

Here is the call graph for this function:

GNUNET_CONFIGURATION_config_settings_free()

void GNUNET_CONFIGURATION_config_settings_free

(

struct GNUNET_CONFIGURATION_ConfigSettings *

cs

)

Free resources associated with cs.

Parameters

[in]

cs

settings to free (actual memory of cs itself is not released)

Definition at line 3651 of file configuration.c.

{
  GNUNET_free (cs->option);
  GNUNET_free (cs->section);
  GNUNET_free (cs->value);
}

References GNUNET_free, GNUNET_CONFIGURATION_ConfigSettings::option, GNUNET_CONFIGURATION_ConfigSettings::section, and GNUNET_CONFIGURATION_ConfigSettings::value.

Referenced by main().

Here is the caller graph for this function:

GNUNET_CONFIGURATION_config_tool_run()

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

Main task to run to perform operations typical for gnunet-config as per the configuration settings given in cls.

Parameters

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

Definition at line 3456 of file configuration.c.

{
  struct GNUNET_CONFIGURATION_ConfigSettings *cs = cls;
  struct GNUNET_CONFIGURATION_Handle *out = NULL;
  struct GNUNET_CONFIGURATION_Handle *ncfg = NULL;
 
  (void) args;
  if (cs->diagnostics &&
      (! cfg->diagnostics))
  {
    /* Re-parse the configuration with diagnostics enabled. */
    ncfg = GNUNET_CONFIGURATION_create (cfg->pd);
    GNUNET_CONFIGURATION_enable_diagnostics (ncfg);
    if (GNUNET_OK !=
        GNUNET_CONFIGURATION_load (ncfg,
                                   cfgfile))
    {
      fprintf (stderr,
               _ ("Failed to load config file `%s'"),
               cfgfile);
      return;
    }
    cfg = ncfg;
  }
 
  if (cs->full)
    cs->rewrite = GNUNET_YES;
  if (cs->list_sections)
  {
    fprintf (stderr,
             _ ("The following sections are available:\n"));
    GNUNET_CONFIGURATION_iterate_sections (cfg,
                                           &print_section_name,
                                           NULL);
    return;
  }
  if ( (! cs->rewrite) &&
       (NULL == cs->section) )
  {
    char *serialization;
 
    if (! cs->diagnostics)
    {
      fprintf (stderr,
               _ ("%s, %s or %s argument is required\n"),
               "--section",
               "--list-sections",
               "--diagnostics");
      cs->global_ret = EXIT_INVALIDARGUMENT;
      return;
    }
    serialization = (cs->diagnostics > 1)
                    ? GNUNET_CONFIGURATION_serialize_diagnostics_verbose (cfg)
                    : GNUNET_CONFIGURATION_serialize_diagnostics (cfg);
    fprintf (stdout,
             "%s",
             serialization);
    GNUNET_free (serialization);
  }
  else if ( (NULL != cs->section) &&
            (NULL == cs->value) )
  {
    if (NULL == cs->option)
    {
      GNUNET_CONFIGURATION_iterate_section_values (
        cfg,
        cs->section,
        cs->is_filename
        ? &print_filename_option
        : &print_option,
        (void *) cfg);
    }
    else
    {
      char *value;
 
      if (cs->is_filename)
      {
        if (GNUNET_OK !=
            GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                     cs->section,
                                                     cs->option,
                                                     &value))
        {
          GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                                     cs->section,
                                     cs->option);
          cs->global_ret = EXIT_NOTCONFIGURED;
          return;
        }
      }
      else
      {
        if (GNUNET_OK !=
            GNUNET_CONFIGURATION_get_value_string (cfg,
                                                   cs->section,
                                                   cs->option,
                                                   &value))
        {
          GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                                     cs->section,
                                     cs->option);
          cs->global_ret = EXIT_NOTCONFIGURED;
          return;
        }
      }
      fprintf (stdout,
               "%s\n",
               value);
      GNUNET_free (value);
    }
  }
  else if (NULL != cs->section)
  {
    if (NULL == cs->option)
    {
      fprintf (stderr,
               _ ("--option argument required to set value\n"));
      cs->global_ret = EXIT_INVALIDARGUMENT;
      return;
    }
    out = GNUNET_CONFIGURATION_dup (cfg);
    GNUNET_CONFIGURATION_set_value_string (out,
                                           cs->section,
                                           cs->option,
                                           cs->value);
    cs->rewrite = GNUNET_YES;
  }
  if (cs->rewrite)
  {
    char *cfg_fn = NULL;
 
    if (NULL == out)
      out = GNUNET_CONFIGURATION_dup (cfg);
 
    if (NULL == cfgfile)
    {
      const char *xdg = getenv ("XDG_CONFIG_HOME");
 
      if (NULL != xdg)
        GNUNET_asprintf (&cfg_fn,
                         "%s%s%s",
                         xdg,
                         DIR_SEPARATOR_STR,
                         cfg->pd->config_file);
      else
        cfg_fn = GNUNET_strdup (cfg->pd->user_config_file);
      cfgfile = cfg_fn;
    }
 
    if (! cs->full)
    {
      struct GNUNET_CONFIGURATION_Handle *def;
 
      def = GNUNET_CONFIGURATION_create (cfg->pd);
      if (GNUNET_OK !=
          GNUNET_CONFIGURATION_load (def,
                                     NULL))
      {
        fprintf (stderr,
                 _ ("failed to load configuration defaults"));
        cs->global_ret = 1;
        GNUNET_CONFIGURATION_destroy (def);
        GNUNET_CONFIGURATION_destroy (out);
        GNUNET_free (cfg_fn);
        return;
      }
      if (GNUNET_OK !=
          GNUNET_CONFIGURATION_write_diffs (def,
                                            out,
                                            cfgfile))
        cs->global_ret = 2;
      GNUNET_CONFIGURATION_destroy (def);
    }
    else
    {
      if (GNUNET_OK !=
          GNUNET_CONFIGURATION_write (out,
                                      cfgfile))
        cs->global_ret = 2;
    }
    GNUNET_free (cfg_fn);
  }
  if (NULL != out)
    GNUNET_CONFIGURATION_destroy (out);
  if (NULL != ncfg)
    GNUNET_CONFIGURATION_destroy (ncfg);
}

References _, cfg, GNUNET_OS_ProjectData::config_file, GNUNET_CONFIGURATION_ConfigSettings::diagnostics, GNUNET_CONFIGURATION_Handle::diagnostics, DIR_SEPARATOR_STR, EXIT_INVALIDARGUMENT, EXIT_NOTCONFIGURED, GNUNET_CONFIGURATION_ConfigSettings::full, getenv(), GNUNET_CONFIGURATION_ConfigSettings::global_ret, GNUNET_asprintf(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_enable_diagnostics(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_iterate_section_values(), GNUNET_CONFIGURATION_iterate_sections(), GNUNET_CONFIGURATION_load(), GNUNET_CONFIGURATION_serialize_diagnostics(), GNUNET_CONFIGURATION_serialize_diagnostics_verbose(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_CONFIGURATION_write(), GNUNET_CONFIGURATION_write_diffs(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_config_missing(), GNUNET_OK, GNUNET_strdup, GNUNET_YES, GNUNET_CONFIGURATION_ConfigSettings::is_filename, GNUNET_CONFIGURATION_ConfigSettings::list_sections, GNUNET_CONFIGURATION_ConfigSettings::option, GNUNET_CONFIGURATION_Handle::pd, print_filename_option(), print_option(), print_section_name(), GNUNET_CONFIGURATION_ConfigSettings::rewrite, GNUNET_CONFIGURATION_ConfigSettings::section, GNUNET_OS_ProjectData::user_config_file, value, and GNUNET_CONFIGURATION_ConfigSettings::value.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONFIGURATION_get_suid_binary_path()

char * GNUNET_CONFIGURATION_get_suid_binary_path	(	const struct GNUNET_OS_ProjectData *	pd,
		const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	progname
	)

Given the name of a helper, service or daemon binary construct the full path to the binary using the SUID_BINARY_PATH in the PATHS section of the configuration.

If that option is not present, fall back to GNUNET_OS_get_libexec_binary_path. If progname is an absolute path, a copy of this path is returned.

Parameters

pd	project data to use to determine paths
cfg	configuration to inspect
progname	name of the binary

Returns

full path to the binary, if possible, a copy of progname otherwise

Definition at line 3669 of file configuration.c.

{
  static char *cache;
  char *binary = NULL;
  char *path = NULL;
  size_t path_len;
 
  if (GNUNET_YES ==
      GNUNET_STRINGS_path_is_absolute (progname,
                                       GNUNET_NO,
                                       NULL,
                                       NULL))
  {
    return GNUNET_strdup (progname);
  }
  if (NULL != cache)
    path = cache;
  else
    GNUNET_CONFIGURATION_get_value_string (cfg,
                                           "PATHS",
                                           "SUID_BINARY_PATH",
                                           &path);
  if ( (NULL == path) ||
       (0 == strlen (path)) )
  {
    if (NULL != path)
      GNUNET_free (path);
    cache = NULL;
    return GNUNET_OS_get_libexec_binary_path (pd,
                                              progname);
  }
  path_len = strlen (path);
  GNUNET_asprintf (&binary,
                   "%s%s%s",
                   path,
                   (path[path_len - 1] == DIR_SEPARATOR) ? ""
                   : DIR_SEPARATOR_STR,
                   progname);
  cache = path;
  return binary;
}

References cfg, DIR_SEPARATOR, DIR_SEPARATOR_STR, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_free, GNUNET_NO, GNUNET_OS_get_libexec_binary_path(), GNUNET_strdup, GNUNET_STRINGS_path_is_absolute(), and GNUNET_YES.

Referenced by GN_request_connection_reversal(), restart_nat_server(), run(), run(), and run().

Here is the call graph for this function:

Here is the caller graph for this function: