#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_configuration_lib.h"

Include dependency graph for configuration.c:

Data Structures
struct	ConfigEntry
	configuration entry More...

struct	ConfigSection
	configuration section More...

struct	ConfigFile

struct	GNUNET_CONFIGURATION_Handle
	configuration data More...

struct	DiffHandle
	Used for diffing a configuration object against the default one. More...

struct	CollectFilesContext
	Closure to collect_files_cb. More...

Macros
#define	LOG(kind, ...) GNUNET_log_from (kind, "util", __VA_ARGS__)

#define	LOG_STRERROR_FILE(kind, syscall, filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename)

Functions
void	GNUNET_CONFIGURATION_enable_diagnostics (struct GNUNET_CONFIGURATION_Handle *cfg)
	Enable extra diagnostics. More...

struct GNUNET_CONFIGURATION_Handle *	GNUNET_CONFIGURATION_create ()
	Create a new configuration object. More...

void	GNUNET_CONFIGURATION_destroy (struct GNUNET_CONFIGURATION_Handle *cfg)
	Destroy configuration object. More...

enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_parse_and_run (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. More...

static enum GNUNET_GenericReturnValue	collect_files_cb (void cls, const char filename)
	Function called with a filename. More...

static struct ConfigSection *	find_section (const struct GNUNET_CONFIGURATION_Handle cfg, const char section)
	Find a section entry from a configuration. More...

static int	pstrcmp (const void a, const void b)

static enum GNUNET_GenericReturnValue	handle_inline (struct GNUNET_CONFIGURATION_Handle cfg, const char path_or_glob, bool path_is_glob, const char restrict_section, const char source_filename, unsigned int source_lineno)
	Handle an inline directive. More...

static struct ConfigEntry *	find_entry (const struct GNUNET_CONFIGURATION_Handle cfg, const char section, const char *key)
	Find an entry from a configuration. More...

static void	set_entry_hint (struct GNUNET_CONFIGURATION_Handle cfg, const char section, const char option, const char hint_filename, unsigned int hint_line)
	Set a configuration hint. More...

enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_deserialize (struct GNUNET_CONFIGURATION_Handle cfg, const char mem, size_t size, const char *source_filename)
	De-serializes configuration. More...

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. More...

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. More...

static bool	do_skip (const char sec, const char key)
	Should we skip this configuration entry when serializing? More...

char *	GNUNET_CONFIGURATION_serialize (const struct GNUNET_CONFIGURATION_Handle cfg, size_t size)
	Serializes the given configuration. More...

char *	GNUNET_CONFIGURATION_serialize_diagnostics (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Serializes the given configuration with diagnostics information. More...

enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_write (struct GNUNET_CONFIGURATION_Handle cfg, const char filename)
	Write configuration file. More...

void	GNUNET_CONFIGURATION_iterate (const struct GNUNET_CONFIGURATION_Handle cfg, GNUNET_CONFIGURATION_Iterator iter, void iter_cls)
	Iterate over all options in the configuration. More...

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. More...

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. More...

void	GNUNET_CONFIGURATION_remove_section (struct GNUNET_CONFIGURATION_Handle cfg, const char section)
	Remove the given section and all options in it. More...

static void	copy_entry (void cls, const char section, const char option, const char value)
	Copy a configuration value to the given target configuration. More...

struct GNUNET_CONFIGURATION_Handle *	GNUNET_CONFIGURATION_dup (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Duplicate an existing configuration object. More...

static void	compare_entries (void cls, const char section, const char option, const char value)
	A callback function, compares entries from two configurations (default against a new configuration) and write the diffs in a diff-configuration object (the callback object). More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

static char *	expand_dollar (const struct GNUNET_CONFIGURATION_Handle cfg, char orig, unsigned int depth)
	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". More...

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". More...

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. More...

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". More...

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. More...

static char *	escape_name (const char *value)
	FIXME. More...

static enum GNUNET_GenericReturnValue	test_match (void cls, const char fn)
	FIXME. More...

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. More...

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. More...

enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_load_from (struct GNUNET_CONFIGURATION_Handle cfg, const char defaults_d)
	Load default configuration. More...

char *	GNUNET_CONFIGURATION_default_filename (void)
	Return the filename of the default configuration filename that is used when no explicit configuration entry point has been specified. More...

struct GNUNET_CONFIGURATION_Handle *	GNUNET_CONFIGURATION_default (void)
	Return GNUnet's default configuration. More...

enum GNUNET_GenericReturnValue	GNUNET_CONFIGURATION_load (struct GNUNET_CONFIGURATION_Handle cfg, const char filename)
	Load configuration (starts with defaults, then loads system-specific configuration). More...

Macro Definition Documentation

◆ LOG

#define LOG	(	kind,
		...
	)	GNUNET_log_from (kind, "util", __VA_ARGS__)

Definition at line 30 of file configuration.c.

◆ LOG_STRERROR_FILE

#define LOG_STRERROR_FILE	(	kind,
		syscall,
		filename
	)	GNUNET_log_from_strerror_file (kind, "util", syscall, filename)

Definition at line 32 of file configuration.c.

Function Documentation

◆ collect_files_cb()

static enum GNUNET_GenericReturnValue collect_files_cb	(	void *	cls,
		const char *	filename
	)

static

Function called with a filename.

Parameters

cls	closure
filename	complete filename (absolute path)

Returns: GNUNET_OK to continue to iterate, GNUNET_NO to stop iteration with no error, GNUNET_SYSERR to abort iteration with error!

Definition at line 378 of file configuration.c.

{
  struct CollectFilesContext *igc = cls;
 
  GNUNET_array_append (igc->files,
                       igc->files_length,
                       GNUNET_strdup (filename));
  return GNUNET_OK;
}

References filename, CollectFilesContext::files, CollectFilesContext::files_length, GNUNET_array_append, GNUNET_OK, and GNUNET_strdup.

Referenced by GNUNET_CONFIGURATION_load_from(), and handle_inline().

Here is the caller graph for this function:

◆ find_section()

static struct ConfigSection * find_section	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section
	)

