GNUnet 0.22.0
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 745 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 245 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 298 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 311 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 struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:108
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(), create_unique_cfgs(), gg_load_configuration(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_default(), GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_get_diff(), GNUNET_CONFIGURATION_parse_and_run(), GNUNET_PROGRAM_conf_and_options(), GNUNET_PROGRAM_run2(), GNUNET_SERVICE_run_(), GNUNET_TESTING_get_topo_from_string_(), GNUNET_TRANSPORT_TESTING_start_peer(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), handle_auto_result(), handle_autoconfig_request(), handle_inline(), iter_check_config(), load_member(), load_member_session(), load_member_session_next(), load_operation(), main(), run(), save_member(), save_member_session(), save_operation(), and start_peer_run().

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

◆ GNUNET_CONFIGURATION_dup()

struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup ( const struct GNUNET_CONFIGURATION_Handle cfg)

Duplicate an existing configuration object.

Parameters
cfgconfiguration to duplicate
Returns
duplicate configuration

Definition at line 1537 of file configuration.c.

1539{
1541
1544 &copy_entry,
1545 ret);
1546 return ret;
1547}
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
Final status code.
Definition: gnunet-arm.c:93
void GNUNET_CONFIGURATION_iterate(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CONFIGURATION_Iterator iter, void *iter_cls)
Iterate over all options in the configuration.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create()
Create a new configuration object.

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

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

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

◆ GNUNET_CONFIGURATION_destroy()

void GNUNET_CONFIGURATION_destroy ( struct GNUNET_CONFIGURATION_Handle cfg)

Destroy configuration object.

Parameters
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 }
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 auto_config_cb(), clean_node(), conclude_autoconfig_request(), create_unique_cfgs(), do_shutdown(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_default(), GNUNET_CONFIGURATION_parse_and_run(), GNUNET_CONFIGURATION_write_diffs(), GNUNET_NAT_autoconfig_cancel(), GNUNET_PROGRAM_conf_and_options(), GNUNET_PROGRAM_run2(), GNUNET_SERVICE_run_(), GNUNET_TESTING_get_topo_from_string_(), GNUNET_TRANSPORT_TESTING_start_peer(), GNUNET_TRANSPORT_TESTING_stop_peer(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_stop(), handle_auto_result(), handle_autoconfig_request(), handle_inline(), load_member(), load_member_session(), load_member_session_next(), load_operation(), main(), next_phase(), save_member(), save_member_session(), save_operation(), shutdown_task(), start_peer_cleanup(), and start_peer_run().

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

◆ GNUNET_CONFIGURATION_load()

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

Load configuration.

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

Parameters
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 2565 of file configuration.c.

2568{
2569 char *baseconfig;
2570 const char *base_config_varname;
2571
2572 if (cfg->load_called)
2573 {
2574 /* FIXME: Make this a GNUNET_assert later */
2575 GNUNET_break (0);
2577 }
2578 cfg->load_called = true;
2579 if (NULL != filename)
2580 {
2583 }
2584
2585 base_config_varname = GNUNET_OS_project_data_get ()->base_config_varname;
2586
2587 if ((NULL != base_config_varname)
2588 && (NULL != (baseconfig = getenv (base_config_varname))))
2589 {
2590 baseconfig = GNUNET_strdup (baseconfig);
2591 }
2592 else
2593 {
2594 char *ipath;
2595
2597 if (NULL == ipath)
2598 {
2599 GNUNET_break (0);
2600 return GNUNET_SYSERR;
2601 }
2602 GNUNET_asprintf (&baseconfig,
2603 "%s%s",
2604 ipath,
2605 "config.d");
2606 GNUNET_free (ipath);
2607 }
2608
2609 {
2610 char *dname = GNUNET_STRINGS_filename_expand (baseconfig);
2611 GNUNET_free (baseconfig);
2612
2613 if ((GNUNET_YES ==
2615 GNUNET_YES)) &&
2616 (GNUNET_SYSERR ==
2618 dname)))
2619 {
2621 "Failed to load base configuration from '%s'\n",
2622 filename);
2623 GNUNET_free (dname);
2624 return GNUNET_SYSERR; /* no configuration at all found */
2625 }
2626 GNUNET_free (dname);
2627 }
2628 if ((NULL != filename) &&
2629 (GNUNET_OK !=
2631 filename)))
2632 {
2633 /* specified configuration not found */
2635 "Failed to load configuration from file '%s'\n",
2636 filename);
2637 return GNUNET_SYSERR;
2638 }
2639 if (((GNUNET_YES !=
2641 "PATHS",
2642 "DEFAULTCONFIG"))) &&
2643 (filename != NULL))
2645 "PATHS",
2646 "DEFAULTCONFIG",
2647 filename);
2648 return GNUNET_OK;
2649}
#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:404
@ 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:495
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_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_default(), GNUNET_CONFIGURATION_parse_and_run(), GNUNET_PROGRAM_conf_and_options(), GNUNET_PROGRAM_run2(), GNUNET_SERVICE_run_(), GNUNET_TRANSPORT_TESTING_start_peer(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), iter_check_config(), main(), 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 2394 of file configuration.c.

