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

Typedefs

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. More...
 
typedef void(* GNUNET_CONFIGURATION_Iterator) (void *cls, const char *section, const char *option, const char *value)
 Function to iterate over options. More...
 
typedef void(* GNUNET_CONFIGURATION_SectionIterator) (void *cls, const char *section)
 Function to iterate over section. More...
 

Functions

struct GNUNET_CONFIGURATION_HandleGNUNET_CONFIGURATION_create (void)
 Create a new configuration object. More...
 
struct GNUNET_CONFIGURATION_HandleGNUNET_CONFIGURATION_dup (const struct GNUNET_CONFIGURATION_Handle *cfg)
 Duplicate an existing configuration object. More...
 
void GNUNET_CONFIGURATION_destroy (struct GNUNET_CONFIGURATION_Handle *cfg)
 Destroy configuration object. More...
 
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load (struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
 Load configuration. More...
 
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load_from (struct GNUNET_CONFIGURATION_Handle *cfg, const char *defaults_d)
 Load default configuration. More...
 
struct GNUNET_CONFIGURATION_HandleGNUNET_CONFIGURATION_default (void)
 Return GNUnet's 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...
 
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...
 
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_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_write (struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
 Write configuration file. 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...
 
struct GNUNET_CONFIGURATION_HandleGNUNET_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_is_dirty (const struct GNUNET_CONFIGURATION_Handle *cfg)
 Test if there are configuration options that were changed since the last save. 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...
 
void GNUNET_CONFIGURATION_enable_diagnostics (struct GNUNET_CONFIGURATION_Handle *cfg)
 Enable extra diagnostics. 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_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...
 
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_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...
 
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_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...
 
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...
 
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...
 
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_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...
 
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...
 
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...
 
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...
 
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...
 
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_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...
 
void GNUNET_CONFIGURATION_config_settings_free (struct GNUNET_CONFIGURATION_ConfigSettings *cs)
 Free resources associated with cs. More...
 
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. More...
 

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
csconfiguration settings to initialize

Definition at line 716 of file gnunet_configuration_lib.h.

Typedef Documentation

◆ 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
clsclosure
cfgthe configuration
Returns
status code

Definition at line 223 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
clsclosure
sectionname of the section
optionname of the option
valuevalue of the option

Definition at line 286 of file gnunet_configuration_lib.h.

◆ GNUNET_CONFIGURATION_SectionIterator

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

Function to iterate over section.

Parameters
clsclosure
sectionname of the section

Definition at line 299 of file gnunet_configuration_lib.h.

Function Documentation

◆ GNUNET_CONFIGURATION_create()

struct GNUNET_CONFIGURATION_Handle* GNUNET_CONFIGURATION_create ( void  )

Create a new configuration object.

Returns
fresh configuration object

Definition at line 222 of file configuration.c.

223 {
225  char *p;
226 
228  /* make certain values from the project data available
229  as PATHS */
231  if (NULL != p)
232  {
234  "PATHS",
235  "DATADIR",
236  p);
237  GNUNET_free (p);
238  }
240  if (NULL != p)
241  {
243  "PATHS",
244  "LIBDIR",
245  p);
246  GNUNET_free (p);
247  }
249  if (NULL != p)
250  {
252  "PATHS",
253  "BINDIR",
254  p);
255  GNUNET_free (p);
256  }
258  if (NULL != p)
259  {
261  "PATHS",
262  "PREFIX",
263  p);
264  GNUNET_free (p);
265  }
267  if (NULL != p)
268  {
270  "PATHS",
271  "LOCALEDIR",
272  p);
273  GNUNET_free (p);
274  }
276  if (NULL != p)
277  {
279  "PATHS",
280  "ICONDIR",
281  p);
282  GNUNET_free (p);
283  }
285  if (NULL != p)
286  {
288  "PATHS",
289  "DOCDIR",
290  p);
291  GNUNET_free (p);
292  }
294  if (NULL != p)
295  {
297  "PATHS",
298  "LIBEXECDIR",
299  p);
300  GNUNET_free (p);
301  }
302  return cfg;
303 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
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.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
char * GNUNET_OS_installation_get_path(enum GNUNET_OS_InstallationPathKind dirkind)
Get the path to a specific GNUnet installation directory or, with GNUNET_OS_IPK_SELF_PREFIX,...
@ GNUNET_OS_IPK_ICONDIR
Return the prefix of the path with application icons (share/icons/).
@ GNUNET_OS_IPK_DATADIR
Return the directory where data is installed (share/gnunet/)
@ GNUNET_OS_IPK_DOCDIR
Return the prefix of the path with documentation files, including the license (share/doc/gnunet/).
@ GNUNET_OS_IPK_LOCALEDIR
Return the directory where translations are installed (share/locale/)
@ GNUNET_OS_IPK_LIBDIR
Return the directory where libraries are installed.
@ GNUNET_OS_IPK_PREFIX
Return the "PREFIX" directory given to configure.
@ GNUNET_OS_IPK_BINDIR
Return the directory where the program binaries are installed.
@ GNUNET_OS_IPK_LIBEXECDIR
Return the directory where helper binaries are installed (lib/gnunet/libexec/)

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, and p.