static

Find a section entry from a configuration.

Parameters

cfg	configuration to search in
section	name of the section to look for

Returns: matching entry, NULL if not found

Definition at line 398 of file configuration.c.

{
  struct ConfigSection *pos;
 
  if (NULL == cfg)
    return NULL;
 
  pos = cfg->sections;
  while ((pos != NULL) && (0 != strcasecmp (section, pos->name)))
    pos = pos->next;
  return pos;
}

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

Referenced by find_entry(), GNUNET_CONFIGURATION_set_value_string(), and handle_inline().

Here is the caller graph for this function:

◆ pstrcmp()

static int pstrcmp	(	const void *	a,
		const void *	b
	)

static

Definition at line 414 of file configuration.c.

{
  return strcmp (*((const char **) a),
                 *((const char **) b));
}

Referenced by GNUNET_CONFIGURATION_load_from(), and handle_inline().

Here is the caller graph for this function:

◆ handle_inline()

static enum GNUNET_GenericReturnValue handle_inline	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	path_or_glob,
		bool	path_is_glob,
		const char *	restrict_section,
		const char *	source_filename,
		unsigned int	source_lineno
	)

static

Handle an inline directive.

Returns: GNUNET_SYSERR on error, GNUNET_OK otherwise

Definition at line 428 of file configuration.c.

