[people/ms/network.git] / src / networkd / config.c

/*#############################################################################
#                                                                             #
# IPFire.org - A linux based firewall                                         #
# Copyright (C) 2023 IPFire Network Development Team                          #
#                                                                             #
# This program is free software: you can redistribute it and/or modify        #
# it under the terms of the GNU General Public License as published by        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
# GNU General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/queue.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include "address.h"
#include "config.h"
#include "logging.h"
#include "string.h"

struct nw_config_entry {
	STAILQ_ENTRY(nw_config_entry) nodes;

	char key[NETWORK_CONFIG_KEY_MAX_LENGTH];
	char value[NETWORK_CONFIG_KEY_MAX_LENGTH];
};

struct nw_config_option {
	STAILQ_ENTRY(nw_config_option) nodes;

	const char* key;
	void* value;
	size_t length;

	// Callbacks
	nw_config_option_read_callback_t read_callback;
	nw_config_option_write_callback_t write_callback;
	void* data;
};

struct nw_config {
	int nrefs;

	STAILQ_HEAD(config_entries, nw_config_entry) entries;

	// Options
	STAILQ_HEAD(parser_entries, nw_config_option) options;
};

static void nw_config_entry_free(struct nw_config_entry* entry) {
	free(entry);
}

static void nw_config_option_free(struct nw_config_option* option) {
	free(option);
}

static struct nw_config_entry* nw_config_entry_create(
		nw_config* config, const char* key) {
	int r;

	// Check input value
	if (!key) {
		errno = EINVAL;
		return NULL;
	}

	// Allocate a new object
	struct nw_config_entry* entry = calloc(1, sizeof(*entry));
	if (!entry)
		return NULL;

	// Store the key
	r = nw_string_set(entry->key, key);
	if (r)
		goto ERROR;

	// Append the new entry
	STAILQ_INSERT_TAIL(&config->entries, entry, nodes);

	return entry;

ERROR:
	nw_config_entry_free(entry);
	return NULL;
}

static void nw_config_free(nw_config* config) {
	struct nw_config_option* option = NULL;

	// Flush all entries
	nw_config_flush(config);

	// Free all options
	while (!STAILQ_EMPTY(&config->options)) {
		option = STAILQ_FIRST(&config->options);
		STAILQ_REMOVE_HEAD(&config->options, nodes);

		// Free the options
		nw_config_option_free(option);
	}

	free(config);
}

int nw_config_create(nw_config** config, FILE* f) {
	int r;

	nw_config* c = calloc(1, sizeof(*c));
	if (!c)
		return 1;

	// Initialize reference counter
	c->nrefs = 1;

	// Initialise entries
	STAILQ_INIT(&c->entries);

	// Initialise options
	STAILQ_INIT(&c->options);

	// Read configuration
	if (f) {
		r = nw_config_read(c, f);
		if (r < 0)
			goto ERROR;
	}

	*config = c;

	return 0;

ERROR:
	nw_config_free(c);

	return r;
}

int nw_config_open(nw_config** config, const char* path) {
	FILE* f = NULL;
	int r;

	// Open path
	f = fopen(path, "r");
	if (!f)
		return -errno;

	// Create a new configuration
	r = nw_config_create(config, f);

	if (f)
		fclose(f);

	return r;
}

nw_config* nw_config_ref(nw_config* config) {
	config->nrefs++;

	return config;
}

nw_config* nw_config_unref(nw_config* config) {
	if (--config->nrefs > 0)
		return config;

	nw_config_free(config);
	return NULL;
}

int nw_config_copy(nw_config* config, nw_config** copy) {
	struct nw_config_entry* entry = NULL;
	nw_config* c = NULL;
	int r;

	// Create a new configuration
	r = nw_config_create(&c, NULL);
	if (r)
		return r;

	// Copy everything
	STAILQ_FOREACH(entry, &config->entries, nodes) {
		r = nw_config_set(c, entry->key, entry->value);
		if (r)
			goto ERROR;
	}

	*copy = c;
	return 0;

ERROR:
	if (c)
		nw_config_unref(c);

	return r;
}

int nw_config_flush(nw_config* config) {
	struct nw_config_entry* entry = NULL;

	while (!STAILQ_EMPTY(&config->entries)) {
		entry = STAILQ_FIRST(&config->entries);
		STAILQ_REMOVE_HEAD(&config->entries, nodes);

		// Free the entry
		nw_config_entry_free(entry);
	}

	return 0;
}

int nw_config_read(nw_config* config, FILE* f) {
	char* line = NULL;
	size_t length = 0;
	int r;

	ssize_t bytes_read = 0;

	char* key = NULL;
	char* val = NULL;

	for (;;) {
		// Read the next line
		bytes_read = getline(&line, &length, f);
		if (bytes_read < 0)
			break;

		// Key starts at the beginning of the line
		key = line;

		// Value starts after '='
		val = strchr(line, '=');

		// Invalid line without a '=' character
		if (!val)
			continue;

		// Split the string
		*val++ = '\0';

		// Strip any whitespace from value
		r = nw_string_strip(val);
		if (r)
			break;

		// Store the setting
		r = nw_config_set(config, key, val);
		if (r)
			break;
	}

	if (line)
		free(line);

	return r;
}

int nw_config_write(nw_config* config, FILE* f) {
	struct nw_config_entry* entry = NULL;
	int r;

	STAILQ_FOREACH(entry, &config->entries, nodes) {
		// Skip if value is NULL
		if (!*entry->value)
			continue;

		// Write the entry
		r = fprintf(f, "%s=%s\n", entry->key, entry->value);
		if (r < 0) {
			ERROR("Failed to write configuration: %m\n");
			return r;
		}
	}

	return 0;
}

static struct nw_config_entry* nw_config_find(nw_config* config, const char* key) {
	struct nw_config_entry* entry = NULL;

	STAILQ_FOREACH(entry, &config->entries, nodes) {
		// Key must match
		if (strcmp(entry->key, key) != 0)
			continue;

		// Match!
		return entry;
	}

	// No match
	return NULL;
}

int nw_config_del(nw_config* config, const char* key) {
	struct nw_config_entry* entry = NULL;

	// Find an entry matching the key
	entry = nw_config_find(config, key);

	// If there is no entry, there is nothing to do
	if (!entry)
		return 0;

	// Otherwise remove the object
	STAILQ_REMOVE(&config->entries, entry, nw_config_entry, nodes);

	// Free the entry
	nw_config_entry_free(entry);

	return 0;
}

const char* nw_config_get(nw_config* config, const char* key) {
	struct nw_config_entry* entry = nw_config_find(config, key);

	// Return the value if found and set
	if (entry && *entry->value)
		return entry->value;

	// Otherwise return NULL
	return NULL;
}

int nw_config_set(nw_config* config, const char* key, const char* value) {
	struct nw_config_entry* entry = NULL;

	// Log the change
	DEBUG("%p: Setting %s = %s\n", config, key, value);

	// Delete the entry if val is NULL
	if (!value)
		return nw_config_del(config, key);

	// Find any existing entries
	entry = nw_config_find(config, key);

	// Create a new entry if it doesn't exist, yet
	if (!entry) {
		entry = nw_config_entry_create(config, key);
		if (!entry)
			return 1;
	}

	// Store the new value
	return nw_string_set(entry->value, value);
}

int nw_config_get_int(nw_config* config, const char* key, const int __default) {
	char* p = NULL;
	int r;

	const char* value = nw_config_get(config, key);

	// Return zero if not set
	if (!value)
		return __default;

	// Parse the input
	r = strtoul(value, &p, 10);

	// If we have characters following the input, we throw it away
	if (p)
		return __default;

	return r;
}

int nw_config_set_int(nw_config* config, const char* key, const int value) {
	char __value[1024];
	int r;

	// Format the value as string
	r = nw_string_format(__value, "%d", value);
	if (r)
		return r;

	return nw_config_set(config, key, __value);
}

static const char* nw_config_true[] = {
	"true",
	"yes",
	"1",
	NULL,
};

int nw_config_get_bool(nw_config* config, const char* key) {
	const char* value = nw_config_get(config, key);

	// No value indicates false
	if (!value)
		return 0;

	// Check if we match any known true words
	for (const char** s = nw_config_true; *s; s++) {
		if (strcasecmp(value, *s) == 0)
			return 1;
	}

	// No match means false
	return 0;
}

int nw_config_set_bool(nw_config* config, const char* key, const int value) {
	return nw_config_set(config, key, value ? "true" : "false");
}

/*
	Directory
*/