2397{
2398 struct CollectFilesContext files_context = {
2399 .files = NULL,
2400 .files_length = 0,
2401 };
2402 enum GNUNET_GenericReturnValue fun_ret;
2403
2404 if (GNUNET_SYSERR ==
2406 &files_context))
2407 return GNUNET_SYSERR; /* no configuration at all found */
2408 qsort (files_context.files,
2409 files_context.files_length,
2410 sizeof (char *),
2411 pstrcmp);
2412 for (unsigned int i = 0; i < files_context.files_length; i++)
2413 {
2414 char *ext;
2415 const char *filename = files_context.files[i];
2416
2417 /* Examine file extension */
2418 ext = strrchr (filename, '.');
2419 if ((NULL == ext) || (0 != strcmp (ext, ".conf")))
2420 {
2421 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Skipping file `%s'\n", filename);
2422 fun_ret = GNUNET_OK;
2423 goto cleanup;
2424 }
2426 if (fun_ret != GNUNET_OK)
2427 break;
2428 }
2429cleanup:
2430 if (files_context.files_length > 0)
2431 {
2432 for (size_t i = 0; i < files_context.files_length; i++)
2433 GNUNET_free (files_context.files[i]);
2434 GNUNET_array_grow (files_context.files,
2435 files_context.files_length,
2436 0);
2437 }
2438 return fun_ret;
2439}
static int pstrcmp(const void *a, const void *b)
static enum GNUNET_GenericReturnValue collect_files_cb(void *cls, const char *filename)
Function called with a filename.
static void cleanup(void *cls)
Disconnect and shutdown.
Definition: gnunet-did.c:130
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:815
#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.

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

Referenced by GNUNET_CONFIGURATION_load().

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

◆ GNUNET_CONFIGURATION_default()

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 2485 of file configuration.c.

2486{
2489 const char *xdg = getenv ("XDG_CONFIG_HOME");
2490 char *cfgname = NULL;
2492
2493 /* Makes sure function implicitly looking at the installation directory (for
2494 example GNUNET_CONFIGURATION_load further down) use GNUnet's environment
2495 instead of the caller's. It's done at the start to make sure as many
2496 functions as possible are directed to the proper paths. */
2497 GNUNET_OS_init (dpd);
2498
2500
2501 /* First, try user configuration. */
2502 if (NULL != xdg)
2503 GNUNET_asprintf (&cfgname,
2504 "%s/%s",
2505 xdg,
2506 dpd->config_file);
2507 else
2508 cfgname = GNUNET_strdup (dpd->user_config_file);
2509
2510 /* If user config doesn't exist, try in
2511 /etc/<projdir>/<cfgfile> and /etc/<cfgfile> */
2512 if (GNUNET_OK != GNUNET_DISK_file_test (cfgname))
2513 {
2514 GNUNET_free (cfgname);
2515 GNUNET_asprintf (&cfgname,
2516 "/etc/%s",
2517 dpd->config_file);
2518 }
2519 if (GNUNET_OK != GNUNET_DISK_file_test (cfgname))
2520 {
2521 GNUNET_free (cfgname);
2522 GNUNET_asprintf (&cfgname,
2523 "/etc/%s/%s",
2524 dpd->project_dirname,
2525 dpd->config_file);
2526 }
2527 if (GNUNET_OK != GNUNET_DISK_file_test (cfgname))
2528 {
2530 "Unable to top-level configuration file.\n");
2531 GNUNET_OS_init (pd);
2533 GNUNET_free (cfgname);
2534 return NULL;
2535 }
2536
2537 /* We found a configuration file that looks good, try to load it. */
2538
2540 "Loading top-level configuration from '%s'\n",
2541 cfgname);
2542 if (GNUNET_OK !=
2543 GNUNET_CONFIGURATION_load (cfg, cfgname))
2544 {
2545 GNUNET_OS_init (pd);
2547 GNUNET_free (cfgname);
2548 return NULL;
2549 }
2550 GNUNET_free (cfgname);
2551 GNUNET_OS_init (pd);
2552 return cfg;
2553}
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration (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:483
@ 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 2443 of file configuration.c.

2444{
2445 char *cfg_fn;
2447 const char *xdg = getenv ("XDG_CONFIG_HOME");
2448
2449 if (NULL != xdg)
2450 GNUNET_asprintf (&cfg_fn,
2451 "%s%s%s",
2452 xdg,
2454 pd->config_file);
2455 else
2456 cfg_fn = GNUNET_strdup (pd->user_config_file);
2457
2458 if (GNUNET_OK == GNUNET_DISK_file_test_read (cfg_fn))
2459 return cfg_fn;
2460 GNUNET_free (cfg_fn);
2461
2462 /* Fall back to /etc/ for the default configuration.
2463 Should be okay to use forward slashes here. */
2464
2465 GNUNET_asprintf (&cfg_fn,
2466 "/etc/%s",
2467 pd->config_file);
2468 if (GNUNET_OK == GNUNET_DISK_file_test_read (cfg_fn))
2469 return cfg_fn;
2470 GNUNET_free (cfg_fn);
2471
2472 GNUNET_asprintf (&cfg_fn,
2473 "/etc/%s/%s",
2474 pd->project_dirname,
2475 pd->config_file);
2476 if (GNUNET_OK == GNUNET_DISK_file_test_read (cfg_fn))
2477 return cfg_fn;
2478
2479 GNUNET_free (cfg_fn);
2480 return NULL;
2481}
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:490
#define DIR_SEPARATOR_STR
Definition: platform.h:166

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.

Referenced by GNUNET_PROGRAM_run2(), and main().

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

◆ GNUNET_CONFIGURATION_parse()

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

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

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

Definition at line 974 of file configuration.c.

976{
977 uint64_t fs64;
978 size_t fs;
979 char *fn;
980 char *mem;
981 int dirty;
983 ssize_t sret;
984
986 LOG (GNUNET_ERROR_TYPE_DEBUG, "Asked to parse config file `%s'\n", fn);
987 if (NULL == fn)
988 return GNUNET_SYSERR;
989
990
991 /* Check for cycles */
992 {
993 unsigned int lvl = cfg->current_nest_level;
994 struct ConfigFile *cf = cfg->loaded_files_tail;
995 struct ConfigFile *parent = NULL;
996
997
998 for (; NULL != cf; parent = cf, cf = cf->prev)
999 {
1000 /* Check parents based on level, skipping children of siblings. */
1001 if (cf->level >= lvl)
1002 continue;
1003 lvl = cf->level;
1004 if ( (NULL == cf->source_filename) || (NULL == filename))
1005 continue;
1006 if (0 == strcmp (cf->source_filename, filename))
1007 {
1008 if (NULL == parent)
1009 {
1011 "Forbidden direct cyclic configuration import (%s -> %s)\n",
1012 cf->source_filename,
1013 filename);
1014 }
1015 else
1017 "Forbidden indirect cyclic configuration import (%s -> ... -> %s -> %s)\n",
1018 cf->source_filename,
1019 parent->source_filename,
1020 filename);
1021 GNUNET_free (fn);
1022 return GNUNET_SYSERR;
1023 }
1024 }
1025
1026 }
1027
1028 /* Keep track of loaded files.*/
1029 {
1030 struct ConfigFile *cf = GNUNET_new (struct ConfigFile);
1031
1033 cf->source_filename = GNUNET_strdup (filename ? filename : "<input>");
1036 cf);
1037 }
1038
1039 dirty = cfg->dirty; /* back up value! */
1040 if (GNUNET_SYSERR ==
1042 &fs64,
1043 GNUNET_YES,
1044 GNUNET_YES))
1045 {
1047 "Error while determining the file size of `%s'\n",
1048 fn);
1049 GNUNET_free (fn);
1050 return GNUNET_SYSERR;
1051 }
1052 if (fs64 > SIZE_MAX)
1053 {
1054 GNUNET_break (0); /* File size is more than the heap size */
1055 GNUNET_free (fn);
1056 return GNUNET_SYSERR;
1057 }
1058 fs = fs64;
1059 mem = GNUNET_malloc (fs);
1060 sret = GNUNET_DISK_fn_read (fn, mem, fs);
1061 if ((sret < 0) || (fs != (size_t) sret))
1062 {
1064 "Error while reading file `%s'\n",
1065 fn);
1066 GNUNET_free (fn);
1067 GNUNET_free (mem);
1068 return GNUNET_SYSERR;
1069 }
1071 "Deserializing contents of file `%s'\n",
1072 fn);
1074 mem,
1075 fs,
1076 fn);
1077 if (GNUNET_SYSERR == ret)
1078 {
1080 _ ("Failed to parse configuration file `%s'\n"),
1081 fn);
1082 }
1083 GNUNET_free (fn);
1084 GNUNET_free (mem);
1085 /* restore dirty flag - anything we set in the meantime
1086 * came from disk */
1087 cfg->dirty = dirty;
1088 return ret;
1089}
static struct GNUNET_FS_Handle * fs
Handle to FS service.
Definition: gnunet-fs.c:35
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:222
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:665
#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:178
#define SIZE_MAX
Definition: platform.h:208
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...

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

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

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