{
  char *inline_path = NULL;
  struct GNUNET_CONFIGURATION_Handle *other_cfg = NULL;
  struct CollectFilesContext igc = {
    .files = NULL,
    .files_length = 0,
  };
  enum GNUNET_GenericReturnValue fun_ret;
  unsigned int old_nest_level = cfg->current_nest_level++;
 
  /* We support the section restriction only for non-globs */
  GNUNET_assert (! (path_is_glob && (NULL != restrict_section)));
 
  if (NULL == source_filename)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Refusing to parse inline configurations, "
         "not allowed without source filename!\n");
    fun_ret = GNUNET_SYSERR;
    goto cleanup;
  }
 
  if ('/' == *path_or_glob)
    inline_path = GNUNET_strdup (path_or_glob);
  else
  {
    /* We compute the canonical, absolute path first,
       so that relative imports resolve properly with symlinked
       config files.  */
    char *source_realpath;
    char *endsep;
 
    source_realpath = realpath (source_filename,
                                NULL);
    if (NULL == source_realpath)
    {
      /* Couldn't even resolve path of base dir. */
      GNUNET_break (0);
      /* failed to parse included config */
      fun_ret = GNUNET_SYSERR;
      goto cleanup;
    }
    endsep = strrchr (source_realpath, '/');
    GNUNET_assert (NULL != endsep);
    *endsep = '\0';
    GNUNET_asprintf (&inline_path,
                     "%s/%s",
                     source_realpath,
                     path_or_glob);
    free (source_realpath);
  }
 
  if (path_is_glob)
  {
    int nret;
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "processing config glob '%s'\n",
         inline_path);
 
    nret = GNUNET_DISK_glob (inline_path, collect_files_cb, &igc);
    if (-1 == nret)
    {
      fun_ret = GNUNET_SYSERR;
      goto cleanup;
    }
    GNUNET_assert (nret == igc.files_length);
    qsort (igc.files, igc.files_length, sizeof (char *), pstrcmp);
    for (int i = 0; i < nret; i++)
    {
      if (GNUNET_OK !=
          GNUNET_CONFIGURATION_parse (cfg,
                                      igc.files[i]))
      {
        fun_ret = GNUNET_SYSERR;
        goto cleanup;
      }
    }
    fun_ret = GNUNET_OK;
  }
  else if (NULL != restrict_section)
  {
    enum GNUNET_GenericReturnValue inner_ret;
    struct ConfigSection *cs;
    struct ConfigFile *cf = GNUNET_new (struct ConfigFile);
 
    inner_ret = GNUNET_DISK_file_test_read (inline_path);
 
    cs = find_section (cfg, restrict_section);
 
    if (NULL == cs)
    {
      cs = GNUNET_new (struct ConfigSection);
      cs->name = GNUNET_strdup (restrict_section);
      cs->next = cfg->sections;
      cfg->sections = cs;
      cs->entries = NULL;
    }
    if (cfg->diagnostics)
    {
      const char *pwname;
      const char *grname;
      char *sfn = GNUNET_STRINGS_filename_expand (inline_path);
      struct stat istat;
 
      cs->hint_secret_filename = sfn;
      if (0 == stat (sfn, &istat))
      {
        struct passwd *pw = getpwuid (istat.st_uid);
        struct group *gr = getgrgid (istat.st_gid);
        pwname = (NULL == pw) ? "<unknown>" : pw->pw_name;
        grname = (NULL == gr) ? "<unknown>" : gr->gr_name;
 
        GNUNET_asprintf (&cs->hint_secret_stat,
                         "%s:%s %o",
                         pwname,
                         grname,
                         istat.st_mode);
      }
      else
      {
        cs->hint_secret_stat = GNUNET_strdup ("<can't stat file>");
      }
      if (source_filename)
      {
        /* Possible that this secret section has been inlined before */
        GNUNET_free (cs->hint_inlined_from_filename);
        cs->hint_inlined_from_filename = GNUNET_strdup (source_filename);
        cs->hint_inlined_from_line = source_lineno;
      }
    }
 
    /* Put file in the load list for diagnostics, even if we can't access it. */
    {
      cf->level = cfg->current_nest_level;
      cf->source_filename = GNUNET_strdup (inline_path);
      cf->hint_restrict_section = GNUNET_strdup (restrict_section);
      GNUNET_CONTAINER_DLL_insert_tail (cfg->loaded_files_head,
                                        cfg->loaded_files_tail,
                                        cf);
    }
 
    if (GNUNET_OK != inner_ret)
    {
      cs->inaccessible = true;
      cf->hint_inaccessible = true;
      /* File can't be accessed, but that's okay. */
      fun_ret = GNUNET_OK;
      goto cleanup;
    }
 
    other_cfg = GNUNET_CONFIGURATION_create ();
    other_cfg->restrict_section = restrict_section;
    inner_ret = GNUNET_CONFIGURATION_parse (other_cfg,
                                            inline_path);
    if (GNUNET_OK != inner_ret)
    {
      cf->hint_inaccessible = true;
      fun_ret = inner_ret;
      goto cleanup;
    }
 
    cs = find_section (other_cfg, restrict_section);
    if (NULL == cs)
    {
      LOG (GNUNET_ERROR_TYPE_INFO,
           "Configuration file '%s' loaded with @inline-secret@ "
           "does not contain section '%s'.\n",
           inline_path,
           restrict_section);
      /* Inlined onfiguration is accessible but doesn't contain any values.
         We treat this as if the inlined section was empty, and do not
         consider it an error. */
      fun_ret = GNUNET_OK;
      goto cleanup;
    }
    for (struct ConfigEntry *ce = cs->entries;
         NULL != ce;
         ce = ce->next)
      GNUNET_CONFIGURATION_set_value_string (cfg,
                                             restrict_section,
                                             ce->key,
                                             ce->val);
    fun_ret = GNUNET_OK;
  }
  else if (GNUNET_OK !=
           GNUNET_CONFIGURATION_parse (cfg,
                                       inline_path))
  {
    fun_ret = GNUNET_SYSERR;
    goto cleanup;
  }
  else
  {
    fun_ret = GNUNET_OK;
  }
