netlink_message_parser.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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/malloc.h>
   34 #include <sys/rmlock.h>
   35 #include <sys/socket.h>
   36 
   37 #include <machine/stdarg.h>
   38 
   39 #include <net/if.h>
   40 #include <net/route.h>
   41 #include <net/route/nhop.h>
   42 
   43 #include <net/route/route_ctl.h>
   44 #include <netlink/netlink.h>
   45 #include <netlink/netlink_ctl.h>
   46 #include <netlink/netlink_var.h>
   47 #include <netlink/netlink_route.h>
   48 
   49 #define DEBUG_MOD_NAME  nl_parser
   50 #define DEBUG_MAX_LEVEL LOG_DEBUG3
   51 #include <netlink/netlink_debug.h>
   52 _DECLARE_DEBUG(LOG_DEBUG);
   53 
   54 bool
   55 nlmsg_report_err_msg(struct nl_pstate *npt, const char *fmt, ...)
   56 {
   57         va_list ap;
   58 
   59         if (npt->err_msg != NULL)
   60                 return (false);
   61         char *buf = npt_alloc(npt, NL_MAX_ERROR_BUF);
   62         if (buf == NULL)
   63                 return (false);
   64         va_start(ap, fmt);
   65         vsnprintf(buf, NL_MAX_ERROR_BUF, fmt, ap);
   66         va_end(ap);
   67 
   68         npt->err_msg = buf;
   69         return (true);
   70 }
   71 
   72 bool
   73 nlmsg_report_err_offset(struct nl_pstate *npt, uint32_t off)
   74 {
   75         if (npt->err_off != 0)
   76                 return (false);
   77         npt->err_off = off;
   78         return (true);
   79 }
   80 
   81 static const struct nlattr_parser *
   82 search_states(const struct nlattr_parser *ps, int pslen, int key)
   83 {
   84         int left_i = 0, right_i = pslen - 1;
   85 
   86         if (key < ps[0].type || key > ps[pslen - 1].type)
   87                 return (NULL);
   88 
   89         while (left_i + 1 < right_i) {
   90                 int mid_i = (left_i + right_i) / 2;
   91                 if (key < ps[mid_i].type)
   92                         right_i = mid_i;
   93                 else if (key > ps[mid_i].type)
   94                         left_i = mid_i + 1;
   95                 else
   96                         return (&ps[mid_i]);
   97         }
   98         if (ps[left_i].type == key)
   99                 return (&ps[left_i]);
  100         else if (ps[right_i].type == key)
  101                 return (&ps[right_i]);
  102         return (NULL);
  103 }
  104 
  105 int
  106 nl_parse_attrs_raw(struct nlattr *nla_head, int len, const struct nlattr_parser *ps, int pslen,
  107     struct nl_pstate *npt, void *target)
  108 {
  109         struct nlattr *nla = NULL;
  110         int error = 0;
  111 
  112         NL_LOG(LOG_DEBUG3, "parse %p remaining_len %d", nla_head, len);
  113         int orig_len = len;
  114         NLA_FOREACH(nla, nla_head, len) {
  115                 NL_LOG(LOG_DEBUG3, ">> parsing %p attr_type %d len %d (rem %d)", nla, nla->nla_type, nla->nla_len, len);
  116                 if (nla->nla_len < sizeof(struct nlattr)) {
  117                         NLMSG_REPORT_ERR_MSG(npt, "Invalid attr %p type %d len: %d",
  118                             nla, nla->nla_type, nla->nla_len);
  119                         uint32_t off = (char *)nla - (char *)npt->hdr;
  120                         nlmsg_report_err_offset(npt, off);
  121                         return (EINVAL);
  122                 }
  123 
  124                 int nla_type = nla->nla_type & NLA_TYPE_MASK;
  125                 const struct nlattr_parser *s = search_states(ps, pslen, nla_type);
  126                 if (s != NULL) {
  127                         void *ptr = (void *)((char *)target + s->off);
  128                         error = s->cb(nla, npt, s->arg, ptr);
  129                         if (error != 0) {
  130                                 uint32_t off = (char *)nla - (char *)npt->hdr;
  131                                 nlmsg_report_err_offset(npt, off);
  132                                 NL_LOG(LOG_DEBUG3, "parse failed att offset %u", off);
  133                                 return (error);
  134                         }
  135                 } else {
  136                         /* Ignore non-specified attributes */
  137                         NL_LOG(LOG_DEBUG3, "ignoring attr %d", nla->nla_type);
  138                 }
  139         }
  140         if (len >= sizeof(struct nlattr)) {
  141                 nla = (struct nlattr *)((char *)nla_head + (orig_len - len));
  142                 NL_LOG(LOG_DEBUG3, " >>> end %p attr_type %d len %d", nla,
  143                     nla->nla_type, nla->nla_len);
  144         }
  145         NL_LOG(LOG_DEBUG3, "end parse: %p remaining_len %d", nla, len);
  146 
  147         return (0);
  148 }
  149 
  150 void
  151 nl_get_attrs_bmask_raw(struct nlattr *nla_head, int len, struct nlattr_bmask *bm)
  152 {
  153         struct nlattr *nla = NULL;
  154 
  155         BIT_ZERO(NL_ATTR_BMASK_SIZE, bm);
  156 
  157         NLA_FOREACH(nla, nla_head, len) {
  158                 if (nla->nla_len < sizeof(struct nlattr))
  159                         return;
  160                 int nla_type = nla->nla_type & NLA_TYPE_MASK;
  161                 if (nla_type < NL_ATTR_BMASK_SIZE)
  162                         BIT_SET(NL_ATTR_BMASK_SIZE, nla_type, bm);
  163                 else
  164                         NL_LOG(LOG_DEBUG2, "Skipping type %d in the mask: too short",
  165                             nla_type);
  166         }
  167 }
  168 
  169 bool
  170 nl_has_attr(const struct nlattr_bmask *bm, unsigned int nla_type)
  171 {
  172         MPASS(nla_type < NL_ATTR_BMASK_SIZE);
  173 
  174         return (BIT_ISSET(NL_ATTR_BMASK_SIZE, nla_type, bm));
  175 }
  176 
  177 int
  178 nlattr_get_flag(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  179 {
  180         if (__predict_false(NLA_DATA_LEN(nla) != 0)) {
  181                 NLMSG_REPORT_ERR_MSG(npt, "nla type %d size(%u) is not a flag",
  182                     nla->nla_type, NLA_DATA_LEN(nla));
  183                 return (EINVAL);
  184         }
  185 
  186         *((uint8_t *)target) = 1;
  187         return (0);
  188 }
  189 
  190 static struct sockaddr *
  191 parse_rta_ip4(void *rta_data, struct nl_pstate *npt, int *perror)
  192 {
  193         struct sockaddr_in *sin;
  194 
  195         sin = (struct sockaddr_in *)npt_alloc_sockaddr(npt, sizeof(struct sockaddr_in));
  196         if (__predict_false(sin == NULL)) {
  197                 *perror = ENOBUFS;
  198                 return (NULL);
  199         }
  200         sin->sin_len = sizeof(struct sockaddr_in);
  201         sin->sin_family = AF_INET;
  202         memcpy(&sin->sin_addr, rta_data, sizeof(struct in_addr));
  203         return ((struct sockaddr *)sin);
  204 }
  205 
  206 static struct sockaddr *
  207 parse_rta_ip6(void *rta_data, struct nl_pstate *npt, int *perror)
  208 {
  209         struct sockaddr_in6 *sin6;
  210 
  211         sin6 = (struct sockaddr_in6 *)npt_alloc_sockaddr(npt, sizeof(struct sockaddr_in6));
  212         if (__predict_false(sin6 == NULL)) {
  213                 *perror = ENOBUFS;
  214                 return (NULL);
  215         }
  216         sin6->sin6_len = sizeof(struct sockaddr_in6);
  217         sin6->sin6_family = AF_INET6;
  218         memcpy(&sin6->sin6_addr, rta_data, sizeof(struct in6_addr));
  219         return ((struct sockaddr *)sin6);
  220 }
  221 
  222 static struct sockaddr *
  223 parse_rta_ip(struct rtattr *rta, struct nl_pstate *npt, int *perror)
  224 {
  225         void *rta_data = NL_RTA_DATA(rta);
  226         int rta_len = NL_RTA_DATA_LEN(rta);
  227 
  228         if (rta_len == sizeof(struct in_addr)) {
  229                 return (parse_rta_ip4(rta_data, npt, perror));
  230         } else if (rta_len == sizeof(struct in6_addr)) {
  231                 return (parse_rta_ip6(rta_data, npt, perror));
  232         } else {
  233                 NLMSG_REPORT_ERR_MSG(npt, "unknown IP len: %d for rta type %d",
  234                     rta_len, rta->rta_type);
  235                 *perror = ENOTSUP;
  236                 return (NULL);
  237         }
  238         return (NULL);
  239 }
  240 
  241 int
  242 nlattr_get_ip(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  243 {
  244         int error = 0;
  245 
  246         struct sockaddr *sa = parse_rta_ip((struct rtattr *)nla, npt, &error);
  247 
  248         *((struct sockaddr **)target) = sa;
  249         return (error);
  250 }
  251 
  252 static struct sockaddr *
  253 parse_rta_via(struct rtattr *rta, struct nl_pstate *npt, int *perror)
  254 {
  255         struct rtvia *via = NL_RTA_DATA(rta);
  256         int data_len = NL_RTA_DATA_LEN(rta);
  257 
  258         if (__predict_false(data_len) < sizeof(struct rtvia)) {
  259                 NLMSG_REPORT_ERR_MSG(npt, "undersized RTA_VIA(%d) attr: len %d",
  260                     rta->rta_type, data_len);
  261                 *perror = EINVAL;
  262                 return (NULL);
  263         }
  264         data_len -= offsetof(struct rtvia, rtvia_addr);
  265 
  266         switch (via->rtvia_family) {
  267         case AF_INET:
  268                 if (__predict_false(data_len < sizeof(struct in_addr))) {
  269                         *perror = EINVAL;
  270                         return (NULL);
  271                 }
  272                 return (parse_rta_ip4(via->rtvia_addr, npt, perror));
  273         case AF_INET6:
  274                 if (__predict_false(data_len < sizeof(struct in6_addr))) {
  275                         *perror = EINVAL;
  276                         return (NULL);
  277                 }
  278                 return (parse_rta_ip6(via->rtvia_addr, npt, perror));
  279         default:
  280                 *perror = ENOTSUP;
  281                 return (NULL);
  282         }
  283 }
  284 
  285 int
  286 nlattr_get_ipvia(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  287 {
  288         int error = 0;
  289 
  290         struct sockaddr *sa = parse_rta_via((struct rtattr *)nla, npt, &error);
  291 
  292         *((struct sockaddr **)target) = sa;
  293         return (error);
  294 }
  295 
  296 
  297 int
  298 nlattr_get_uint16(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  299 {
  300         if (__predict_false(NLA_DATA_LEN(nla) != sizeof(uint16_t))) {
  301                 NLMSG_REPORT_ERR_MSG(npt, "nla type %d size(%u) is not uint32",
  302                     nla->nla_type, NLA_DATA_LEN(nla));
  303                 return (EINVAL);
  304         }
  305         *((uint16_t *)target) = *((const uint16_t *)NL_RTA_DATA_CONST(nla));
  306         return (0);
  307 }
  308 
  309 int
  310 nlattr_get_uint32(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  311 {
  312         if (__predict_false(NLA_DATA_LEN(nla) != sizeof(uint32_t))) {
  313                 NLMSG_REPORT_ERR_MSG(npt, "nla type %d size(%u) is not uint32",
  314                     nla->nla_type, NLA_DATA_LEN(nla));
  315                 return (EINVAL);
  316         }
  317         *((uint32_t *)target) = *((const uint32_t *)NL_RTA_DATA_CONST(nla));
  318         return (0);
  319 }
  320 
  321 int
  322 nlattr_get_uint64(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  323 {
  324         if (__predict_false(NLA_DATA_LEN(nla) != sizeof(uint64_t))) {
  325                 NLMSG_REPORT_ERR_MSG(npt, "nla type %d size(%u) is not uint64",
  326                     nla->nla_type, NLA_DATA_LEN(nla));
  327                 return (EINVAL);
  328         }
  329         memcpy(target, NL_RTA_DATA_CONST(nla), sizeof(uint64_t));
  330         return (0);
  331 }
  332 
  333 static int
  334 nlattr_get_ifp_internal(struct nlattr *nla, struct nl_pstate *npt,
  335     void *target, bool zero_ok)
  336 {
  337         if (__predict_false(NLA_DATA_LEN(nla) != sizeof(uint32_t))) {
  338                 NLMSG_REPORT_ERR_MSG(npt, "nla type %d size(%u) is not uint32",
  339                     nla->nla_type, NLA_DATA_LEN(nla));
  340                 return (EINVAL);
  341         }
  342         uint32_t ifindex = *((const uint32_t *)NLA_DATA_CONST(nla));
  343 
  344         if (ifindex == 0 && zero_ok) {
  345                 *((struct ifnet **)target) = NULL;
  346                 return (0);
  347         }
  348 
  349         NET_EPOCH_ASSERT();
  350 
  351         struct ifnet *ifp = ifnet_byindex(ifindex);
  352         if (__predict_false(ifp == NULL)) {
  353                 NLMSG_REPORT_ERR_MSG(npt, "nla type %d: ifindex %u invalid",
  354                     nla->nla_type, ifindex);
  355                 return (ENOENT);
  356         }
  357         *((struct ifnet **)target) = ifp;
  358         NL_LOG(LOG_DEBUG3, "nla type %d: ifindex %u -> %s", nla->nla_type,
  359             ifindex, if_name(ifp));
  360 
  361         return (0);
  362 }
  363 
  364 int
  365 nlattr_get_ifp(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  366 {
  367         return (nlattr_get_ifp_internal(nla, npt, target, false));
  368 }
  369 
  370 int
  371 nlattr_get_ifpz(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  372 {
  373         return (nlattr_get_ifp_internal(nla, npt, target, true));
  374 }
  375 
  376 int
  377 nlattr_get_string(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  378 {
  379         int maxlen = NLA_DATA_LEN(nla);
  380 
  381         if (__predict_false(strnlen((char *)NLA_DATA(nla), maxlen) >= maxlen)) {
  382                 NLMSG_REPORT_ERR_MSG(npt, "nla type %d size(%u) is not NULL-terminated",
  383                     nla->nla_type, maxlen);
  384                 return (EINVAL);
  385         }
  386 
  387         *((char **)target) = (char *)NLA_DATA(nla);
  388         return (0);
  389 }
  390 
  391 int
  392 nlattr_get_stringn(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  393 {
  394         int maxlen = NLA_DATA_LEN(nla);
  395 
  396         char *buf = npt_alloc(npt, maxlen + 1);
  397         if (buf == NULL)
  398                 return (ENOMEM);
  399         buf[maxlen] = '\0';
  400         memcpy(buf, NLA_DATA(nla), maxlen);
  401 
  402         *((char **)target) = buf;
  403         return (0);
  404 }
  405 int
  406 nlattr_get_nla(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  407 {
  408         NL_LOG(LOG_DEBUG3, "STORING %p len %d", nla, nla->nla_len);
  409         *((struct nlattr **)target) = nla;
  410         return (0);
  411 }
  412 
  413 int
  414 nlattr_get_nested(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
  415 {
  416         const struct nlhdr_parser *p = (const struct nlhdr_parser *)arg;
  417         int error;
  418 
  419         /* Assumes target points to the beginning of the structure */
  420         error = nl_parse_header(NLA_DATA(nla), NLA_DATA_LEN(nla), p, npt, target);
  421         return (error);
  422 }
  423 
  424 int
  425 nlf_get_ifp(void *src, struct nl_pstate *npt, void *target)
  426 {
  427         int ifindex = *((const int *)src);
  428 
  429         NET_EPOCH_ASSERT();
  430 
  431         struct ifnet *ifp = ifnet_byindex(ifindex);
  432         if (ifp == NULL) {
  433                 NL_LOG(LOG_DEBUG, "ifindex %u invalid", ifindex);
  434                 return (ENOENT);
  435         }
  436         *((struct ifnet **)target) = ifp;
  437 
  438         return (0);
  439 }
  440 
  441 int
  442 nlf_get_ifpz(void *src, struct nl_pstate *npt, void *target)
  443 {
  444         int ifindex = *((const int *)src);
  445 
  446         NET_EPOCH_ASSERT();
  447 
  448         struct ifnet *ifp = ifnet_byindex(ifindex);
  449         if (ifindex != 0 && ifp == NULL) {
  450                 NL_LOG(LOG_DEBUG, "ifindex %u invalid", ifindex);
  451                 return (ENOENT);
  452         }
  453         *((struct ifnet **)target) = ifp;
  454 
  455         return (0);
  456 }
  457 
  458 int
  459 nlf_get_u8(void *src, struct nl_pstate *npt, void *target)
  460 {
  461         uint8_t val = *((const uint8_t *)src);
  462 
  463         *((uint8_t *)target) = val;
  464 
  465         return (0);
  466 }
  467 
  468 int
  469 nlf_get_u8_u32(void *src, struct nl_pstate *npt, void *target)
  470 {
  471         *((uint32_t *)target) = *((const uint8_t *)src);
  472         return (0);
  473 }
  474 
  475 int
  476 nlf_get_u16(void *src, struct nl_pstate *npt, void *target)
  477 {
  478         *((uint16_t *)target) = *((const uint16_t *)src);
  479         return (0);
  480 }
  481 
  482 int
  483 nlf_get_u32(void *src, struct nl_pstate *npt, void *target)
  484 {
  485         *((uint32_t *)target) = *((const uint32_t *)src);
  486         return (0);
  487 }
  488
Cache object: 78c93fbdd7e3fe73f2f888c7442e84c4
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/netlink/netlink_message_parser.c

FreeBSD/Linux Kernel Cross Reference
sys/netlink/netlink_message_parser.c
