[network.git] / src / networkd / link.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 <linux/if.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>

#include <systemd/sd-netlink.h>

#include "daemon.h"
#include "link.h"
#include "links.h"
#include "logging.h"
#include "string.h"

struct nw_link {
	nw_daemon* daemon;
	int nrefs;

	// Interface Index
	int ifindex;

	// Interface Name
	char ifname[IFNAMSIZ];

	// MTU
	uint32_t mtu;
	uint32_t min_mtu;
	uint32_t max_mtu;

	// Flags
	unsigned int flags;
	uint8_t operstate;
};

int nw_link_create(nw_link** link, nw_daemon* daemon, int ifindex) {
	// Allocate a new object
	nw_link* l = calloc(1, sizeof(*l));
	if (!l)
		return 1;

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

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

	// Store the ifindex
	l->ifindex = ifindex;

	DEBUG("New link allocated (ifindex = %d)\n", l->ifindex);

	*link = l;

	return 0;
}

static void nw_link_free(nw_link* link) {
	DEBUG("Freeing link (ifindex = %d)\n", link->ifindex);

	if (link->daemon)
		nw_daemon_unref(link->daemon);
}

nw_link* nw_link_ref(nw_link* link) {
	link->nrefs++;

	return link;
}

nw_link* nw_link_unref(nw_link* link) {
	if (--link->nrefs > 0)
		return link;

	nw_link_free(link);
	return NULL;
}

int nw_link_ifindex(nw_link* link) {
	return link->ifindex;
}

const char* nw_link_ifname(nw_link* link) {
	return link->ifname;
}

// Carrier

int nw_link_has_carrier(nw_link* link) {
	return link->operstate == IF_OPER_UP;
}

static int nw_link_carrier_gained(nw_link* link) {
	return 0; // XXX TODO
}

static int nw_link_carrier_lost(nw_link* link) {
	return 0; // XXX TODO
}

static int nw_link_update_ifname(nw_link* link, sd_netlink_message* message) {
	const char* ifname = NULL;
	int r;

	r = sd_netlink_message_read_string(message, IFLA_IFNAME, &ifname);
	if (r < 0) {
		ERROR("Could not read link name for link %d: %m\n", link->ifindex);
		return 1;
	}

	// Do nothing if the name is already set
	if (strcmp(link->ifname, ifname) == 0)
		return 0;

	// Otherwise update the name
	r = nw_string_set(link->ifname, ifname);
	if (r) {
		ERROR("Could not set link name: %m\n");
		return 1;
	}

	DEBUG("Link %d has been renamed to '%s'\n", link->ifindex, link->ifname);

	return 0;
}

static int nw_link_update_mtu(nw_link* link, sd_netlink_message* message) {
	uint32_t mtu = 0;
	uint32_t min_mtu = 0;
	uint32_t max_mtu = 0;
	int r;

	// Read the MTU
	r = sd_netlink_message_read_u32(message, IFLA_MTU, &mtu);
	if (r < 0) {
		ERROR("Could not read MTU for link %d: %m\n", link->ifindex);
		return r;
	}

	// Read the minimum MTU
	r = sd_netlink_message_read_u32(message, IFLA_MIN_MTU, &min_mtu);
	if (r < 0) {
		ERROR("Could not read the minimum MTU for link %d: %m\n", link->ifindex);
		return r;
	}

	// Read the maximum MTU
	r = sd_netlink_message_read_u32(message, IFLA_MAX_MTU, &max_mtu);
	if (r < 0) {
		ERROR("Could not read the maximum MTU for link %d: %m\n", link->ifindex);
		return r;
	}

	// Set the maximum MTU to infinity
	if (!max_mtu)
		max_mtu = UINT32_MAX;

	// Store min/max MTU
	link->min_mtu = min_mtu;
	link->max_mtu = max_mtu;

	// End here, if the MTU has not been changed
	if (link->mtu == mtu)
		return 0;

	DEBUG("Link %d: MTU has changed to %" PRIu32 " (min: %" PRIu32 ", max: %" PRIu32 ")\n",
		link->ifindex, link->mtu, link->min_mtu, link->max_mtu);

	// Store MTU
	link->mtu = mtu;

	return 0;
}

