sys/netlink/netlink_message_parser.c

   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