Referenced by auto_config_cb(), callback_scan_for_rooms(), create_unique_cfgs(), gg_load_configuration(), GNUNET_ATS_solvers_experimentation_load(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_default(), GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_get_diff(), GNUNET_CRYPTO_eddsa_setup_key(), GNUNET_SERVICE_run_(), GNUNET_TESTBED_barrier_wait(), GNUNET_TESTBED_extract_config_(), GNUNET_TESTING_service_run(), GNUNET_TESTING_system_create_with_portrange(), GNUNET_TRANSPORT_TESTING_start_peer(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), handle_auto_result(), handle_autoconfig_request(), helper_mst(), iter_check_config(), iterate_save_rooms(), LEGACY_SERVICE_run(), load_member(), load_member_session(), load_member_session_next(), load_operation(), main(), run(), save_member(), save_operation(), start_peer_run(), and tokenizer_cb().

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
cfgconfiguration to duplicate
Returns
duplicate configuration

Definition at line 1520 of file configuration.c.

1521 {
1523 
1526  return ret;
1527 }
static void copy_entry(void *cls, const char *section, const char *option, const char *value)
Copy a configuration value to the given target configuration.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create()
Create a new configuration object.
void GNUNET_CONFIGURATION_iterate(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CONFIGURATION_Iterator iter, void *iter_cls)
Iterate over all options in the configuration.

References cfg, copy_entry(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_iterate(), and ret.

Referenced by associate_shared_service(), auto_config_cb(), controller_status_cb(), create_unique_cfgs(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_NAT_autoconfig_start(), GNUNET_TESTBED_controller_connect(), GNUNET_TESTBED_host_create_with_id(), GNUNET_TESTBED_host_replace_cfg_(), GNUNET_TESTBED_run(), GNUNET_TESTING_peer_configure(), GST_connection_pool_get_handle(), handle_autoconfig_request(), run(), set_cont(), and testbed_run().

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
cfgconfiguration to destroy

Definition at line 307 of file configuration.c.

308 {
309  struct ConfigSection *sec;
310  struct ConfigFile *cf;
311 
312  while (NULL != (sec = cfg->sections))
314  while (NULL != (cf = cfg->loaded_files_head))
315  {
320  cf);
321  GNUNET_free (cf);
322  }
324  GNUNET_free (cfg);
325 }
void GNUNET_CONFIGURATION_remove_section(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section)
Remove the given section and all options in it.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
char * hint_restrict_section
Was this configuration file parsed via @inline-secret@?
char * source_filename
Source filename.
configuration section
Definition: configuration.c:71
char * name
name of the section
Definition: configuration.c:85
struct ConfigFile * loaded_files_tail
Linked list of loaded files.
struct ConfigSection * sections
Configuration sections.
struct ConfigFile * loaded_files_head
Linked list of loaded files.
char * main_filename
Name of the entry point configuration file.

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 associate_shared_service(), auto_config_cb(), callback_scan_for_rooms(), clean_node(), cleanup(), cleanup_prc(), conclude_autoconfig_request(), controller_status_cb(), create_unique_cfgs(), destroy_pooled_connection(), do_shutdown(), GNUNET_ATS_solvers_experimentation_load(), GNUNET_ATS_solvers_experimentation_stop(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_default(), GNUNET_CRYPTO_eddsa_setup_key(), GNUNET_NAT_autoconfig_cancel(), GNUNET_SERVICE_run_(), GNUNET_TESTBED_barrier_wait(), GNUNET_TESTBED_barrier_wait_cancel(), GNUNET_TESTBED_controller_disconnect(), GNUNET_TESTBED_host_destroy(), GNUNET_TESTBED_host_replace_cfg_(), GNUNET_TESTBED_run(), GNUNET_TESTING_peer_destroy(), GNUNET_TESTING_service_run(), GNUNET_TESTING_system_destroy(), GNUNET_TRANSPORT_TESTING_start_peer(), GNUNET_TRANSPORT_TESTING_stop_peer(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_stop(), GST_destroy_peer(), GST_destroy_peers(), handle_add_host(), handle_auto_result(), handle_autoconfig_request(), handle_link_controllers_result(), helper_mst(), iterate_save_rooms(), LEGACY_SERVICE_run(), load_member(), load_member_session(), load_member_session_next(), load_operation(), main(), next_phase(), oprelease_get_slave_config(), oprelease_peer_getinfo(), oprelease_service_connect(), save_member(), save_operation(), shutdown_task(), start_peer_run(), tokenizer_cb(), and update_peer_config().

Here is the call 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
cfgconfiguration to update
filenamename of the configuration file, NULL to load defaults
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Load configuration.

Parameters
cfgconfiguration to update
filenamename of the configuration file, NULL to load defaults
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 2459 of file configuration.c.

2461 {
2462  char *baseconfig;
2463  const char *base_config_varname;
2464 
2465  if (cfg->load_called)
2466  {
2467  /* FIXME: Make this a GNUNET_assert later */
2468  GNUNET_break (0);
2470  }
2471  cfg->load_called = true;
2472  if (NULL != filename)
2473  {
2476  }
2477 
2478  base_config_varname = GNUNET_OS_project_data_get ()->base_config_varname;
2479 
2480  if ((NULL != base_config_varname)
2481  && (NULL != (baseconfig = getenv (base_config_varname))))
2482  {
2483  baseconfig = GNUNET_strdup (baseconfig);
2484  }
2485  else
2486  {
2487  char *ipath;
2488 
2490  if (NULL == ipath)
2491  {
2492  GNUNET_break (0);
2493  return GNUNET_SYSERR;
2494  }
2495  GNUNET_asprintf (&baseconfig, "%s%s", ipath, "config.d");
2496  GNUNET_free (ipath);
2497  }
2498 
2499  char *dname = GNUNET_STRINGS_filename_expand (baseconfig);
2500  GNUNET_free (baseconfig);
2501 
2502  if ((GNUNET_YES == GNUNET_DISK_directory_test (dname, GNUNET_YES)) &&
2504  {
2506  "Failed to load base configuration from '%s'\n",
2507  filename);
2508  GNUNET_free (dname);
2509  return GNUNET_SYSERR; /* no configuration at all found */
2510  }
2511  GNUNET_free (dname);
2512  if ((NULL != filename) &&
2514  {
2515  /* specified configuration not found */
2517  "Failed to load configuration from file '%s'\n",
2518  filename);
2519  return GNUNET_SYSERR;
2520  }
2521  if (((GNUNET_YES !=
2522  GNUNET_CONFIGURATION_have_value (cfg, "PATHS", "DEFAULTCONFIG"))) &&
2523  (filename != NULL))
2524  GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG",
2525  filename);
2526  return GNUNET_OK;
2527 }
#define LOG(kind,...)
Definition: configuration.c:30
char * getenv()
static char * filename
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.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load_from(struct GNUNET_CONFIGURATION_Handle *cfg, const char *defaults_d)
Load default configuration.
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_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:403
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_SYSERR
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_WARNING
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
const struct GNUNET_OS_ProjectData * GNUNET_OS_project_data_get(void)
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:494
bool load_called
Was the configuration ever loaded via GNUNET_CONFIGURATION_load?
const char * base_config_varname
Name of an environment variable that can be used to override the location from which default configur...

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_OS_project_data_get(), GNUNET_strdup, GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, GNUNET_YES, GNUNET_CONFIGURATION_Handle::load_called, LOG, and GNUNET_CONFIGURATION_Handle::main_filename.

Referenced by auto_config_cb(), create_unique_cfgs(), gg_load_configuration(), GNUNET_ATS_solvers_experimentation_load(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_default(), GNUNET_CRYPTO_eddsa_setup_key(), GNUNET_SERVICE_run_(), GNUNET_TESTBED_barrier_wait(), GNUNET_TESTING_service_run(), GNUNET_TRANSPORT_TESTING_start_peer(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), iter_check_config(), LEGACY_SERVICE_run(), main(), 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
cfgconfiguration to update
defaults_ddirectory with the defaults
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 2135 of file configuration.c.

2296 {
2297  struct CollectFilesContext files_context = {
2298  .files = NULL,
2299  .files_length = 0,
2300  };
2301  enum GNUNET_GenericReturnValue fun_ret;
2302 
2303  if (GNUNET_SYSERR ==
2305  &files_context))
2306  return GNUNET_SYSERR; /* no configuration at all found */
2307  qsort (files_context.files,
2308  files_context.files_length,
2309  sizeof (char *),
2310  pstrcmp);
2311  for (unsigned int i = 0; i < files_context.files_length; i++)
2312  {
2313  char *ext;
2314  const char *filename = files_context.files[i];
2315 
2316  /* Examine file extension */
2317  ext = strrchr (filename, '.');
2318  if ((NULL == ext) || (0 != strcmp (ext, ".conf")))
2319  {
2320  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Skipping file `%s'\n", filename);
2321  fun_ret = GNUNET_OK;
2322  goto cleanup;
2323  }
2325  if (fun_ret != GNUNET_OK)
2326  break;
2327  }
2328 cleanup:
2329  if (files_context.files_length > 0)
2330  {
2331  for (size_t i = 0; i < files_context.files_length; i++)
2332  GNUNET_free (files_context.files[i]);
2333  GNUNET_array_grow (files_context.files,
2334  files_context.files_length,
2335  0);
2336  }
2337  return fun_ret;
2338 }
static int pstrcmp(const void *a, const void *b)
static int collect_files_cb(void *cls, const char *filename)
Function called with a filename.
static void cleanup(void *cls)
Function scheduled as very last function, cleans up after us.
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:813
#define GNUNET_log(kind,...)
GNUNET_GenericReturnValue
Named constants for return values.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
Closure to collect_files_cb.
char ** files
Collected files from globbing.
unsigned int files_length
Size of the files array.

Referenced by GNUNET_CONFIGURATION_load().

Here is the caller graph for this function:

◆ GNUNET_CONFIGURATION_default()

struct GNUNET_CONFIGURATION_Handle* GNUNET_CONFIGURATION_default ( void  )

Return GNUnet's default configuration.

A new configuration is allocated each time and it's up to the caller to destroy it when done. This function returns GNUnet's configuration even when GNUNET_OS_init has been called with a value different from GNUNET_OS_project_data_default.

Returns
a freshly allocated configuration

Definition at line 2384 of file configuration.c.

2385 {
2386  const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get ();
2388  const char *xdg = getenv ("XDG_CONFIG_HOME");
2389  char *cfgname = NULL;
2391 
2392  /* Makes sure function implicitly looking at the installation directory (for
2393  example GNUNET_CONFIGURATION_load further down) use GNUnet's environment
2394  instead of the caller's. It's done at the start to make sure as many
2395  functions as possible are directed to the proper paths. */
2396  GNUNET_OS_init (dpd);
2397 
2399 
2400  /* First, try user configuration. */
2401  if (NULL != xdg)
2402  GNUNET_asprintf (&cfgname, "%s/%s", xdg, dpd->config_file);
2403  else
2404  cfgname = GNUNET_strdup (dpd->user_config_file);
2405 
2406  /* If user config doesn't exist, try in
2407  /etc/<projdir>/<cfgfile> and /etc/<cfgfile> */
2408  if (GNUNET_OK != GNUNET_DISK_file_test (cfgname))
2409  {
2410  GNUNET_free (cfgname);
2411  GNUNET_asprintf (&cfgname, "/etc/%s", dpd->config_file);
2412  }
2413  if (GNUNET_OK != GNUNET_DISK_file_test (cfgname))
2414  {
2415  GNUNET_free (cfgname);
2416  GNUNET_asprintf (&cfgname,
2417  "/etc/%s/%s",
2418  dpd->project_dirname,
2419  dpd->config_file);
2420  }
2421  if (GNUNET_OK != GNUNET_DISK_file_test (cfgname))
2422  {
2424  "Unable to top-level configuration file.\n");
2425  GNUNET_OS_init (pd);
2427  GNUNET_free (cfgname);
2428  return NULL;
2429  }
2430 
2431  /* We found a configuration file that looks good, try to load it. */
2432 
2434  "Loading top-level configuration from '%s'\n",
2435  cfgname);
2436  if (GNUNET_OK !=
2437  GNUNET_CONFIGURATION_load (cfg, cfgname))
2438  {
2439  GNUNET_OS_init (pd);
2441  GNUNET_free (cfgname);
2442  return NULL;
2443  }
2444  GNUNET_free (cfgname);
2445  GNUNET_OS_init (pd);
2446  return cfg;
2447 }
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
int GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration (starts with defaults, then loads system-specific configuration).
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:481
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
const struct GNUNET_OS_ProjectData * GNUNET_OS_project_data_default(void)
Return default project data used by 'libgnunetutil' for GNUnet.
void GNUNET_OS_init(const struct GNUNET_OS_ProjectData *pd)
Setup OS subsystem with project data.
Project-specific data used to help the OS subsystem find installation paths.
const char * project_dirname
Name of the project that is used in the "libexec" prefix, For example, "gnunet".
const char * user_config_file
Configuration file name to use (if $XDG_CONFIG_HOME is not set).
const char * config_file
Configuration file name (in $XDG_CONFIG_HOME) to use.

References cfg, GNUNET_OS_ProjectData::config_file, getenv(), GNUNET_asprintf(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_load(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_OK, GNUNET_OS_init(), GNUNET_OS_project_data_default(), GNUNET_OS_project_data_get(), GNUNET_strdup, LOG, GNUNET_OS_ProjectData::project_dirname, and GNUNET_OS_ProjectData::user_config_file.

Here is the call graph for this function:

◆ GNUNET_CONFIGURATION_default_filename()

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.

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

Definition at line 2342 of file configuration.c.

2343 {
2344  char *cfg_fn;
2345  const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get ();
2346  const char *xdg = getenv ("XDG_CONFIG_HOME");
2347 
2348  if (NULL != xdg)
2349  GNUNET_asprintf (&cfg_fn,
2350  "%s%s%s",
2351  xdg,
2353  pd->config_file);
2354  else
2355  cfg_fn = GNUNET_strdup (pd->user_config_file);
2356 
2357  if (GNUNET_OK == GNUNET_DISK_file_test_read (cfg_fn))
2358  return cfg_fn;
2359  GNUNET_free (cfg_fn);
2360 
2361  /* Fall back to /etc/ for the default configuration.
2362  Should be okay to use forward slashes here. */
2363 
2364  GNUNET_asprintf (&cfg_fn,
2365  "/etc/%s",
2366  pd->config_file);
2367  if (GNUNET_OK == GNUNET_DISK_file_test_read (cfg_fn))
2368  return cfg_fn;
2369  GNUNET_free (cfg_fn);
2370 
2371  GNUNET_asprintf (&cfg_fn,
2372  "/etc/%s/%s",
2373  pd->project_dirname,
2374  pd->config_file);
2375  if (GNUNET_OK == GNUNET_DISK_file_test_read (cfg_fn))
2376  return cfg_fn;
2377 
2378  GNUNET_free (cfg_fn);
2379  return NULL;
2380 }
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test_read(const char *fil)
Check that fil corresponds to a filename and the file has read permissions.
Definition: disk.c:488
#define DIR_SEPARATOR_STR
Definition: platform.h:165

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

Here is the call 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
cfgconfiguration to update
filenamename of the configuration file
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 683 of file configuration.c.

971 {
972  uint64_t fs64;
973  size_t fs;
974  char *fn;
975  char *mem;
976  int dirty;
978  ssize_t sret;
979 
981  LOG (GNUNET_ERROR_TYPE_DEBUG, "Asked to parse config file `%s'\n", fn);
982  if (NULL == fn)
983  return GNUNET_SYSERR;
984 
985 
986  /* Check for cycles */
987  {
988  unsigned int lvl = cfg->current_nest_level;
989  struct ConfigFile *cf = cfg->loaded_files_tail;
990  struct ConfigFile *parent = NULL;
991 
992 
993  for (; NULL != cf; parent = cf, cf = cf->prev)
994  {
995  /* Check parents based on level, skipping children of siblings. */
996  if (cf->level >= lvl)
997  continue;
998  lvl = cf->level;
999  if ( (NULL == cf->source_filename) || (NULL == filename))
1000  continue;
1001  if (0 == strcmp (cf->source_filename, filename))
1002  {
1003  if (NULL == parent)
1004  {
1006  "Forbidden direct cyclic configuration import (%s -> %s)\n",
1007  cf->source_filename,
1008  filename);
1009  }
1010  else
1012  "Forbidden indirect cyclic configuration import (%s -> ... -> %s -> %s)\n",
1013  cf->source_filename,
1014  parent->source_filename,
1015  filename);
1016  GNUNET_free (fn);
1017  return GNUNET_SYSERR;
1018  }
1019  }
1020 
1021  }
1022 
1023  /* Keep track of loaded files.*/
1024  {
1025  struct ConfigFile *cf = GNUNET_new (struct ConfigFile);
1026 
1027  cf->level = cfg->current_nest_level;
1028  cf->source_filename = GNUNET_strdup (filename ? filename : "<input>");
1031  cf);
1032  }
1033 
1034  dirty = cfg->dirty; /* back up value! */
1035  if (GNUNET_SYSERR ==
1037  {
1039  "Error while determining the file size of `%s'\n",
1040  fn);
1041  GNUNET_free (fn);
1042  return GNUNET_SYSERR;
1043  }
1044  if (fs64 > SIZE_MAX)
1045  {
1046  GNUNET_break (0); /* File size is more than the heap size */
1047  GNUNET_free (fn);
1048  return GNUNET_SYSERR;
1049  }
1050  fs = fs64;
1051  mem = GNUNET_malloc (fs);
1052  sret = GNUNET_DISK_fn_read (fn, mem, fs);
1053  if ((sret < 0) || (fs != (size_t) sret))
1054  {
1055  LOG (GNUNET_ERROR_TYPE_WARNING, _ ("Error while reading file `%s'\n"), fn);
1056  GNUNET_free (fn);
1057  GNUNET_free (mem);
1058  return GNUNET_SYSERR;
1059  }
1060  LOG (GNUNET_ERROR_TYPE_DEBUG, "Deserializing contents of file `%s'\n", fn);
1062  mem,
1063  fs,
1064  fn);
1065  if (GNUNET_SYSERR == ret)
1066  {
1068  _ ("Failed to parse configuration file `%s'\n"),
1069  fn);
1070  }
1071  GNUNET_free (fn);
1072  GNUNET_free (mem);
1073  /* restore dirty flag - anything we set in the meantime
1074  * came from disk */
1075  cfg->dirty = dirty;
1076  return ret;
1077 }
static struct GNUNET_FS_Handle * fs
Handle to FS service.
Definition: gnunet-fs.c:37
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_DISK_file_size(const char *filename, uint64_t *size, int include_symbolic_links, int single_file_mode)
Get the size of the file (or directory) of the given file (in bytes).
Definition: disk.c:221
ssize_t GNUNET_DISK_fn_read(const char *fn, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:663
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
#define SIZE_MAX
Definition: platform.h:207
struct ConfigFile * prev
unsigned int level
Level in the tree of loaded config files.
unsigned int current_nest_level
Current nesting level of file loading.
enum GNUNET_GenericReturnValue dirty
Modification indication since last save GNUNET_NO if clean, GNUNET_YES if dirty, GNUNET_SYSERR on err...

Referenced by callback_scan_for_rooms(), GNUNET_CONFIGURATION_load(), load_member(), load_member_session(), load_member_session_next(), load_operation(), and run().

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
cfgconfiguration to serialize
sizewill 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 1123 of file configuration.c.

1125 {
1126  char *mem;
1127  char *cbuf;
1128  char *val;
1129  char *pos;
1130  size_t m_size;
1131  size_t c_size;
1132 
1133  /* Pass1 : calculate the buffer size required */
1134  m_size = 0;
1135  for (struct ConfigSection *sec = cfg->sections;
1136  NULL != sec;
1137  sec = sec->next)
1138  {
1139  if (sec->inaccessible)
1140  continue;
1141  /* For each section we need to add 3 characters: {'[',']','\n'} */
1142  m_size += strlen (sec->name) + 3;
1143  for (struct ConfigEntry *ent = sec->entries;
1144  NULL != ent;
1145  ent = ent->next)
1146  {
1147  if (do_skip (sec->name,
1148  ent->key))
1149  continue;
1150  if (NULL != ent->val)
1151  {
1152  /* if val has any '\n' then they occupy +1 character as '\n'->'\\','n' */
1153  pos = ent->val;
1154  while (NULL != (pos = strstr (pos, "\n")))
1155  {
1156  m_size++;
1157  pos++;
1158  }
1159  /* For each key = value pair we need to add 4 characters (2
1160  spaces and 1 equal-to character and 1 new line) */
1161  m_size += strlen (ent->key) + strlen (ent->val) + 4;
1162  }
1163  }
1164  /* A new line after section end */
1165  m_size++;
1166  }
1167 
1168  /* Pass2: Allocate memory and write the configuration to it */
1169  mem = GNUNET_malloc (m_size);
1170  c_size = 0;
1171  *size = c_size;
1172  for (struct ConfigSection *sec = cfg->sections;
1173  NULL != sec;
1174  sec = sec->next)
1175  {
1176  int len;
1177 
1178  len = GNUNET_asprintf (&cbuf,
1179  "[%s]\n",
1180  sec->name);
1181  GNUNET_assert (0 < len);
1182  GNUNET_memcpy (mem + c_size,
1183  cbuf,
1184  len);
1185  c_size += len;
1186  GNUNET_free (cbuf);
1187  for (struct ConfigEntry *ent = sec->entries;
1188  NULL != ent;
1189  ent = ent->next)
1190  {
1191  if (do_skip (sec->name,
1192  ent->key))
1193  continue;
1194  if (NULL != ent->val)
1195  {
1196  val = GNUNET_malloc (strlen (ent->val) * 2 + 1);
1197  strcpy (val, ent->val);
1198  while (NULL != (pos = strstr (val, "\n")))
1199  {
1200  memmove (&pos[2], &pos[1], strlen (&pos[1]));
1201  pos[0] = '\\';
1202  pos[1] = 'n';
1203  }
1204  len = GNUNET_asprintf (&cbuf, "%s = %s\n", ent->key, val);
1205  GNUNET_free (val);
1206  GNUNET_memcpy (mem + c_size, cbuf, len);
1207  c_size += len;
1208  GNUNET_free (cbuf);
1209  }
1210  }
1211  GNUNET_memcpy (mem + c_size, "\n", 1);
1212  c_size++;
1213  }
1214  GNUNET_assert (c_size == m_size);
1215  *size = c_size;
1216  return mem;
1217 }
static bool do_skip(const char *sec, const char *key)
Should we skip this configuration entry when serializing?
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static unsigned int size
Size of the "table".
Definition: peer.c:68
configuration entry
Definition: configuration.c:39
struct ConfigEntry * next
This is a linked list.
Definition: configuration.c:43
struct ConfigSection * next
This is a linked list.
Definition: configuration.c:75

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

Referenced by conclude_autoconfig_request(), GNUNET_NAT_AUTO_autoconfig_start(), GNUNET_TESTBED_compress_cfg_(), GNUNET_TESTBED_create_helper_init_msg_(), GNUNET_TESTBED_peer_update_configuration(), GNUNET_TESTBED_register_host(), handle_peer_get_config(), handle_slave_get_config(), opstart_peer_create(), and tokenizer_cb().

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
cfgconfiguration to serialize
Returns
the memory block where the serialized configuration is present. This memory should be freed by the caller

Definition at line 1221 of file configuration.c.

1223 {
1224  struct GNUNET_Buffer buf = { 0 };
1225 
1227  "#\n# Configuration file diagnostics\n#\n");
1229  "# Entry point: %s\n",
1231  "<none>");
1233  "#\n# Files Loaded:\n");
1234 
1235  for (struct ConfigFile *cfil = cfg->loaded_files_head;
1236  NULL != cfil;
1237  cfil = cfil->next)
1238  {
1240  "# ");
1241  for (unsigned int i = 0; i < cfil->level; i++)
1243  "+");
1244  if (0 != cfil->level)
1246  " ");
1247 
1249  "%s",
1250  cfil->source_filename);
1251 
1252  if (NULL != cfil->hint_restrict_section)
1254  " (%s secret section %s)",
1255  cfil->hint_inaccessible
1256  ? "inaccessible"
1257  : "loaded",
1258  cfil->hint_restrict_section);
1259 
1261  "\n");
1262  }
1263 
1265  "#\n\n");
1266 
1267  for (struct ConfigSection *sec = cfg->sections;
1268  NULL != sec;
1269  sec = sec->next)
1270  {
1271  if (sec->hint_secret_filename)
1273  "# secret section from %s\n# secret file stat %s\n",
1274  sec->hint_secret_filename,
1275  sec->hint_secret_stat);
1276  if (sec->hint_inlined_from_filename)
1277  {
1279  "# inlined from %s:%u\n",
1280  sec->hint_inlined_from_filename,
1281  sec->hint_inlined_from_line);
1282  }
1284  "[%s]\n\n",
1285  sec->name);
1286  if (sec->inaccessible)
1287  {
1289  "# <section contents inaccessible>\n\n\n");
1290  continue;
1291  }
1292  for (struct ConfigEntry *ent = sec->entries;
1293  NULL != ent;
1294  ent = ent->next)
1295  {
1296  if (do_skip (sec->name,
1297  ent->key))
1298  continue;
1299  if (NULL != ent->val)
1300  {
1301  char *pos;
1302  char *val = GNUNET_malloc (strlen (ent->val) * 2 + 1);
1303  strcpy (val, ent->val);
1304  while (NULL != (pos = strstr (val, "\n")))
1305  {
1306  memmove (&pos[2], &pos[1], strlen (&pos[1]));
1307  pos[0] = '\\';
1308  pos[1] = 'n';
1309  }
1310  if (NULL != ent->hint_filename)
1311  {
1313  "# %s:%u\n",
1314  ent->hint_filename,
1315  ent->hint_lineno);
1316  }
1318  "%s = %s\n",
1319  ent->key,
1320  val);
1321  GNUNET_free (val);
1322  }
1323  GNUNET_buffer_write_str (&buf, "\n");
1324  }
1325  GNUNET_buffer_write_str (&buf, "\n");
1326  }
1327  return GNUNET_buffer_reap_str (&buf);
1328 }
static char buf[2048]
char * GNUNET_buffer_reap_str(struct GNUNET_Buffer *buf)
Clear the buffer and return the string it contained.
Definition: buffer.c:123
void GNUNET_buffer_write_fstr(struct GNUNET_Buffer *buf, const char *fmt,...) __attribute__((format(printf
Write a 0-terminated formatted string to a buffer, excluding the 0-terminator.
void GNUNET_buffer_write_str(struct GNUNET_Buffer *buf, const char *str)
Write a 0-terminated string to a buffer, excluding the 0-terminator.
Definition: buffer.c:103
struct ConfigFile * next
Dynamically growing buffer.

References buf, cfg, do_skip(), GNUNET_buffer_reap_str(), GNUNET_buffer_write_fstr(), GNUNET_buffer_write_str(), GNUNET_free, GNUNET_malloc, GNUNET_CONFIGURATION_Handle::loaded_files_head, GNUNET_CONFIGURATION_Handle::main_filename, ConfigEntry::next, ConfigSection::next, ConfigFile::next, and GNUNET_CONFIGURATION_Handle::sections.

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_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
cfgconfiguration to update
memthe memory block of serialized configuration
sizethe size of the memory block
source_filenamesource filename, will be used to resolve relative @INLINE@ statements
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 683 of file configuration.c.

704 {
705  size_t line_size;
706  unsigned int nr;
707  size_t r_bytes;
708  size_t to_read;
710  char *section;
711  char *eq;
712  char *tag;
713  char *value;
714  char *line_orig = NULL;
715 
716  ret = GNUNET_OK;
717  section = NULL;
718  nr = 0;
719  r_bytes = 0;
720  while (r_bytes < size)
721  {
722  char *pos;
723  char *line;
724  bool emptyline;
725 
726  GNUNET_free (line_orig);
727  /* fgets-like behaviour on buffer */
728  to_read = size - r_bytes;
729  pos = memchr (&mem[r_bytes], '\n', to_read);
730  if (NULL == pos)
731  {
732  line_orig = GNUNET_strndup (&mem[r_bytes],
733  line_size = to_read);
734  r_bytes += line_size;
735  }
736  else
737  {
738  line_orig = GNUNET_strndup (&mem[r_bytes],
739  line_size = (pos - &mem[r_bytes]));
740  r_bytes += line_size + 1;
741  }
742  line = line_orig;
743  /* increment line number */
744  nr++;
745  /* tabs and '\r' are whitespace */
746  emptyline = GNUNET_YES;
747  for (size_t i = 0; i < line_size; i++)
748  {
749  if (line[i] == '\t')
750  line[i] = ' ';
751  if (line[i] == '\r')
752  line[i] = ' ';
753  if (' ' != line[i])
754  emptyline = GNUNET_NO;
755  }
756  /* ignore empty lines */
757  if (GNUNET_YES == emptyline)
758  continue;
759 
760  /* remove tailing whitespace */
761  for (size_t i = line_size - 1;
762  (i >= 1) && (isspace ((unsigned char) line[i]));
763  i--)
764  line[i] = '\0';
765 
766  /* remove leading whitespace */
767  for (; line[0] != '\0' && (isspace ((unsigned char) line[0])); line++)
768  ;
769 
770  /* ignore comments */
771  if ( ('#' == line[0]) ||
772  ('%' == line[0]) )
773  continue;
774 
775  /* Handle special directives. */
776  if ('@' == line[0])
777  {
778  char *end = strchr (line + 1, '@');
779  char *directive;
780  enum GNUNET_GenericReturnValue directive_ret;
781 
782  if (NULL != cfg->restrict_section)
783  {
785  _ (
786  "Illegal directive in line %u (parsing restricted section %s)\n"),
787  nr,
789  ret = GNUNET_SYSERR;
790  break;
791  }
792 
793  if (NULL == end)
794  {
796  _ ("Bad directive in line %u\n"),
797  nr);
798  ret = GNUNET_SYSERR;
799  break;
800  }
801  *end = '\0';
802  directive = line + 1;
803 
804  if (0 == strcasecmp (directive,
805  "INLINE"))
806  {
807  const char *path = end + 1;
808 
809  /* Skip space before path */
810  for (; isspace (*path); path++)
811  ;
812 
813  directive_ret = handle_inline (cfg,
814  path,
815  false,
816  NULL,
817  source_filename,
818  nr);
819  }
820  else if (0 == strcasecmp (directive,
821  "INLINE-MATCHING"))
822  {
823  const char *path = end + 1;
824 
825  /* Skip space before path */
826  for (; isspace (*path); path++)
827  ;
828 
829  directive_ret = handle_inline (cfg,
830  path,
831  true,
832  NULL,
833  source_filename,
834  nr);
835  }
836  else if (0 == strcasecmp (directive,
837  "INLINE-SECRET"))
838  {
839  char *secname = end + 1;
840  char *secname_end;
841  const char *path;
842 
843  /* Skip space before secname */
844  for (; isspace (*secname); secname++)
845  ;
846 
847  secname_end = strchr (secname, ' ');
848 
849  if (NULL == secname_end)
850  {
852  _ ("Bad inline-secret directive in line %u\n"),
853  nr);
854  ret = GNUNET_SYSERR;
855  break;
856  }
857  *secname_end = '\0';
858  path = secname_end + 1;
859 
860  /* Skip space before path */
861  for (; isspace (*path); path++)
862  ;
863 
864  directive_ret = handle_inline (cfg,
865  path,
866  false,
867  secname,
868  source_filename,
869  nr);
870  }
871  else
872  {
874  _ ("Unknown or malformed directive '%s' in line %u\n"),
875  directive,
876  nr);
877  ret = GNUNET_SYSERR;
878  break;
879  }
880  if (GNUNET_OK != directive_ret)
881  {
882  ret = directive_ret;
883  break;
884  }
885  continue;
886  }
887  if ( ('[' == line[0]) &&
888  (']' == line[line_size - 1]) )
889  {
890  /* [value] */
891  line[line_size - 1] = '\0';
892  value = &line[1];
893  GNUNET_free (section);
894  section = GNUNET_strdup (value);
895  continue;
896  }
897  if (NULL != (eq = strchr (line, '=')))
898  {
899  size_t i;
900 
901  if (NULL == section)
902  {
904  _ (
905  "Syntax error while deserializing in line %u (option without section)\n"),
906  nr);
907  ret = GNUNET_SYSERR;
908  break;
909  }
910 
911  /* tag = value */
912  tag = GNUNET_strndup (line, eq - line);
913  /* remove tailing whitespace */
914  for (i = strlen (tag) - 1;
915  (i >= 1) && (isspace ((unsigned char) tag[i]));
916  i--)
917  tag[i] = '\0';
918 
919  /* Strip whitespace */
920  value = eq + 1;
921  while (isspace ((unsigned char) value[0]))
922  value++;
923  for (i = strlen (value) - 1;
924  (i >= 1) && (isspace ((unsigned char) value[i]));
925  i--)
926  value[i] = '\0';
927 
928  /* remove quotes */
929  i = 0;
930  if ( ('"' == value[0]) &&
931  ('"' == value[strlen (value) - 1]) )
932  {
933  value[strlen (value) - 1] = '\0';
934  value++;
935  }
937  section,
938  tag,
939  &value[i]);
940  if (cfg->diagnostics)
941  {
943  section,
944  tag,
945  source_filename
946  ? source_filename
947  : "<input>",
948  nr);
949  }
950  GNUNET_free (tag);
951  continue;
952  }
953  /* parse error */
955  _ ("Syntax error while deserializing in line %u\n"),
956  nr);
957  ret = GNUNET_SYSERR;
958  break;
959  }
960  GNUNET_free (line_orig);
961  GNUNET_free (section);
962  GNUNET_assert ( (GNUNET_OK != ret) ||
963  (r_bytes == size) );
964  return ret;
965 }
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.
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.
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
static char * line
Desired phone line (string to be converted to a hash).
static char * value
Value of the record to add/remove.
@ GNUNET_NO
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
bool diagnostics
Enable diagnostics.
const char * restrict_section
When parsing into this configuration, and this value is non-NULL, only parse sections of the same nam...

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