cleanup:
  cfg->current_nest_level = old_nest_level;
  if (NULL != other_cfg)
    GNUNET_CONFIGURATION_destroy (other_cfg);
  GNUNET_free (inline_path);
  if (igc.files_length > 0)
  {
    for (size_t i = 0; i < igc.files_length; i++)
      GNUNET_free (igc.files[i]);
    GNUNET_array_grow (igc.files, igc.files_length, 0);
  }
  return fun_ret;
}

Referenced by GNUNET_CONFIGURATION_deserialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_entry()

static struct ConfigEntry * find_entry	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	key
	)

static

Find an entry from a configuration.

Parameters

cfg	handle to the configuration
section	section the option is in
key	the option

Returns: matching entry, NULL if not found

Definition at line 654 of file configuration.c.

{
  struct ConfigSection *sec;
  struct ConfigEntry *pos;
 
  if (NULL == (sec = find_section (cfg, section)))
    return NULL;
  if (sec->inaccessible)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Section '%s' is marked as inaccessible, because the configuration "
         " file that contains the section can't be read.  Attempts to use "
         "option '%s' will fail.\n",
         section,
         key);
    return NULL;
  }
  pos = sec->entries;
  while ((pos != NULL) && (0 != strcasecmp (key, pos->key)))
    pos = pos->next;
  return pos;
}

References cfg, ConfigSection::entries, find_section(), GNUNET_ERROR_TYPE_WARNING, ConfigSection::inaccessible, key, ConfigEntry::key, LOG, and ConfigEntry::next.