static int nw_link_update_flags(nw_link* link, sd_netlink_message* message) {
	unsigned int flags = 0;
	uint8_t operstate = 0;
	int r;

	// Fetch flags
	r = sd_rtnl_message_link_get_flags(message, &flags);
	if (r < 0) {
		DEBUG("Could not read link flags: %m\n");
		return 1;
	}

	// Fetch operstate
	r = sd_netlink_message_read_u8(message, IFLA_OPERSTATE, &operstate);
	if (r < 1) {
		ERROR("Could not read operstate: %m\n");
		return 1;
	}

	// End here if there have been no changes
	if (link->flags == flags && link->operstate == operstate)
		return 0;

	// XXX We should log any changes here

	// Fetch current carrier state
	const int had_carrier = nw_link_has_carrier(link);

	// Store the new flags & operstate
	link->flags = flags;
	link->operstate = operstate;

	// Notify if carrier was gained or lost
	if (!had_carrier && nw_link_has_carrier(link)) {
		r = nw_link_carrier_gained(link);
		if (r < 0)
			return r;

	} else if (had_carrier && !nw_link_has_carrier(link)) {
		r = nw_link_carrier_lost(link);
		if (r < 0)
			return r;
	}

	return 0;
}

/*
	This function is called whenever anything changes, so that we can
	update our internal link object.
*/
static int nw_link_update(nw_link* link, sd_netlink_message* message) {
	int r;

	// Update the interface name
	r = nw_link_update_ifname(link, message);
	if (r)
		return r;

	// Update the MTU
	r = nw_link_update_mtu(link, message);
	if (r)
		return r;

	// Update flags
	r = nw_link_update_flags(link, message);
	if (r)
		return r;

	return 0;
}

int nw_link_process(sd_netlink* rtnl, sd_netlink_message* message, void* data) {
	nw_links* links = NULL;
	nw_link* link = NULL;
	const char* ifname = NULL;
	int ifindex;
	uint16_t type;
	int r;

	nw_daemon* daemon = (nw_daemon*)data;

	// Fetch links
	links = nw_daemon_links(daemon);
	if (!links) {
		r = 1;
		goto ERROR;
	}

	// Check if this message could be received
	if (sd_netlink_message_is_error(message)) {
		r = sd_netlink_message_get_errno(message);
		if (r < 0)
			ERROR("Could not receive link message: %m\n");

		goto IGNORE;
	}

	// Fetch the message type
	r = sd_netlink_message_get_type(message, &type);
	if (r < 0) {
		ERROR("Could not fetch message type: %m\n");
		goto IGNORE;
	}

	// Check type
	switch (type) {
		case RTM_NEWLINK:
		case RTM_DELLINK:
			break;

		default:
			ERROR("Received an unexpected message (type %u)\n", type);
			goto IGNORE;
	}

	// Fetch the interface index
	r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
	if (r < 0) {
		ERROR("Could not fetch ifindex: %m\n");
		goto IGNORE;
	}

	// Check interface index
	if (ifindex <= 0) {
		ERROR("Received an invalid ifindex\n");
		goto IGNORE;
	}

	// Fetch the interface name
	r = sd_netlink_message_read_string(message, IFLA_IFNAME, &ifname);
	if (r < 0) {
		ERROR("Received a netlink message without interface name: %m\n");
		goto IGNORE;
	}

	// Try finding an existing link
	link = nw_daemon_get_link_by_ifindex(daemon, ifindex);

	switch (type) {
		case RTM_NEWLINK:
			// If the link doesn't exist, create it
			if (!link) {
				r = nw_link_create(&link, daemon, ifindex);
				if (r) {
					ERROR("Could not create link: %m\n");
					goto ERROR;
				}

				// Add it to the list
				r = nw_links_add_link(links, link);
				if (r)
					goto ERROR;
			}

			// Import any data from the netlink message
			r = nw_link_update(link, message);
			if (r)
				goto ERROR;

			break;

		case RTM_DELLINK:
			if (link)
				nw_links_drop_link(links, link);

			break;
	}

IGNORE:
	r = 0;

ERROR:
	if (links)
		nw_links_unref(links);
	if (link)
		nw_link_unref(link);

	return r;
}
Commit	Line	Data
87a1e1e0 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
dfd49c2c	21	#include <linux/if.h>
87a1e1e0 MT	22	#include <stddef.h>
87a1e1e0 MT	23	#include <stdlib.h>
f650f6cd	24	#include <string.h>
87a1e1e0	25
766f08ca MT	26	#include <systemd/sd-netlink.h>
766f08ca MT	27
87a1e1e0 MT	28	#include "daemon.h"
87a1e1e0 MT	29	#include "link.h"
766f08ca	30	#include "links.h"
eaf649ee	31	#include "logging.h"
f650f6cd	32	#include "string.h"
87a1e1e0 MT	33
87a1e1e0 MT	34	struct nw_link {
2361667e	35	nw_daemon* daemon;
87a1e1e0 MT	36	int nrefs;
	37
	38	// Interface Index
	39	int ifindex;
f650f6cd MT	40
f650f6cd MT	41	// Interface Name
dfd49c2c	42	char ifname[IFNAMSIZ];
f37df5ea MT	43
	44	// MTU
	45	uint32_t mtu;
	46	uint32_t min_mtu;
	47	uint32_t max_mtu;
c65300b4 MT	48
	49	// Flags
	50	unsigned int flags;
69ef50c7	51	uint8_t operstate;
87a1e1e0 MT	52	};
87a1e1e0 MT	53
2361667e	54	int nw_link_create(nw_link** link, nw_daemon* daemon, int ifindex) {
87a1e1e0	55	// Allocate a new object
2361667e	56	nw_link* l = calloc(1, sizeof(*l));
87a1e1e0 MT	57	if (!l)
	58	return 1;
	59
	60	// Store a reference to the daemon
	61	l->daemon = nw_daemon_ref(daemon);
	62
	63	// Initialize the reference counter
	64	l->nrefs = 1;
	65
	66	// Store the ifindex
	67	l->ifindex = ifindex;
	68
766f08ca MT	69	DEBUG("New link allocated (ifindex = %d)\n", l->ifindex);
766f08ca MT	70
87a1e1e0 MT	71	*link = l;
	72
	73	return 0;
	74	}
	75