Referenced by GNUNET_TESTBED_extract_config_(), handle_auto_result(), handle_autoconfig_request(), helper_mst(), and tokenizer_cb().

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
cfgconfiguration to write
filenamewhere to write the configuration
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1221 of file configuration.c.

1334 {
1335  char *fn;
1336  char *cfg_buf;
1337  size_t size;
1338 
1340  if (fn == NULL)
1341  return GNUNET_SYSERR;
1343  {
1344  GNUNET_free (fn);
1345  return GNUNET_SYSERR;
1346  }
1348  &size);
1349  {
1350  struct GNUNET_DISK_FileHandle *h;
1351 
1352  h = GNUNET_DISK_file_open (fn,
1360  if (NULL == h)
1361  {
1362  GNUNET_free (fn);
1363  GNUNET_free (cfg_buf);
1364  return GNUNET_SYSERR;
1365  }
1366  if (((ssize_t) size) !=
1368  cfg_buf,
1369  size))
1370  {
1372  "write",
1373  fn);
1375  (void) GNUNET_DISK_directory_remove (fn);
1376  GNUNET_free (fn);
1377  GNUNET_free (cfg_buf);
1378  cfg->dirty = GNUNET_SYSERR; /* last write failed */
1379  return GNUNET_SYSERR;
1380  }
1383  }
1384  GNUNET_free (fn);
1385  GNUNET_free (cfg_buf);
1386  cfg->dirty = GNUNET_NO; /* last write succeeded */
1387  return GNUNET_OK;
1388 }
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
char * GNUNET_CONFIGURATION_serialize(const struct GNUNET_CONFIGURATION_Handle *cfg, size_t *size)
Serializes the given configuration.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1234
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:685
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1084
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1305
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:581
@ GNUNET_DISK_OPEN_WRITE
Open the file for writing.
@ GNUNET_DISK_OPEN_TRUNCATE
Truncate file if it exists.
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_GROUP_READ
Group can read.
@ GNUNET_DISK_PERM_GROUP_WRITE
Group can write.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
Handle used to access files (and pipes).

