[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 "port.h"
#include "port-bonding.h"
#include "port-dummy.h"
#include "port-vlan.h"
#include "stats-collector.h"
#include "string.h"

static const struct nw_port_type_map {
	nw_port_type_t type;
	const char* name;
} nw_port_type_map[] = {
	{ NW_PORT_BONDING, "bonding" },
	{ NW_PORT_DUMMY,   "dummy" },
	{ NW_PORT_VLAN,    "vlan" },
	{ 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) {
	char* __address = NULL;
	int r;

	// Read ADDRESS from configuration
	const char* s = nw_config_get(port->config, "ADDRESS");
	if (!s) {
		ERROR("Port %s: Address is not 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;
	}

	// Format the generated address
	__address = nw_address_to_string(&port->address);
	if (__address) {
		ERROR("Generated a random Ethernet address for %s: %s\n", port->name, __address);

		// Free the address
		free(__address);
	}

	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 int nw_port_set_link(nw_port* port, nw_link* link) {
	// Do nothing if the same link is being re-assigned
	if (port->link == link)
		return 0;

	// Dereference the former link if set
	if (port->link)
		nw_link_unref(port->link);

	// Store the new link
	if (link) {
		port->link = nw_link_ref(link);

		DEBUG("Port %s: Assigned link %d\n", port->name, nw_link_ifindex(port->link));

	// Or clear the pointer if no link has been provided
	} else {
		port->link = NULL;

		DEBUG("Port %s: Removed link\n", port->name);
	}

	return 0;
}

static int nw_port_setup(nw_port* port) {
	nw_link* link = NULL;
	char path[PATH_MAX];
	int r;

	// Find the link
	link = nw_daemon_get_link_by_name(port->daemon, port->name);
	if (link) {
		r = nw_port_set_link(port, link);
		if (r)
			goto ERROR;
	}

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

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

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

	// Call any custom initialization
	if (NW_PORT_OPS(port)->config_read) {
		r = NW_PORT_OPS(port)->config_read(port);
		if (r)
			goto ERROR;
	}

ERROR:
	if (link)
		nw_link_unref(link);

	return r;
}

int nw_port_create(nw_port** port, nw_daemon* daemon, nw_port_type_t type, 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 type
	p->type = type;

	// Set operations
	switch (p->type) {
		case NW_PORT_BONDING:
			p->info = &nw_port_info_bonding;
			break;

		case NW_PORT_DUMMY:
			p->info = &nw_port_info_dummy;
			break;

		case NW_PORT_VLAN:
			p->info = &nw_port_info_vlan;
			break;
	}

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

int nw_port_create_from_config(nw_port** port, nw_daemon* daemon,
		const char* name, const char* path) {
	nw_config* config = NULL;
	int r;

	// Initialize the configuration
	r = nw_config_create(&config, path);
	if (r)
		goto ERROR;

	// Fetch the type
	const char* type = nw_config_get(config, "TYPE");
	if (!type) {
		ERROR("Port configuration %s has no TYPE\n", path);
		r = 1;
		goto ERROR;
	}

	// Create a new port
	r = nw_port_create(port, daemon, nw_port_type_from_string(type), name);
	if (r)
		goto ERROR;

ERROR:
	if (config)
		nw_config_unref(config);

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

/*
	This is a helper function for when we pass a reference to the event loop
	it will have to dereference the port instance later.
*/
static void __nw_port_unref(void* data) {
	nw_port* port = (nw_port*)data;

	nw_port_unref(port);
}

int nw_port_destroy(nw_port* port) {
	int r;

	DEBUG("Destroying port %s\n", port->name);

	// Destroy the physical link (if exists)
	if (port->link) {
		r = nw_link_destroy(port->link);
		if (r)
			return r;
	}

	// Dereference the port from other ports
	r = nw_daemon_ports_walk(port->daemon, __nw_port_drop_port, port);
	if (r)
		return r;

	// Dereference the port from other zones
	r = nw_daemon_zones_walk(port->daemon, __nw_zone_drop_port, port);
	if (r)
		return r;

	// Destroy the configuration
	r = nw_config_destroy(port->config);
	if (r)
		return r;

	// Reset type
	port->type = NW_PORT_UNKNOWN;

	return 0;
}

int __nw_port_drop_port(nw_daemon* daemon, nw_port* port, void* data) {
	nw_port* dropped_port = (nw_port*)data;
	int r;

	switch (port->type) {
		case NW_PORT_VLAN:
			if (port->vlan.parent == dropped_port) {
				r = nw_port_set_vlan_parent(port, NULL);
				if (r)
					return r;
			}
			break;

		case NW_PORT_BONDING:
		case NW_PORT_DUMMY:
		case NW_PORT_UNKNOWN:
			break;
	}

	return 0;
}

int nw_port_save(nw_port* port) {
	int r;

	// Call the custom handler
	if (NW_PORT_OPS(port)->config_write) {
		r = NW_PORT_OPS(port)->config_write(port);
		if (r)
			goto ERROR;
	}

	// Write the configuration
	r = nw_config_write(port->config);
	if (r)
		return r;

	return 0;

ERROR:
	ERROR("Could not save configuration for port %s: %m\n", port->name);

	return 1;
}

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

int __nw_port_set_link(nw_daemon* daemon, nw_port* port, void* data) {
	nw_link* link = (nw_link*)data;

	// Fetch the link name
	const char* ifname = nw_link_ifname(link);
	if (!ifname) {
		ERROR("Link does not have a name set\n");
		return 1;
	}

	// Set link if the name matches
	if (strcmp(port->name, ifname) == 0)
		return nw_port_set_link(port, link);

	// If we have the link set but the name did not match, we will remove it
	else if (port->link == link)
		return nw_port_set_link(port, NULL);

	return 0;
}

int __nw_port_drop_link(nw_daemon* daemon, nw_port* port, void* data) {
	nw_link* link = (nw_link*)data;

	// Drop the link if it matches
	if (port->link == link)
		return nw_port_set_link(port, NULL);

	return 0;
}

static nw_link* nw_port_get_link(nw_port* port) {
	// Fetch the link if not set
	if (!port->link)
		port->link = nw_daemon_get_link_by_name(port->daemon, port->name);

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

static int nw_port_is_disabled(nw_port* port) {
	return nw_config_get_bool(port->config, "DISABLED");
}

nw_port* nw_port_get_parent_port(nw_port* port) {
	if (!NW_PORT_OPS(port)->get_parent_port)
		return NULL;

	return NW_PORT_OPS(port)->get_parent_port(port);
}

static nw_link* nw_port_get_parent_link(nw_port* port) {
	nw_port* parent = NULL;
	nw_link* link = NULL;

	// Fetch the parent
	parent = nw_port_get_parent_port(port);
	if (!parent)
		return NULL;

	// Fetch the link
	link = nw_port_get_link(parent);

	// Cleanup
	if (parent)
		nw_port_unref(parent);

	return link;
}

static int __nw_port_create_link(sd_netlink* rtnl, sd_netlink_message* m, void* data) {
	nw_port* port = (nw_port*)data;
	int r;

	// Check if the operation was successful
	r = sd_netlink_message_get_errno(m);
	if (r < 0) {
		ERROR("Could not create port %s: %s\n", port->name, strerror(-r));
		// XXX We should extract the error message

		return 0;
	}

	DEBUG("Successfully created %s\n", port->name);

	return 0;
}

static int nw_port_create_link(nw_port* port) {
	sd_netlink_message* m = NULL;
	nw_link* link = NULL;
	int r;

	sd_netlink* rtnl = nw_daemon_get_rtnl(port->daemon);

	DEBUG("Creating port %s...\n", port->name);

	// Create a new link
	r = sd_rtnl_message_new_link(rtnl, &m, RTM_NEWLINK, 0);
	if (r < 0) {
		ERROR("Could not create netlink message: %m\n");
		goto ERROR;
	}

	// Set the name
	r = sd_netlink_message_append_string(m, IFLA_IFNAME, port->name);
	if (r < 0) {
		ERROR("Could not set port name: %s\n", strerror(-r));
		goto ERROR;
	}

	// XXX Set common things like MTU, etc.

	// Set Ethernet address
	r = sd_netlink_message_append_ether_addr(m, IFLA_ADDRESS, &port->address);
	if (r < 0) {
		ERROR("Could not set MAC address: %s\n", strerror(-r));
		goto ERROR;
	}

	// Fetch the parent link
	link = nw_port_get_parent_link(port);
	if (link) {
		r = sd_netlink_message_append_u32(m, IFLA_LINK, nw_link_ifindex(link));
		if (r < 0)
			goto ERROR;
	}

	// Open an IFLA_LINKINFO container
	r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
	if (r < 0)
		goto ERROR;

	// Run the custom setup
	if (NW_PORT_OPS(port)->create_link) {
		r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, NW_PORT_INFO(port)->kind);
		if (r < 0) {
			ERROR("Could not open IFLA_INFO_DATA container: %s\n", strerror(-r));
			goto ERROR;
		}

		r = NW_PORT_OPS(port)->create_link(port, m);
		if (r) {
			ERROR("Could not create port %s: %m\n", port->name);
			goto ERROR;
		}

		// Close the container
		r = sd_netlink_message_close_container(m);
		if (r < 0)
			goto ERROR;

	// Just set IFLA_INFO_KIND if there is no custom function
	} else {
		r = sd_netlink_message_append_string(m, IFLA_INFO_KIND, NW_PORT_INFO(port)->kind);
		if (r < 0)
			goto ERROR;
	}

	// Close the container
	r = sd_netlink_message_close_container(m);
	if (r < 0)
		goto ERROR;

	// Send the message
	r = sd_netlink_call_async(rtnl, NULL, m, __nw_port_create_link,
		__nw_port_unref, nw_port_ref(port), -1, NULL);
	if (r < 0) {
		ERROR("Could not send netlink message: %s\n", strerror(-r));
		goto ERROR;
	}

	r = 0;

ERROR:
	if (m)
		sd_netlink_message_unref(m);
	if (link)
		nw_link_unref(link);

	return r;
}

int nw_port_reconfigure(nw_port* port) {
	int r;

	// If the port is disabled, we will try to destroy it
	if (nw_port_is_disabled(port)) {
		if (port->link) {
			r = nw_link_destroy(port->link);
			if (r)
				return r;
		}

		return 0;
	}

	// If there is no link, we will try to create it
	if (!port->link)
		return nw_port_create_link(port);

	// XXX TODO

	return 0;
}

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

	return nw_link_has_carrier(port->link);
}

/*
	Stats
*/

const struct rtnl_link_stats64* nw_port_get_stats64(nw_port* port) {
	if (!port->link)
		return NULL;

	return nw_link_get_stats64(port->link);
}

int __nw_port_update_stats(nw_daemon* daemon, nw_port* port, void* data) {
	nw_link* link = (nw_link*)data;

	// Emit stats if link matches
	if (port->link == link)
		return nw_stats_collector_emit_port_stats(daemon, port);

	return 0;
}

int nw_port_update_stats(nw_port* port) {
	if (port->link)
		return nw_link_update_stats(port->link);

	return 0;
}

int nw_port_check_type(nw_port* port, const nw_port_type_t type) {
	if (port->type == type)
		return 0;

	errno = ENOTSUP;
	return -errno;
}
Commit	Line	Data
abeab069 MT	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
827435c8	21	#include <limits.h>
abeab069	22	#include <net/if.h>
2e7f4705	23	#include <stdint.h>
abeab069 MT	24	#include <stdlib.h>
abeab069 MT	25
7297ba7f MT	26	#include <systemd/sd-bus.h>
7297ba7f MT	27
2e7f4705	28	#include "address.h"
abeab069	29	#include "config.h"
30d4ab67	30	#include "link.h"
827435c8	31	#include "logging.h"
abeab069	32	#include "port.h"
95c5dca2	33	#include "port-bonding.h"
9e8af30e	34	#include "port-dummy.h"
ff886975	35	#include "port-vlan.h"
15240e08 MT	36	#include "stats-collector.h"
15240e08 MT	37	#include "string.h"
abeab069	38
827435c8 MT	39	static const struct nw_port_type_map {
	40	nw_port_type_t type;
	41	const char* name;
	42	} nw_port_type_map[] = {
95c5dca2	43	{ NW_PORT_BONDING, "bonding" },
c7761af8 MT	44	{ NW_PORT_DUMMY, "dummy" },
c7761af8 MT	45	{ NW_PORT_VLAN, "vlan" },
827435c8 MT	46	{ NW_PORT_UNKNOWN, NULL },
	47	};
	48
	49	static nw_port_type_t nw_port_type_from_string(const char* s) {
	50	const struct nw_port_type_map* map = NULL;
	51
	52	for (map = nw_port_type_map; *map->name; map++) {
	53	if (strcmp(map->name, s) == 0)
	54	return map->type;
	55	}
	56
	57	return NW_PORT_UNKNOWN;
	58	}
	59
2361667e	60	static void nw_port_free(nw_port* port) {
02801f0d MT	61	if (port->link)
02801f0d MT	62	nw_link_unref(port->link);
abeab069 MT	63	if (port->config)
abeab069 MT	64	nw_config_unref(port->config);
30d4ab67 MT	65	if (port->daemon)
30d4ab67 MT	66	nw_daemon_unref(port->daemon);
abeab069 MT	67
	68	free(port);
	69	}
	70
2361667e	71	static int nw_port_setup_address(nw_port* port) {
d667fff4	72	char* __address = NULL;
2e7f4705 MT	73	int r;
	74
	75	// Read ADDRESS from configuration
	76	const char* s = nw_config_get(port->config, "ADDRESS");
	77	if (!s) {
240e331b	78	ERROR("Port %s: Address is not set\n", port->name);
9a93da54	79	goto ERROR;
2e7f4705 MT	80	}
	81
	82	// Parse the address
	83	r = nw_address_from_string(&port->address, s);
	84	if (r) {
	85	ERROR("Port %s: Could not parse address: %m\n", port->name);
9a93da54	86	goto ERROR;
2e7f4705 MT	87	}
2e7f4705 MT	88
d81d9cf5 MT	89	// Check if this address is usable
	90	r = nw_address_is_multicast(&port->address);
	91	if (r) {
	92	DEBUG("Port %s: Multicast bit is set on Ethernet address\n", port->name);
	93	goto ERROR;
	94	}
2e7f4705	95
9a93da54 MT	96	return 0;
	97
	98	ERROR:
	99	// Generate a random Ethernet address
	100	r = nw_address_generate(&port->address);
	101	if (r) {
	102	ERROR("Could not generate a random Ethernet address: %m\n");
	103	return r;
	104	}
	105
d667fff4 MT	106	// Format the generated address
	107	__address = nw_address_to_string(&port->address);
	108	if (__address) {
	109	ERROR("Generated a random Ethernet address for %s: %s\n", port->name, __address);
	110
	111	// Free the address
	112	free(__address);
	113	}
	114
2e7f4705 MT	115	return 0;
	116	}
	117
2361667e	118	static int nw_port_setup_common(nw_port* port) {
2e7f4705 MT	119	int r;
	120
	121	// Address
	122	r = nw_port_setup_address(port);
	123	if (r)
	124	return r;
	125
	126	return 0;
827435c8 MT	127	}
827435c8 MT	128
611d4aca MT	129	static int nw_port_set_link(nw_port* port, nw_link* link) {
	130	// Do nothing if the same link is being re-assigned
	131	if (port->link == link)
	132	return 0;
	133
	134	// Dereference the former link if set
	135	if (port->link)
	136	nw_link_unref(port->link);
	137
	138	// Store the new link
	139	if (link) {
	140	port->link = nw_link_ref(link);
	141
	142	DEBUG("Port %s: Assigned link %d\n", port->name, nw_link_ifindex(port->link));
	143
	144	// Or clear the pointer if no link has been provided
	145	} else {
	146	port->link = NULL;
	147
	148	DEBUG("Port %s: Removed link\n", port->name);
	149	}
	150
	151	return 0;
	152	}
	153
2361667e	154	static int nw_port_setup(nw_port* port) {
611d4aca	155	nw_link* link = NULL;
827435c8 MT	156	char path[PATH_MAX];
	157	int r;
	158
02801f0d	159	// Find the link
611d4aca MT	160	link = nw_daemon_get_link_by_name(port->daemon, port->name);
	161	if (link) {
	162	r = nw_port_set_link(port, link);
	163	if (r)
	164	goto ERROR;
02801f0d MT	165	}
02801f0d MT	166
827435c8 MT	167	// Compose the path to the main configuration file
	168	r = nw_path_join(path, PORT_CONFIG_DIR, port->name);
	169	if (r)
611d4aca	170	goto ERROR;
827435c8 MT	171
	172	// Initialize the configuration
	173	r = nw_config_create(&port->config, path);
	174	if (r)
611d4aca	175	goto ERROR;
827435c8	176
827435c8 MT	177	// Perform some common initialization
	178	r = nw_port_setup_common(port);
	179	if (r)
611d4aca	180	goto ERROR;
827435c8 MT	181
827435c8 MT	182	// Call any custom initialization
89f8f6af MT	183	if (NW_PORT_OPS(port)->config_read) {
89f8f6af MT	184	r = NW_PORT_OPS(port)->config_read(port);
ff886975 MT	185	if (r)
ff886975 MT	186	goto ERROR;
827435c8 MT	187	}
827435c8 MT	188
611d4aca MT	189	ERROR:
	190	if (link)
	191	nw_link_unref(link);
	192
	193	return r;
827435c8 MT	194	}
827435c8 MT	195
06bc93d3	196	int nw_port_create(nw_port** port, nw_daemon* daemon, nw_port_type_t type, const char* name) {
abeab069 MT	197	int r;
	198
	199	// Allocate a new object
2361667e	200	nw_port* p = calloc(1, sizeof(*p));
abeab069 MT	201	if (!p)
	202	return 1;
	203
30d4ab67 MT	204	// Store a reference to the daemon
	205	p->daemon = nw_daemon_ref(daemon);
	206
abeab069 MT	207	// Initialize reference counter
	208	p->nrefs = 1;
	209
06bc93d3 MT	210	// Store the type
	211	p->type = type;
	212
9e8af30e MT	213	// Set operations
9e8af30e MT	214	switch (p->type) {
95c5dca2 MT	215	case NW_PORT_BONDING:
	216	p->info = &nw_port_info_bonding;
	217	break;
	218
9e8af30e	219	case NW_PORT_DUMMY:
89f8f6af	220	p->info = &nw_port_info_dummy;
9e8af30e	221	break;
ff886975 MT	222
ff886975 MT	223	case NW_PORT_VLAN:
89f8f6af	224	p->info = &nw_port_info_vlan;
ff886975	225	break;
9e8af30e MT	226	}
9e8af30e MT	227
abeab069 MT	228	// Store the name
	229	r = nw_string_set(p->name, name);
	230	if (r)
	231	goto ERROR;
	232
827435c8 MT	233	// Setup the port
	234	r = nw_port_setup(p);
	235	if (r)
	236	goto ERROR;
	237
abeab069 MT	238	*port = p;
	239	return 0;
	240
	241	ERROR:
	242	nw_port_free(p);
	243	return r;
	244	}
	245
06bc93d3 MT	246	int nw_port_create_from_config(nw_port** port, nw_daemon* daemon,
	247	const char* name, const char* path) {
	248	nw_config* config = NULL;
	249	int r;
	250
	251	// Initialize the configuration
	252	r = nw_config_create(&config, path);
	253	if (r)
	254	goto ERROR;
	255
	256	// Fetch the type
	257	const char* type = nw_config_get(config, "TYPE");
	258	if (!type) {
	259	ERROR("Port configuration %s has no TYPE\n", path);
	260	r = 1;
	261	goto ERROR;
	262	}
	263
	264	// Create a new port
	265	r = nw_port_create(port, daemon, nw_port_type_from_string(type), name);
	266	if (r)
	267	goto ERROR;
	268
	269	ERROR:
	270	if (config)
	271	nw_config_unref(config);
	272
	273	return r;
	274	}
	275
2361667e	276	nw_port* nw_port_ref(nw_port* port) {
abeab069 MT	277	port->nrefs++;
	278
	279	return port;
	280	}
	281
2361667e	282	nw_port* nw_port_unref(nw_port* port) {
abeab069 MT	283	if (--port->nrefs > 0)
	284	return port;
	285
	286	nw_port_free(port);
	287	return NULL;
	288	}
	289
240e331b MT	290	/*
	291	This is a helper function for when we pass a reference to the event loop
	292	it will have to dereference the port instance later.
	293	*/
	294	static void __nw_port_unref(void* data) {
	295	nw_port* port = (nw_port*)data;
	296
	297	nw_port_unref(port);
	298	}
	299
c403eb4c MT	300	int nw_port_destroy(nw_port* port) {
	301	int r;
	302
	303	DEBUG("Destroying port %s\n", port->name);
	304
	305	// Destroy the physical link (if exists)
	306	if (port->link) {
	307	r = nw_link_destroy(port->link);
	308	if (r)
	309	return r;
	310	}
	311
	312	// Dereference the port from other ports
	313	r = nw_daemon_ports_walk(port->daemon, __nw_port_drop_port, port);
	314	if (r)
	315	return r;
	316
	317	// Dereference the port from other zones
	318	r = nw_daemon_zones_walk(port->daemon, __nw_zone_drop_port, port);
	319	if (r)
	320	return r;
	321
	322	// Destroy the configuration
	323	r = nw_config_destroy(port->config);
	324	if (r)
	325	return r;
	326
	327	// Reset type
	328	port->type = NW_PORT_UNKNOWN;
	329
	330	return 0;
	331	}
	332
	333	int __nw_port_drop_port(nw_daemon* daemon, nw_port* port, void* data) {
	334	nw_port* dropped_port = (nw_port*)data;
	335	int r;
	336
	337	switch (port->type) {
	338	case NW_PORT_VLAN:
	339	if (port->vlan.parent == dropped_port) {
	340	r = nw_port_set_vlan_parent(port, NULL);
	341	if (r)
	342	return r;
	343	}
	344	break;
	345
95c5dca2	346	case NW_PORT_BONDING:
c403eb4c MT	347	case NW_PORT_DUMMY:
	348	case NW_PORT_UNKNOWN:
	349	break;
	350	}
	351
	352	return 0;
	353	}
	354
605e975f MT	355	int nw_port_save(nw_port* port) {
	356	int r;
	357
ff886975	358	// Call the custom handler
89f8f6af MT	359	if (NW_PORT_OPS(port)->config_write) {
89f8f6af MT	360	r = NW_PORT_OPS(port)->config_write(port);
ff886975 MT	361	if (r)
ff886975 MT	362	goto ERROR;
c7761af8 MT	363	}
c7761af8 MT	364
ff886975	365	// Write the configuration
605e975f MT	366	r = nw_config_write(port->config);
	367	if (r)
	368	return r;
	369
	370	return 0;
c7761af8 MT	371
	372	ERROR:
	373	ERROR("Could not save configuration for port %s: %m\n", port->name);
	374
	375	return 1;
605e975f MT	376	}
605e975f MT	377
2361667e	378	const char* nw_port_name(nw_port* port) {
abeab069 MT	379	return port->name;
abeab069 MT	380	}
7297ba7f	381
2361667e	382	char* nw_port_bus_path(nw_port* port) {
7297ba7f MT	383	char* p = NULL;
	384	int r;
	385
	386	// Encode the bus path
	387	r = sd_bus_path_encode("/org/ipfire/network1/port", port->name, &p);
	388	if (r < 0)
	389	return NULL;
	390
	391	return p;
	392	}
4a383286	393
611d4aca MT	394	int __nw_port_set_link(nw_daemon* daemon, nw_port* port, void* data) {
	395	nw_link* link = (nw_link*)data;
	396
	397	// Fetch the link name
	398	const char* ifname = nw_link_ifname(link);
	399	if (!ifname) {
	400	ERROR("Link does not have a name set\n");
	401	return 1;
	402	}
	403
	404	// Set link if the name matches
	405	if (strcmp(port->name, ifname) == 0)
	406	return nw_port_set_link(port, link);
	407
	408	// If we have the link set but the name did not match, we will remove it
	409	else if (port->link == link)
	410	return nw_port_set_link(port, NULL);
	411
	412	return 0;
	413	}
	414
	415	int __nw_port_drop_link(nw_daemon* daemon, nw_port* port, void* data) {
	416	nw_link* link = (nw_link*)data;
02801f0d	417
611d4aca MT	418	// Drop the link if it matches
	419	if (port->link == link)
	420	return nw_port_set_link(port, NULL);
	421
	422	return 0;
30d4ab67 MT	423	}
30d4ab67 MT	424
240e331b MT	425	static nw_link* nw_port_get_link(nw_port* port) {
	426	// Fetch the link if not set
	427	if (!port->link)
	428	port->link = nw_daemon_get_link_by_name(port->daemon, port->name);
	429
	430	if (!port->link)
	431	return NULL;
	432
	433	return nw_link_ref(port->link);
	434	}
	435
2361667e	436	const nw_address_t* nw_port_get_address(nw_port* port) {
4a383286 MT	437	return &port->address;
4a383286 MT	438	}
20375a08	439
371b836a MT	440	static int nw_port_is_disabled(nw_port* port) {
	441	return nw_config_get_bool(port->config, "DISABLED");
	442	}
	443
5a5c346c MT	444	nw_port* nw_port_get_parent_port(nw_port* port) {
	445	if (!NW_PORT_OPS(port)->get_parent_port)
	446	return NULL;
	447
	448	return NW_PORT_OPS(port)->get_parent_port(port);
	449	}
	450
240e331b MT	451	static nw_link* nw_port_get_parent_link(nw_port* port) {
	452	nw_port* parent = NULL;
	453	nw_link* link = NULL;
	454
240e331b	455	// Fetch the parent
5a5c346c	456	parent = nw_port_get_parent_port(port);
240e331b	457	if (!parent)
5a5c346c	458	return NULL;
240e331b MT	459
	460	// Fetch the link
	461	link = nw_port_get_link(parent);
	462
5a5c346c	463	// Cleanup
240e331b MT	464	if (parent)
	465	nw_port_unref(parent);
	466
	467	return link;
	468	}
	469
	470	static int __nw_port_create_link(sd_netlink* rtnl, sd_netlink_message* m, void* data) {
	471	nw_port* port = (nw_port*)data;
	472	int r;
	473
	474	// Check if the operation was successful
	475	r = sd_netlink_message_get_errno(m);
	476	if (r < 0) {
	477	ERROR("Could not create port %s: %s\n", port->name, strerror(-r));
	478	// XXX We should extract the error message
	479
	480	return 0;
	481	}
	482
	483	DEBUG("Successfully created %s\n", port->name);
	484
	485	return 0;
	486	}
	487
96b1b84d	488	static int nw_port_create_link(nw_port* port) {
240e331b MT	489	sd_netlink_message* m = NULL;
240e331b MT	490	nw_link* link = NULL;
ff886975 MT	491	int r;
ff886975 MT	492
240e331b MT	493	sd_netlink* rtnl = nw_daemon_get_rtnl(port->daemon);
240e331b MT	494
575d1a3f MT	495	DEBUG("Creating port %s...\n", port->name);
575d1a3f MT	496
240e331b MT	497	// Create a new link
	498	r = sd_rtnl_message_new_link(rtnl, &m, RTM_NEWLINK, 0);
	499	if (r < 0) {
	500	ERROR("Could not create netlink message: %m\n");
	501	goto ERROR;
	502	}
	503
	504	// Set the name
	505	r = sd_netlink_message_append_string(m, IFLA_IFNAME, port->name);
	506	if (r < 0) {
	507	ERROR("Could not set port name: %s\n", strerror(-r));
	508	goto ERROR;
ff886975 MT	509	}
ff886975 MT	510
1574bc00 MT	511	// XXX Set common things like MTU, etc.
1574bc00 MT	512
d667fff4	513	// Set Ethernet address
1574bc00 MT	514	r = sd_netlink_message_append_ether_addr(m, IFLA_ADDRESS, &port->address);
	515	if (r < 0) {
	516	ERROR("Could not set MAC address: %s\n", strerror(-r));
	517	goto ERROR;
	518	}
240e331b MT	519
	520	// Fetch the parent link
	521	link = nw_port_get_parent_link(port);
	522	if (link) {
	523	r = sd_netlink_message_append_u32(m, IFLA_LINK, nw_link_ifindex(link));
	524	if (r < 0)
	525	goto ERROR;
	526	}
	527
	528	// Open an IFLA_LINKINFO container
	529	r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
	530	if (r < 0)
	531	goto ERROR;
	532
	533	// Run the custom setup
89f8f6af MT	534	if (NW_PORT_OPS(port)->create_link) {
89f8f6af MT	535	r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, NW_PORT_INFO(port)->kind);
240e331b MT	536	if (r < 0) {
	537	ERROR("Could not open IFLA_INFO_DATA container: %s\n", strerror(-r));
	538	goto ERROR;
	539	}
	540
89f8f6af	541	r = NW_PORT_OPS(port)->create_link(port, m);
240e331b MT	542	if (r) {
	543	ERROR("Could not create port %s: %m\n", port->name);
	544	goto ERROR;
	545	}
	546
	547	// Close the container
	548	r = sd_netlink_message_close_container(m);
	549	if (r < 0)
	550	goto ERROR;
	551
	552	// Just set IFLA_INFO_KIND if there is no custom function
	553	} else {
89f8f6af	554	r = sd_netlink_message_append_string(m, IFLA_INFO_KIND, NW_PORT_INFO(port)->kind);
240e331b MT	555	if (r < 0)
	556	goto ERROR;
	557	}
	558
	559	// Close the container
	560	r = sd_netlink_message_close_container(m);
	561	if (r < 0)
	562	goto ERROR;
	563
	564	// Send the message
	565	r = sd_netlink_call_async(rtnl, NULL, m, __nw_port_create_link,
	566	__nw_port_unref, nw_port_ref(port), -1, NULL);
	567	if (r < 0) {
	568	ERROR("Could not send netlink message: %s\n", strerror(-r));
	569	goto ERROR;
	570	}
	571
	572	r = 0;
	573
	574	ERROR:
	575	if (m)
	576	sd_netlink_message_unref(m);
	577	if (link)
	578	nw_link_unref(link);
ff886975 MT	579
ff886975 MT	580	return r;
96b1b84d MT	581	}
96b1b84d MT	582
b9769b09	583	int nw_port_reconfigure(nw_port* port) {
371b836a MT	584	int r;
	585
	586	// If the port is disabled, we will try to destroy it
	587	if (nw_port_is_disabled(port)) {
	588	if (port->link) {
	589	r = nw_link_destroy(port->link);
	590	if (r)
	591	return r;
	592	}
	593
	594	return 0;
	595	}
	596
96b1b84d	597	// If there is no link, we will try to create it
895f7134 MT	598	if (!port->link)
895f7134 MT	599	return nw_port_create_link(port);
96b1b84d	600
371b836a	601	// XXX TODO
96b1b84d MT	602
96b1b84d MT	603	return 0;
b9769b09 MT	604	}
b9769b09 MT	605
20375a08	606	int nw_port_has_carrier(nw_port* port) {
02801f0d MT	607	if (!port->link)
02801f0d MT	608	return 0;
20375a08	609
02801f0d	610	return nw_link_has_carrier(port->link);
20375a08	611	}
15240e08 MT	612
	613	/*
	614	Stats
	615	*/
	616
	617	const struct rtnl_link_stats64* nw_port_get_stats64(nw_port* port) {
	618	if (!port->link)
	619	return NULL;
	620
	621	return nw_link_get_stats64(port->link);
	622	}
	623
	624	int __nw_port_update_stats(nw_daemon* daemon, nw_port* port, void* data) {
	625	nw_link* link = (nw_link*)data;
	626
	627	// Emit stats if link matches
	628	if (port->link == link)
	629	return nw_stats_collector_emit_port_stats(daemon, port);
	630
	631	return 0;
	632	}
	633
	634	int nw_port_update_stats(nw_port* port) {
	635	if (port->link)
	636	return nw_link_update_stats(port->link);
	637
	638	return 0;
	639	}
c7761af8	640
ff886975	641	int nw_port_check_type(nw_port* port, const nw_port_type_t type) {
c7761af8 MT	642	if (port->type == type)
	643	return 0;
	644
	645	errno = ENOTSUP;
	646	return -errno;
	647	}