struct nw_configd {
	int nrefs;

	char path[PATH_MAX];
	int fd;
};

static void nw_configd_free(nw_configd* dir) {
	if (dir->fd >= 0)
		close(dir->fd);

	free(dir);
}

static int __nw_configd_create(nw_configd** dir, int fd, const char* path) {
	nw_configd* d = NULL;
	int r;

	// Allocate a new object
	d = calloc(1, sizeof(*d));
	if (!d)
		return -errno;

	// Initialize the reference counter
	d->nrefs = 1;

	// Store the file descriptor
	d->fd = dup(fd);
	if (d->fd < 0) {
		r = -errno;
		goto ERROR;
	}

	// Store path
	if (path) {
		r = nw_string_set(d->path, path);
		if (r < 0)
			goto ERROR;
	}

	*dir = d;
	return 0;

ERROR:
	nw_configd_free(d);
	return r;
}

int nw_configd_create(nw_configd** dir, const char* path) {
	int fd;

	// Open the directory
	fd = open(path, O_DIRECTORY);
	if (fd < 0) {
		ERROR("Could not open %s: %m\n", path);
		return -errno;
	}

	return __nw_configd_create(dir, fd, path);
}

nw_configd* nw_configd_ref(nw_configd* dir) {
	dir->nrefs++;

	return dir;
}