Referenced by compare_entries(), GNUNET_CONFIGURATION_get_value_choice(), GNUNET_CONFIGURATION_get_value_float(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_size(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONFIGURATION_have_value(), GNUNET_CONFIGURATION_set_value_string(), and set_entry_hint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_entry_hint()

static void set_entry_hint	(	struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	option,
		const char *	hint_filename,
		unsigned int	hint_line
	)

static

Set a configuration hint.

Parameters

cfg	configuration handle
section	section
option	config option
hint_filename
hint_line

Definition at line 690 of file configuration.c.

{
  struct ConfigEntry *e = find_entry (cfg, section, option);
  if (! cfg->diagnostics)
    return;
  if (! e)
    return;
  e->hint_filename = GNUNET_strdup (hint_filename);
  e->hint_lineno = hint_line;
}

References cfg, GNUNET_CONFIGURATION_Handle::diagnostics, find_entry(), GNUNET_strdup, ConfigEntry::hint_filename, and ConfigEntry::hint_lineno.

Referenced by GNUNET_CONFIGURATION_deserialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_skip()

static bool do_skip	(	const char *	sec,
		const char *	key
	)

static

Should we skip this configuration entry when serializing?

Parameters

sec	section name
key	key

Returns: true if we should skip it

Definition at line 1107 of file configuration.c.

{
  if (0 != strcasecmp ("PATHS",
                       sec))
    return false;
  return ( (0 == strcasecmp ("DATADIR",
                             key)) ||
           (0 == strcasecmp ("LIBDIR",
                             key)) ||
           (0 == strcasecmp ("BINDIR",
                             key)) ||
           (0 == strcasecmp ("PREFIX",
                             key)) ||
           (0 == strcasecmp ("LOCALEDIR",
                             key)) ||
           (0 == strcasecmp ("ICONDIR",
                             key)) ||
           (0 == strcasecmp ("DOCDIR",
                             key)) ||
           (0 == strcasecmp ("DEFAULTCONFIG",
                             key)) ||
           (0 == strcasecmp ("LIBEXECDIR",
                             key)) );
}

References key.

Referenced by GNUNET_CONFIGURATION_serialize(), and GNUNET_CONFIGURATION_serialize_diagnostics().

Here is the caller graph for this function:

◆ copy_entry()

static void copy_entry	(	void *	cls,
		const char *	section,
		const char *	option,
		const char *	value
	)

static

Copy a configuration value to the given target configuration.

Overwrites existing entries.

Parameters

cls	the destination configuration (`struct GNUNET_CONFIGURATION_Handle *`)
section	section for the value
option	option name of the value
value	value to copy

Definition at line 1522 of file configuration.c.

{
  struct GNUNET_CONFIGURATION_Handle *dst = cls;
 
  GNUNET_CONFIGURATION_set_value_string (dst,
                                         section,
                                         option,
                                         value);
}

References GNUNET_CONFIGURATION_set_value_string(), and value.

Referenced by GNUNET_CONFIGURATION_dup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compare_entries()

static void compare_entries	(	void *	cls,
		const char *	section,
		const char *	option,
		const char *	value
	)

static

A callback function, compares entries from two configurations (default against a new configuration) and write the diffs in a diff-configuration object (the callback object).

Parameters

cls	the diff configuration (`struct DiffHandle *`)
section	section for the value (of the default conf.)
option	option name of the value (of the default conf.)
value	value to copy (of the default conf.)

Definition at line 1561 of file configuration.c.

{
  struct DiffHandle *dh = cls;
  struct ConfigEntry *entNew;
 
  entNew = find_entry (dh->cfg_default, section, option);
  if ((NULL != entNew) && (NULL != entNew->val) &&
      (0 == strcmp (entNew->val, value)))
    return;
  GNUNET_CONFIGURATION_set_value_string (dh->cfgDiff,
                                         section,
                                         option,
                                         value);
}

References DiffHandle::cfg_default, DiffHandle::cfgDiff, find_entry(), GNUNET_CONFIGURATION_set_value_string(), ConfigEntry::val, and value.

Referenced by GNUNET_CONFIGURATION_get_diff().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ expand_dollar()

static char * expand_dollar	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		char *	orig,
		unsigned int	depth
	)

static

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!)
depth	recursion depth, used to detect recursive expansions

Returns: $-expanded string, never NULL unless orig was NULL

Definition at line 1904 of file configuration.c.