Referenced by associate_shared_service(), create_unique_cfgs(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_TESTING_peer_configure(), handle_delete_message(), handle_rename_message(), iterate_save_rooms(), save_member(), save_operation(), set_cont(), testing_main(), and tokenizer_cb().

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_defaultdefault configuration
cfg_newnew configuration
filenamewhere to write the configuration diff between default and new
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1558 of file configuration.c.

1576 {
1577  int ret;
1578  struct GNUNET_CONFIGURATION_Handle *diff;
1579 
1580  diff = GNUNET_CONFIGURATION_get_diff (cfg_default, cfg_new);
1583  return ret;
1584 }
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_write(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Write configuration file.

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

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_defaultoriginal configuration
cfg_newnew configuration
Returns
configuration with only the differences, never NULL

Definition at line 1558 of file configuration.c.

1561 {
1562  struct DiffHandle diffHandle;
1563 
1564  diffHandle.cfgDiff = GNUNET_CONFIGURATION_create ();
1565  diffHandle.cfg_default = cfg_default;
1566  GNUNET_CONFIGURATION_iterate (cfg_new, &compare_entries, &diffHandle);
1567  return diffHandle.cfgDiff;
1568 }
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) a...
Used for diffing a configuration object against the default one.
const struct GNUNET_CONFIGURATION_Handle * cfg_default
struct GNUNET_CONFIGURATION_Handle * cfgDiff

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

Referenced by conclude_autoconfig_request(), 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
cfgconfiguration to inspect
Returns
GNUNET_NO if clean, GNUNET_YES if dirty, GNUNET_SYSERR on error (i.e. last save failed)

Definition at line 683 of file configuration.c.

1082 {
1083  return cfg->dirty;
1084 }

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 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
filenameconfiguration to parse, NULL for "default"
cbfunction to run
cb_clsclosure for cb
Returns
GNUNET_SYSERR if parsing the configuration failed, otherwise return value from cb.

Definition at line 307 of file configuration.c.

332 {
335 
337  if (GNUNET_OK !=
339  filename))
340  {
341  GNUNET_break (0);
343  return GNUNET_SYSERR;
344  }
345  ret = cb (cb_cls, cfg);
347  return ret;
348 }