nw_configd* nw_configd_unref(nw_configd* dir) {
	if (--dir->nrefs > 0)
		return dir;

	nw_configd_free(dir);
	return NULL;
}

static int nw_configd_open(nw_configd* dir, const char* path, int flags) {
	return openat(dir->fd, path, flags);
}

FILE* nw_configd_fopen(nw_configd* dir, const char* path, const char* mode) {
	int fd;

	// Open file
	fd = nw_configd_open(dir, path, 0);
	if (fd < 0)
		return NULL;

	// Return a file handle
	return fdopen(fd, mode);
}

int nw_configd_open_config(nw_config** config, nw_configd* dir, const char* path) {
	FILE* f = NULL;
	int r;

	// Open the file
	f = nw_configd_fopen(dir, path, "r");
	if (!f)
		return -errno;

	// Create configuration
	r = nw_config_create(config, f);
	if (r < 0)
		goto ERROR;

ERROR:
	if (f)
		fclose(f);

	return r;
}

int nw_configd_unlink(nw_configd* dir, const char* path, int flags) {
	return unlinkat(dir->fd, path, flags);
}

nw_configd* nw_configd_descend(nw_configd* dir, const char* path) {
	nw_configd* d = NULL;
	char p[PATH_MAX];
	int fd = -1;
	int r;

	// Join paths
	r = nw_path_join(p, dir->path, path);
	if (r < 0)
		goto ERROR;

	// Open directory
	fd = nw_configd_open(dir, path, O_DIRECTORY);
	if (fd < 0) {
		ERROR("Could not open %s: %m\n", p);
		goto ERROR;
	}

	// Create a new config directory object
	r = __nw_configd_create(&d, fd, p);
	if (r < 0)
		goto ERROR;

ERROR:
	if (fd >= 0)
		close(fd);

	return d;
}

int nw_configd_walk(nw_configd* dir, nw_configd_walk_callback callback, void* data) {
	FILE* f = NULL;
	DIR* d = NULL;
	struct dirent* e = NULL;
	int r;

	// Re-open the directory
	d = fdopendir(dir->fd);
	if (!d) {
		r = -errno;
		goto ERROR;
	}

	// Walk trough everything
	for (;;) {
		// Read the next entry
		e = readdir(d);
		if (!e)
			break;

		// Skip anything that is not a regular file
		if (e->d_type != DT_REG)
			continue;

		// Skip hidden files
		if (e->d_name[0] == '.')
			continue;

		// Open the file
		f = nw_configd_fopen(dir, e->d_name, "r");
		if (!f) {
			r = -errno;
			goto ERROR;
		}

		// Call the callback
		r = callback(e, f, data);
		fclose(f);

		if (r < 0)
			goto ERROR;
	}

	r = 0;

ERROR:
	if (d)
		closedir(d);

	return r;
}

/*
	Options
*/

int nw_config_options_read(nw_config* config) {
	struct nw_config_option* option = NULL;
	int r;

	STAILQ_FOREACH(option, &config->options, nodes) {
		r = option->read_callback(config,
			option->key, option->value, option->length, option->data);
		if (r < 0)
			return r;
	}

	return 0;
}

int nw_config_options_write(nw_config* config) {
	struct nw_config_option* option = NULL;
	int r;

	STAILQ_FOREACH(option, &config->options, nodes) {
		r = option->write_callback(config,
			option->key, option->value, option->length, option->data);
		if (r < 0)
			return r;
	}

	return 0;
}

int nw_config_option_add(nw_config* config,
		const char* key, void* value, const size_t length,
		nw_config_option_read_callback_t read_callback,
		nw_config_option_write_callback_t write_callback, void* data) {
	// Check input
	if (!key || !value || !read_callback || !write_callback)
		return -EINVAL;

	// Allocate a new option
	struct nw_config_option* option = calloc(1, sizeof(*option));
	if (!option)
		return -errno;

	// Set key
	option->key = key;

	// Set value
	option->value = value;
	option->length = length;

	// Set callbacks
	option->read_callback = read_callback;
	option->write_callback = write_callback;
	option->data = data;

	// Append the new option
	STAILQ_INSERT_TAIL(&config->options, option, nodes);

	return 0;
}

int nw_config_read_int(nw_config* config,
		const char* key, void* value, const size_t length, void* data) {
	// Fetch the value
	*(int*)value = nw_config_get_int(config, key, -1);

	return 0;
}

int nw_config_write_int(nw_config* config,
		const char* key, const void* value, const size_t length, void* data) {
	return 0;
}

// String

int nw_config_read_string(nw_config* config,
		const char* key, void* value, const size_t length, void* data) {
	// Fetch the value
	const char* p = nw_config_get(config, key);
	if (p)
		*(const char**)value = p;

	return 0;
}

int nw_config_write_string(nw_config* config,
		const char* key, const void* value, const size_t length, void* data) {
	return nw_config_set(config, key, *(const char**)value);
}

