xref: /freebsd/sys/netlink/route/iface.c (revision f374ba41f55c1a127303d92d830dd58eef2f5243)
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 <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
30 #include "opt_inet.h"
31 #include "opt_inet6.h"
32 #include <sys/types.h>
33 #include <sys/eventhandler.h>
34 #include <sys/kernel.h>
35 #include <sys/malloc.h>
36 #include <sys/socket.h>
37 #include <sys/sockio.h>
38 #include <sys/syslog.h>
39 
40 #include <net/if.h>
41 #include <net/if_dl.h>
42 #include <net/if_media.h>
43 #include <net/if_var.h>
44 #include <net/if_clone.h>
45 #include <net/route.h>
46 #include <net/route/nhop.h>
47 #include <net/route/route_ctl.h>
48 #include <netlink/netlink.h>
49 #include <netlink/netlink_ctl.h>
50 #include <netlink/netlink_route.h>
51 #include <netlink/route/route_var.h>
52 
53 #include <netinet6/scope6_var.h> /* scope deembedding */
54 
55 #define	DEBUG_MOD_NAME	nl_iface
56 #define	DEBUG_MAX_LEVEL	LOG_DEBUG3
57 #include <netlink/netlink_debug.h>
58 _DECLARE_DEBUG(LOG_DEBUG);
59 
60 struct netlink_walkargs {
61 	struct nl_writer *nw;
62 	struct nlmsghdr hdr;
63 	struct nlpcb *so;
64 	uint32_t fibnum;
65 	int family;
66 	int error;
67 	int count;
68 	int dumped;
69 };
70 
71 static eventhandler_tag ifdetach_event, ifattach_event, iflink_event, ifaddr_event;
72 
73 static SLIST_HEAD(, nl_cloner) nl_cloners = SLIST_HEAD_INITIALIZER(nl_cloners);
74 
75 static struct sx rtnl_cloner_lock;
76 SX_SYSINIT(rtnl_cloner_lock, &rtnl_cloner_lock, "rtnl cloner lock");
77 
78 static struct nl_cloner *rtnl_iface_find_cloner_locked(const char *name);
79 
80 /*
81  * RTM_GETLINK request
82  * sendto(3, {{len=32, type=RTM_GETLINK, flags=NLM_F_REQUEST|NLM_F_DUMP, seq=1641940952, pid=0},
83  *  {ifi_family=AF_INET, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0}}, 32, 0, NULL, 0) = 32
84  *
85  * Reply:
86  * {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_ETHER, ifi_index=if_nametoindex("enp0s31f6"), ifi_flags=IFF_UP|IFF_BROADCAST|IFF_RUNNING|IFF_MULTICAST|IFF_LOWER_UP, ifi_change=0},
87 {{nla_len=10, nla_type=IFLA_ADDRESS}, "\xfe\x54\x00\x52\x3e\x90"}
88 
89 [
90 {{nla_len=14, nla_type=IFLA_IFNAME}, "enp0s31f6"},
91 {{nla_len=8, nla_type=IFLA_TXQLEN}, 1000},
92 {{nla_len=5, nla_type=IFLA_OPERSTATE}, 6},
93 {{nla_len=5, nla_type=IFLA_LINKMODE}, 0},
94 {{nla_len=8, nla_type=IFLA_MTU}, 1500},
95 {{nla_len=8, nla_type=IFLA_MIN_MTU}, 68},
96  {{nla_len=8, nla_type=IFLA_MAX_MTU}, 9000},
97 {{nla_len=8, nla_type=IFLA_GROUP}, 0},
98 {{nla_len=8, nla_type=IFLA_PROMISCUITY}, 0},
99 {{nla_len=8, nla_type=IFLA_NUM_TX_QUEUES}, 1},
100 {{nla_len=8, nla_type=IFLA_GSO_MAX_SEGS}, 65535},
101 {{nla_len=8, nla_type=IFLA_GSO_MAX_SIZE}, 65536},
102 {{nla_len=8, nla_type=IFLA_NUM_RX_QUEUES}, 1},
103 {{nla_len=5, nla_type=IFLA_CARRIER}, 1},
104 {{nla_len=13, nla_type=IFLA_QDISC}, "fq_codel"},
105 {{nla_len=8, nla_type=IFLA_CARRIER_CHANGES}, 2},
106 {{nla_len=5, nla_type=IFLA_PROTO_DOWN}, 0},
107 {{nla_len=8, nla_type=IFLA_CARRIER_UP_COUNT}, 1},
108 {{nla_len=8, nla_type=IFLA_CARRIER_DOWN_COUNT}, 1},
109  */
110 
111 struct if_state {
112 	uint8_t		ifla_operstate;
113 	uint8_t		ifla_carrier;
114 };
115 
116 static void
117 get_operstate_ether(struct ifnet *ifp, struct if_state *pstate)
118 {
119 	struct ifmediareq ifmr = {};
120 	int error;
121 	error = (*ifp->if_ioctl)(ifp, SIOCGIFMEDIA, (void *)&ifmr);
122 
123 	if (error != 0) {
124 		NL_LOG(LOG_DEBUG, "error calling SIOCGIFMEDIA on %s: %d",
125 		    if_name(ifp), error);
126 		return;
127 	}
128 
129 	switch (IFM_TYPE(ifmr.ifm_active)) {
130 	case IFM_ETHER:
131 		if (ifmr.ifm_status & IFM_ACTIVE) {
132 			pstate->ifla_carrier = 1;
133 			if (ifp->if_flags & IFF_MONITOR)
134 				pstate->ifla_operstate = IF_OPER_DORMANT;
135 			else
136 				pstate->ifla_operstate = IF_OPER_UP;
137 		} else
138 			pstate->ifla_operstate = IF_OPER_DOWN;
139 	}
140 }
141 
142 static bool
143 get_stats(struct nl_writer *nw, struct ifnet *ifp)
144 {
145 	struct rtnl_link_stats64 *stats;
146 
147 	int nla_len = sizeof(struct nlattr) + sizeof(*stats);
148 	struct nlattr *nla = nlmsg_reserve_data(nw, nla_len, struct nlattr);
149 	if (nla == NULL)
150 		return (false);
151 	nla->nla_type = IFLA_STATS64;
152 	nla->nla_len = nla_len;
153 	stats = (struct rtnl_link_stats64 *)(nla + 1);
154 
155 	stats->rx_packets = ifp->if_get_counter(ifp, IFCOUNTER_IPACKETS);
156 	stats->tx_packets = ifp->if_get_counter(ifp, IFCOUNTER_OPACKETS);
157 	stats->rx_bytes = ifp->if_get_counter(ifp, IFCOUNTER_IBYTES);
158 	stats->tx_bytes = ifp->if_get_counter(ifp, IFCOUNTER_OBYTES);
159 	stats->rx_errors = ifp->if_get_counter(ifp, IFCOUNTER_IERRORS);
160 	stats->tx_errors = ifp->if_get_counter(ifp, IFCOUNTER_OERRORS);
161 	stats->rx_dropped = ifp->if_get_counter(ifp, IFCOUNTER_IQDROPS);
162 	stats->tx_dropped = ifp->if_get_counter(ifp, IFCOUNTER_OQDROPS);
163 	stats->multicast = ifp->if_get_counter(ifp, IFCOUNTER_IMCASTS);
164 	stats->rx_nohandler = ifp->if_get_counter(ifp, IFCOUNTER_NOPROTO);
165 
166 	return (true);
167 }
168 
169 static void
170 get_operstate(struct ifnet *ifp, struct if_state *pstate)
171 {
172 	pstate->ifla_operstate = IF_OPER_UNKNOWN;
173 	pstate->ifla_carrier = 0; /* no carrier */
174 
175 	switch (ifp->if_type) {
176 	case IFT_ETHER:
177 		get_operstate_ether(ifp, pstate);
178 		break;
179 	case IFT_LOOP:
180 		if (ifp->if_flags & IFF_UP) {
181 			pstate->ifla_operstate = IF_OPER_UP;
182 			pstate->ifla_carrier = 1;
183 		} else
184 			pstate->ifla_operstate = IF_OPER_DOWN;
185 		break;
186 	}
187 }
188 
189 static unsigned
190 ifp_flags_to_netlink(const struct ifnet *ifp)
191 {
192         return (ifp->if_flags | ifp->if_drv_flags);
193 }
194 
195 #define LLADDR_CONST(s) ((const void *)((s)->sdl_data + (s)->sdl_nlen))
196 static bool
197 dump_sa(struct nl_writer *nw, int attr, const struct sockaddr *sa)
198 {
199         uint32_t addr_len = 0;
200         const void *addr_data = NULL;
201 #ifdef INET6
202         struct in6_addr addr6;
203 #endif
204 
205         if (sa == NULL)
206                 return (true);
207 
208         switch (sa->sa_family) {
209 #ifdef INET
210         case AF_INET:
211                 addr_len = sizeof(struct in_addr);
212                 addr_data = &((const struct sockaddr_in *)sa)->sin_addr;
213                 break;
214 #endif
215 #ifdef INET6
216         case AF_INET6:
217                 in6_splitscope(&((const struct sockaddr_in6 *)sa)->sin6_addr, &addr6, &addr_len);
218                 addr_len = sizeof(struct in6_addr);
219                 addr_data = &addr6;
220                 break;
221 #endif
222         case AF_LINK:
223                 addr_len = ((const struct sockaddr_dl *)sa)->sdl_alen;
224                 addr_data = LLADDR_CONST((const struct sockaddr_dl *)sa);
225                 break;
226         default:
227                 NL_LOG(LOG_DEBUG, "unsupported family: %d, skipping", sa->sa_family);
228                 return (true);
229         }
230 
231         return (nlattr_add(nw, attr, addr_len, addr_data));
232 }
233 
234 /*
235  * Dumps interface state, properties and metrics.
236  * @nw: message writer
237  * @ifp: target interface
238  * @hdr: template header
239  * @if_flags_mask: changed if_[drv]_flags bitmask
240  *
241  * This function is called without epoch and MAY sleep.
242  */
243 static bool
244 dump_iface(struct nl_writer *nw, struct ifnet *ifp, const struct nlmsghdr *hdr,
245     int if_flags_mask)
246 {
247         struct ifinfomsg *ifinfo;
248 
249         NL_LOG(LOG_DEBUG3, "dumping interface %s data", if_name(ifp));
250 
251 	if (!nlmsg_reply(nw, hdr, sizeof(struct ifinfomsg)))
252 		goto enomem;
253 
254         ifinfo = nlmsg_reserve_object(nw, struct ifinfomsg);
255         ifinfo->ifi_family = AF_UNSPEC;
256         ifinfo->__ifi_pad = 0;
257         ifinfo->ifi_type = ifp->if_type;
258         ifinfo->ifi_index = ifp->if_index;
259         ifinfo->ifi_flags = ifp_flags_to_netlink(ifp);
260         ifinfo->ifi_change = if_flags_mask;
261 
262 	struct if_state ifs = {};
263 	get_operstate(ifp, &ifs);
264 
265 	if (ifs.ifla_operstate == IF_OPER_UP)
266 		ifinfo->ifi_flags |= IFF_LOWER_UP;
267 
268         nlattr_add_string(nw, IFLA_IFNAME, if_name(ifp));
269         nlattr_add_u8(nw, IFLA_OPERSTATE, ifs.ifla_operstate);
270         nlattr_add_u8(nw, IFLA_CARRIER, ifs.ifla_carrier);
271 
272 /*
273         nlattr_add_u8(nw, IFLA_PROTO_DOWN, val);
274         nlattr_add_u8(nw, IFLA_LINKMODE, val);
275 */
276         if ((ifp->if_addr != NULL)) {
277                 dump_sa(nw, IFLA_ADDRESS, ifp->if_addr->ifa_addr);
278         }
279 
280         if ((ifp->if_broadcastaddr != NULL)) {
281 		nlattr_add(nw, IFLA_BROADCAST, ifp->if_addrlen,
282 		    ifp->if_broadcastaddr);
283         }
284 
285         nlattr_add_u32(nw, IFLA_MTU, ifp->if_mtu);
286 /*
287         nlattr_add_u32(nw, IFLA_MIN_MTU, 60);
288         nlattr_add_u32(nw, IFLA_MAX_MTU, 9000);
289         nlattr_add_u32(nw, IFLA_GROUP, 0);
290 */
291 
292 	if (ifp->if_description != NULL)
293 		nlattr_add_string(nw, IFLA_IFALIAS, ifp->if_description);
294 
295 	get_stats(nw, ifp);
296 
297 	uint32_t val = (ifp->if_flags & IFF_PROMISC) != 0;
298         nlattr_add_u32(nw, IFLA_PROMISCUITY, val);
299 
300 	sx_slock(&rtnl_cloner_lock);
301 	struct nl_cloner *cloner = rtnl_iface_find_cloner_locked(ifp->if_dname);
302 	if (cloner != NULL && cloner->dump_f != NULL) {
303 		/* Ignore any dump error */
304 		cloner->dump_f(ifp, nw);
305 	}
306 	sx_sunlock(&rtnl_cloner_lock);
307 
308         if (nlmsg_end(nw))
309 		return (true);
310 
311 enomem:
312         NL_LOG(LOG_DEBUG, "unable to dump interface %s state (ENOMEM)", if_name(ifp));
313         nlmsg_abort(nw);
314         return (false);
315 }
316 
317 static bool
318 check_ifmsg(void *hdr, struct nl_pstate *npt)
319 {
320 	struct ifinfomsg *ifm = hdr;
321 
322 	if (ifm->__ifi_pad != 0 || ifm->ifi_type != 0 ||
323 	    ifm->ifi_flags != 0 || ifm->ifi_change != 0) {
324 		nlmsg_report_err_msg(npt,
325 		    "strict checking: non-zero values in ifinfomsg header");
326 		return (false);
327 	}
328 
329 	return (true);
330 }
331 
332 #define	_IN(_field)	offsetof(struct ifinfomsg, _field)
333 #define	_OUT(_field)	offsetof(struct nl_parsed_link, _field)
334 static const struct nlfield_parser nlf_p_if[] = {
335 	{ .off_in = _IN(ifi_type), .off_out = _OUT(ifi_type), .cb = nlf_get_u16 },
336 	{ .off_in = _IN(ifi_index), .off_out = _OUT(ifi_index), .cb = nlf_get_u32 },
337 	{ .off_in = _IN(ifi_flags), .off_out = _OUT(ifi_flags), .cb = nlf_get_u32 },
338 	{ .off_in = _IN(ifi_change), .off_out = _OUT(ifi_change), .cb = nlf_get_u32 },
339 };
340 
341 static const struct nlattr_parser nla_p_linfo[] = {
342 	{ .type = IFLA_INFO_KIND, .off = _OUT(ifla_cloner), .cb = nlattr_get_stringn },
343 	{ .type = IFLA_INFO_DATA, .off = _OUT(ifla_idata), .cb = nlattr_get_nla },
344 };
345 NL_DECLARE_ATTR_PARSER(linfo_parser, nla_p_linfo);
346 
347 static const struct nlattr_parser nla_p_if[] = {
348 	{ .type = IFLA_IFNAME, .off = _OUT(ifla_ifname), .cb = nlattr_get_string },
349 	{ .type = IFLA_MTU, .off = _OUT(ifla_mtu), .cb = nlattr_get_uint32 },
350 	{ .type = IFLA_LINK, .off = _OUT(ifi_index), .cb = nlattr_get_uint32 },
351 	{ .type = IFLA_LINKINFO, .arg = &linfo_parser, .cb = nlattr_get_nested },
352 	{ .type = IFLA_IFALIAS, .off = _OUT(ifla_ifalias), .cb = nlattr_get_string },
353 	{ .type = IFLA_GROUP, .off = _OUT(ifla_group), .cb = nlattr_get_string },
354 	{ .type = IFLA_ALT_IFNAME, .off = _OUT(ifla_ifname), .cb = nlattr_get_string },
355 };
356 #undef _IN
357 #undef _OUT
358 NL_DECLARE_STRICT_PARSER(ifmsg_parser, struct ifinfomsg, check_ifmsg, nlf_p_if, nla_p_if);
359 
360 static bool
361 match_iface(struct nl_parsed_link *attrs, struct ifnet *ifp)
362 {
363 	if (attrs->ifi_index != 0 && attrs->ifi_index != ifp->if_index)
364 		return (false);
365 	if (attrs->ifi_type != 0 && attrs->ifi_index != ifp->if_type)
366 		return (false);
367 	if (attrs->ifla_ifname != NULL && strcmp(attrs->ifla_ifname, if_name(ifp)))
368 		return (false);
369 	/* TODO: add group match */
370 
371 	return (true);
372 }
373 
374 /*
375  * {nlmsg_len=52, nlmsg_type=RTM_GETLINK, nlmsg_flags=NLM_F_REQUEST, nlmsg_seq=1662842818, nlmsg_pid=0},
376  *  {ifi_family=AF_PACKET, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0},
377  *   [
378  *    [{nla_len=10, nla_type=IFLA_IFNAME}, "vnet9"],
379  *    [{nla_len=8, nla_type=IFLA_EXT_MASK}, RTEXT_FILTER_VF]
380  *   ]
381  */
382 static int
383 rtnl_handle_getlink(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_pstate *npt)
384 {
385 	struct epoch_tracker et;
386         struct ifnet *ifp;
387 	int error = 0;
388 
389 	struct nl_parsed_link attrs = {};
390 	error = nl_parse_nlmsg(hdr, &ifmsg_parser, npt, &attrs);
391 	if (error != 0)
392 		return (error);
393 
394 	struct netlink_walkargs wa = {
395 		.so = nlp,
396 		.nw = npt->nw,
397 		.hdr.nlmsg_pid = hdr->nlmsg_pid,
398 		.hdr.nlmsg_seq = hdr->nlmsg_seq,
399 		.hdr.nlmsg_flags = hdr->nlmsg_flags,
400 		.hdr.nlmsg_type = NL_RTM_NEWLINK,
401 	};
402 
403 	/* Fast track for an interface w/ explicit name or index match */
404 	if ((attrs.ifi_index != 0) || (attrs.ifla_ifname != NULL)) {
405 		if (attrs.ifi_index != 0) {
406 			NLP_LOG(LOG_DEBUG3, nlp, "fast track -> searching index %u",
407 			    attrs.ifi_index);
408 			NET_EPOCH_ENTER(et);
409 			ifp = ifnet_byindex_ref(attrs.ifi_index);
410 			NET_EPOCH_EXIT(et);
411 		} else {
412 			NLP_LOG(LOG_DEBUG3, nlp, "fast track -> searching name %s",
413 			    attrs.ifla_ifname);
414 			ifp = ifunit_ref(attrs.ifla_ifname);
415 		}
416 
417 		if (ifp != NULL) {
418 			if (match_iface(&attrs, ifp)) {
419 				if (!dump_iface(wa.nw, ifp, &wa.hdr, 0))
420 					error = ENOMEM;
421 			} else
422 				error = ENODEV;
423 			if_rele(ifp);
424 		} else
425 			error = ENODEV;
426 		return (error);
427 	}
428 
429 	/* Always treat non-direct-match as a multipart message */
430 	wa.hdr.nlmsg_flags |= NLM_F_MULTI;
431 
432 	/*
433 	 * Fetching some link properties require performing ioctl's that may be blocking.
434 	 * Address it by saving referenced pointers of the matching links,
435 	 * exiting from epoch and going through the list one-by-one.
436 	 */
437 
438 	NL_LOG(LOG_DEBUG2, "Start dump");
439 
440 	struct ifnet **match_array;
441 	int offset = 0, base_count = 16; /* start with 128 bytes */
442 	match_array = malloc(base_count * sizeof(void *), M_TEMP, M_NOWAIT);
443 
444 	NLP_LOG(LOG_DEBUG3, nlp, "MATCHING: index=%u type=%d name=%s",
445 	    attrs.ifi_index, attrs.ifi_type, attrs.ifla_ifname);
446 	NET_EPOCH_ENTER(et);
447         CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
448 		wa.count++;
449 		if (match_iface(&attrs, ifp)) {
450 			if (offset < base_count) {
451 				if (!if_try_ref(ifp))
452 					continue;
453 				match_array[offset++] = ifp;
454 				continue;
455 			}
456 			/* Too many matches, need to reallocate */
457 			struct ifnet **new_array;
458 			int sz = base_count * sizeof(void *);
459 			base_count *= 2;
460 			new_array = malloc(sz * 2, M_TEMP, M_NOWAIT);
461 			if (new_array == NULL) {
462 				error = ENOMEM;
463 				break;
464 			}
465 			memcpy(new_array, match_array, sz);
466 			free(match_array, M_TEMP);
467 			match_array = new_array;
468                 }
469         }
470 	NET_EPOCH_EXIT(et);
471 
472 	NL_LOG(LOG_DEBUG2, "Matched %d interface(s), dumping", offset);
473 	for (int i = 0; error == 0 && i < offset; i++) {
474 		if (!dump_iface(wa.nw, match_array[i], &wa.hdr, 0))
475 			error = ENOMEM;
476 	}
477 	for (int i = 0; i < offset; i++)
478 		if_rele(match_array[i]);
479 	free(match_array, M_TEMP);
480 
481 	NL_LOG(LOG_DEBUG2, "End dump, iterated %d dumped %d", wa.count, wa.dumped);
482 
483 	if (!nlmsg_end_dump(wa.nw, error, &wa.hdr)) {
484                 NL_LOG(LOG_DEBUG, "Unable to finalize the dump");
485                 return (ENOMEM);
486         }
487 
488 	return (error);
489 }
490 
491 /*
492  * sendmsg(3, {msg_name={sa_family=AF_NETLINK, nl_pid=0, nl_groups=00000000}, msg_namelen=12, msg_iov=[{iov_base=[
493  * {nlmsg_len=60, nlmsg_type=RTM_NEWLINK, nlmsg_flags=NLM_F_REQUEST|NLM_F_ACK|NLM_F_EXCL|NLM_F_CREATE, nlmsg_seq=1662715618, nlmsg_pid=0},
494  *  {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0},
495  *   {nla_len=11, nla_type=IFLA_IFNAME}, "dummy0"],
496  *   [
497  *    {nla_len=16, nla_type=IFLA_LINKINFO},
498  *     [
499  *      {nla_len=9, nla_type=IFLA_INFO_KIND}, "dummy"...
500  *     ]
501  *    ]
502  */
503 
504 static int
505 rtnl_handle_dellink(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_pstate *npt)
506 {
507 	struct epoch_tracker et;
508         struct ifnet *ifp;
509 	int error;
510 
511 	struct nl_parsed_link attrs = {};
512 	error = nl_parse_nlmsg(hdr, &ifmsg_parser, npt, &attrs);
513 	if (error != 0)
514 		return (error);
515 
516 	NET_EPOCH_ENTER(et);
517 	ifp = ifnet_byindex_ref(attrs.ifi_index);
518 	NET_EPOCH_EXIT(et);
519 	if (ifp == NULL) {
520 		NLP_LOG(LOG_DEBUG, nlp, "unable to find interface %u", attrs.ifi_index);
521 		return (ENOENT);
522 	}
523 	NLP_LOG(LOG_DEBUG3, nlp, "mapped ifindex %u to %s", attrs.ifi_index, if_name(ifp));
524 
525 	sx_xlock(&ifnet_detach_sxlock);
526 	error = if_clone_destroy(if_name(ifp));
527 	sx_xunlock(&ifnet_detach_sxlock);
528 
529 	NLP_LOG(LOG_DEBUG2, nlp, "deleting interface %s returned %d", if_name(ifp), error);
530 
531 	if_rele(ifp);
532 	return (error);
533 }
534 
535 /*
536  * New link:
537  * type=RTM_NEWLINK, flags=NLM_F_REQUEST|NLM_F_ACK|NLM_F_EXCL|NLM_F_CREATE, seq=1668185590, pid=0},
538  *   {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0}
539  *    [
540  *     {{nla_len=8, nla_type=IFLA_MTU}, 123},
541  *     {{nla_len=10, nla_type=IFLA_IFNAME}, "vlan1"},
542  *     {{nla_len=24, nla_type=IFLA_LINKINFO},
543  *      [
544  *       {{nla_len=8, nla_type=IFLA_INFO_KIND}, "vlan"...},
545  *       {{nla_len=12, nla_type=IFLA_INFO_DATA}, "\x06\x00\x01\x00\x7b\x00\x00\x00"}]}]}
546  *
547  * Update link:
548  * type=RTM_NEWLINK, flags=NLM_F_REQUEST|NLM_F_ACK, seq=1668185923, pid=0},
549  * {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_NETROM, ifi_index=if_nametoindex("lo"), ifi_flags=0, ifi_change=0},
550  * {{nla_len=8, nla_type=IFLA_MTU}, 123}}
551  *
552  *
553  * Check command availability:
554  * type=RTM_NEWLINK, flags=NLM_F_REQUEST|NLM_F_ACK, seq=0, pid=0},
555  *  {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0}
556  */
557 
558 
559 static int
560 create_link(struct nlmsghdr *hdr, struct nl_parsed_link *lattrs,
561     struct nlattr_bmask *bm, struct nlpcb *nlp, struct nl_pstate *npt)
562 {
563 	if (lattrs->ifla_ifname == NULL || strlen(lattrs->ifla_ifname) == 0) {
564 		NLMSG_REPORT_ERR_MSG(npt, "empty IFLA_IFNAME attribute");
565 		return (EINVAL);
566 	}
567 	if (lattrs->ifla_cloner == NULL || strlen(lattrs->ifla_cloner) == 0) {
568 		NLMSG_REPORT_ERR_MSG(npt, "empty IFLA_INFO_KIND attribute");
569 		return (EINVAL);
570 	}
571 
572 	bool found = false;
573 	int error = 0;
574 
575 	sx_slock(&rtnl_cloner_lock);
576 	struct nl_cloner *cloner = rtnl_iface_find_cloner_locked(lattrs->ifla_cloner);
577 	if (cloner != NULL) {
578 		found = true;
579 		error = cloner->create_f(lattrs, bm, nlp, npt);
580 	}
581 	sx_sunlock(&rtnl_cloner_lock);
582 
583 	if (!found)
584 		error = generic_cloner.create_f(lattrs, bm, nlp, npt);
585 
586 	return (error);
587 }
588 
589 static int
590 modify_link(struct nlmsghdr *hdr, struct nl_parsed_link *lattrs,
591     struct nlattr_bmask *bm, struct nlpcb *nlp, struct nl_pstate *npt)
592 {
593 	struct ifnet *ifp = NULL;
594 	struct epoch_tracker et;
595 
596 	if (lattrs->ifi_index == 0 && lattrs->ifla_ifname == NULL) {
597 		/*
598 		 * Applications like ip(8) verify RTM_NEWLINK command
599 		 * existence by calling it with empty arguments. Always
600 		 * return "innocent" error in that case.
601 		 */
602 		NLMSG_REPORT_ERR_MSG(npt, "empty ifi_index field");
603 		return (EPERM);
604 	}
605 
606 	if (lattrs->ifi_index != 0) {
607 		NET_EPOCH_ENTER(et);
608 		ifp = ifnet_byindex_ref(lattrs->ifi_index);
609 		NET_EPOCH_EXIT(et);
610 		if (ifp == NULL) {
611 			NLMSG_REPORT_ERR_MSG(npt, "unable to find interface #%u",
612 			    lattrs->ifi_index);
613 			return (ENOENT);
614 		}
615 	}
616 
617 	if (ifp == NULL && lattrs->ifla_ifname != NULL) {
618 		ifp = ifunit_ref(lattrs->ifla_ifname);
619 		if (ifp == NULL) {
620 			NLMSG_REPORT_ERR_MSG(npt, "unable to find interface %s",
621 			    lattrs->ifla_ifname);
622 			return (ENOENT);
623 		}
624 	}
625 
626 	MPASS(ifp != NULL);
627 
628 	/*
629 	 * There can be multiple kinds of interfaces:
630 	 * 1) cloned, with additional options
631 	 * 2) cloned, but w/o additional options
632 	 * 3) non-cloned (e.g. "physical).
633 	 *
634 	 * Thus, try to find cloner-specific callback and fallback to the
635 	 * "default" handler if not found.
636 	 */
637 	bool found = false;
638 	int error = 0;
639 
640 	sx_slock(&rtnl_cloner_lock);
641 	struct nl_cloner *cloner = rtnl_iface_find_cloner_locked(ifp->if_dname);
642 	if (cloner != NULL) {
643 		found = true;
644 		error = cloner->modify_f(ifp, lattrs, bm, nlp, npt);
645 	}
646 	sx_sunlock(&rtnl_cloner_lock);
647 
648 	if (!found)
649 		error = generic_cloner.modify_f(ifp, lattrs, bm, nlp, npt);
650 
651 	if_rele(ifp);
652 
653 	return (error);
654 }
655 
656 
657 static int
658 rtnl_handle_newlink(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_pstate *npt)
659 {
660 	struct nlattr_bmask bm;
661 	int error;
662 
663 	struct nl_parsed_link attrs = {};
664 	error = nl_parse_nlmsg(hdr, &ifmsg_parser, npt, &attrs);
665 	if (error != 0)
666 		return (error);
667 	nl_get_attrs_bmask_nlmsg(hdr, &ifmsg_parser, &bm);
668 
669 	if (hdr->nlmsg_flags & NLM_F_CREATE)
670 		return (create_link(hdr, &attrs, &bm, nlp, npt));
671 	else
672 		return (modify_link(hdr, &attrs, &bm, nlp, npt));
673 }
674 
675 struct nl_parsed_ifa {
676 	uint8_t		ifa_family;
677 	uint8_t		ifa_prefixlen;
678 	uint8_t		ifa_scope;
679 	uint32_t	ifa_index;
680 	uint32_t	ifa_flags;
681 	struct sockaddr	*ifa_address;
682 	struct sockaddr	*ifa_local;
683 };
684 
685 #define	_IN(_field)	offsetof(struct ifaddrmsg, _field)
686 #define	_OUT(_field)	offsetof(struct nl_parsed_ifa, _field)
687 static const struct nlfield_parser nlf_p_ifa[] = {
688 	{ .off_in = _IN(ifa_family), .off_out = _OUT(ifa_family), .cb = nlf_get_u8 },
689 	{ .off_in = _IN(ifa_prefixlen), .off_out = _OUT(ifa_prefixlen), .cb = nlf_get_u8 },
690 	{ .off_in = _IN(ifa_scope), .off_out = _OUT(ifa_scope), .cb = nlf_get_u8 },
691 	{ .off_in = _IN(ifa_flags), .off_out = _OUT(ifa_flags), .cb = nlf_get_u8_u32 },
692 	{ .off_in = _IN(ifa_index), .off_out = _OUT(ifa_index), .cb = nlf_get_u32 },
693 };
694 
695 static const struct nlattr_parser nla_p_ifa[] = {
696 	{ .type = IFA_ADDRESS, .off = _OUT(ifa_address), .cb = nlattr_get_ip },
697 	{ .type = IFA_LOCAL, .off = _OUT(ifa_local), .cb = nlattr_get_ip },
698 	{ .type = IFA_FLAGS, .off = _OUT(ifa_flags), .cb = nlattr_get_uint32 },
699 };
700 #undef _IN
701 #undef _OUT
702 NL_DECLARE_PARSER(ifaddrmsg_parser, struct ifaddrmsg, nlf_p_ifa, nla_p_ifa);
703 
704 
705 /*
706 
707 {ifa_family=AF_INET, ifa_prefixlen=8, ifa_flags=IFA_F_PERMANENT, ifa_scope=RT_SCOPE_HOST, ifa_index=if_nametoindex("lo")},
708  [
709         {{nla_len=8, nla_type=IFA_ADDRESS}, inet_addr("127.0.0.1")},
710         {{nla_len=8, nla_type=IFA_LOCAL}, inet_addr("127.0.0.1")},
711         {{nla_len=7, nla_type=IFA_LABEL}, "lo"},
712         {{nla_len=8, nla_type=IFA_FLAGS}, IFA_F_PERMANENT},
713         {{nla_len=20, nla_type=IFA_CACHEINFO}, {ifa_prefered=4294967295, ifa_valid=4294967295, cstamp=3619, tstamp=3619}}]},
714 ---
715 
716 {{len=72, type=RTM_NEWADDR, flags=NLM_F_MULTI, seq=1642191126, pid=566735},
717  {ifa_family=AF_INET6, ifa_prefixlen=96, ifa_flags=IFA_F_PERMANENT, ifa_scope=RT_SCOPE_UNIVERSE, ifa_index=if_nametoindex("virbr0")},
718    [
719     {{nla_len=20, nla_type=IFA_ADDRESS}, inet_pton(AF_INET6, "2a01:4f8:13a:70c:ffff::1")},
720    {{nla_len=20, nla_type=IFA_CACHEINFO}, {ifa_prefered=4294967295, ifa_valid=4294967295, cstamp=4283, tstamp=4283}},
721    {{nla_len=8, nla_type=IFA_FLAGS}, IFA_F_PERMANENT}]},
722 */
723 
724 static uint8_t
725 ifa_get_scope(const struct ifaddr *ifa)
726 {
727         const struct sockaddr *sa;
728         uint8_t addr_scope = RT_SCOPE_UNIVERSE;
729 
730         sa = ifa->ifa_addr;
731         switch (sa->sa_family) {
732 #ifdef INET
733         case AF_INET:
734                 {
735                         struct in_addr addr;
736                         addr = ((const struct sockaddr_in *)sa)->sin_addr;
737                         if (IN_LOOPBACK(addr.s_addr))
738                                 addr_scope = RT_SCOPE_HOST;
739                         else if (IN_LINKLOCAL(addr.s_addr))
740                                 addr_scope = RT_SCOPE_LINK;
741                         break;
742                 }
743 #endif
744 #ifdef INET6
745         case AF_INET6:
746                 {
747                         const struct in6_addr *addr;
748                         addr = &((const struct sockaddr_in6 *)sa)->sin6_addr;
749                         if (IN6_IS_ADDR_LOOPBACK(addr))
750                                 addr_scope = RT_SCOPE_HOST;
751                         else if (IN6_IS_ADDR_LINKLOCAL(addr))
752                                 addr_scope = RT_SCOPE_LINK;
753                         break;
754                 }
755 #endif
756         }
757 
758         return (addr_scope);
759 }
760 
761 static uint8_t
762 inet6_get_plen(const struct in6_addr *addr)
763 {
764 
765 	return (bitcount32(addr->s6_addr32[0]) + bitcount32(addr->s6_addr32[1]) +
766 	    bitcount32(addr->s6_addr32[2]) + bitcount32(addr->s6_addr32[3]));
767 }
768 
769 static uint8_t
770 get_sa_plen(const struct sockaddr *sa)
771 {
772 #ifdef INET
773         const struct in_addr *paddr;
774 #endif
775 #ifdef INET6
776         const struct in6_addr *paddr6;
777 #endif
778 
779         switch (sa->sa_family) {
780 #ifdef INET
781         case AF_INET:
782                 if (sa == NULL)
783                         return (32);
784                 paddr = &(((const struct sockaddr_in *)sa)->sin_addr);
785                 return bitcount32(paddr->s_addr);;
786 #endif
787 #ifdef INET6
788         case AF_INET6:
789                 if (sa == NULL)
790                         return (128);
791                 paddr6 = &(((const struct sockaddr_in6 *)sa)->sin6_addr);
792                 return inet6_get_plen(paddr6);
793 #endif
794         }
795 
796         return (0);
797 }
798 
799 
800 /*
801  * {'attrs': [('IFA_ADDRESS', '12.0.0.1'),
802            ('IFA_LOCAL', '12.0.0.1'),
803            ('IFA_LABEL', 'eth10'),
804            ('IFA_FLAGS', 128),
805            ('IFA_CACHEINFO', {'ifa_preferred': 4294967295, 'ifa_valid': 4294967295, 'cstamp': 63745746, 'tstamp': 63745746})],
806  */
807 static bool
808 dump_iface_addr(struct nl_writer *nw, struct ifnet *ifp, struct ifaddr *ifa,
809     const struct nlmsghdr *hdr)
810 {
811         struct ifaddrmsg *ifamsg;
812         struct sockaddr *sa = ifa->ifa_addr;
813 
814         NL_LOG(LOG_DEBUG3, "dumping ifa %p type %s(%d) for interface %s",
815             ifa, rib_print_family(sa->sa_family), sa->sa_family, if_name(ifp));
816 
817 	if (!nlmsg_reply(nw, hdr, sizeof(struct ifaddrmsg)))
818 		goto enomem;
819 
820         ifamsg = nlmsg_reserve_object(nw, struct ifaddrmsg);
821         ifamsg->ifa_family = sa->sa_family;
822         ifamsg->ifa_prefixlen = get_sa_plen(ifa->ifa_netmask);
823         ifamsg->ifa_flags = 0; // ifa_flags is useless
824         ifamsg->ifa_scope = ifa_get_scope(ifa);
825         ifamsg->ifa_index = ifp->if_index;
826 
827 	if (ifp->if_flags & IFF_POINTOPOINT) {
828 		dump_sa(nw, IFA_ADDRESS, ifa->ifa_dstaddr);
829 		dump_sa(nw, IFA_LOCAL, sa);
830 	} else {
831 		dump_sa(nw, IFA_ADDRESS, sa);
832 #ifdef INET
833 		/*
834 		 * In most cases, IFA_ADDRESS == IFA_LOCAL
835 		 * Skip IFA_LOCAL for anything except INET
836 		 */
837 		if (sa->sa_family == AF_INET)
838 			dump_sa(nw, IFA_LOCAL, sa);
839 #endif
840 	}
841 	if (ifp->if_flags & IFF_BROADCAST)
842 		dump_sa(nw, IFA_BROADCAST, ifa->ifa_broadaddr);
843 
844         nlattr_add_string(nw, IFA_LABEL, if_name(ifp));
845 
846         uint32_t val = 0; // ifa->ifa_flags;
847         nlattr_add_u32(nw, IFA_FLAGS, val);
848 
849 	if (nlmsg_end(nw))
850 		return (true);
851 enomem:
852         NL_LOG(LOG_DEBUG, "Failed to dump ifa type %s(%d) for interface %s",
853             rib_print_family(sa->sa_family), sa->sa_family, if_name(ifp));
854         nlmsg_abort(nw);
855         return (false);
856 }
857 
858 static int
859 dump_iface_addrs(struct netlink_walkargs *wa, struct ifnet *ifp)
860 {
861         struct ifaddr *ifa;
862 
863 	CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
864 		if (wa->family != 0 && wa->family != ifa->ifa_addr->sa_family)
865 			continue;
866 		if (ifa->ifa_addr->sa_family == AF_LINK)
867 			continue;
868 		wa->count++;
869 		if (!dump_iface_addr(wa->nw, ifp, ifa, &wa->hdr))
870 			return (ENOMEM);
871 		wa->dumped++;
872 	}
873 
874 	return (0);
875 }
876 
877 static int
878 rtnl_handle_getaddr(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_pstate *npt)
879 {
880         struct ifnet *ifp;
881 	int error = 0;
882 
883 	struct nl_parsed_ifa attrs = {};
884 	error = nl_parse_nlmsg(hdr, &ifaddrmsg_parser, npt, &attrs);
885 	if (error != 0)
886 		return (error);
887 
888 	struct netlink_walkargs wa = {
889 		.so = nlp,
890 		.nw = npt->nw,
891 		.family = attrs.ifa_family,
892 		.hdr.nlmsg_pid = hdr->nlmsg_pid,
893 		.hdr.nlmsg_seq = hdr->nlmsg_seq,
894 		.hdr.nlmsg_flags = hdr->nlmsg_flags | NLM_F_MULTI,
895 		.hdr.nlmsg_type = NL_RTM_NEWADDR,
896 	};
897 
898 	NL_LOG(LOG_DEBUG2, "Start dump");
899 
900 	if (attrs.ifa_index != 0) {
901 		ifp = ifnet_byindex(attrs.ifa_index);
902 		if (ifp == NULL)
903 			error = ENOENT;
904 		else
905 			error = dump_iface_addrs(&wa, ifp);
906 	} else {
907 		CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
908 			error = dump_iface_addrs(&wa, ifp);
909 			if (error != 0)
910 				break;
911 		}
912 	}
913 
914 	NL_LOG(LOG_DEBUG2, "End dump, iterated %d dumped %d", wa.count, wa.dumped);
915 
916 	if (!nlmsg_end_dump(wa.nw, error, &wa.hdr)) {
917                 NL_LOG(LOG_DEBUG, "Unable to finalize the dump");
918                 return (ENOMEM);
919         }
920 
921 	return (error);
922 }
923 
924 static void
925 rtnl_handle_ifaddr(void *arg __unused, struct ifaddr *ifa, int cmd)
926 {
927 	struct nlmsghdr hdr = {};
928 	struct nl_writer nw = {};
929 	uint32_t group = 0;
930 
931 	switch (ifa->ifa_addr->sa_family) {
932 #ifdef INET
933 	case AF_INET:
934 		group = RTNLGRP_IPV4_IFADDR;
935 		break;
936 #endif
937 #ifdef INET6
938 	case AF_INET6:
939 		group = RTNLGRP_IPV6_IFADDR;
940 		break;
941 #endif
942 	default:
943 		NL_LOG(LOG_DEBUG2, "ifa notification for unknown AF: %d",
944 		    ifa->ifa_addr->sa_family);
945 		return;
946 	}
947 
948 	if (!nl_has_listeners(NETLINK_ROUTE, group))
949 		return;
950 
951 	if (!nlmsg_get_group_writer(&nw, NLMSG_LARGE, NETLINK_ROUTE, group)) {
952 		NL_LOG(LOG_DEBUG, "error allocating group writer");
953 		return;
954 	}
955 
956 	hdr.nlmsg_type = (cmd == RTM_DELETE) ? NL_RTM_DELADDR : NL_RTM_NEWADDR;
957 
958 	dump_iface_addr(&nw, ifa->ifa_ifp, ifa, &hdr);
959 	nlmsg_flush(&nw);
960 }
961 
962 static void
963 rtnl_handle_ifevent(struct ifnet *ifp, int nlmsg_type, int if_flags_mask)
964 {
965 	struct nlmsghdr hdr = { .nlmsg_type = nlmsg_type };
966 	struct nl_writer nw = {};
967 
968 	if (!nl_has_listeners(NETLINK_ROUTE, RTNLGRP_LINK))
969 		return;
970 
971 	if (!nlmsg_get_group_writer(&nw, NLMSG_LARGE, NETLINK_ROUTE, RTNLGRP_LINK)) {
972 		NL_LOG(LOG_DEBUG, "error allocating mbuf");
973 		return;
974 	}
975 	dump_iface(&nw, ifp, &hdr, if_flags_mask);
976         nlmsg_flush(&nw);
977 }
978 
979 static void
980 rtnl_handle_ifattach(void *arg, struct ifnet *ifp)
981 {
982 	NL_LOG(LOG_DEBUG2, "ifnet %s", if_name(ifp));
983 	rtnl_handle_ifevent(ifp, NL_RTM_NEWLINK, 0);
984 }
985 
986 static void
987 rtnl_handle_ifdetach(void *arg, struct ifnet *ifp)
988 {
989 	NL_LOG(LOG_DEBUG2, "ifnet %s", if_name(ifp));
990 	rtnl_handle_ifevent(ifp, NL_RTM_DELLINK, 0);
991 }
992 
993 static void
994 rtnl_handle_iflink(void *arg, struct ifnet *ifp)
995 {
996 	NL_LOG(LOG_DEBUG2, "ifnet %s", if_name(ifp));
997 	rtnl_handle_ifevent(ifp, NL_RTM_NEWLINK, 0);
998 }
999 
1000 void
1001 rtnl_handle_ifnet_event(struct ifnet *ifp, int if_flags_mask)
1002 {
1003 	NL_LOG(LOG_DEBUG2, "ifnet %s", if_name(ifp));
1004 	rtnl_handle_ifevent(ifp, NL_RTM_NEWLINK, if_flags_mask);
1005 }
1006 
1007 static const struct rtnl_cmd_handler cmd_handlers[] = {
1008 	{
1009 		.cmd = NL_RTM_GETLINK,
1010 		.name = "RTM_GETLINK",
1011 		.cb = &rtnl_handle_getlink,
1012 		.flags = RTNL_F_NOEPOCH,
1013 	},
1014 	{
1015 		.cmd = NL_RTM_DELLINK,
1016 		.name = "RTM_DELLINK",
1017 		.cb = &rtnl_handle_dellink,
1018 		.priv = PRIV_NET_IFDESTROY,
1019 		.flags = RTNL_F_NOEPOCH,
1020 	},
1021 	{
1022 		.cmd = NL_RTM_NEWLINK,
1023 		.name = "RTM_NEWLINK",
1024 		.cb = &rtnl_handle_newlink,
1025 		.priv = PRIV_NET_IFCREATE,
1026 		.flags = RTNL_F_NOEPOCH,
1027 	},
1028 	{
1029 		.cmd = NL_RTM_GETADDR,
1030 		.name = "RTM_GETADDR",
1031 		.cb = &rtnl_handle_getaddr,
1032 	},
1033 	{
1034 		.cmd = NL_RTM_NEWADDR,
1035 		.name = "RTM_NEWADDR",
1036 		.cb = &rtnl_handle_getaddr,
1037 	},
1038 	{
1039 		.cmd = NL_RTM_DELADDR,
1040 		.name = "RTM_DELADDR",
1041 		.cb = &rtnl_handle_getaddr,
1042 	},
1043 };
1044 
1045 static const struct nlhdr_parser *all_parsers[] = { &ifmsg_parser, &ifaddrmsg_parser };
1046 
1047 void
1048 rtnl_iface_add_cloner(struct nl_cloner *cloner)
1049 {
1050 	sx_xlock(&rtnl_cloner_lock);
1051 	SLIST_INSERT_HEAD(&nl_cloners, cloner, next);
1052 	sx_xunlock(&rtnl_cloner_lock);
1053 }
1054 
1055 void
1056 rtnl_iface_del_cloner(struct nl_cloner *cloner)
1057 {
1058 	sx_xlock(&rtnl_cloner_lock);
1059 	SLIST_REMOVE(&nl_cloners, cloner, nl_cloner, next);
1060 	sx_xunlock(&rtnl_cloner_lock);
1061 }
1062 
1063 static struct nl_cloner *
1064 rtnl_iface_find_cloner_locked(const char *name)
1065 {
1066 	struct nl_cloner *cloner;
1067 
1068 	SLIST_FOREACH(cloner, &nl_cloners, next) {
1069 		if (!strcmp(name, cloner->name))
1070 			return (cloner);
1071 	}
1072 
1073 	return (NULL);
1074 }
1075 
1076 void
1077 rtnl_ifaces_init(void)
1078 {
1079 	ifattach_event = EVENTHANDLER_REGISTER(
1080 	    ifnet_arrival_event, rtnl_handle_ifattach, NULL,
1081 	    EVENTHANDLER_PRI_ANY);
1082 	ifdetach_event = EVENTHANDLER_REGISTER(
1083 	    ifnet_departure_event, rtnl_handle_ifdetach, NULL,
1084 	    EVENTHANDLER_PRI_ANY);
1085 	ifaddr_event = EVENTHANDLER_REGISTER(
1086 	    rt_addrmsg, rtnl_handle_ifaddr, NULL,
1087 	    EVENTHANDLER_PRI_ANY);
1088 	iflink_event = EVENTHANDLER_REGISTER(
1089 	    ifnet_link_event, rtnl_handle_iflink, NULL,
1090 	    EVENTHANDLER_PRI_ANY);
1091 	NL_VERIFY_PARSERS(all_parsers);
1092 	rtnl_iface_drivers_register();
1093 	rtnl_register_messages(cmd_handlers, NL_ARRAY_LEN(cmd_handlers));
1094 }
1095 
1096 void
1097 rtnl_ifaces_destroy(void)
1098 {
1099 	EVENTHANDLER_DEREGISTER(ifnet_arrival_event, ifattach_event);
1100 	EVENTHANDLER_DEREGISTER(ifnet_departure_event, ifdetach_event);
1101 	EVENTHANDLER_DEREGISTER(rt_addrmsg, ifaddr_event);
1102 	EVENTHANDLER_DEREGISTER(ifnet_link_event, iflink_event);
1103 }
1104