Referenced by GNUNET_DISK_purge_cfg_dir().

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
cfgconfiguration handle

Definition at line 214 of file configuration.c.

216 {
217  cfg->diagnostics = true;
218 }

References cfg, and GNUNET_CONFIGURATION_Handle::diagnostics.

Referenced by GNUNET_CONFIGURATION_config_tool_run().

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
cfgconfiguration to inspect
iterfunction to call on each option
iter_clsclosure for iter

Definition at line 1392 of file configuration.c.

1395 {
1396  for (struct ConfigSection *spos = cfg->sections;
1397  NULL != spos;
1398  spos = spos->next)
1399  for (struct ConfigEntry *epos = spos->entries;
1400  NULL != epos;
1401  epos = epos->next)
1402  if (NULL != epos->val)
1403  iter (iter_cls,
1404  spos->name,
1405  epos->key,
1406  epos->val);
1407 }

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

Referenced by get_cont(), GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_get_diff(), and GNUNET_TESTING_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
cfgconfiguration to inspect
iterfunction to call on each section
iter_clsclosure for iter

Definition at line 1440 of file configuration.c.

1444 {
1445  struct ConfigSection *spos;
1446  struct ConfigSection *next;
1447 
1448  next = cfg->sections;
1449  while (next != NULL)
1450  {
1451  spos = next;
1452  next = spos->next;
1453  iter (iter_cls, spos->name);
1454  }
1455 }

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

Referenced by GNUNET_CONFIGURATION_config_tool_run(), GNUNET_TESTING_configuration_create_(), handle_delete_message(), handle_rename_message(), 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
cfgconfiguration to inspect
sectionname of the section to remove

Definition at line 1459 of file configuration.c.

1461 {
1462  struct ConfigSection *spos;
1463  struct ConfigSection *prev;
1464  struct ConfigEntry *ent;
1465 
1466  prev = NULL;
1467  spos = cfg->sections;
1468  while (NULL != spos)
1469  {
1470  if (0 == strcasecmp (section, spos->name))
1471  {
1472  if (NULL == prev)
1473  cfg->sections = spos->next;
1474  else
1475  prev->next = spos->next;
1476  while (NULL != (ent = spos->entries))
1477  {
1478  spos->entries = ent->next;
1479  GNUNET_free (ent->key);
1480  GNUNET_free (ent->val);
1481  GNUNET_free (ent->hint_filename);
1482  GNUNET_free (ent);
1483  cfg->dirty = GNUNET_YES;
1484  }
1485  GNUNET_free (spos->name);
1487  GNUNET_free (spos->hint_secret_stat);
1489  GNUNET_free (spos);
1490  return;
1491  }
1492  prev = spos;
1493  spos = spos->next;
1494  }
1495 }
char * hint_filename
Diagnostics information for the filename.
Definition: configuration.c:58
char * key
key for this entry
Definition: configuration.c:48
char * val
current, committed value
Definition: configuration.c:53
char * hint_inlined_from_filename
For secret sections: Where was this inlined from?
struct ConfigEntry * entries
entries in the section
Definition: configuration.c:80
char * hint_secret_filename
Diagnostics hint for the secret file.
Definition: configuration.c:98
char * hint_secret_stat
Extra information regarding permissions of the secret file.

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

Referenced by GNUNET_CONFIGURATION_destroy(), and GNUNET_TESTING_peer_configure().

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
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
numberwhere to store the numeric value of the option
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1630 of file configuration.c.