// String Buffer

int nw_config_read_string_buffer(nw_config* config,
		const char* key, void* value, const size_t length, void* data) {
	char* string = (char*)value;

	// Fetch the value
	const char* p = nw_config_get(config, key);
	if (p)
		return __nw_string_set(string, length, p);

	return 0;
}

// String Table

int nw_config_read_string_table(nw_config* config,
		const char* key, void* value, const size_t length, void* data) {
	const char* s = NULL;
	int* v = (int*)value;

	const nw_string_table_t* table = (nw_string_table_t*)data;

	// Fetch the string
	s = nw_config_get(config, key);
	if (!s)
		return -errno;

	// Lookup the string in the table
	*v = nw_string_table_lookup_id(table, s);

	// If the result is negative, nothing was found
	if (*v < 0)
		return -EINVAL;

	return 0;
}

int nw_config_write_string_table(nw_config* config,
		const char* key, const void* value, const size_t length, void* data) {
	int* v = (int*)value;

	const nw_string_table_t* table = (nw_string_table_t*)data;

	// Lookup the string
	const char* s = nw_string_table_lookup_string(table, *v);
	if (!s)
		return -errno;

	return nw_config_set(config, key, s);
}

// Address

int nw_config_read_address(nw_config* config,
		const char* key, void* value, const size_t length, void* data) {
	nw_address_t* address = (nw_address_t*)value;
	int r;

	// Fetch the value
	const char* p = nw_config_get(config, key);
	if (!p)
		return -EINVAL;

	r = nw_address_from_string(address, p);
	if (r < 0)
		ERROR("Could not parse address: %s\n", p);

	return r;
}