2361667e	76	static void nw_link_free(nw_link* link) {
766f08ca MT	77	DEBUG("Freeing link (ifindex = %d)\n", link->ifindex);
766f08ca MT	78
87a1e1e0 MT	79	if (link->daemon)
	80	nw_daemon_unref(link->daemon);
	81	}
	82
2361667e	83	nw_link* nw_link_ref(nw_link* link) {
87a1e1e0 MT	84	link->nrefs++;
	85
	86	return link;
	87	}
	88
2361667e	89	nw_link* nw_link_unref(nw_link* link) {
87a1e1e0 MT	90	if (--link->nrefs > 0)
	91	return link;
	92
	93	nw_link_free(link);
	94	return NULL;
	95	}
eaf649ee	96
2361667e	97	int nw_link_ifindex(nw_link* link) {
766f08ca MT	98	return link->ifindex;
766f08ca MT	99	}
eaf649ee	100
207abe4e MT	101	const char* nw_link_ifname(nw_link* link) {
	102	return link->ifname;
	103	}
	104
dfd49c2c MT	105	// Carrier
	106
	107	int nw_link_has_carrier(nw_link* link) {
	108	return link->operstate == IF_OPER_UP;
	109	}
	110
	111	static int nw_link_carrier_gained(nw_link* link) {
	112	return 0; // XXX TODO
	113	}
	114
	115	static int nw_link_carrier_lost(nw_link* link) {
	116	return 0; // XXX TODO
	117	}
	118
