xref: /freebsd/sys/compat/linux/linux_netlink.c (revision e6bfd18d21b225af6a0ed67ceeaf1293b7b9eba5)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 2022 Alexander V. Chernikov
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 
31 #include "opt_inet.h"
32 #include "opt_inet6.h"
33 #include "opt_netlink.h"
34 
35 #include <sys/types.h>
36 #include <sys/ck.h>
37 #include <sys/lock.h>
38 #include <sys/malloc.h>
39 #include <sys/rmlock.h>
40 #include <sys/socket.h>
41 #include <sys/vnode.h>
42 
43 #include <net/if.h>
44 #include <net/if_dl.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_linux.h>
51 #include <netlink/netlink_route.h>
52 
53 #include <compat/linux/linux.h>
54 #include <compat/linux/linux_common.h>
55 #include <compat/linux/linux_util.h>
56 
57 #define	DEBUG_MOD_NAME	nl_linux
58 #define	DEBUG_MAX_LEVEL	LOG_DEBUG3
59 #include <netlink/netlink_debug.h>
60 _DECLARE_DEBUG(LOG_INFO);
61 
62 static bool
63 valid_rta_size(const struct rtattr *rta, int sz)
64 {
65 	return (NL_RTA_DATA_LEN(rta) == sz);
66 }
67 
68 static bool
69 valid_rta_u32(const struct rtattr *rta)
70 {
71 	return (valid_rta_size(rta, sizeof(uint32_t)));
72 }
73 
74 static uint32_t
75 _rta_get_uint32(const struct rtattr *rta)
76 {
77 	return (*((const uint32_t *)NL_RTA_DATA_CONST(rta)));
78 }
79 
80 static struct nlmsghdr *
81 rtnl_neigh_from_linux(struct nlmsghdr *hdr, struct nl_pstate *npt)
82 {
83 	struct ndmsg *ndm = (struct ndmsg *)(hdr + 1);
84 
85 	if (hdr->nlmsg_len >= sizeof(struct nlmsghdr) + sizeof(struct ndmsg))
86 		ndm->ndm_family = linux_to_bsd_domain(ndm->ndm_family);
87 
88 	return (hdr);
89 }
90 
91 static struct nlmsghdr *
92 rtnl_ifaddr_from_linux(struct nlmsghdr *hdr, struct nl_pstate *npt)
93 {
94 	struct ifaddrmsg *ifam = (struct ifaddrmsg *)(hdr + 1);
95 
96 	if (hdr->nlmsg_len >= sizeof(struct nlmsghdr) + sizeof(struct ifaddrmsg))
97 		ifam->ifa_family = linux_to_bsd_domain(ifam->ifa_family);
98 
99 	return (hdr);
100 }
101 
102 static struct nlmsghdr *
103 rtnl_route_from_linux(struct nlmsghdr *hdr, struct nl_pstate *npt)
104 {
105 	/* Tweak address families and default fib only */
106 	struct rtmsg *rtm = (struct rtmsg *)(hdr + 1);
107 	struct nlattr *nla, *nla_head;
108 	int attrs_len;
109 
110 	rtm->rtm_family = linux_to_bsd_domain(rtm->rtm_family);
111 
112 	if (rtm->rtm_table == 254)
113 		rtm->rtm_table = 0;
114 
115 	attrs_len = hdr->nlmsg_len - sizeof(struct nlmsghdr);
116 	attrs_len -= NETLINK_ALIGN(sizeof(struct rtmsg));
117 	nla_head = (struct nlattr *)((char *)rtm + NETLINK_ALIGN(sizeof(struct rtmsg)));
118 
119 	NLA_FOREACH(nla, nla_head, attrs_len) {
120 		RT_LOG(LOG_DEBUG3, "GOT type %d len %d total %d",
121 		    nla->nla_type, nla->nla_len, attrs_len);
122 		struct rtattr *rta = (struct rtattr *)nla;
123 		if (rta->rta_len < sizeof(struct rtattr)) {
124 			break;
125 		}
126 		switch (rta->rta_type) {
127 		case NL_RTA_TABLE:
128 			if (!valid_rta_u32(rta))
129 				goto done;
130 			rtm->rtm_table = 0;
131 			uint32_t fibnum = _rta_get_uint32(rta);
132 			RT_LOG(LOG_DEBUG3, "GET RTABLE: %u", fibnum);
133 			if (fibnum == 254) {
134 				*((uint32_t *)NL_RTA_DATA(rta)) = 0;
135 			}
136 			break;
137 		}
138 	}
139 
140 done:
141 	return (hdr);
142 }
143 
144 static struct nlmsghdr *
145 rtnl_from_linux(struct nlmsghdr *hdr, struct nl_pstate *npt)
146 {
147 	switch (hdr->nlmsg_type) {
148 	case NL_RTM_GETROUTE:
149 	case NL_RTM_NEWROUTE:
150 	case NL_RTM_DELROUTE:
151 		return (rtnl_route_from_linux(hdr, npt));
152 	case NL_RTM_GETNEIGH:
153 		return (rtnl_neigh_from_linux(hdr, npt));
154 	case NL_RTM_GETADDR:
155 		return (rtnl_ifaddr_from_linux(hdr, npt));
156 	/* Silence warning for the messages where no translation is required */
157 	case NL_RTM_NEWLINK:
158 	case NL_RTM_DELLINK:
159 	case NL_RTM_GETLINK:
160 		break;
161 	default:
162 		RT_LOG(LOG_DEBUG, "Passing message type %d untranslated",
163 		    hdr->nlmsg_type);
164 	}
165 
166 	return (hdr);
167 }
168 
169 static struct nlmsghdr *
170 nlmsg_from_linux(int netlink_family, struct nlmsghdr *hdr,
171     struct nl_pstate *npt)
172 {
173 	switch (netlink_family) {
174 	case NETLINK_ROUTE:
175 		return (rtnl_from_linux(hdr, npt));
176 	}
177 
178 	return (hdr);
179 }
180 
181 
182 /************************************************************
183  * Kernel -> Linux
184  ************************************************************/
185 
186 static bool
187 handle_default_out(struct nlmsghdr *hdr, struct nl_writer *nw)
188 {
189 	char *out_hdr;
190 	out_hdr = nlmsg_reserve_data(nw, NLMSG_ALIGN(hdr->nlmsg_len), char);
191 
192 	if (out_hdr != NULL) {
193 		memcpy(out_hdr, hdr, hdr->nlmsg_len);
194 		return (true);
195 	}
196 	return (false);
197 }
198 
199 static bool
200 nlmsg_copy_header(struct nlmsghdr *hdr, struct nl_writer *nw)
201 {
202 	return (nlmsg_add(nw, hdr->nlmsg_pid, hdr->nlmsg_seq, hdr->nlmsg_type,
203 	    hdr->nlmsg_flags, 0));
204 }
205 
206 static void *
207 _nlmsg_copy_next_header(struct nlmsghdr *hdr, struct nl_writer *nw, int sz)
208 {
209 	void *next_hdr = nlmsg_reserve_data(nw, sz, void);
210 	memcpy(next_hdr, hdr + 1, NLMSG_ALIGN(sz));
211 
212 	return (next_hdr);
213 }
214 #define	nlmsg_copy_next_header(_hdr, _ns, _t)	\
215 	((_t *)(_nlmsg_copy_next_header(_hdr, _ns, sizeof(_t))))
216 
217 static bool
218 nlmsg_copy_nla(const struct nlattr *nla_orig, struct nl_writer *nw)
219 {
220 	struct nlattr *nla = nlmsg_reserve_data(nw, nla_orig->nla_len, struct nlattr);
221 	if (nla != NULL) {
222 		memcpy(nla, nla_orig, nla_orig->nla_len);
223 		return (true);
224 	}
225 	return (false);
226 }
227 
228 /*
229  * Translate a FreeBSD interface name to a Linux interface name.
230  */
231 static bool
232 nlmsg_translate_ifname_nla(struct nlattr *nla, struct nl_writer *nw)
233 {
234 	char ifname[LINUX_IFNAMSIZ];
235 
236 	if (ifname_bsd_to_linux_name((char *)(nla + 1), ifname,
237 	    sizeof(ifname)) <= 0)
238 		return (false);
239 	return (nlattr_add_string(nw, IFLA_IFNAME, ifname));
240 }
241 
242 #define	LINUX_NLA_UNHANDLED	-1
243 /*
244  * Translate a FreeBSD attribute to a Linux attribute.
245  * Returns LINUX_NLA_UNHANDLED when the attribute is not processed
246  * and the caller must take care of it, otherwise the result is returned.
247  */
248 static int
249 nlmsg_translate_all_nla(struct nlmsghdr *hdr, struct nlattr *nla,
250     struct nl_writer *nw)
251 {
252 
253 	switch (hdr->nlmsg_type) {
254 	case NL_RTM_NEWLINK:
255 	case NL_RTM_DELLINK:
256 	case NL_RTM_GETLINK:
257 		switch (nla->nla_type) {
258 		case IFLA_IFNAME:
259 			return (nlmsg_translate_ifname_nla(nla, nw));
260 		default:
261 			break;
262 		}
263 	default:
264 		break;
265 	}
266 	return (LINUX_NLA_UNHANDLED);
267 }
268 
269 static bool
270 nlmsg_copy_all_nla(struct nlmsghdr *hdr, int raw_hdrlen, struct nl_writer *nw)
271 {
272 	struct nlattr *nla;
273 	int ret;
274 
275 	int hdrlen = NETLINK_ALIGN(raw_hdrlen);
276 	int attrs_len = hdr->nlmsg_len - sizeof(struct nlmsghdr) - hdrlen;
277 	struct nlattr *nla_head = (struct nlattr *)((char *)(hdr + 1) + hdrlen);
278 
279 	NLA_FOREACH(nla, nla_head, attrs_len) {
280 		RT_LOG(LOG_DEBUG3, "reading attr %d len %d", nla->nla_type, nla->nla_len);
281 		if (nla->nla_len < sizeof(struct nlattr)) {
282 			return (false);
283 		}
284 		ret = nlmsg_translate_all_nla(hdr, nla, nw);
285 		if (ret == LINUX_NLA_UNHANDLED)
286 			ret = nlmsg_copy_nla(nla, nw);
287 		if (!ret)
288 			return (false);
289 	}
290 	return (true);
291 }
292 #undef LINUX_NLA_UNHANDLED
293 
294 static unsigned int
295 rtnl_if_flags_to_linux(unsigned int if_flags)
296 {
297 	unsigned int result = 0;
298 
299 	for (int i = 0; i < 31; i++) {
300 		unsigned int flag = 1 << i;
301 		if (!(flag & if_flags))
302 			continue;
303 		switch (flag) {
304 		case IFF_UP:
305 		case IFF_BROADCAST:
306 		case IFF_DEBUG:
307 		case IFF_LOOPBACK:
308 		case IFF_POINTOPOINT:
309 		case IFF_DRV_RUNNING:
310 		case IFF_NOARP:
311 		case IFF_PROMISC:
312 		case IFF_ALLMULTI:
313 			result |= flag;
314 			break;
315 		case IFF_NEEDSEPOCH:
316 		case IFF_DRV_OACTIVE:
317 		case IFF_SIMPLEX:
318 		case IFF_LINK0:
319 		case IFF_LINK1:
320 		case IFF_LINK2:
321 		case IFF_CANTCONFIG:
322 		case IFF_PPROMISC:
323 		case IFF_MONITOR:
324 		case IFF_STATICARP:
325 		case IFF_STICKYARP:
326 		case IFF_DYING:
327 		case IFF_RENAMING:
328 		case IFF_NOGROUP:
329 			/* No Linux analogue */
330 			break;
331 		case IFF_MULTICAST:
332 			result |= 1 << 12;
333 		}
334 	}
335 	return (result);
336 }
337 
338 static bool
339 rtnl_newlink_to_linux(struct nlmsghdr *hdr, struct nlpcb *nlp,
340     struct nl_writer *nw)
341 {
342 	if (!nlmsg_copy_header(hdr, nw))
343 		return (false);
344 
345 	struct ifinfomsg *ifinfo;
346 	ifinfo = nlmsg_copy_next_header(hdr, nw, struct ifinfomsg);
347 
348 	ifinfo->ifi_family = bsd_to_linux_domain(ifinfo->ifi_family);
349 	/* Convert interface type */
350 	switch (ifinfo->ifi_type) {
351 	case IFT_ETHER:
352 		ifinfo->ifi_type = LINUX_ARPHRD_ETHER;
353 		break;
354 	}
355 	ifinfo->ifi_flags = rtnl_if_flags_to_linux(ifinfo->ifi_flags);
356 
357 	/* Copy attributes unchanged */
358 	if (!nlmsg_copy_all_nla(hdr, sizeof(struct ifinfomsg), nw))
359 		return (false);
360 
361 	/* make ip(8) happy */
362 	if (!nlattr_add_string(nw, IFLA_QDISC, "noqueue"))
363 		return (false);
364 
365 	if (!nlattr_add_u32(nw, IFLA_TXQLEN, 1000))
366 		return (false);
367 
368 	nlmsg_end(nw);
369 	RT_LOG(LOG_DEBUG2, "done processing nw %p", nw);
370 	return (true);
371 }
372 
373 static bool
374 rtnl_newaddr_to_linux(struct nlmsghdr *hdr, struct nlpcb *nlp,
375     struct nl_writer *nw)
376 {
377 	if (!nlmsg_copy_header(hdr, nw))
378 		return (false);
379 
380 	struct ifaddrmsg *ifamsg;
381 	ifamsg = nlmsg_copy_next_header(hdr, nw, struct ifaddrmsg);
382 
383 	ifamsg->ifa_family = bsd_to_linux_domain(ifamsg->ifa_family);
384 	/* XXX: fake ifa_flags? */
385 
386 	/* Copy attributes unchanged */
387 	if (!nlmsg_copy_all_nla(hdr, sizeof(struct ifaddrmsg), nw))
388 		return (false);
389 
390 	nlmsg_end(nw);
391 	RT_LOG(LOG_DEBUG2, "done processing nw %p", nw);
392 	return (true);
393 }
394 
395 static bool
396 rtnl_newneigh_to_linux(struct nlmsghdr *hdr, struct nlpcb *nlp,
397     struct nl_writer *nw)
398 {
399 	if (!nlmsg_copy_header(hdr, nw))
400 		return (false);
401 
402 	struct ndmsg *ndm;
403 	ndm = nlmsg_copy_next_header(hdr, nw, struct ndmsg);
404 
405 	ndm->ndm_family = bsd_to_linux_domain(ndm->ndm_family);
406 
407 	/* Copy attributes unchanged */
408 	if (!nlmsg_copy_all_nla(hdr, sizeof(struct ndmsg), nw))
409 		return (false);
410 
411 	nlmsg_end(nw);
412 	RT_LOG(LOG_DEBUG2, "done processing nw %p", nw);
413 	return (true);
414 }
415 
416 static bool
417 rtnl_newroute_to_linux(struct nlmsghdr *hdr, struct nlpcb *nlp,
418     struct nl_writer *nw)
419 {
420 	if (!nlmsg_copy_header(hdr, nw))
421 		return (false);
422 
423 	struct rtmsg *rtm;
424 	rtm = nlmsg_copy_next_header(hdr, nw, struct rtmsg);
425 	rtm->rtm_family = bsd_to_linux_domain(rtm->rtm_family);
426 
427 	struct nlattr *nla;
428 
429 	int hdrlen = NETLINK_ALIGN(sizeof(struct rtmsg));
430 	int attrs_len = hdr->nlmsg_len - sizeof(struct nlmsghdr) - hdrlen;
431 	struct nlattr *nla_head = (struct nlattr *)((char *)(hdr + 1) + hdrlen);
432 
433 	NLA_FOREACH(nla, nla_head, attrs_len) {
434 		struct rtattr *rta = (struct rtattr *)nla;
435 		//RT_LOG(LOG_DEBUG, "READING attr %d len %d", nla->nla_type, nla->nla_len);
436 		if (rta->rta_len < sizeof(struct rtattr)) {
437 			break;
438 		}
439 
440 		switch (rta->rta_type) {
441 		case NL_RTA_TABLE:
442 			{
443 				uint32_t fibnum;
444 				fibnum = _rta_get_uint32(rta);
445 				if (fibnum == 0)
446 					fibnum = 254;
447 				RT_LOG(LOG_DEBUG3, "XFIBNUM %u", fibnum);
448 				if (!nlattr_add_u32(nw, NL_RTA_TABLE, fibnum))
449 					return (false);
450 			}
451 			break;
452 		default:
453 			if (!nlmsg_copy_nla(nla, nw))
454 				return (false);
455 			break;
456 		}
457 	}
458 
459 	nlmsg_end(nw);
460 	RT_LOG(LOG_DEBUG2, "done processing nw %p", nw);
461 	return (true);
462 }
463 
464 static bool
465 rtnl_to_linux(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_writer *nw)
466 {
467 	RT_LOG(LOG_DEBUG2, "Got message type %d", hdr->nlmsg_type);
468 
469 	switch (hdr->nlmsg_type) {
470 	case NL_RTM_NEWLINK:
471 	case NL_RTM_DELLINK:
472 	case NL_RTM_GETLINK:
473 		return (rtnl_newlink_to_linux(hdr, nlp, nw));
474 	case NL_RTM_NEWADDR:
475 	case NL_RTM_DELADDR:
476 		return (rtnl_newaddr_to_linux(hdr, nlp, nw));
477 	case NL_RTM_NEWROUTE:
478 	case NL_RTM_DELROUTE:
479 		return (rtnl_newroute_to_linux(hdr, nlp, nw));
480 	case NL_RTM_NEWNEIGH:
481 	case NL_RTM_DELNEIGH:
482 	case NL_RTM_GETNEIGH:
483 		return (rtnl_newneigh_to_linux(hdr, nlp, nw));
484 	default:
485 		RT_LOG(LOG_DEBUG, "[WARN] Passing message type %d untranslated",
486 		    hdr->nlmsg_type);
487 		return (handle_default_out(hdr, nw));
488 	}
489 }
490 
491 static bool
492 nlmsg_error_to_linux(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_writer *nw)
493 {
494 	if (!nlmsg_copy_header(hdr, nw))
495 		return (false);
496 
497 	struct nlmsgerr *nlerr;
498 	nlerr = nlmsg_copy_next_header(hdr, nw, struct nlmsgerr);
499 	nlerr->error = bsd_to_linux_errno(nlerr->error);
500 
501 	int copied_len = sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr);
502 	if (hdr->nlmsg_len == copied_len) {
503 		nlmsg_end(nw);
504 		return (true);
505 	}
506 
507 	/*
508 	 * CAP_ACK was not set. Original request needs to be translated.
509 	 * XXX: implement translation of the original message
510 	 */
511 	RT_LOG(LOG_DEBUG, "[WARN] Passing ack message type %d untranslated",
512 	    nlerr->msg.nlmsg_type);
513 	char *dst_payload, *src_payload;
514 	int copy_len = hdr->nlmsg_len - copied_len;
515 	dst_payload = nlmsg_reserve_data(nw, NLMSG_ALIGN(copy_len), char);
516 
517 	src_payload = (char *)hdr + copied_len;
518 
519 	memcpy(dst_payload, src_payload, copy_len);
520 	nlmsg_end(nw);
521 
522 	return (true);
523 }
524 
525 static bool
526 nlmsg_to_linux(int netlink_family, struct nlmsghdr *hdr, struct nlpcb *nlp,
527     struct nl_writer *nw)
528 {
529 	if (hdr->nlmsg_type < NLMSG_MIN_TYPE) {
530 		switch (hdr->nlmsg_type) {
531 		case NLMSG_ERROR:
532 			return (nlmsg_error_to_linux(hdr, nlp, nw));
533 		case NLMSG_NOOP:
534 		case NLMSG_DONE:
535 		case NLMSG_OVERRUN:
536 			return (handle_default_out(hdr, nw));
537 		default:
538 			RT_LOG(LOG_DEBUG, "[WARN] Passing message type %d untranslated",
539 			    hdr->nlmsg_type);
540 			return (handle_default_out(hdr, nw));
541 		}
542 	}
543 
544 	switch (netlink_family) {
545 	case NETLINK_ROUTE:
546 		return (rtnl_to_linux(hdr, nlp, nw));
547 	default:
548 		return (handle_default_out(hdr, nw));
549 	}
550 }
551 
552 static struct mbuf *
553 nlmsgs_to_linux(int netlink_family, char *buf, int data_length, struct nlpcb *nlp)
554 {
555 	RT_LOG(LOG_DEBUG3, "LINUX: get %p size %d", buf, data_length);
556 	struct nl_writer nw = {};
557 
558 	struct mbuf *m = NULL;
559 	if (!nlmsg_get_chain_writer(&nw, data_length, &m)) {
560 		RT_LOG(LOG_DEBUG, "unable to setup chain writer for size %d",
561 		    data_length);
562 		return (NULL);
563 	}
564 
565 	/* Assume correct headers. Buffer IS mutable */
566 	int count = 0;
567 	for (int offset = 0; offset + sizeof(struct nlmsghdr) <= data_length;) {
568 		struct nlmsghdr *hdr = (struct nlmsghdr *)&buf[offset];
569 		int msglen = NLMSG_ALIGN(hdr->nlmsg_len);
570 		count++;
571 
572 		if (!nlmsg_to_linux(netlink_family, hdr, nlp, &nw)) {
573 			RT_LOG(LOG_DEBUG, "failed to process msg type %d",
574 			    hdr->nlmsg_type);
575 			m_freem(m);
576 			return (NULL);
577 		}
578 		offset += msglen;
579 	}
580 	nlmsg_flush(&nw);
581 	RT_LOG(LOG_DEBUG3, "Processed %d messages, chain size %d", count,
582 	    m ? m_length(m, NULL) : 0);
583 
584 	return (m);
585 }
586 
587 static struct mbuf *
588 mbufs_to_linux(int netlink_family, struct mbuf *m, struct nlpcb *nlp)
589 {
590 	/* XXX: easiest solution, not optimized for performance */
591 	int data_length = m_length(m, NULL);
592 	char *buf = malloc(data_length, M_LINUX, M_NOWAIT);
593 	if (buf == NULL) {
594 		RT_LOG(LOG_DEBUG, "unable to allocate %d bytes, dropping message",
595 		    data_length);
596 		m_freem(m);
597 		return (NULL);
598 	}
599 	m_copydata(m, 0, data_length, buf);
600 	m_freem(m);
601 
602 	m = nlmsgs_to_linux(netlink_family, buf, data_length, nlp);
603 	free(buf, M_LINUX);
604 
605 	return (m);
606 }
607 
608 static struct linux_netlink_provider linux_netlink_v1 = {
609 	.mbufs_to_linux = mbufs_to_linux,
610 	.msgs_to_linux = nlmsgs_to_linux,
611 	.msg_from_linux = nlmsg_from_linux,
612 };
613 
614 void
615 linux_netlink_register(void)
616 {
617 	linux_netlink_p = &linux_netlink_v1;
618 }
619 
620 void
621 linux_netlink_deregister(void)
622 {
623 	linux_netlink_p = NULL;
624 }
625