sys/compat/linux/linux_netlink.c

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