◆ GNUNET_CONFIGURATION_serialize()

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

Serializes the given configuration.

Parameters
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 1135 of file configuration.c.

1137{
1138 char *mem;
1139 char *cbuf;
1140 char *val;
1141 char *pos;
1142 size_t m_size;
1143 size_t c_size;
1144
1145 /* Pass1 : calculate the buffer size required */
1146 m_size = 0;
1147 for (struct ConfigSection *sec = cfg->sections;
1148 NULL != sec;
1149 sec = sec->next)
1150 {
1151 if (sec->inaccessible)
1152 continue;
1153 /* For each section we need to add 3 characters: {'[',']','\n'} */
1154 m_size += strlen (sec->name) + 3;
1155 for (struct ConfigEntry *ent = sec->entries;
1156 NULL != ent;
1157 ent = ent->next)
1158 {
1159 if (do_skip (sec->name,
1160 ent->key))
1161 continue;
1162 if (NULL != ent->val)
1163 {
1164 /* if val has any '\n' then they occupy +1 character as '\n'->'\\','n' */
1165 pos = ent->val;
1166 while (NULL != (pos = strstr (pos, "\n")))
1167 {
1168 m_size++;
1169 pos++;
1170 }
1171 /* For each key = value pair we need to add 4 characters (2
1172 spaces and 1 equal-to character and 1 new line) */
1173 m_size += strlen (ent->key) + strlen (ent->val) + 4;
1174 }
1175 }
1176 /* A new line after section end */
1177 m_size++;
1178 }
1179
1180 /* Pass2: Allocate memory and write the configuration to it */
1181 mem = GNUNET_malloc (m_size);
1182 c_size = 0;
1183 *size = c_size;
1184 for (struct ConfigSection *sec = cfg->sections;
1185 NULL != sec;
1186 sec = sec->next)
1187 {
1188 int len;
1189
1190 len = GNUNET_asprintf (&cbuf,
1191 "[%s]\n",
1192 sec->name);
1193 GNUNET_assert (0 < len);
1194 GNUNET_memcpy (mem + c_size,
1195 cbuf,
1196 len);
1197 c_size += len;
1198 GNUNET_free (cbuf);
1199 for (struct ConfigEntry *ent = sec->entries;
1200 NULL != ent;
1201 ent = ent->next)
1202 {
1203 if (do_skip (sec->name,
1204 ent->key))
1205 continue;
1206 if (NULL != ent->val)
1207 {
1208 val = GNUNET_malloc (strlen (ent->val) * 2 + 1);
1209 strcpy (val, ent->val);
1210 while (NULL != (pos = strstr (val, "\n")))
1211 {
1212 memmove (&pos[2], &pos[1], strlen (&pos[1]));
1213 pos[0] = '\\';
1214 pos[1] = 'n';
1215 }
1216 len = GNUNET_asprintf (&cbuf, "%s = %s\n", ent->key, val);
1217 GNUNET_free (val);
1218 GNUNET_memcpy (mem + c_size, cbuf, len);
1219 c_size += len;
1220 GNUNET_free (cbuf);
1221 }
1222 }
1223 GNUNET_memcpy (mem + c_size, "\n", 1);
1224 c_size++;
1225 }
1226 GNUNET_assert (c_size == m_size);
1227 *size = c_size;
1228 return mem;
1229}
static bool do_skip(const char *sec, const char *key)
Should we skip this configuration entry when serializing?
#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, ConfigEntry::next, ConfigSection::next, GNUNET_CONFIGURATION_Handle::sections, and size.

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

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