1648 {
1649  struct ConfigEntry *e;
1650  char dummy[2];
1651 
1652  if (NULL == (e = find_entry (cfg, section, option)))
1653  return GNUNET_SYSERR;
1654  if (NULL == e->val)
1655  return GNUNET_SYSERR;
1656  if (1 != sscanf (e->val, "%llu%1s", number, dummy))
1657  return GNUNET_SYSERR;
1658  return GNUNET_OK;
1659 }
static struct ConfigEntry * find_entry(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *key)
Find an entry from a configuration.
static struct Experiment * e
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
uint32_t number

Referenced by client_configure_plugin(), event_cb(), GCD_init(), GCO_init(), get_server_addresses(), GNUNET_ATS_solvers_load_quotas(), GNUNET_CLIENT_connect(), GNUNET_CLIENT_test(), GNUNET_HOSTLIST_server_start(), GNUNET_NAT_AUTO_test_start(), GNUNET_REVOCATION_revoke(), GNUNET_SERVICE_run_(), GNUNET_SOCKS_do_connect(), GNUNET_TESTBED_controller_connect(), GNUNET_TESTBED_run(), GNUNET_TRANSPORT_communicator_connect(), GSF_cadet_start_server(), GSF_pending_request_init_(), GST_plugins_load(), iopen(), LEGACY_SERVICE_get_server_addresses(), LEGACY_SERVICE_run(), libgnunet_plugin_block_revocation_init(), libgnunet_plugin_datastore_heap_init(), libgnunet_plugin_dhtu_ip_init(), libgnunet_plugin_transport_tcp_init(), libgnunet_plugin_transport_udp_init(), load_member_session(), load_op_add_address(), load_op_del_address(), load_op_start_request(), load_op_start_set_preference(), load_op_start_set_property(), load_op_stop_request(), load_op_stop_set_preference(), load_op_stop_set_property(), load_operation(), run(), run_service(), server_configure_plugin(), server_get_addresses(), setup_exit_helper_args(), test_service_configuration(), test_stun(), testbed_run(), and update_config().

Here is the caller 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
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
numberwhere to store the floating value of the option
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1630 of file configuration.c.

1668 {
1669  struct ConfigEntry *e;
1670  char dummy[2];
1671 
1672  if (NULL == (e = find_entry (cfg, section, option)))
1673  return GNUNET_SYSERR;
1674  if (NULL == e->val)
1675  return GNUNET_SYSERR;
1676  if (1 != sscanf (e->val, "%f%1s", number, dummy))
1677  return GNUNET_SYSERR;
1678  return GNUNET_OK;
1679 }

Referenced by GNUNET_RPS_connect(), and libgnunet_plugin_ats_proportional_init().

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
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
timeset to the time value stored in the configuration
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1630 of file configuration.c.

1688 {
1689  struct ConfigEntry *e;
1690  int ret;
1691 
1692  if (NULL == (e = find_entry (cfg, section, option)))
1693  return GNUNET_SYSERR;
1694  if (NULL == e->val)
1695  return GNUNET_SYSERR;
1697  if (GNUNET_OK != ret)
1699  section,
1700  option,
1701  _ ("Not a valid relative time specification"));
1702  return ret;
1703 }
void GNUNET_log_config_invalid(enum GNUNET_ErrorType kind, const char *section, const char *option, const char *required)
Log error message about invalid configuration option value.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_fancy_time_to_relative(const char *fancy_time, struct GNUNET_TIME_Relative *rtime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:260

Referenced by GCD_init(), GNUNET_ATS_solvers_experimentation_load(), GNUNET_REVOCATION_revoke(), GNUNET_SPEEDUP_start_(), GNUNET_TESTBED_run(), GSF_push_init_(), GST_manipulation_init(), libgnunet_plugin_block_revocation_init(), libgnunet_plugin_rest_openid_connect_init(), libgnunet_plugin_transport_tcp_init(), libgnunet_plugin_transport_udp_init(), load_episodes(), load_op_start_set_preference(), load_op_start_set_property(), RECLAIM_TICKETS_init(), run(), run_service(), setup_service(), testbed_run(), and token_endpoint().

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
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
sizeset to the size in bytes as stored in the configuration
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1630 of file configuration.c.

1712 {
1713  struct ConfigEntry *e;
1714 
1715  if (NULL == (e = find_entry (cfg, section, option)))
1716  return GNUNET_SYSERR;
1717  if (NULL == e->val)
1718  return GNUNET_SYSERR;
1719  return GNUNET_STRINGS_fancy_size_to_bytes (e->val, size);
1720 }
enum GNUNET_GenericReturnValue GNUNET_STRINGS_fancy_size_to_bytes(const char *fancy_size, unsigned long long *size)
Convert a given fancy human-readable size to bytes.
Definition: strings.c:236

Referenced by GNUNET_DATACACHE_create(), and run().

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
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
Returns
GNUNET_YES if so, GNUNET_NO if not.

Definition at line 1630 of file configuration.c.

1819 {
1820  struct ConfigEntry *e;
1821 
1822  if ((NULL == (e = find_entry (cfg, section, option))) || (NULL == e->val))
1823  return GNUNET_NO;
1824  return GNUNET_YES;
1825 }

Referenced by check_config(), get_my_cnf_path(), get_server_addresses(), GNUNET_CLIENT_connect(), GNUNET_CLIENT_test(), GNUNET_CONFIGURATION_load(), GNUNET_HOSTLIST_server_start(), GNUNET_SERVICE_run_(), GNUNET_SOCKS_check_service(), GNUNET_TESTBED_run(), GNUNET_TESTING_peer_configure(), iopen(), LEGACY_SERVICE_get_server_addresses(), LEGACY_SERVICE_run(), LEGACY_SERVICE_stop(), process_acl4(), process_acl6(), server_configure_plugin(), server_get_addresses(), setup_service(), test_service_configuration(), and update_config_sections().

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
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
valuewill 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 1630 of file configuration.c.

1739 {
1740  struct ConfigEntry *e;
1741 
1742  if ((NULL == (e = find_entry (cfg, section, option))) || (NULL == e->val))
1743  {
1744  *value = NULL;
1745  return GNUNET_SYSERR;
1746  }
1747  *value = GNUNET_strdup (e->val);
1748  return GNUNET_OK;
1749 }

Referenced by advertise_dns_exit(), check_authorization(), check_config(), client_configure_plugin(), client_connect_cb(), communicator_start(), expand_dollar(), GAS_plugin_init(), get_bootstrap_server(), get_server_addresses(), gg_load_configuration(), GNUNET_ATS_solvers_experimentation_load(), GNUNET_ATS_solvers_load_quotas(), GNUNET_CLIENT_connect(), GNUNET_CLIENT_test(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_iterate_value_filenames(), 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_OS_check_helper_binary(), GNUNET_PQ_connect_with_cfg2(), GNUNET_SERVICE_run_(), GNUNET_SOCKS_do_connect(), GNUNET_TESTBED_run(), GNUNET_TESTING_peer_configure(), GNUNET_TESTING_service_run(), GPI_plugins_load(), GST_plugins_load(), handle_ego_delete(), handle_ego_rename(), handle_init(), handle_register(), handle_uri(), identity_continuation(), iopen(), LEGACY_SERVICE_get_server_addresses(), LEGACY_SERVICE_run(), LEGACY_SERVICE_stop(), libgnunet_plugin_dhtu_ip_init(), libgnunet_plugin_transport_udp_init(), load_episode(), load_member_session(), load_member_session_next(), load_op_add_address(), load_op_del_address(), load_op_start_set_preference(), load_op_start_set_property(), load_op_stop_set_preference(), load_op_stop_set_property(), load_quota(), login_redirect(), print_quotas(), process_acl4(), process_acl6(), read_service_conf(), run(), server_configure_plugin(), server_get_addresses(), setup_exit_helper_args(), setup_service(), start_process(), test_icmp_client(), test_icmp_server(), test_service_configuration(), testbed_run(), token_endpoint(), and update_config_sections().

◆ 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
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
valuewill 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 1991 of file configuration.c.

2021 {
2022  char *tmp;
2023 
2024  if (GNUNET_OK !=
2025  GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &tmp))
2026  {
2027  LOG (GNUNET_ERROR_TYPE_DEBUG, "Failed to retrieve filename\n");
2028  *value = NULL;
2029  return GNUNET_SYSERR;
2030  }
2033  GNUNET_free (tmp);
2034  if (*value == NULL)
2035  return GNUNET_SYSERR;
2036  return GNUNET_OK;
2037 }
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...
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.

Referenced by create_service(), database_setup(), get_my_cnf_path(), get_oidc_dir_path(), get_pid_file_name(), get_serialization_file_name(), get_serialization_file_name_in_dir(), get_server_addresses(), get_update_information_directory(), get_user_name(), GNUNET_ATS_solvers_experimentation_load(), GNUNET_CLIENT_test(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_FRIENDS_parse(), GNUNET_FRIENDS_write_start(), GNUNET_HOSTLIST_client_start(), GNUNET_PQ_connect_with_cfg2(), GNUNET_TESTBED_controller_start(), GNUNET_TESTBED_is_host_habitable(), GNUNET_TESTBED_run(), GNUNET_TESTING_peer_configure(), GST_stats_init(), LEGACY_SERVICE_get_server_addresses(), libgnunet_plugin_transport_unix_init(), load(), load_hostlist_file(), logger_run(), main_init(), new_sub(), print_filename_option(), read_index_list(), run(), run_service(), save(), save_hostlist_file(), setup_service(), test_service_configuration(), testbed_run(), tokenizer_cb(), try_unixpath(), write_index_list(), and write_proof().

Here is the caller 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
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
cbfunction to call on each filename
cb_clsclosure for cb
Returns
number of filenames iterated over, -1 on error

Definition at line 2061 of file configuration.c.

2067 {
2068  char *list;
2069  char *pos;
2070  char *end;
2071  char old;
2072  int ret;
2073 
2074  if (GNUNET_OK !=
2075  GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &list))
2076  return 0;
2077  GNUNET_assert (list != NULL);
2078  ret = 0;
2079  pos = list;
2080  while (1)
2081  {
2082  while (pos[0] == ' ')
2083  pos++;
2084  if (strlen (pos) == 0)
2085  break;
2086  end = pos + 1;
2087  while ((end[0] != ' ') && (end[0] != '\0'))
2088  {
2089  if (end[0] == '\\')
2090  {
2091  switch (end[1])
2092  {
2093  case '\\':
2094  case ' ':
2095  memmove (end, &end[1], strlen (&end[1]) + 1);
2096 
2097  case '\0':
2098  /* illegal, but just keep it */
2099  break;
2100 
2101  default:
2102  /* illegal, but just ignore that there was a '/' */
2103  break;
2104  }
2105  }
2106  end++;
2107  }
2108  old = end[0];
2109  end[0] = '\0';
2110  if (strlen (pos) > 0)
2111  {
2112  ret++;
2113  if ((cb != NULL) && (GNUNET_OK != cb (cb_cls, pos)))
2114  {
2115  ret = GNUNET_SYSERR;
2116  break;
2117  }
2118  }
2119  if (old == '\0')
2120  break;
2121  pos = end + 1;
2122  }
2123  GNUNET_free (list);
2124  return ret;
2125 }
static int list
Set if we should print a list of currently running services.
Definition: gnunet-arm.c:69

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

Here is the call 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
cfgconfiguration to inspect
sectionthe section
iterfunction to call on each option
iter_clsclosure for iter

Definition at line 1411 of file configuration.c.

1416 {
1417  struct ConfigSection *spos;
1418  struct ConfigEntry *epos;
1419 
1420  spos = cfg->sections;
1421  while ((spos != NULL) && (0 != strcasecmp (spos->name, section)))
1422  spos = spos->next;
1423  if (NULL == spos)
1424  return;
1425  if (spos->inaccessible)
1426  {
1428  "Section '%s' is marked as inaccessible, because the configuration "
1429  " file that contains the section can't be read.\n",
1430  section);
1431  return;
1432  }
1433  for (epos = spos->entries; NULL != epos; epos = epos->next)
1434  if (NULL != epos->val)
1435  iter (iter_cls, spos->name, epos->key, epos->val);
1436 }
bool inaccessible
Is the configuration section marked as inaccessible?
Definition: configuration.c:93

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