int nw_config_write_address(nw_config* config,
		const char* key, const void* value, const size_t length, void* data) {
	const nw_address_t* address = (nw_address_t*)value;
	int r;

	// Format the address to string
	char* p = nw_address_to_string(address);
	if (!p)
		return -errno;

	// Store the value
	r = nw_config_set(config, key, p);
	if (r < 0)
		goto ERROR;

	// Success
	r = 0;

ERROR:
	if (p)
		free(p);

	return r;
}
Commit	Line	Data
	1	/*#############################################################################
	2	# #
	3	# IPFire.org - A linux based firewall #
	4	# Copyright (C) 2023 IPFire Network Development Team #
	5	# #
	6	# This program is free software: you can redistribute it and/or modify #
	7	# it under the terms of the GNU General Public License as published by #
	8	# the Free Software Foundation, either version 3 of the License, or #
	9	# (at your option) any later version. #
	10	# #
	11	# This program is distributed in the hope that it will be useful, #
	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of #
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
	14	# GNU General Public License for more details. #
	15	# #
	16	# You should have received a copy of the GNU General Public License #
	17	# along with this program. If not, see <http://www.gnu.org/licenses/>. #
	18	# #
	19	#############################################################################*/
	20
	21	#include <dirent.h>
	22	#include <errno.h>
	23	#include <fcntl.h>
	24	#include <limits.h>
	25	#include <stdio.h>
	26	#include <stdlib.h>
	27	#include <string.h>
	28	#include <sys/queue.h>
	29	#include <sys/types.h>
	30	#include <sys/stat.h>
	31	#include <unistd.h>
	32
	33	#include "address.h"
	34	#include "config.h"
	35	#include "logging.h"
	36	#include "string.h"
	37
	38	struct nw_config_entry {
	39	STAILQ_ENTRY(nw_config_entry) nodes;
	40
	41	char key[NETWORK_CONFIG_KEY_MAX_LENGTH];
	42	char value[NETWORK_CONFIG_KEY_MAX_LENGTH];
	43	};
	44
	45	struct nw_config_option {
	46	STAILQ_ENTRY(nw_config_option) nodes;
	47
	48	const char* key;
	49	void* value;
	50	size_t length;
	51
	52	// Callbacks
	53	nw_config_option_read_callback_t read_callback;
	54	nw_config_option_write_callback_t write_callback;
	55	void* data;
	56	};
	57
	58	struct nw_config {
	59	int nrefs;
	60
	61	STAILQ_HEAD(config_entries, nw_config_entry) entries;
	62
	63	// Options
	64	STAILQ_HEAD(parser_entries, nw_config_option) options;
	65	};
	66
	67	static void nw_config_entry_free(struct nw_config_entry* entry) {
	68	free(entry);
	69	}
	70
	71	static void nw_config_option_free(struct nw_config_option* option) {
	72	free(option);
	73	}
	74
	75	static struct nw_config_entry* nw_config_entry_create(
	76	nw_config* config, const char* key) {
	77	int r;
	78
	79	// Check input value
	80	if (!key) {
	81	errno = EINVAL;
	82	return NULL;
	83	}
	84
	85	// Allocate a new object
	86	struct nw_config_entry* entry = calloc(1, sizeof(*entry));
	87	if (!entry)
	88	return NULL;
	89
	90	// Store the key
	91	r = nw_string_set(entry->key, key);
	92	if (r)
	93	goto ERROR;
	94
	95	// Append the new entry
	96	STAILQ_INSERT_TAIL(&config->entries, entry, nodes);
	97
	98	return entry;
	99
	100	ERROR:
	101	nw_config_entry_free(entry);
	102	return NULL;
	103	}
	104
	105	static void nw_config_free(nw_config* config) {
	106	struct nw_config_option* option = NULL;
	107
	108	// Flush all entries
	109	nw_config_flush(config);
	110
	111	// Free all options
	112	while (!STAILQ_EMPTY(&config->options)) {
	113	option = STAILQ_FIRST(&config->options);
	114	STAILQ_REMOVE_HEAD(&config->options, nodes);
	115
	116	// Free the options
	117	nw_config_option_free(option);
	118	}
	119
	120	free(config);
	121	}
	122
	123	int nw_config_create(nw_config** config, FILE* f) {
	124	int r;
	125
	126	nw_config* c = calloc(1, sizeof(*c));
	127	if (!c)
	128	return 1;
	129
	130	// Initialize reference counter
	131	c->nrefs = 1;
	132
	133	// Initialise entries
	134	STAILQ_INIT(&c->entries);
	135
	136	// Initialise options
	137	STAILQ_INIT(&c->options);
	138
	139	// Read configuration
	140	if (f) {
	141	r = nw_config_read(c, f);
	142	if (r < 0)
	143	goto ERROR;
	144	}
	145
	146	*config = c;
	147
	148	return 0;
	149
	150	ERROR:
	151	nw_config_free(c);
	152
	153	return r;
	154	}
	155
	156	int nw_config_open(nw_config** config, const char* path) {
	157	FILE* f = NULL;
	158	int r;
	159
	160	// Open path
	161	f = fopen(path, "r");
	162	if (!f)
	163	return -errno;
	164
	165	// Create a new configuration
	166	r = nw_config_create(config, f);
	167
	168	if (f)
	169	fclose(f);
	170
	171	return r;
	172	}
	173
	174	nw_config* nw_config_ref(nw_config* config) {
	175	config->nrefs++;
	176
	177	return config;
	178	}
	179
	180	nw_config* nw_config_unref(nw_config* config) {
	181	if (--config->nrefs > 0)
	182	return config;
	183
	184	nw_config_free(config);
	185	return NULL;
	186	}
	187
	188	int nw_config_copy(nw_config* config, nw_config** copy) {
	189	struct nw_config_entry* entry = NULL;
	190	nw_config* c = NULL;
	191	int r;
	192
	193	// Create a new configuration
	194	r = nw_config_create(&c, NULL);
	195	if (r)
	196	return r;
	197
	198	// Copy everything
	199	STAILQ_FOREACH(entry, &config->entries, nodes) {
	200	r = nw_config_set(c, entry->key, entry->value);
	201	if (r)
	202	goto ERROR;
	203	}
	204
	205	*copy = c;
	206	return 0;
	207
	208	ERROR:
	209	if (c)
	210	nw_config_unref(c);
	211
	212	return r;
	213	}
	214
	215	int nw_config_flush(nw_config* config) {
	216	struct nw_config_entry* entry = NULL;
	217
	218	while (!STAILQ_EMPTY(&config->entries)) {
	219	entry = STAILQ_FIRST(&config->entries);
	220	STAILQ_REMOVE_HEAD(&config->entries, nodes);
	221
	222	// Free the entry
	223	nw_config_entry_free(entry);
	224	}
	225
	226	return 0;
	227	}
	228
	229	int nw_config_read(nw_config* config, FILE* f) {
	230	char* line = NULL;
	231	size_t length = 0;
	232	int r;
	233
	234	ssize_t bytes_read = 0;
	235
	236	char* key = NULL;
	237	char* val = NULL;
	238
	239	for (;;) {
	240	// Read the next line
	241	bytes_read = getline(&line, &length, f);
	242	if (bytes_read < 0)
	243	break;
	244
	245	// Key starts at the beginning of the line
	246	key = line;
	247
	248	// Value starts after '='
	249	val = strchr(line, '=');
	250
	251	// Invalid line without a '=' character
	252	if (!val)
	253	continue;
	254
	255	// Split the string
	256	*val++ = '\0';
	257
	258	// Strip any whitespace from value
	259	r = nw_string_strip(val);
	260	if (r)
	261	break;
	262
	263	// Store the setting
	264	r = nw_config_set(config, key, val);
	265	if (r)
	266	break;
	267	}
	268
	269	if (line)
	270	free(line);
	271
	272	return r;
	273	}
	274
	275	int nw_config_write(nw_config* config, FILE* f) {
	276	struct nw_config_entry* entry = NULL;
	277	int r;
	278
	279	STAILQ_FOREACH(entry, &config->entries, nodes) {
	280	// Skip if value is NULL
	281	if (!*entry->value)
	282	continue;
	283
	284	// Write the entry
	285	r = fprintf(f, "%s=%s\n", entry->key, entry->value);
	286	if (r < 0) {
	287	ERROR("Failed to write configuration: %m\n");
	288	return r;
	289	}
	290	}
	291
	292	return 0;
	293	}
	294
	295	static struct nw_config_entry* nw_config_find(nw_config* config, const char* key) {
	296	struct nw_config_entry* entry = NULL;
	297
	298	STAILQ_FOREACH(entry, &config->entries, nodes) {
	299	// Key must match
	300	if (strcmp(entry->key, key) != 0)
	301	continue;
	302
	303	// Match!
	304	return entry;
	305	}
	306
	307	// No match
	308	return NULL;
	309	}
	310
	311	int nw_config_del(nw_config* config, const char* key) {
	312	struct nw_config_entry* entry = NULL;
	313
	314	// Find an entry matching the key
	315	entry = nw_config_find(config, key);
	316
	317	// If there is no entry, there is nothing to do
	318	if (!entry)
	319	return 0;
	320
	321	// Otherwise remove the object
	322	STAILQ_REMOVE(&config->entries, entry, nw_config_entry, nodes);
	323
	324	// Free the entry
	325	nw_config_entry_free(entry);
	326
	327	return 0;
	328	}
	329
	330	const char* nw_config_get(nw_config* config, const char* key) {
	331	struct nw_config_entry* entry = nw_config_find(config, key);
	332
	333	// Return the value if found and set
	334	if (entry && *entry->value)
	335	return entry->value;
	336
	337	// Otherwise return NULL
	338	return NULL;
	339	}
	340
	341	int nw_config_set(nw_config* config, const char* key, const char* value) {
	342	struct nw_config_entry* entry = NULL;
	343
	344	// Log the change
	345	DEBUG("%p: Setting %s = %s\n", config, key, value);
	346
	347	// Delete the entry if val is NULL
	348	if (!value)
	349	return nw_config_del(config, key);
	350
	351	// Find any existing entries
	352	entry = nw_config_find(config, key);
	353
	354	// Create a new entry if it doesn't exist, yet
	355	if (!entry) {
	356	entry = nw_config_entry_create(config, key);
	357	if (!entry)
	358	return 1;
	359	}
	360
	361	// Store the new value
	362	return nw_string_set(entry->value, value);
	363	}
	364
	365	int nw_config_get_int(nw_config* config, const char* key, const int __default) {
	366	char* p = NULL;
	367	int r;
	368
	369	const char* value = nw_config_get(config, key);
	370
	371	// Return zero if not set
	372	if (!value)
	373	return __default;
	374
	375	// Parse the input
	376	r = strtoul(value, &p, 10);
	377
	378	// If we have characters following the input, we throw it away
	379	if (p)
	380	return __default;
	381
	382	return r;
	383	}
	384
	385	int nw_config_set_int(nw_config* config, const char* key, const int value) {
	386	char __value[1024];
	387	int r;
	388
	389	// Format the value as string
	390	r = nw_string_format(__value, "%d", value);
	391	if (r)
	392	return r;
	393
	394	return nw_config_set(config, key, __value);
	395	}
	396
	397	static const char* nw_config_true[] = {
	398	"true",
	399	"yes",
	400	"1",
	401	NULL,
	402	};
	403
	404	int nw_config_get_bool(nw_config* config, const char* key) {
	405	const char* value = nw_config_get(config, key);
	406
	407	// No value indicates false
	408	if (!value)
	409	return 0;
	410
	411	// Check if we match any known true words
	412	for (const char** s = nw_config_true; *s; s++) {
	413	if (strcasecmp(value, *s) == 0)
	414	return 1;
	415	}
	416
	417	// No match means false
	418	return 0;
	419	}
	420
	421	int nw_config_set_bool(nw_config* config, const char* key, const int value) {
	422	return nw_config_set(config, key, value ? "true" : "false");
	423	}
	424
	425	/*
	426	Directory
	427	*/
	428
	429	struct nw_configd {
	430	int nrefs;
	431
	432	char path[PATH_MAX];
	433	int fd;
	434	};
	435
	436	static void nw_configd_free(nw_configd* dir) {
	437	if (dir->fd >= 0)
	438	close(dir->fd);
	439
	440	free(dir);
	441	}
	442
	443	static int __nw_configd_create(nw_configd** dir, int fd, const char* path) {
	444	nw_configd* d = NULL;
	445	int r;
	446
	447	// Allocate a new object
	448	d = calloc(1, sizeof(*d));
	449	if (!d)
	450	return -errno;
	451
	452	// Initialize the reference counter
	453	d->nrefs = 1;
	454
	455	// Store the file descriptor
	456	d->fd = dup(fd);
	457	if (d->fd < 0) {
	458	r = -errno;
	459	goto ERROR;
	460	}
	461
	462	// Store path
	463	if (path) {
	464	r = nw_string_set(d->path, path);
	465	if (r < 0)
	466	goto ERROR;
	467	}
	468
	469	*dir = d;
	470	return 0;
	471
	472	ERROR:
	473	nw_configd_free(d);
	474	return r;
	475	}
	476
	477	int nw_configd_create(nw_configd** dir, const char* path) {
	478	int fd;
	479
	480	// Open the directory
	481	fd = open(path, O_DIRECTORY);
	482	if (fd < 0) {
	483	ERROR("Could not open %s: %m\n", path);
	484	return -errno;
	485	}
	486
	487	return __nw_configd_create(dir, fd, path);
	488	}
	489
	490	nw_configd* nw_configd_ref(nw_configd* dir) {
	491	dir->nrefs++;
	492
	493	return dir;
	494	}
	495
	496	nw_configd* nw_configd_unref(nw_configd* dir) {
	497	if (--dir->nrefs > 0)
	498	return dir;
	499
	500	nw_configd_free(dir);
	501	return NULL;
	502	}
	503
	504	static int nw_configd_open(nw_configd* dir, const char* path, int flags) {
	505	return openat(dir->fd, path, flags);
	506	}
	507
	508	FILE* nw_configd_fopen(nw_configd* dir, const char* path, const char* mode) {
	509	int fd;
	510
	511	// Open file
	512	fd = nw_configd_open(dir, path, 0);
	513	if (fd < 0)
	514	return NULL;
	515
	516	// Return a file handle
	517	return fdopen(fd, mode);
	518	}
	519
	520	int nw_configd_open_config(nw_config** config, nw_configd* dir, const char* path) {
	521	FILE* f = NULL;
	522	int r;
	523
	524	// Open the file
	525	f = nw_configd_fopen(dir, path, "r");
	526	if (!f)
	527	return -errno;
	528
	529	// Create configuration
	530	r = nw_config_create(config, f);
	531	if (r < 0)
	532	goto ERROR;
	533
	534	ERROR:
	535	if (f)
	536	fclose(f);
	537
	538	return r;
	539	}
	540
	541	int nw_configd_unlink(nw_configd* dir, const char* path, int flags) {
	542	return unlinkat(dir->fd, path, flags);
	543	}
	544
	545	nw_configd* nw_configd_descend(nw_configd* dir, const char* path) {
	546	nw_configd* d = NULL;
	547	char p[PATH_MAX];
	548	int fd = -1;
	549	int r;
	550
	551	// Join paths
	552	r = nw_path_join(p, dir->path, path);
	553	if (r < 0)
	554	goto ERROR;
	555
	556	// Open directory
	557	fd = nw_configd_open(dir, path, O_DIRECTORY);
	558	if (fd < 0) {
	559	ERROR("Could not open %s: %m\n", p);
	560	goto ERROR;
	561	}
	562
	563	// Create a new config directory object
	564	r = __nw_configd_create(&d, fd, p);
	565	if (r < 0)
	566	goto ERROR;
	567
	568	ERROR:
	569	if (fd >= 0)
	570	close(fd);
	571
	572	return d;
	573	}
	574
	575	int nw_configd_walk(nw_configd* dir, nw_configd_walk_callback callback, void* data) {
	576	FILE* f = NULL;
	577	DIR* d = NULL;
	578	struct dirent* e = NULL;
	579	int r;
	580
	581	// Re-open the directory
	582	d = fdopendir(dir->fd);
	583	if (!d) {
	584	r = -errno;
	585	goto ERROR;
	586	}
	587
	588	// Walk trough everything
	589	for (;;) {
	590	// Read the next entry
	591	e = readdir(d);
	592	if (!e)
	593	break;
	594
	595	// Skip anything that is not a regular file
	596	if (e->d_type != DT_REG)
	597	continue;
	598
	599	// Skip hidden files
	600	if (e->d_name[0] == '.')
	601	continue;
	602
	603	// Open the file
	604	f = nw_configd_fopen(dir, e->d_name, "r");
	605	if (!f) {
	606	r = -errno;
	607	goto ERROR;
	608	}
	609
	610	// Call the callback
	611	r = callback(e, f, data);
	612	fclose(f);
	613
	614	if (r < 0)
	615	goto ERROR;
	616	}
	617
	618	r = 0;
	619
	620	ERROR:
	621	if (d)
	622	closedir(d);
	623
	624	return r;
	625	}
	626
	627	/*
	628	Options
	629	*/
	630
	631	int nw_config_options_read(nw_config* config) {
	632	struct nw_config_option* option = NULL;
	633	int r;
	634
	635	STAILQ_FOREACH(option, &config->options, nodes) {
	636	r = option->read_callback(config,
	637	option->key, option->value, option->length, option->data);
	638	if (r < 0)
	639	return r;
	640	}
	641
	642	return 0;
	643	}
	644
	645	int nw_config_options_write(nw_config* config) {
	646	struct nw_config_option* option = NULL;
	647	int r;
	648
	649	STAILQ_FOREACH(option, &config->options, nodes) {
	650	r = option->write_callback(config,
	651	option->key, option->value, option->length, option->data);
	652	if (r < 0)
	653	return r;
	654	}
	655
	656	return 0;
	657	}
	658
	659	int nw_config_option_add(nw_config* config,
	660	const char* key, void* value, const size_t length,
	661	nw_config_option_read_callback_t read_callback,
	662	nw_config_option_write_callback_t write_callback, void* data) {
	663	// Check input
	664	if (!key \|\| !value \|\| !read_callback \|\| !write_callback)
	665	return -EINVAL;
	666
	667	// Allocate a new option
	668	struct nw_config_option* option = calloc(1, sizeof(*option));
	669	if (!option)
	670	return -errno;
	671
	672	// Set key
	673	option->key = key;
	674
	675	// Set value
	676	option->value = value;
	677	option->length = length;
	678
	679	// Set callbacks
	680	option->read_callback = read_callback;
	681	option->write_callback = write_callback;
	682	option->data = data;
	683
	684	// Append the new option
	685	STAILQ_INSERT_TAIL(&config->options, option, nodes);
	686
	687	return 0;
	688	}
	689
	690	int nw_config_read_int(nw_config* config,
	691	const char* key, void* value, const size_t length, void* data) {
	692	// Fetch the value
	693	(int)value = nw_config_get_int(config, key, -1);
	694
	695	return 0;
	696	}
	697
	698	int nw_config_write_int(nw_config* config,
	699	const char* key, const void* value, const size_t length, void* data) {
	700	return 0;
	701	}
	702
	703	// String
	704
	705	int nw_config_read_string(nw_config* config,
	706	const char* key, void* value, const size_t length, void* data) {
	707	// Fetch the value
	708	const char* p = nw_config_get(config, key);
	709	if (p)
	710	(const char*)value = p;
	711
	712	return 0;
	713	}
	714
	715	int nw_config_write_string(nw_config* config,
	716	const char* key, const void* value, const size_t length, void* data) {
	717	return nw_config_set(config, key, (const char*)value);
	718	}
	719
	720	// String Buffer
	721
	722	int nw_config_read_string_buffer(nw_config* config,
	723	const char* key, void* value, const size_t length, void* data) {
	724	char* string = (char*)value;
	725
	726	// Fetch the value
	727	const char* p = nw_config_get(config, key);
	728	if (p)
	729	return __nw_string_set(string, length, p);
	730
	731	return 0;
	732	}
	733
	734	// String Table
	735
	736	int nw_config_read_string_table(nw_config* config,
	737	const char* key, void* value, const size_t length, void* data) {
	738	const char* s = NULL;
	739	int* v = (int*)value;
	740
	741	const nw_string_table_t* table = (nw_string_table_t*)data;
	742
	743	// Fetch the string
	744	s = nw_config_get(config, key);
	745	if (!s)
	746	return -errno;
	747
	748	// Lookup the string in the table
	749	*v = nw_string_table_lookup_id(table, s);
	750
	751	// If the result is negative, nothing was found
	752	if (*v < 0)
	753	return -EINVAL;
	754
	755	return 0;
	756	}
	757
	758	int nw_config_write_string_table(nw_config* config,
	759	const char* key, const void* value, const size_t length, void* data) {
	760	int* v = (int*)value;
	761
	762	const nw_string_table_t* table = (nw_string_table_t*)data;
	763
	764	// Lookup the string
	765	const char* s = nw_string_table_lookup_string(table, *v);
	766	if (!s)
	767	return -errno;
	768
	769	return nw_config_set(config, key, s);
	770	}
	771
	772	// Address
	773
	774	int nw_config_read_address(nw_config* config,
	775	const char* key, void* value, const size_t length, void* data) {
	776	nw_address_t* address = (nw_address_t*)value;
	777	int r;
	778
	779	// Fetch the value
	780	const char* p = nw_config_get(config, key);
	781	if (!p)
	782	return -EINVAL;
	783
	784	r = nw_address_from_string(address, p);
	785	if (r < 0)
	786	ERROR("Could not parse address: %s\n", p);
	787
	788	return r;
	789	}
	790
	791	int nw_config_write_address(nw_config* config,
	792	const char* key, const void* value, const size_t length, void* data) {
	793	const nw_address_t* address = (nw_address_t*)value;
	794	int r;
	795
	796	// Format the address to string
	797	char* p = nw_address_to_string(address);
	798	if (!p)
	799	return -errno;
	800
	801	// Store the value
	802	r = nw_config_set(config, key, p);
	803	if (r < 0)
	804	goto ERROR;
	805
	806	// Success
	807	r = 0;
	808
	809	ERROR:
	810	if (p)
	811	free(p);
	812
	813	return r;
	814	}