◆ GNUNET_CONFIGURATION_serialize_diagnostics()

char * GNUNET_CONFIGURATION_serialize_diagnostics ( const struct GNUNET_CONFIGURATION_Handle cfg)

Serializes the given configuration with diagnostics information.

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

Parameters
cfgconfiguration to serialize
Returns
the memory block where the serialized configuration is present. This memory should be freed by the caller

Definition at line 1233 of file configuration.c.

1235{
1236 struct GNUNET_Buffer buf = { 0 };
1237
1239 "#\n# Configuration file diagnostics\n#\n");
1241 "# Entry point: %s\n",
1243 "<none>");
1245 "#\n# Files Loaded:\n");
1246
1247 for (struct ConfigFile *cfil = cfg->loaded_files_head;
1248 NULL != cfil;
1249 cfil = cfil->next)
1250 {
1252 "# ");
1253 for (unsigned int i = 0; i < cfil->level; i++)
1255 "+");
1256 if (0 != cfil->level)
1258 " ");
1259
1261 "%s",
1262 cfil->source_filename);
1263
1264 if (NULL != cfil->hint_restrict_section)
1266 " (%s secret section %s)",
1267 cfil->hint_inaccessible
1268 ? "inaccessible"
1269 : "loaded",
1270 cfil->hint_restrict_section);
1271
1273 "\n");
1274 }
1275
1277 "#\n\n");
1278
1279 for (struct ConfigSection *sec = cfg->sections;
1280 NULL != sec;
1281 sec = sec->next)
1282 {
1283 if (sec->hint_secret_filename)
1285 "# secret section from %s\n# secret file stat %s\n",
1286 sec->hint_secret_filename,
1287 sec->hint_secret_stat);
1288 if (sec->hint_inlined_from_filename)
1289 {
1291 "# inlined from %s:%u\n",
1292 sec->hint_inlined_from_filename,
1293 sec->hint_inlined_from_line);
1294 }
1296 "[%s]\n\n",
1297 sec->name);
1298 if (sec->inaccessible)
1299 {
1301 "# <section contents inaccessible>\n\n\n");
1302 continue;
1303 }
1304 for (struct ConfigEntry *ent = sec->entries;
1305 NULL != ent;
1306 ent = ent->next)
1307 {
1308 if (do_skip (sec->name,
1309 ent->key))
1310 continue;
1311 if (NULL != ent->val)
1312 {
1313 char *pos;
1314 char *val = GNUNET_malloc (strlen (ent->val) * 2 + 1);
1315 strcpy (val, ent->val);
1316 while (NULL != (pos = strstr (val, "\n")))
1317 {
1318 memmove (&pos[2], &pos[1], strlen (&pos[1]));
1319 pos[0] = '\\';
1320 pos[1] = 'n';
1321 }
1322 if (NULL != ent->hint_filename)
1323 {
1325 "# %s:%u\n",
1326 ent->hint_filename,
1327 ent->hint_lineno);
1328 }
1330 "%s = %s\n",
1331 ent->key,
1332 val);
1333 GNUNET_free (val);
1334 }
1335 GNUNET_buffer_write_str (&buf, "\n");
1336 }
1337 GNUNET_buffer_write_str (&buf, "\n");
1338 }
1339 return GNUNET_buffer_reap_str (&buf);
1340}
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 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 707 of file configuration.c.

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

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

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

◆ GNUNET_CONFIGURATION_write()

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

Write configuration file.

Parameters
cfgconfiguration to write
filenamewhere to write the configuration
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1344 of file configuration.c.

1347{
1348 char *fn;
1349 char *cfg_buf;
1350 size_t size;
1351
1353 if (fn == NULL)
1354 return GNUNET_SYSERR;
1356 {
1357 GNUNET_free (fn);
1358 return GNUNET_SYSERR;
1359 }
1361 &size);
1362 {
1363 struct GNUNET_DISK_FileHandle *h;
1364
1373 if (NULL == h)
1374 {
1375 GNUNET_free (fn);
1376 GNUNET_free (cfg_buf);
1377 return GNUNET_SYSERR;
1378 }
1379 if (((ssize_t) size) !=
1381 cfg_buf,
1382 size))
1383 {
1385 "write",
1386 fn);
1388 (void) GNUNET_DISK_directory_remove (fn);
1389 GNUNET_free (fn);
1390 GNUNET_free (cfg_buf);
1391 cfg->dirty = GNUNET_SYSERR; /* last write failed */
1392 return GNUNET_SYSERR;
1393 }
1396 }
1397 GNUNET_free (fn);
1398 GNUNET_free (cfg_buf);
1399 cfg->dirty = GNUNET_NO; /* last write succeeded */
1400 return GNUNET_OK;
1401}
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:98
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:1238
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:687
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1088
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1309
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:583
@ 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).