Referenced by associate_shared_service(), authorize_endpoint(), auto_config_cb(), get_cont(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_TESTING_system_create_with_portrange(), read_blacklist_configuration(), 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
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
choicesNULL-terminated list of legal values
valuewill 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_SYSERR on error

Definition at line 1630 of file configuration.c.

1759 {
1760  struct ConfigEntry *e;
1761  unsigned int i;
1762 
1763  if (NULL == (e = find_entry (cfg, section, option)))
1764  return GNUNET_SYSERR;
1765  for (i = 0; NULL != choices[i]; i++)
1766  if (0 == strcasecmp (choices[i], e->val))
1767  break;
1768  if (NULL == choices[i])
1769  {
1771  _ ("Configuration value '%s' for '%s'"
1772  " in section '%s' is not in set of legal choices\n"),
1773  e->val,
1774  option,
1775  section);
1776  return GNUNET_SYSERR;
1777  }
1778  *value = choices[i];
1779  return GNUNET_OK;
1780 }

Referenced by start_process().

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
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
Returns
GNUNET_YES, GNUNET_NO or if option has no valid value, GNUNET_SYSERR

Definition at line 1991 of file configuration.c.

2045 {
2046  static const char *yesno[] = { "YES", "NO", NULL };
2047  const char *val;
2048  int ret;
2049 
2050  ret =
2051  GNUNET_CONFIGURATION_get_value_choice (cfg, section, option, yesno, &val);
2052  if (ret == GNUNET_SYSERR)
2053  return ret;
2054  if (val == yesno[0])
2055  return GNUNET_YES;
2056  return GNUNET_NO;
2057 }
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.

Referenced by advertise_dns_exit(), client_configure_plugin(), create_listen_socket(), get_server_addresses(), gg_load_configuration(), GNS_resolver_init(), GNUNET_ATS_solvers_experimentation_load(), GNUNET_CONNECTION_create_from_connect_to_unixpath(), GNUNET_DATACACHE_create(), GNUNET_STATISTICS_create(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), GSF_pending_request_init_(), GSF_push_init_(), LEGACY_SERVICE_get_server_addresses(), libgnunet_plugin_datacache_sqlite_init(), libgnunet_plugin_transport_http_client_init(), libgnunet_plugin_transport_tcp_init(), libgnunet_plugin_transport_udp_init(), libgnunet_plugin_transport_unix_init(), load_underlay(), main_init(), parse_ip_options(), run(), server_configure_plugin(), setup_broadcast(), setup_service(), sign_ephemeral_key(), start_process(), tcp_address_to_sockaddr_port_only(), test_icmp_client(), test_icmp_server(), test_master(), udp_address_to_sockaddr(), and update_config().

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
cfgconfiguration to access
sectionsection to access
optionoption to access
bufwhere to store the decoded binary result
buf_sizeexact 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 1630 of file configuration.c.

1789 {
1790  char *enc;
1791  int res;
1792  size_t data_size;
1793 
1794  if (GNUNET_OK !=
1795  (res =
1796  GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &enc)))
1797  return res;
1798  data_size = (strlen (enc) * 5) / 8;
1799  if (data_size != buf_size)
1800  {
1801  GNUNET_free (enc);
1802  return GNUNET_SYSERR;
1803  }
1804  if (GNUNET_OK !=
1805  GNUNET_STRINGS_string_to_data (enc, strlen (enc), buf, buf_size))
1806  {
1807  GNUNET_free (enc);
1808  return GNUNET_SYSERR;
1809  }
1810  GNUNET_free (enc);
1811  return GNUNET_OK;
1812 }
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static int res
static OpusEncoder * enc
OPUS encoder.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert CrockfordBase32 encoding back to data.
Definition: strings.c:788

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

Referenced by callback_scan_for_rooms(), 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
cfgconfiguration to use for path expansion
origstring 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 1991 of file configuration.c.

1994 {
1995  char *dup;
1996  size_t i;
1997  size_t len;
1998 
1999  for (i = 0; '\0' != orig[i]; i++)
2000  {
2001  if ('$' != orig[i])
2002  continue;
2003  dup = GNUNET_strdup (orig + i);
2004  dup = expand_dollar (cfg, dup, 0);
2005  GNUNET_assert (NULL != dup); /* make compiler happy */
2006  len = strlen (dup) + 1;
2007  orig = GNUNET_realloc (orig, i + len);
2008  GNUNET_memcpy (orig + i, dup, len);
2009  GNUNET_free (dup);
2010  }
2011  return orig;
2012 }
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...
#define GNUNET_realloc(ptr, size)
Wrapper around realloc.

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

Referenced by expand_dollar(), GNUNET_TESTING_peer_start(), run(), 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
cfgconfiguration to update
sectionsection of interest
optionoption of interest
numbervalue to set

Definition at line 1630 of file configuration.c.

1634 {
1635  char s[64];
1636 
1637  GNUNET_snprintf (s, 64, "%llu", number);
1638  GNUNET_CONFIGURATION_set_value_string (cfg, section, option, s);
1639 }
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.

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

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
cfgconfiguration to update
sectionsection of interest
optionoption of interest
valuevalue to set

Definition at line 1588 of file configuration.c.

1592 {
1593  struct ConfigSection *sec;
1594  struct ConfigEntry *e;
1595  char *nv;
1596 
1597  e = find_entry (cfg, section, option);
1598  if (NULL != e)
1599  {
1600  if (NULL == value)
1601  {
1602  GNUNET_free (e->val);
1603  e->val = NULL;
1604  }
1605  else
1606  {
1607  nv = GNUNET_strdup (value);
1608  GNUNET_free (e->val);
1609  e->val = nv;
1610  }
1611  return;
1612  }
1613  sec = find_section (cfg, section);
1614  if (sec == NULL)
1615  {
1616  sec = GNUNET_new (struct ConfigSection);
1617  sec->name = GNUNET_strdup (section);
1618  sec->next = cfg->sections;
1619  cfg->sections = sec;
1620  }
1621  e = GNUNET_new (struct ConfigEntry);
1622  e->key = GNUNET_strdup (option);
1623  e->val = GNUNET_strdup (value);
1624  e->next = sec->entries;
1625  sec->entries = e;
1626 }
static struct ConfigSection * find_section(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section)
Find a section entry from a configuration.

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