2361667e	119	static int nw_link_update_ifname(nw_link* link, sd_netlink_message* message) {
f650f6cd MT	120	const char* ifname = NULL;
	121	int r;
	122
	123	r = sd_netlink_message_read_string(message, IFLA_IFNAME, &ifname);
	124	if (r < 0) {
	125	ERROR("Could not read link name for link %d: %m\n", link->ifindex);
	126	return 1;
	127	}
	128
	129	// Do nothing if the name is already set
	130	if (strcmp(link->ifname, ifname) == 0)
	131	return 0;
	132
	133	// Otherwise update the name
	134	r = nw_string_set(link->ifname, ifname);
	135	if (r) {
	136	ERROR("Could not set link name: %m\n");
	137	return 1;
	138	}
	139
	140	DEBUG("Link %d has been renamed to '%s'\n", link->ifindex, link->ifname);
	141
	142	return 0;
	143	}
	144
2361667e	145	static int nw_link_update_mtu(nw_link* link, sd_netlink_message* message) {
f37df5ea MT	146	uint32_t mtu = 0;
	147	uint32_t min_mtu = 0;
	148	uint32_t max_mtu = 0;
	149	int r;
	150
	151	// Read the MTU
	152	r = sd_netlink_message_read_u32(message, IFLA_MTU, &mtu);
	153	if (r < 0) {
	154	ERROR("Could not read MTU for link %d: %m\n", link->ifindex);
	155	return r;
	156	}
	157
	158	// Read the minimum MTU
	159	r = sd_netlink_message_read_u32(message, IFLA_MIN_MTU, &min_mtu);
	160	if (r < 0) {
	161	ERROR("Could not read the minimum MTU for link %d: %m\n", link->ifindex);
	162	return r;
	163	}
	164
	165	// Read the maximum MTU
	166	r = sd_netlink_message_read_u32(message, IFLA_MAX_MTU, &max_mtu);
	167	if (r < 0) {
	168	ERROR("Could not read the maximum MTU for link %d: %m\n", link->ifindex);
	169	return r;
	170	}
	171
	172	// Set the maximum MTU to infinity
	173	if (!max_mtu)
	174	max_mtu = UINT32_MAX;
	175
	176	// Store min/max MTU
	177	link->min_mtu = min_mtu;
	178	link->max_mtu = max_mtu;
	179
	180	// End here, if the MTU has not been changed
	181	if (link->mtu == mtu)
	182	return 0;
	183
	184	DEBUG("Link %d: MTU has changed to %" PRIu32 " (min: %" PRIu32 ", max: %" PRIu32 ")\n",
	185	link->ifindex, link->mtu, link->min_mtu, link->max_mtu);
	186
	187	// Store MTU
	188	link->mtu = mtu;
	189
	190	return 0;
	191	}
	192
c65300b4 MT	193	static int nw_link_update_flags(nw_link* link, sd_netlink_message* message) {
c65300b4 MT	194	unsigned int flags = 0;
69ef50c7	195	uint8_t operstate = 0;
c65300b4 MT	196	int r;
	197
	198	// Fetch flags
	199	r = sd_rtnl_message_link_get_flags(message, &flags);
	200	if (r < 0) {
1a70a686	201	DEBUG("Could not read link flags: %m\n");
c65300b4 MT	202	return 1;
	203	}
	204
69ef50c7 MT	205	// Fetch operstate
	206	r = sd_netlink_message_read_u8(message, IFLA_OPERSTATE, &operstate);
	207	if (r < 1) {
	208	ERROR("Could not read operstate: %m\n");
	209	return 1;
	210	}
	211
c65300b4	212	// End here if there have been no changes
69ef50c7	213	if (link->flags == flags && link->operstate == operstate)
c65300b4 MT	214	return 0;
	215
	216	// XXX We should log any changes here
	217
dfd49c2c MT	218	// Fetch current carrier state
	219	const int had_carrier = nw_link_has_carrier(link);
	220
69ef50c7	221	// Store the new flags & operstate
c65300b4	222	link->flags = flags;
69ef50c7 MT	223	link->operstate = operstate;
69ef50c7 MT	224
dfd49c2c MT	225	// Notify if carrier was gained or lost
	226	if (!had_carrier && nw_link_has_carrier(link)) {
	227	r = nw_link_carrier_gained(link);
	228	if (r < 0)
	229	return r;
	230
	231	} else if (had_carrier && !nw_link_has_carrier(link)) {
	232	r = nw_link_carrier_lost(link);
	233	if (r < 0)
	234	return r;
	235	}
c65300b4 MT	236
	237	return 0;
	238	}
	239