References cfg, GNUNET_CONFIGURATION_Handle::dirty, filename, GNUNET_assert, GNUNET_CONFIGURATION_serialize(), GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_directory_remove(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_GROUP_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror_file, GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, h, and size.

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

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

◆ GNUNET_CONFIGURATION_write_diffs()

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

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

Parameters
cfg_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 1595 of file configuration.c.

1599{
1600 int ret;
1601 struct GNUNET_CONFIGURATION_Handle *diff;
1602
1603 diff = GNUNET_CONFIGURATION_get_diff (cfg_default, cfg_new);
1606 return ret;
1607}
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.

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

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

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

◆ GNUNET_CONFIGURATION_get_diff()

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

Compute configuration with only entries that have been changed.

Parameters
cfg_defaultoriginal configuration
cfg_newnew configuration
Returns
configuration with only the differences, never NULL

Definition at line 1581 of file configuration.c.

1584{
1585 struct DiffHandle diffHandle;
1586
1587 diffHandle.cfgDiff = GNUNET_CONFIGURATION_create ();
1588 diffHandle.cfg_default = cfg_default;
1589 GNUNET_CONFIGURATION_iterate (cfg_new, &compare_entries, &diffHandle);
1590 return diffHandle.cfgDiff;
1591}
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(), GNUNET_CONFIGURATION_write_diffs(), and next_phase().

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

◆ GNUNET_CONFIGURATION_is_dirty()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_is_dirty ( const struct GNUNET_CONFIGURATION_Handle cfg)

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

Parameters
cfgconfiguration to inspect
Returns
GNUNET_NO if clean, GNUNET_YES if dirty, GNUNET_SYSERR on error (i.e. last save failed)

Definition at line 1093 of file configuration.c.

1094{
1095 return cfg->dirty;
1096}

References cfg, and GNUNET_CONFIGURATION_Handle::dirty.

Referenced by auto_config_cb().

Here is the caller graph for this function:

◆ GNUNET_CONFIGURATION_parse_and_run()

enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_parse_and_run ( const 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 329 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}

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

Referenced by GNUNET_DISK_purge_cfg_dir().

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

◆ GNUNET_CONFIGURATION_enable_diagnostics()

void GNUNET_CONFIGURATION_enable_diagnostics ( struct GNUNET_CONFIGURATION_Handle cfg)

Enable extra diagnostics.

Will produce more log output and allocate more memory.

Parameters
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 1405 of file configuration.c.

1409{
1410 for (struct ConfigSection *spos = cfg->sections;
1411 NULL != spos;
1412 spos = spos->next)
1413 for (struct ConfigEntry *epos = spos->entries;
1414 NULL != epos;
1415 epos = epos->next)
1416 if (NULL != epos->val)
1417 iter (iter_cls,
1418 spos->name,
1419 epos->key,
1420 epos->val);
1421}

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

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

Here is the caller graph for this function:

◆ GNUNET_CONFIGURATION_iterate_sections()

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

Iterate over all sections in the configuration.

Parameters
cfgconfiguration to inspect
iterfunction to call on each section
iter_clsclosure for iter

Definition at line 1454 of file configuration.c.

1458{
1459 struct ConfigSection *spos;
1460 struct ConfigSection *next;
1461
1462 next = cfg->sections;
1463 while (next != NULL)
1464 {
1465 spos = next;
1466 next = spos->next;
1467 iter (iter_cls, spos->name);
1468 }
1469}

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

Referenced by GNUNET_CONFIGURATION_config_tool_run(), GNUNET_TESTBED_configuration_create(), handle_delete_message(), handle_rename_message(), 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 1473 of file configuration.c.

1475{
1476 struct ConfigSection *spos;
1477 struct ConfigSection *prev;
1478 struct ConfigEntry *ent;
1479
1480 prev = NULL;
1481 spos = cfg->sections;
1482 while (NULL != spos)
1483 {
1484 if (0 == strcasecmp (section, spos->name))
1485 {
1486 if (NULL == prev)
1487 cfg->sections = spos->next;
1488 else
1489 prev->next = spos->next;
1490 while (NULL != (ent = spos->entries))
1491 {
1492 spos->entries = ent->next;
1493 GNUNET_free (ent->key);
1494 GNUNET_free (ent->val);
1496 GNUNET_free (ent);
1497 cfg->dirty = GNUNET_YES;
1498 }
1499 GNUNET_free (spos->name);
1503 GNUNET_free (spos);
1504 return;
1505 }
1506 prev = spos;
1507 spos = spos->next;
1508 }
1509}
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().

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_NO if option is not set GNUNET_SYSERR on error (value is malformed)

Definition at line 1673 of file configuration.c.

1678{
1679 struct ConfigEntry *e;
1680 char dummy[2];
1681
1682 if (NULL == (e = find_entry (cfg,
1683 section,
1684 option)))
1685 return GNUNET_NO;
1686 if (NULL == e->val)
1687 return GNUNET_NO;
1688 if (1 != sscanf (e->val,
1689 "%llu%1s",
1690 number,
1691 dummy))
1692 return GNUNET_SYSERR;
1693 return GNUNET_OK;
1694}
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 in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
uint32_t number

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

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

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

◆ GNUNET_CONFIGURATION_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_NO if option is not set GNUNET_SYSERR on error (value is malformed)

Definition at line 1698 of file configuration.c.

1703{
1704 struct ConfigEntry *e;
1705 char dummy[2];
1706
1707 if (NULL == (e = find_entry (cfg,
1708 section,
1709 option)))
1710 return GNUNET_NO;
1711 if (NULL == e->val)
1712 return GNUNET_NO;
1713 if (1 != sscanf (e->val,
1714 "%f%1s",
1715 number,
1716 dummy))
1717 return GNUNET_SYSERR;
1718 return GNUNET_OK;
1719}

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

Referenced by GNUNET_RPS_connect().

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

◆ GNUNET_CONFIGURATION_get_value_time()

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

Get a configuration value that should be a relative time.

Parameters
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
timeset to the time value stored in the configuration
Returns
GNUNET_OK on success, GNUNET_NO if option is not set GNUNET_SYSERR on error (value is malformed)

Definition at line 1723 of file configuration.c.

1728{
1729 struct ConfigEntry *e;
1730 int ret;
1731
1732 if (NULL == (e = find_entry (cfg,
1733 section,
1734 option)))
1735 return GNUNET_NO;
1736 if (NULL == e->val)
1737 return GNUNET_NO;
1739 time);
1740 if (GNUNET_OK != ret)
1742 section,
1743 option,
1744 _ ("Not a valid relative time specification"));
1745 return ret;
1746}
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

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

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

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