Referenced by associate_shared_service(), auto_conf_iter(), auto_config_cb(), cfg_copy_iterator(), compare_entries(), copy_entry(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_get_data(), GNUNET_CONFIGURATION_load(), GNUNET_NAT_autoconfig_start(), GNUNET_TESTING_configuration_create_(), handle_ego_delete(), handle_ego_rename(), helper_mst(), identity_cb(), iterate_save_rooms(), next_phase(), process_if(), result_callback(), run(), save_member(), 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
cfgconfiguration to update
sectionsection of interest
optionoption of interest
valuefilename to remove
Returns
GNUNET_OK on success, GNUNET_SYSERR if the filename is not in the list

Definition at line 2135 of file configuration.c.

2223 {
2224  char *list;
2225  char *pos;
2226  char *end;
2227  char *match;
2228  char old;
2229 
2230  if (GNUNET_OK !=
2231  GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &list))
2232  return GNUNET_NO;
2233  match = escape_name (value);
2234  pos = list;
2235  while (1)
2236  {
2237  while (pos[0] == ' ')
2238  pos++;
2239  if (strlen (pos) == 0)
2240  break;
2241  end = pos + 1;
2242  while ((end[0] != ' ') && (end[0] != '\0'))
2243  {
2244  if (end[0] == '\\')
2245  {
2246  switch (end[1])
2247  {
2248  case '\\':
2249  case ' ':
2250  end++;
2251  break;
2252 
2253  case '\0':
2254  /* illegal, but just keep it */
2255  break;
2256 
2257  default:
2258  /* illegal, but just ignore that there was a '/' */
2259  break;
2260  }
2261  }
2262  end++;
2263  }
2264  old = end[0];
2265  end[0] = '\0';
2266  if (0 == strcmp (pos, match))
2267  {
2268  if (old != '\0')
2269  memmove (pos, &end[1], strlen (&end[1]) + 1);
2270  else
2271  {
2272  if (pos != list)
2273  pos[-1] = '\0';
2274  else
2275  pos[0] = '\0';
2276  }
2277  GNUNET_CONFIGURATION_set_value_string (cfg, section, option, list);
2278  GNUNET_free (list);
2279  GNUNET_free (match);
2280  return GNUNET_OK;
2281  }
2282  if (old == '\0')
2283  break;
2284  end[0] = old;
2285  pos = end + 1;
2286  }
2287  GNUNET_free (list);
2288  GNUNET_free (match);
2289  return GNUNET_NO;
2290 }
static char * escape_name(const char *value)
FIXME.

◆ 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
cfgconfiguration to update
sectionsection of interest
optionoption of interest
valuefilename to append
Returns
GNUNET_OK on success, GNUNET_SYSERR if the filename already in the list

Definition at line 2135 of file configuration.c.

2188 {
2189  char *escaped;
2190  char *old;
2191  char *nw;
2192 
2193  if (GNUNET_SYSERR ==
2195  section,
2196  option,
2197  &test_match,
2198  (void *) value))
2199  return GNUNET_NO; /* already exists */
2200  if (GNUNET_OK !=
2201  GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &old))
2202  old = GNUNET_strdup ("");
2203  escaped = escape_name (value);
2204  nw = GNUNET_malloc (strlen (old) + strlen (escaped) + 2);
2205  strcpy (nw, old);
2206  if (strlen (old) > 0)
2207  strcat (nw, " ");
2208  strcat (nw, escaped);
2209  GNUNET_CONFIGURATION_set_value_string (cfg, section, option, nw);
2210  GNUNET_free (old);
2211  GNUNET_free (nw);
2212  GNUNET_free (escaped);
2213  return GNUNET_OK;
2214 }
static enum GNUNET_GenericReturnValue test_match(void *cls, const char *fn)
FIXME.
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.

References GNUNET_malloc, and value.

◆ GNUNET_CONFIGURATION_config_settings_free()

void GNUNET_CONFIGURATION_config_settings_free ( struct GNUNET_CONFIGURATION_ConfigSettings cs)

Free resources associated with cs.

Parameters
[in]cssettings to free (actual memory of cs itself is not released)

Definition at line 294 of file configuration_helper.c.

296 {
297  GNUNET_free (cs->option);
298  GNUNET_free (cs->section);
299  GNUNET_free (cs->value);
300 }

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
clsclosure with the struct GNUNET_CONFIGURATION_ConfigSettings
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cfgconfiguration

Definition at line 108 of file configuration_helper.c.

113 {
114  struct GNUNET_CONFIGURATION_ConfigSettings *cs = cls;
115  struct GNUNET_CONFIGURATION_Handle *out = NULL;
116  struct GNUNET_CONFIGURATION_Handle *ncfg = NULL;
117 
118  (void) args;
119  if (cs->diagnostics)
120  {
121  /* Re-parse the configuration with diagnostics enabled. */
122  ncfg = GNUNET_CONFIGURATION_create ();
125  cfgfile);
126  cfg = ncfg;
127  }
128 
129  if (cs->full)
130  cs->rewrite = GNUNET_YES;
131  if (cs->list_sections)
132  {
133  fprintf (stderr,
134  _ ("The following sections are available:\n"));
137  NULL);
138  return;
139  }
140  if ( (! cs->rewrite) &&
141  (NULL == cs->section) )
142  {
143  char *serialization;
144 
145  if (! cs->diagnostics)
146  {
147  fprintf (stderr,
148  _ ("%s, %s or %s argument is required\n"),
149  "--section",
150  "--list-sections",
151  "--diagnostics");
153  return;
154  }
156  fprintf (stdout,
157  "%s",
158  serialization);
159  GNUNET_free (serialization);
160  }
161  else if ( (NULL != cs->section) &&
162  (NULL == cs->value) )
163  {
164  if (NULL == cs->option)
165  {
167  cfg,
168  cs->section,
169  cs->is_filename
171  : &print_option,
172  (void *) cfg);
173  }
174  else
175  {
176  char *value;
177 
178  if (cs->is_filename)
179  {
180  if (GNUNET_OK !=
182  cs->section,
183  cs->option,
184  &value))
185  {
187  cs->section,
188  cs->option);
190  return;
191  }
192  }
193  else
194  {
195  if (GNUNET_OK !=
197  cs->section,
198  cs->option,
199  &value))
200  {
202  cs->section,
203  cs->option);
205  return;
206  }
207  }
208  fprintf (stdout,
209  "%s\n",
210  value);
211  GNUNET_free (value);
212  }
213  }
214  else if (NULL != cs->section)
215  {
216  if (NULL == cs->option)
217  {
218  fprintf (stderr,
219  _ ("--option argument required to set value\n"));
221  return;
222  }
225  cs->section,
226  cs->option,
227  cs->value);
228  cs->rewrite = GNUNET_YES;
229  }
230  if (cs->rewrite)
231  {
232  char *cfg_fn = NULL;
233 
234  if (NULL == out)
236 
237  if (NULL == cfgfile)
238  {
239  const char *xdg = getenv ("XDG_CONFIG_HOME");
240 
241  if (NULL != xdg)
242  GNUNET_asprintf (&cfg_fn,
243  "%s%s%s",
244  xdg,
247  else
248  cfg_fn = GNUNET_strdup (
249  GNUNET_OS_project_data_get ()->user_config_file);
250  cfgfile = cfg_fn;
251  }
252 
253  if (! cs->full)
254  {
255  struct GNUNET_CONFIGURATION_Handle *def;
256 
258  if (GNUNET_OK !=
260  NULL))
261  {
262  fprintf (stderr,
263  _ ("failed to load configuration defaults"));
264  cs->global_ret = 1;
267  GNUNET_free (cfg_fn);
268  return;
269  }
270  if (GNUNET_OK !=
272  out,
273  cfgfile))
274  cs->global_ret = 2;
276  }
277  else
278  {
279  if (GNUNET_OK !=
281  cfgfile))
282  cs->global_ret = 2;
283  }
284  GNUNET_free (cfg_fn);
285  }
286  if (NULL != out)
288  if (NULL != ncfg)
290 }
static void print_filename_option(void *cls, const char *section, const char *option, const char *value)
Print each option in a given section as a filename.
static void print_section_name(void *cls, const char *section)
Print out given section name.
static void print_option(void *cls, const char *section, const char *option, const char *value)
Print each option in a given section.
static char * config_file
Set to the name of the config file used.
Definition: gnunet-arm.c:84
char * GNUNET_CONFIGURATION_serialize_diagnostics(const struct GNUNET_CONFIGURATION_Handle *cfg)
Serializes the given configuration with diagnostics information.
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.
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_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_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_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
void GNUNET_CONFIGURATION_enable_diagnostics(struct GNUNET_CONFIGURATION_Handle *cfg)
Enable extra diagnostics.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
#define EXIT_INVALIDARGUMENT
Definition: platform.h:252
#define EXIT_NOTCONFIGURED
Definition: platform.h:268
Closure for GNUNET_CONFIGURATION_config_tool_run() with settings for what should be done with the con...
int full
Should the generated configuration file contain the whole configuration?
int global_ret
Return value from the operation, to be returned from 'main'.
int diagnostics
Should we give extra diagnostics?
int list_sections
Whether to show the sections.
int rewrite
Should we write out the configuration file, even if no value was changed?
int is_filename
Treat option as a filename.

References _, consensus-simulation::args, cfg, config_file, GNUNET_CONFIGURATION_ConfigSettings::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_set_value_string(), GNUNET_CONFIGURATION_write(), GNUNET_CONFIGURATION_write_diffs(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_config_missing(), GNUNET_OK, GNUNET_OS_project_data_get(), GNUNET_strdup, GNUNET_YES, GNUNET_CONFIGURATION_ConfigSettings::is_filename, GNUNET_CONFIGURATION_ConfigSettings::list_sections, GNUNET_CONFIGURATION_ConfigSettings::option, print_filename_option(), print_option(), print_section_name(), GNUNET_CONFIGURATION_ConfigSettings::rewrite, GNUNET_CONFIGURATION_ConfigSettings::section, GNUNET_CONFIGURATION_ConfigSettings::value, and value.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function: