networkd: config: Add functions to handle boolean values

[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 <stdint.h>
#include <stdlib.h>

#include <systemd/sd-bus.h>

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

struct nw_port {
	nw_daemon* daemon;
	int nrefs;

	// Link
	nw_link* link;

	char name[IF_NAMESIZE];
	nw_port_type_t type;

	// Configuration
	nw_config *config;

	// Common attributes
	nw_address_t address;
};

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(nw_port* port) {
	if (port->link)
		nw_link_unref(port->link);
	if (port->config)
		nw_config_unref(port->config);
	if (port->daemon)
		nw_daemon_unref(port->daemon);

	free(port);
}

static int nw_port_setup_address(nw_port* port) {
	int r;

	// Read ADDRESS from configuration
	const char* s = nw_config_get(port->config, "ADDRESS");
	if (!s) {
		ERROR("Port %s: Address isn't set\n", port->name);
		goto ERROR;
	}

	// Parse the address
	r = nw_address_from_string(&port->address, s);
	if (r) {
		ERROR("Port %s: Could not parse address: %m\n", port->name);
		goto ERROR;
	}

	// Check if this address is usable
	r = nw_address_is_multicast(&port->address);
	if (r) {
		DEBUG("Port %s: Multicast bit is set on Ethernet address\n", port->name);
		goto ERROR;
	}

	return 0;

ERROR:
	// Generate a random Ethernet address
	r = nw_address_generate(&port->address);
	if (r) {
		ERROR("Could not generate a random Ethernet address: %m\n");
		return r;
	}

	return 0;
}

static int nw_port_setup_common(nw_port* port) {
	int r;

	// Address
	r = nw_port_setup_address(port);
	if (r)
		return r;

	return 0;
}

static nw_port_type_t nw_port_setup_type(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(nw_port* port) {
	char path[PATH_MAX];
	int r;

	// Find the link
	port->link = nw_daemon_get_link_by_name(port->daemon, port->name);
	if (port->link) {
		DEBUG("%s: Found matching link %d\n", port->name, nw_link_ifindex(port->link));
	} else {
		DEBUG("%s: Could not find matching link\n", port->name);
	}

	// 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(nw_port** port, nw_daemon* daemon, const char* name) {
	int r;

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

	// Store a reference to the daemon
	p->daemon = nw_daemon_ref(daemon);

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

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

	return port;
}

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

	nw_port_free(port);
	return NULL;
}

int nw_port_save(nw_port* port) {
	int r;

	r = nw_config_write(port->config);
	if (r)
		return r;

	return 0;
}

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

char* nw_port_bus_path(nw_port* port) {
	char* p = NULL;
	int r;

	// Encode the bus path
	r = sd_bus_path_encode("/org/ipfire/network1/port", port->name, &p);
	if (r < 0)
		return NULL;

	return p;
}

static nw_link* nw_port_get_link(nw_port* port) {
	if (!port->link)
		return NULL;

	return nw_link_ref(port->link);
}

const nw_address_t* nw_port_get_address(nw_port* port) {
	return &port->address;
}

int nw_port_has_carrier(nw_port* port) {
	if (!port->link)
		return 0;

	return nw_link_has_carrier(port->link);
}