f650f6cd MT	240	/*
	241	This function is called whenever anything changes, so that we can
	242	update our internal link object.
	243	*/
2361667e	244	static int nw_link_update(nw_link* link, sd_netlink_message* message) {
f650f6cd MT	245	int r;
	246
	247	// Update the interface name
	248	r = nw_link_update_ifname(link, message);
	249	if (r)
	250	return r;
	251
f37df5ea MT	252	// Update the MTU
	253	r = nw_link_update_mtu(link, message);
	254	if (r)
	255	return r;
	256
c65300b4 MT	257	// Update flags
	258	r = nw_link_update_flags(link, message);
	259	if (r)
	260	return r;
	261
f650f6cd MT	262	return 0;
	263	}
	264
766f08ca	265	int nw_link_process(sd_netlink* rtnl, sd_netlink_message* message, void* data) {
2361667e MT	266	nw_links* links = NULL;
2361667e MT	267	nw_link* link = NULL;
766f08ca MT	268	const char* ifname = NULL;
	269	int ifindex;
	270	uint16_t type;
	271	int r;
	272
2361667e	273	nw_daemon* daemon = (nw_daemon*)data;
766f08ca MT	274
	275	// Fetch links
	276	links = nw_daemon_links(daemon);
	277	if (!links) {
	278	r = 1;
	279	goto ERROR;
	280	}
	281
	282	// Check if this message could be received
	283	if (sd_netlink_message_is_error(message)) {
	284	r = sd_netlink_message_get_errno(message);
	285	if (r < 0)
	286	ERROR("Could not receive link message: %m\n");
	287
	288	goto IGNORE;
	289	}
	290
	291	// Fetch the message type
	292	r = sd_netlink_message_get_type(message, &type);
	293	if (r < 0) {
	294	ERROR("Could not fetch message type: %m\n");
	295	goto IGNORE;
	296	}
	297
	298	// Check type
	299	switch (type) {
	300	case RTM_NEWLINK:
	301	case RTM_DELLINK:
	302	break;
	303
	304	default:
	305	ERROR("Received an unexpected message (type %u)\n", type);
	306	goto IGNORE;
	307	}
	308
	309	// Fetch the interface index
	310	r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
	311	if (r < 0) {
	312	ERROR("Could not fetch ifindex: %m\n");
	313	goto IGNORE;
	314	}
	315
	316	// Check interface index
	317	if (ifindex <= 0) {
	318	ERROR("Received an invalid ifindex\n");
	319	goto IGNORE;
	320	}
	321
	322	// Fetch the interface name
	323	r = sd_netlink_message_read_string(message, IFLA_IFNAME, &ifname);
	324	if (r < 0) {
	325	ERROR("Received a netlink message without interface name: %m\n");
	326	goto IGNORE;
	327	}
	328
	329	// Try finding an existing link
	330	link = nw_daemon_get_link_by_ifindex(daemon, ifindex);
	331
	332	switch (type) {
	333	case RTM_NEWLINK:
	334	// If the link doesn't exist, create it
	335	if (!link) {
	336	r = nw_link_create(&link, daemon, ifindex);
	337	if (r) {
338	ERROR("Could not create link: %m\n");
339	goto ERROR;
340	}
b8a1a68c MT	341
	342	// Add it to the list
	343	r = nw_links_add_link(links, link);
	344	if (r)
	345	goto ERROR;
766f08ca MT	346	}
766f08ca MT	347
f650f6cd MT	348	// Import any data from the netlink message
	349	r = nw_link_update(link, message);
	350	if (r)
	351	goto ERROR;
766f08ca	352
766f08ca MT	353	break;
	354
	355	case RTM_DELLINK:
	356	if (link)
	357	nw_links_drop_link(links, link);
	358
	359	break;
	360	}
	361
	362	IGNORE:
	363	r = 0;
	364
	365	ERROR:
	366	if (links)
	367	nw_links_unref(links);
	368	if (link)
	369	nw_link_unref(link);
	370
	371	return r;
eaf649ee	372	}