◆ GNUNET_CONFIGURATION_get_value_size()

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

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

Parameters
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_NO if option is not set GNUNET_SYSERR on error (value is malformed)

Definition at line 1750 of file configuration.c.

1755{
1756 struct ConfigEntry *e;
1757
1758 if (NULL == (e = find_entry (cfg,
1759 section,
1760 option)))
1761 return GNUNET_NO;
1762 if (NULL == e->val)
1763 return GNUNET_NO;
1765 size);
1766}
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

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

Referenced by GNUNET_DATACACHE_create(), and run().

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

◆ GNUNET_CONFIGURATION_have_value()

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

Test if we have a value for a particular option.

Parameters
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
Returns
GNUNET_YES if so, GNUNET_NO if not.

Definition at line 1873 of file configuration.c.

1876{
1877 struct ConfigEntry *e;
1878
1879 if ( (NULL == (e = find_entry (cfg,
1880 section,
1881 option))) ||
1882 (NULL == e->val) )
1883 return GNUNET_NO;
1884 return GNUNET_YES;
1885}

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

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

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

◆ GNUNET_CONFIGURATION_get_value_string()

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

Get a configuration value that should be a string.

Parameters
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_NO if option is not set GNUNET_SYSERR on error (value is malformed)
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 1780 of file configuration.c.

1785{
1786 struct ConfigEntry *e;
1787
1788 if ( (NULL == (e = find_entry (cfg,
1789 section,
1790 option))) ||
1791 (NULL == e->val) )
1792 {
1793 *value = NULL;
1794 return GNUNET_NO;
1795 }
1796 *value = GNUNET_strdup (e->val);
1797 return GNUNET_OK;
1798}

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

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

Here is the call graph for this function:

◆ GNUNET_CONFIGURATION_get_value_filename()

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

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

Parameters
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_NO if option is not set GNUNET_SYSERR on error (value is malformed)

Definition at line 2084 of file configuration.c.

2089{
2090 char *tmp;
2092
2094 section,
2095 option,
2096 &tmp);
2097 if (GNUNET_OK != ret)
2098 {
2100 "Failed to retrieve filename\n");
2101 *value = NULL;
2102 return ret;
2103 }
2105 tmp);
2107 GNUNET_free (tmp);
2108 if (*value == NULL)
2109 return GNUNET_SYSERR;
2110 return GNUNET_OK;
2111}
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.
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...

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

Referenced by create_service(), database_connect(), database_setup(), 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_CLIENT_test(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_HOSTLIST_client_start(), GNUNET_PQ_connect_with_cfg2(), GNUNET_TIME_absolute_get_monotonic(), load(), load_hostlist_file(), main_init(), new_sub(), print_filename_option(), purge_cfg_dir(), read_index_list(), run(), save(), save_hostlist_file(), setup_service(), start_arm_service(), start_peer_run(), test_service_configuration(), try_unixpath(), write_index_list(), and write_proof().

Here is the call graph for this function:
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 2143 of file configuration.c.

2149{
2150 char *list;
2151 char *pos;
2152 char *end;
2153 char old;
2154 int ret;
2155
2156 if (GNUNET_OK !=
2158 section,
2159 option,
2160 &list))
2161 return 0;
2162 GNUNET_assert (list != NULL);
2163 ret = 0;
2164 pos = list;
2165 while (1)
2166 {
2167 while (pos[0] == ' ')
2168 pos++;
2169 if (strlen (pos) == 0)
2170 break;
2171 end = pos + 1;
2172 while ((end[0] != ' ') && (end[0] != '\0'))
2173 {
2174 if (end[0] == '\\')
2175 {
2176 switch (end[1])
2177 {
2178 case '\\':
2179 case ' ':
2180 memmove (end, &end[1], strlen (&end[1]) + 1);
2181
2182 case '\0':
2183 /* illegal, but just keep it */
2184 break;
2185
2186 default:
2187 /* illegal, but just ignore that there was a '/' */
2188 break;
2189 }
2190 }
2191 end++;
2192 }
2193 old = end[0];
2194 end[0] = '\0';
2195 if (strlen (pos) > 0)
2196 {
2197 ret++;
2198 if ( (NULL != cb) &&
2199 (GNUNET_OK != cb (cb_cls,
2200 pos)))
2201 {
2203 break;
2204 }
2205 }
2206 if (old == '\0')
2207 break;
2208 pos = end + 1;
2209 }
2210 GNUNET_free (list);
2211 return ret;
2212}
static int list
Set if we should print a list of currently running services.
Definition: gnunet-arm.c:68

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

