config: Fail if there is garbage after intergers

[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 <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/queue.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 {
	int nrefs;

	// The path to the configuration file
	char path[PATH_MAX];

	STAILQ_HEAD(entries, nw_config_entry) entries;
};

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

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) {
	// Flush all entries
	nw_config_flush(config);

	free(config);
}

int nw_config_create(nw_config** config, const char* path) {
	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);

	// Store the path
	if (path) {
		r = nw_string_set(c->path, path);
		if (r)
			goto ERROR;

		// Try to read the configuration from path
		r = nw_config_read(c);
		if (r)
			goto ERROR;
	}

	*config = c;

	return 0;

ERROR:
	nw_config_free(c);

	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;
}

const char* nw_config_path(nw_config* config) {
	if (*config->path)
		return config->path;

	return NULL;
}

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;
}

static int nw_config_readf(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_read(nw_config* config) {
	FILE* f = NULL;
	int r;

	// We cannot read if path is not set
	if (!*config->path) {
		errno = ENOTSUP;
		return 1;
	}

	// Open the file
	f = fopen(config->path, "r");
	if (!f) {
		// Silently ignore if the file does not exist
		if (errno == ENOENT)
			return 0;

		ERROR("Could not read configuration file %s: %m\n", config->path);
		r = 1;
		goto ERROR;
	}

	// Read from file
	r = nw_config_readf(config, f);

ERROR:
	if (f)
		fclose(f);

	return r;
}

static int nw_config_writef(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;
}

int nw_config_write(nw_config* config) {
	int r;

	// We cannot write if path is not set
	if (!*config->path) {
		errno = ENOTSUP;
		return 1;
	}

	FILE* f = fopen(config->path, "w");
	if (!f) {
		ERROR("Failed to open %s for writing: %m\n", config->path);
		r = 1;
		goto ERROR;
	}

	// Write configuration
	r = nw_config_writef(config, f);

ERROR:
	if (f)
		fclose(f);

	return r;
}

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;

	// 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\n", 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 (strcmp(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");
}