networkd: Perform port setup from configuration

[people/ms/network.git] / src / networkd / port.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 <limits.h>
#include <net/if.h>
#include <stdlib.h>

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

struct nw_port {
	int nrefs;

	char name[IF_NAMESIZE];
	nw_port_type_t type;

	// Configuration
	struct nw_config *config;
};

static const struct nw_port_type_map {
	nw_port_type_t type;
	const char* name;
} nw_port_type_map[] = {
	{ NW_PORT_DUMMY, "dummy" },
	{ NW_PORT_UNKNOWN, NULL },
};

static nw_port_type_t nw_port_type_from_string(const char* s) {
	const struct nw_port_type_map* map = NULL;

	for (map = nw_port_type_map; *map->name; map++) {
		if (strcmp(map->name, s) == 0)
			return map->type;
	}

	return NW_PORT_UNKNOWN;
}

static void nw_port_free(struct nw_port* port) {
	if (port->config)
		nw_config_unref(port->config);

	free(port);
}

static int nw_port_setup_common(struct nw_port* port) {
	return 0; // XXX TODO
}

static nw_port_type_t nw_port_setup_type(struct nw_port* port) {
	const char* type = nw_config_get(port->config, "TYPE");
	if (!type)
		return NW_PORT_UNKNOWN;

	return nw_port_type_from_string(type);
}

static int nw_port_setup(struct nw_port* port) {
	char path[PATH_MAX];
	int r;

	// Compose the path to the main configuration file
	r = nw_path_join(path, PORT_CONFIG_DIR, port->name);
	if (r)
		return r;

	// Initialize the configuration
	r = nw_config_create(&port->config, path);
	if (r)
		return r;

	// Determine type
	port->type = nw_port_setup_type(port);
	if (!port->type) {
		ERROR("Could not determine type of port %s\n", port->name);
		return 0;
	}

	// Perform some common initialization
	r = nw_port_setup_common(port);
	if (r)
		return r;

	// Call any custom initialization
	switch (port->type) {
		// These do not need any special initialization
		case NW_PORT_DUMMY:
		case NW_PORT_UNKNOWN:
			break;
	}

	return 0;
}

int nw_port_create(struct nw_port** port, const char* name) {
	int r;

	// Allocate a new object
	struct nw_port* p = calloc(1, sizeof(*p));
	if (!p)
		return 1;

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

	// Store the name
	r = nw_string_set(p->name, name);
	if (r)
		goto ERROR;

	// Setup the port
	r = nw_port_setup(p);
	if (r)
		goto ERROR;

	*port = p;
	return 0;

ERROR:
	nw_port_free(p);
	return r;
}

struct nw_port* nw_port_ref(struct nw_port* port) {
	port->nrefs++;

	return port;
}

struct nw_port* nw_port_unref(struct nw_port* port) {
	if (--port->nrefs > 0)
		return port;

	nw_port_free(port);
	return NULL;
}

const char* nw_port_name(struct nw_port* port) {
	return port->name;
}