Referenced by GNUNET_CONFIGURATION_append_value_filename().

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

◆ GNUNET_CONFIGURATION_iterate_section_values()

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

Iterate over values of a section in the configuration.

Parameters
cfgconfiguration to inspect
sectionthe section
iterfunction to call on each option
iter_clsclosure for iter

Definition at line 1425 of file configuration.c.

1430{
1431 struct ConfigSection *spos;
1432 struct ConfigEntry *epos;
1433
1434 spos = cfg->sections;
1435 while ((spos != NULL) && (0 != strcasecmp (spos->name, section)))
1436 spos = spos->next;
1437 if (NULL == spos)
1438 return;
1439 if (spos->inaccessible)
1440 {
1442 "Section '%s' is marked as inaccessible, because the configuration "
1443 " file that contains the section can't be read.\n",
1444 section);
1445 return;
1446 }
1447 for (epos = spos->entries; NULL != epos; epos = epos->next)
1448 if (NULL != epos->val)
1449 iter (iter_cls, spos->name, epos->key, epos->val);
1450}
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 authorize_endpoint(), auto_config_cb(), get_cont(), GNUNET_CONFIGURATION_config_tool_run(), and run().

Here is the caller graph for this function:

◆ GNUNET_CONFIGURATION_get_value_choice()

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

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

Parameters
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_NO if option is not set GNUNET_SYSERR on error (value not in choices)

Definition at line 1802 of file configuration.c.

1808{
1809 struct ConfigEntry *e;
1810 unsigned int i;
1811
1812 if (NULL == (e = find_entry (cfg,
1813 section,
1814 option)))
1815 return GNUNET_NO;
1816 for (i = 0; NULL != choices[i]; i++)
1817 if (0 == strcasecmp (choices[i], e->val))
1818 break;
1819 if (NULL == choices[i])
1820 {
1822 _ ("Configuration value '%s' for '%s'"
1823 " in section '%s' is not in set of legal choices\n"),
1824 e->val,
1825 option,
1826 section);
1827 return GNUNET_SYSERR;
1828 }
1829 *value = choices[i];
1830 return GNUNET_OK;
1831}

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

Referenced by GNUNET_CONFIGURATION_get_value_yesno(), and start_process().

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

◆ GNUNET_CONFIGURATION_get_value_yesno()

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

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

Parameters
cfgconfiguration to inspect
sectionsection of interest
optionoption of interest
Returns
GNUNET_OK if option is set to "YES" GNUNET_NO if option is not set or "NO" GNUNET_SYSERR on error (neither YES nor NO)

Definition at line 2115 of file configuration.c.

2119{
2120 static const char *yesno[] = {
2121 "YES",
2122 "NO",
2123 NULL
2124 };
2125 const char *val;
2127
2128 ret =
2130 section,
2131 option,
2132 yesno,
2133 &val);
2134 if (GNUNET_OK != ret)
2135 return ret;
2136 if (val == yesno[0])
2137 return GNUNET_YES;
2138 return GNUNET_NO;
2139}
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.

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

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

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

◆ GNUNET_CONFIGURATION_get_data()

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

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

Parameters
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 1835 of file configuration.c.

1840{
1841 char *enc;
1842 int res;
1843 size_t data_size;
1844
1845 if (GNUNET_OK !=
1846 (res =
1848 section,
1849 option,
1850 &enc)))
1851 return res;
1852 data_size = (strlen (enc) * 5) / 8;
1853 if (data_size != buf_size)
1854 {
1855 GNUNET_free (enc);
1856 return GNUNET_SYSERR;
1857 }
1858 if (GNUNET_OK !=
1860 strlen (enc),
1861 buf,
1862 buf_size))
1863 {
1864 GNUNET_free (enc);
1865 return GNUNET_SYSERR;
1866 }
1867 GNUNET_free (enc);
1868 return GNUNET_OK;
1869}
static OpusEncoder * enc
OPUS encoder.
static char * res
Currently read line or NULL on EOF.
static size_t data_size
Number of bytes in data.
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:789

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

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

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

◆ GNUNET_CONFIGURATION_expand_dollar()

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

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

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

Parameters
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 2059 of file configuration.c.

2062{
2063 char *dup;
2064 size_t i;
2065 size_t len;
2066
2067 for (i = 0; '\0' != orig[i]; i++)
2068 {
2069 if ('$' != orig[i])
2070 continue;
2071 dup = GNUNET_strdup (orig + i);
2072 dup = expand_dollar (cfg, dup, 0);
2073 GNUNET_assert (NULL != dup); /* make compiler happy */
2074 len = strlen (dup) + 1;
2075 orig = GNUNET_realloc (orig, i + len);
2076 GNUNET_memcpy (orig + i, dup, len);
2077 GNUNET_free (dup);
2078 }
2079 return orig;
2080}
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, and GNUNET_strdup.

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

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