{
  char *prefix;
  char *result;
  char *start;
  const char *post;
  const char *env;
  char *def;
  char *end;
  unsigned int lopen;
  char erased_char;
  char *erased_pos;
  size_t len;
 
  if (NULL == orig)
    return NULL;
  if (depth > 128)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Recursive expansion suspected, aborting $-expansion for term `%s'\n",
         orig);
    return orig;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Asked to $-expand %s\n",
       orig);
  if ('$' != orig[0])
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Doesn't start with $ - not expanding\n");
    return orig;
  }
  erased_char = 0;
  erased_pos = NULL;
  if ('{' == orig[1])
  {
    start = &orig[2];
    lopen = 1;
    end = &orig[1];
    while (lopen > 0)
    {
      end++;
      switch (*end)
      {
      case '}':
        lopen--;
        break;
 
      case '{':
        lopen++;
        break;
 
      case '\0':
        LOG (GNUNET_ERROR_TYPE_WARNING,
             "Missing closing `}' in option `%s'\n",
             orig);
        return orig;
 
      default:
        break;
      }
    }
    erased_char = *end;
    erased_pos = end;
    *end = '\0';
    post = end + 1;
    def = strchr (orig, ':');
    if (NULL != def)
    {
      *def = '\0';
      def++;
      if (('-' == *def) || ('=' == *def))
        def++;
      def = GNUNET_strdup (def);
    }
  }
  else
  {
    int i;
 
    start = &orig[1];
    def = NULL;
    i = 0;
    while ( (orig[i] != '/') &&
            (orig[i] != '\\') &&
            (orig[i] != '\0') &&
            (orig[i] != ' ') )
      i++;
    if (orig[i] == '\0')
    {
      post = "";
    }
    else
    {
      erased_char = orig[i];
      erased_pos = &orig[i];
      orig[i] = '\0';
      post = &orig[i + 1];
    }
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Split into `%s' and `%s' with default %s\n",
       start,
       post,
       def);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             "PATHS",
                                             start,
                                             &prefix))
  {
    if (NULL == (env = getenv (start)))
    {
      /* try default */
      def = expand_dollar (cfg,
                           def,
                           depth + 1);
      env = def;
    }
    if (NULL == env)
    {
      start = GNUNET_strdup (start);
      if (erased_pos)
        *erased_pos = erased_char;
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "Failed to expand `%s' in `%s' as it is neither found in [PATHS] nor defined as an environmental variable\n",
           start,
           orig);
      GNUNET_free (start);
      return orig;
    }
    prefix = GNUNET_strdup (env);
  }
  prefix = GNUNET_CONFIGURATION_expand_dollar (cfg,
                                               prefix);
  if ((erased_pos) && ('}' != erased_char))
  {
    len = strlen (prefix) + 1;
    prefix = GNUNET_realloc (prefix, len + 1);
    prefix[len - 1] = erased_char;
    prefix[len] = '\0';
  }
  result = GNUNET_malloc (strlen (prefix) + strlen (post) + 1);
  strcpy (result, prefix);
  strcat (result, post);
  GNUNET_free (def);
  GNUNET_free (prefix);
  GNUNET_free (orig);
  return result;
}

References cfg, end, env, expand_dollar(), getenv(), GNUNET_CONFIGURATION_expand_dollar(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_realloc, GNUNET_strdup, LOG, prefix, result, and start.

Referenced by expand_dollar(), and GNUNET_CONFIGURATION_expand_dollar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ escape_name()

static char * escape_name ( const char * value )

static

FIXME.

Parameters

value FIXME

Returns: FIXME

Definition at line 2222 of file configuration.c.

{
  char *escaped;
  const char *rpos;
  char *wpos;
 
  escaped = GNUNET_malloc (strlen (value) * 2 + 1);
  memset (escaped, 0, strlen (value) * 2 + 1);
  rpos = value;
  wpos = escaped;
  while (rpos[0] != '\0')
  {
    switch (rpos[0])
    {
    case '\\':
    case ' ':
      wpos[0] = '\\';
      wpos[1] = rpos[0];
      wpos += 2;
      break;
 
    default:
      wpos[0] = rpos[0];
      wpos++;
    }
    rpos++;
  }
  return escaped;
}

References GNUNET_malloc, and value.

Referenced by GNUNET_CONFIGURATION_append_value_filename(), and GNUNET_CONFIGURATION_remove_value_filename().

Here is the caller graph for this function:

◆ test_match()

static enum GNUNET_GenericReturnValue test_match	(	void *	cls,
		const char *	fn
	)

static

FIXME.

Parameters

cls	string we compare with (const char*)
fn	filename we are currently looking at

Returns: GNUNET_OK if the names do not match, GNUNET_SYSERR if they do

Definition at line 2261 of file configuration.c.

{
  const char *of = cls;
 
  return (0 == strcmp (of, fn))
    ? GNUNET_SYSERR
    : GNUNET_OK;
}

References GNUNET_OK, and GNUNET_SYSERR.

Referenced by GNUNET_CONFIGURATION_append_value_filename().

Here is the caller graph for this function:

Data Structures

Macros

Functions

Macro Definition Documentation

◆ LOG

◆ LOG_STRERROR_FILE

Function Documentation

◆ collect_files_cb()

◆ find_section()

◆ pstrcmp()

◆ handle_inline()

◆ find_entry()

◆ set_entry_hint()

◆ do_skip()

◆ copy_entry()

◆ compare_entries()

◆ expand_dollar()

◆ escape_name()

◆ test_match()