xref: /freebsd/sbin/ifconfig/ifconfig_netlink.c (revision b17b639832e707aab0e9514cf94727498e2d67bd) 
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2022 Alexander V. Chernikov <melifaro@FreeBSD.org>
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  */
27 
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <stdbool.h>
32 #include <err.h>
33 #include <errno.h>
34 #include <netdb.h>
35 
36 #include <sys/bitcount.h>
37 #include <sys/param.h>
38 #include <sys/linker.h>
39 #include <sys/module.h>
40 #include <sys/socket.h>
41 #include <sys/sysctl.h>
42 #include <sys/time.h>
43 #include <sys/types.h>
44 
45 #include <netinet/in.h>
46 #include <arpa/inet.h>
47 
48 #include <net/ethernet.h>
49 #include <net/if.h>
50 #include <net/if_dl.h>
51 #include <net/if_types.h>
52 #include "ifconfig.h"
53 #include "ifconfig_netlink.h"
54 
55 static const char	*IFFBITS[] = {
56 	"UP",			/* 00:0x1 IFF_UP*/
57 	"BROADCAST",		/* 01:0x2 IFF_BROADCAST*/
58 	"DEBUG",		/* 02:0x4 IFF_DEBUG*/
59 	"LOOPBACK",		/* 03:0x8 IFF_LOOPBACK*/
60 	"POINTOPOINT",		/* 04:0x10 IFF_POINTOPOINT*/
61 	"NEEDSEPOCH",		/* 05:0x20 IFF_NEEDSEPOCH*/
62 	"RUNNING",		/* 06:0x40 IFF_DRV_RUNNING*/
63 	"NOARP",		/* 07:0x80 IFF_NOARP*/
64 	"PROMISC",		/* 08:0x100 IFF_PROMISC*/
65 	"ALLMULTI",		/* 09:0x200 IFF_ALLMULTI*/
66 	"DRV_OACTIVE",		/* 10:0x400 IFF_DRV_OACTIVE*/
67 	"SIMPLEX",		/* 11:0x800 IFF_SIMPLEX*/
68 	"LINK0",		/* 12:0x1000 IFF_LINK0*/
69 	"LINK1",		/* 13:0x2000 IFF_LINK1*/
70 	"LINK2",		/* 14:0x4000 IFF_LINK2*/
71 	"MULTICAST",		/* 15:0x8000 IFF_MULTICAST*/
72 	"CANTCONFIG",		/* 16:0x10000 IFF_CANTCONFIG*/
73 	"PPROMISC",		/* 17:0x20000 IFF_PPROMISC*/
74 	"MONITOR",		/* 18:0x40000 IFF_MONITOR*/
75 	"STATICARP",		/* 19:0x80000 IFF_STATICARP*/
76 	"STICKYARP",		/* 20:0x100000 IFF_STICKYARP*/
77 	"DYING",		/* 21:0x200000 IFF_DYING*/
78 	"RENAMING",		/* 22:0x400000 IFF_RENAMING*/
79 	"NOGROUP",		/* 23:0x800000 IFF_NOGROUP*/
80 	"LOWER_UP",		/* 24:0x1000000 IFF_NETLINK_1*/
81 };
82 
83 static void
84 print_bits(const char *btype, uint32_t *v, const int v_count,
85     const char **names, const int n_count)
86 {
87 	int num = 0;
88 
89 	for (int i = 0; i < v_count * 32; i++) {
90 		bool is_set = v[i / 32] & (1 << (i % 32));
91 		if (i == 31)
92 			v++;
93 		if (is_set) {
94 			if (num++ == 0)
95 				printf("<");
96 			if (num != 1)
97 				printf(",");
98 			if (i < n_count)
99 				printf("%s", names[i]);
100 			else
101 				printf("%s_%d", btype, i);
102 		}
103 	}
104 	if (num > 0)
105 		printf(">");
106 }
107 
108 static void
109 nl_init_socket(struct snl_state *ss)
110 {
111 	if (snl_init(ss, NETLINK_ROUTE))
112 		return;
113 
114 	if (modfind("netlink") == -1 && errno == ENOENT) {
115 		/* Try to load */
116 		if (kldload("netlink") == -1)
117 			err(1, "netlink is not loaded and load attempt failed");
118 		if (snl_init(ss, NETLINK_ROUTE))
119 			return;
120 	}
121 
122 	err(1, "unable to open netlink socket");
123 }
124 
125 int
126 ifconfig_wrapper_nl(struct ifconfig_args *args, int iscreate,
127     const struct afswtch *uafp)
128 {
129 	struct snl_state ss = {};
130 	struct ifconfig_context ctx = {
131 		.args = args,
132 		.io_s = -1,
133 		.io_ss = &ss,
134 	};
135 
136 	nl_init_socket(&ss);
137 
138 	int error = ifconfig(&ctx, iscreate, uafp);
139 
140 	snl_free(&ss);
141 
142 	return (error);
143 }
144 
145 struct ifa {
146 	struct ifa		*next;
147 	uint32_t		idx;
148 	struct snl_parsed_addr	addr;
149 };
150 
151 struct iface {
152 	struct snl_parsed_link	link;
153 	struct ifa		*ifa;
154 	uint32_t		ifa_count;
155 	uint32_t		idx;
156 };
157 
158 struct ifmap {
159 	uint32_t		size;
160 	uint32_t		count;
161 	struct iface		**ifaces;
162 };
163 
164 /*
165  * Returns ifmap ifindex->snl_parsed_link.
166  * Memory is allocated using snl temporary buffers
167  */
168 static struct ifmap *
169 prepare_ifmap(struct snl_state *ss)
170 {
171 	struct snl_writer nw = {};
172 
173 	snl_init_writer(ss, &nw);
174 	struct nlmsghdr *hdr = snl_create_msg_request(&nw, RTM_GETLINK);
175 	hdr->nlmsg_flags |= NLM_F_DUMP;
176 	snl_reserve_msg_object(&nw, struct ifinfomsg);
177 
178 	if (!snl_finalize_msg(&nw) || !snl_send_message(ss, hdr))
179 		return (NULL);
180 
181 	uint32_t nlmsg_seq = hdr->nlmsg_seq;
182 	struct ifmap *ifmap = snl_allocz(ss, sizeof(*ifmap));
183 	struct snl_errmsg_data e = {};
184 
185 	while ((hdr = snl_read_reply_multi(ss, nlmsg_seq, &e)) != NULL) {
186 		struct iface *iface = snl_allocz(ss, sizeof(*iface));
187 
188 		if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_link_parser, &iface->link))
189 			continue;
190 		if (iface->link.ifi_index >= ifmap->size) {
191 			size_t new_size = MAX(ifmap->size, 32);
192 
193 			while (new_size <= iface->link.ifi_index + 1)
194 				new_size *= 2;
195 
196 			struct iface **ifaces= snl_allocz(ss, new_size * sizeof(void *));
197 			memcpy(ifaces, ifmap->ifaces, ifmap->size * sizeof(void *));
198 			ifmap->ifaces = ifaces;
199 			ifmap->size = new_size;
200 		}
201 		ifmap->ifaces[iface->link.ifi_index] = iface;
202 		ifmap->count++;
203 		iface->idx = ifmap->count;
204 	}
205 	return (ifmap);
206 }
207 
208 uint32_t
209 if_nametoindex_nl(struct snl_state *ss, const char *ifname)
210 {
211 	struct snl_writer nw = {};
212 	struct snl_parsed_link_simple link = {};
213 
214 	snl_init_writer(ss, &nw);
215 	struct nlmsghdr *hdr = snl_create_msg_request(&nw, RTM_GETLINK);
216 	snl_reserve_msg_object(&nw, struct ifinfomsg);
217 	snl_add_msg_attr_string(&nw, IFLA_IFNAME, ifname);
218 
219 	if (!snl_finalize_msg(&nw) || !snl_send_message(ss, hdr))
220 		return (0);
221 
222 	hdr = snl_read_reply(ss, hdr->nlmsg_seq);
223 	if (hdr->nlmsg_type != NL_RTM_NEWLINK)
224 		return (0);
225 	if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_link_parser_simple, &link))
226 		return (0);
227 
228 	return (link.ifi_index);
229 }
230 
231 static void
232 prepare_ifaddrs(struct snl_state *ss, struct ifmap *ifmap)
233 {
234 	struct snl_writer nw = {};
235 
236 	snl_init_writer(ss, &nw);
237 	struct nlmsghdr *hdr = snl_create_msg_request(&nw, RTM_GETADDR);
238 	hdr->nlmsg_flags |= NLM_F_DUMP;
239 	snl_reserve_msg_object(&nw, struct ifaddrmsg);
240 
241 	if (!snl_finalize_msg(&nw) || !snl_send_message(ss, hdr))
242 		return;
243 
244 	uint32_t nlmsg_seq = hdr->nlmsg_seq;
245 	struct snl_errmsg_data e = {};
246 	uint32_t count = 0;
247 
248 	while ((hdr = snl_read_reply_multi(ss, nlmsg_seq, &e)) != NULL) {
249 		struct ifa *ifa = snl_allocz(ss, sizeof(*ifa));
250 
251 		if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_addr_parser, &ifa->addr))
252 			continue;
253 
254 		const uint32_t ifindex = ifa->addr.ifa_index;
255 		if (ifindex >= ifmap->size || ifmap->ifaces[ifindex] == NULL)
256 			continue;
257 		struct iface *iface = ifmap->ifaces[ifindex];
258 		ifa->next = iface->ifa;
259 		ifa->idx = ++count;
260 		iface->ifa = ifa;
261 		iface->ifa_count++;
262 	}
263 }
264 
265 static bool
266 match_iface(struct ifconfig_args *args, struct iface *iface)
267 {
268 	if_link_t *link = &iface->link;
269 
270 	if (args->ifname != NULL && strcmp(args->ifname, link->ifla_ifname))
271 		return (false);
272 
273 	if (!match_if_flags(args, link->ifi_flags))
274 		return (false);
275 
276 	if (!group_member(link->ifla_ifname, args->matchgroup, args->nogroup))
277 		return (false);
278 
279 	if (args->afp == NULL)
280 		return (true);
281 
282 	if (!strcmp(args->afp->af_name, "ether")) {
283 		if (link->ifla_address == NULL)
284 			return (false);
285 
286 		struct sockaddr_dl sdl = {
287 			.sdl_len = sizeof(struct sockaddr_dl),
288 			.sdl_family = AF_LINK,
289 			.sdl_type = link->ifi_type,
290 			.sdl_alen = NLA_DATA_LEN(link->ifla_address),
291 		};
292 		return (match_ether(&sdl));
293 	}
294 
295 	for (struct ifa *ifa = iface->ifa; ifa != NULL; ifa = ifa->next) {
296 		if (args->afp->af_af == ifa->addr.ifa_family)
297 			return (true);
298 	}
299 
300 	return (false);
301 }
302 
303 /* Sort according to the kernel-provided order */
304 static int
305 cmp_iface(const void *_a, const void *_b)
306 {
307 	const struct iface *a = *((const void * const *)_a);
308 	const struct iface *b = *((const void * const *)_b);
309 
310 	return ((a->idx > b->idx) * 2 - 1);
311 }
312 
313 static int
314 cmp_ifaddr(const void *_a, const void *_b)
315 {
316 	const struct ifa *a = *((const void * const *)_a);
317 	const struct ifa *b = *((const void * const *)_b);
318 
319 	if (a->addr.ifa_family != b->addr.ifa_family)
320 		return ((a->addr.ifa_family > b->addr.ifa_family) * 2 - 1);
321 	return ((a->idx > b->idx) * 2 - 1);
322 }
323 
324 static void
325 sort_iface_ifaddrs(struct snl_state *ss, struct iface *iface)
326 {
327 	if (iface->ifa_count == 0)
328 		return;
329 
330 	struct ifa **sorted_ifaddrs = snl_allocz(ss, iface->ifa_count * sizeof(void *));
331 	struct ifa *ifa = iface->ifa;
332 
333 	for (uint32_t i = 0; i < iface->ifa_count; i++) {
334 		struct ifa *ifa_next = ifa->next;
335 
336 		sorted_ifaddrs[i] = ifa;
337 		ifa->next = NULL;
338 		ifa = ifa_next;
339 	}
340 	qsort(sorted_ifaddrs, iface->ifa_count, sizeof(void *), cmp_ifaddr);
341 	ifa = sorted_ifaddrs[0];
342 	iface->ifa = ifa;
343 	for (uint32_t i = 1; i < iface->ifa_count; i++) {
344 		ifa->next = sorted_ifaddrs[i];
345 		ifa = sorted_ifaddrs[i];
346 	}
347 }
348 
349 static void
350 status_nl(if_ctx *ctx, struct iface *iface)
351 {
352 	if_link_t *link = &iface->link;
353 	struct ifconfig_args *args = ctx->args;
354 
355 	printf("%s: ", link->ifla_ifname);
356 
357 	printf("flags=%x", link->ifi_flags);
358 	print_bits("IFF", &link->ifi_flags, 1, IFFBITS, nitems(IFFBITS));
359 
360 	print_metric(ctx->io_s);
361 	printf(" mtu %d\n", link->ifla_mtu);
362 
363 	if (link->ifla_ifalias != NULL)
364 		printf("\tdescription: %s\n", link->ifla_ifalias);
365 
366 	/* TODO: convert to netlink */
367 	strlcpy(ifr.ifr_name, link->ifla_ifname, sizeof(ifr.ifr_name));
368 	print_ifcap(args, ctx->io_s);
369 	tunnel_status(ctx->io_s);
370 
371 	if (args->allfamilies | (args->afp != NULL && args->afp->af_af == AF_LINK)) {
372 		/* Start with link-level */
373 		const struct afswtch *p = af_getbyfamily(AF_LINK);
374 		if (p != NULL && link->ifla_address != NULL)
375 			p->af_status(ctx, link, NULL);
376 	}
377 
378 	sort_iface_ifaddrs(ctx->io_ss, iface);
379 
380 	for (struct ifa *ifa = iface->ifa; ifa != NULL; ifa = ifa->next) {
381 		if (args->allfamilies) {
382 			const struct afswtch *p = af_getbyfamily(ifa->addr.ifa_family);
383 
384 			if (p != NULL)
385 				p->af_status(ctx, link, &ifa->addr);
386 		} else if (args->afp->af_af == ifa->addr.ifa_family) {
387 			const struct afswtch *p = args->afp;
388 
389 			p->af_status(ctx, link, &ifa->addr);
390 		}
391 	}
392 
393 	/* TODO: convert to netlink */
394 	if (args->allfamilies)
395 		af_other_status(ctx);
396 	else if (args->afp->af_other_status != NULL)
397 		args->afp->af_other_status(ctx);
398 
399 	print_ifstatus(ctx->io_s);
400 	if (args->verbose > 0)
401 		sfp_status(ctx);
402 }
403 
404 static int
405 get_local_socket(void)
406 {
407 	int s = socket(AF_LOCAL, SOCK_DGRAM, 0);
408 
409 	if (s < 0)
410 		err(1, "socket(family %u,SOCK_DGRAM)", AF_LOCAL);
411 	return (s);
412 }
413 
414 static void
415 set_global_ifname(if_link_t *link)
416 {
417 	size_t iflen = strlcpy(name, link->ifla_ifname, sizeof(name));
418 
419 	if (iflen >= sizeof(name))
420 		errx(1, "%s: cloning name too long", link->ifla_ifname);
421 	strlcpy(ifr.ifr_name, link->ifla_ifname, sizeof(ifr.ifr_name));
422 }
423 
424 void
425 list_interfaces_nl(struct ifconfig_args *args)
426 {
427 	struct snl_state ss = {};
428 	struct ifconfig_context _ctx = {
429 		.args = args,
430 		.io_s = get_local_socket(),
431 		.io_ss = &ss,
432 	};
433 	struct ifconfig_context *ctx = &_ctx;
434 
435 	nl_init_socket(&ss);
436 
437 	struct ifmap *ifmap = prepare_ifmap(&ss);
438 	struct iface **sorted_ifaces = snl_allocz(&ss, ifmap->count * sizeof(void *));
439 	for (uint32_t i = 0, num = 0; i < ifmap->size; i++) {
440 		if (ifmap->ifaces[i] != NULL) {
441 			sorted_ifaces[num++] = ifmap->ifaces[i];
442 			if (num == ifmap->count)
443 				break;
444 		}
445 	}
446 	qsort(sorted_ifaces, ifmap->count, sizeof(void *), cmp_iface);
447 	prepare_ifaddrs(&ss, ifmap);
448 
449 	for (uint32_t i = 0, num = 0; i < ifmap->count; i++) {
450 		struct iface *iface = sorted_ifaces[i];
451 
452 		if (!match_iface(args, iface))
453 			continue;
454 
455 		set_global_ifname(&iface->link);
456 
457 		if (args->namesonly) {
458 			if (num++ != 0)
459 				printf(" ");
460 			fputs(iface->link.ifla_ifname, stdout);
461 		} else if (args->argc == 0)
462 			status_nl(ctx, iface);
463 		else
464 			ifconfig(ctx, 0, args->afp);
465 	}
466 	if (args->namesonly)
467 		printf("\n");
468 
469 	close(ctx->io_s);
470 	snl_free(&ss);
471 }
472 
473