◆ GNUNET_CONFIGURATION_set_value_number()

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

Set a configuration value that should be a number.

Parameters
cfgconfiguration to update
sectionsection of interest
optionoption of interest
numbervalue to set

Definition at line 1654 of file configuration.c.

1658{
1659 char s[64];
1660
1661 GNUNET_snprintf (s,
1662 64,
1663 "%llu",
1664 number);
1666 section,
1667 option,
1668 s);
1669}
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.

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

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

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

◆ GNUNET_CONFIGURATION_set_value_string()

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

Set a configuration value that should be a string.

Parameters
cfgconfiguration to update
sectionsection of interest
optionoption of interest
valuevalue to set

Definition at line 1611 of file configuration.c.

1616{
1617 struct ConfigSection *sec;
1618 struct ConfigEntry *e;
1619 char *nv;
1620
1621 e = find_entry (cfg, section, option);
1622 if (NULL != e)
1623 {
1624 if (NULL == value)
1625 {
1626 GNUNET_free (e->val);
1627 e->val = NULL;
1628 }
1629 else
1630 {
1631 nv = GNUNET_strdup (value);
1632 GNUNET_free (e->val);
1633 e->val = nv;
1634 }
1635 return;
1636 }
1637 sec = find_section (cfg, section);
1638 if (sec == NULL)
1639 {
1640 sec = GNUNET_new (struct ConfigSection);
1641 sec->name = GNUNET_strdup (section);
1642 sec->next = cfg->sections;
1643 cfg->sections = sec;
1644 }
1645 e = GNUNET_new (struct ConfigEntry);
1646 e->key = GNUNET_strdup (option);
1647 e->val = GNUNET_strdup (value);
1648 e->next = sec->entries;
1649 sec->entries = e;
1650}
static struct ConfigSection * find_section(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section)
Find a section entry from a configuration.

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

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

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

◆ GNUNET_CONFIGURATION_remove_value_filename()

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

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

Parameters
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 2310 of file configuration.c.

2315{
2316 char *list;
2317 char *pos;
2318 char *end;
2319 char *match;
2320 char old;
2321
2322 if (GNUNET_OK !=
2324 section,
2325 option,
2326 &list))
2327 return GNUNET_NO;
2328 match = escape_name (value);
2329 pos = list;
2330 while (1)
2331 {
2332 while (pos[0] == ' ')
2333 pos++;
2334 if (strlen (pos) == 0)
2335 break;
2336 end = pos + 1;
2337 while ((end[0] != ' ') && (end[0] != '\0'))
2338 {
2339 if (end[0] == '\\')
2340 {
2341 switch (end[1])
2342 {
2343 case '\\':
2344 case ' ':
2345 end++;
2346 break;
2347
2348 case '\0':
2349 /* illegal, but just keep it */
2350 break;
2351
2352 default:
2353 /* illegal, but just ignore that there was a '/' */
2354 break;
2355 }
2356 }
2357 end++;
2358 }
2359 old = end[0];
2360 end[0] = '\0';
2361 if (0 == strcmp (pos, match))
2362 {
2363 if (old != '\0')
2364 memmove (pos,
2365 &end[1],
2366 strlen (&end[1]) + 1);
2367 else
2368 {
2369 if (pos != list)
2370 pos[-1] = '\0';
2371 else
2372 pos[0] = '\0';
2373 }
2375 section,
2376 option,
2377 list);
2378 GNUNET_free (list);
2379 GNUNET_free (match);
2380 return GNUNET_OK;
2381 }
2382 if (old == '\0')
2383 break;
2384 end[0] = old;
2385 pos = end + 1;
2386 }
2387 GNUNET_free (list);
2388 GNUNET_free (match);
2389 return GNUNET_NO;
2390}
static char * escape_name(const char *value)
FIXME.

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

Here is the call graph for this function:

◆ GNUNET_CONFIGURATION_append_value_filename()

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

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

Parameters
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 2272 of file configuration.c.

2277{
2278 char *escaped;
2279 char *old;
2280 char *nw;
2281
2282 if (GNUNET_SYSERR ==
2284 section,
2285 option,
2286 &test_match,
2287 (void *) value))
2288 return GNUNET_NO; /* already exists */
2289 if (GNUNET_OK !=
2290 GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &old))
2291 old = GNUNET_strdup ("");
2292 escaped = escape_name (value);
2293 nw = GNUNET_malloc (strlen (old) + strlen (escaped) + 2);
2294 strcpy (nw, old);
2295 if (strlen (old) > 0)
2296 strcat (nw, " ");
2297 strcat (nw, escaped);
2299 section,
2300 option,
2301 nw);
2302 GNUNET_free (old);
2303 GNUNET_free (nw);
2304 GNUNET_free (escaped);
2305 return GNUNET_OK;
2306}
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 cfg, escape_name(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_iterate_value_filenames(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_malloc, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, test_match(), and value.

Here is the call graph for this function:

◆ GNUNET_CONFIGURATION_config_settings_free()

void GNUNET_CONFIGURATION_config_settings_free ( struct GNUNET_CONFIGURATION_ConfigSettings cs)

Free resources associated with cs.

Parameters
[in]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{
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. */
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);
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:83
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.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
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.
char * GNUNET_CONFIGURATION_serialize_diagnostics(const struct GNUNET_CONFIGURATION_Handle *cfg)
Serializes the given configuration with diagnostics information.
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:253
#define EXIT_NOTCONFIGURED
Definition: platform.h:269
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, value, and GNUNET_CONFIGURATION_ConfigSettings::value.

Referenced by main().

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