lib/nlattr.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * NETLINK      Netlink attributes
   4  *
   5  *              Authors:        Thomas Graf <tgraf@suug.ch>
   6  *                              Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
   7  */
   8
   9 #include <linux/export.h>
  10 #include <linux/kernel.h>
  11 #include <linux/errno.h>
  12 #include <linux/jiffies.h>
  13 #include <linux/nospec.h>
  14 #include <linux/skbuff.h>
  15 #include <linux/string.h>
  16 #include <linux/types.h>
  17 #include <net/netlink.h>
  18
  19 /* For these data types, attribute length should be exactly the given
  20  * size. However, to maintain compatibility with broken commands, if the
  21  * attribute length does not match the expected size a warning is emitted
  22  * to the user that the command is sending invalid data and needs to be fixed.
  23  */
  24 static const u8 nla_attr_len[NLA_TYPE_MAX+1] = {
  25         [NLA_U8]        = sizeof(u8),
  26         [NLA_U16]       = sizeof(u16),
  27         [NLA_U32]       = sizeof(u32),
  28         [NLA_U64]       = sizeof(u64),
  29         [NLA_S8]        = sizeof(s8),
  30         [NLA_S16]       = sizeof(s16),
  31         [NLA_S32]       = sizeof(s32),
  32         [NLA_S64]       = sizeof(s64),
  33 };
  34
  35 static const u8 nla_attr_minlen[NLA_TYPE_MAX+1] = {
  36         [NLA_U8]        = sizeof(u8),
  37         [NLA_U16]       = sizeof(u16),
  38         [NLA_U32]       = sizeof(u32),
  39         [NLA_U64]       = sizeof(u64),
  40         [NLA_MSECS]     = sizeof(u64),
  41         [NLA_NESTED]    = NLA_HDRLEN,
  42         [NLA_S8]        = sizeof(s8),
  43         [NLA_S16]       = sizeof(s16),
  44         [NLA_S32]       = sizeof(s32),
  45         [NLA_S64]       = sizeof(s64),
  46 };
  47
  48 /*
  49  * Nested policies might refer back to the original
  50  * policy in some cases, and userspace could try to
  51  * abuse that and recurse by nesting in the right
  52  * ways. Limit recursion to avoid this problem.
  53  */
  54 #define MAX_POLICY_RECURSION_DEPTH      10
  55
  56 static int __nla_validate_parse(const struct nlattr *head, int len, int maxtype,
  57                                 const struct nla_policy *policy,
  58                                 unsigned int validate,
  59                                 struct netlink_ext_ack *extack,
  60                                 struct nlattr **tb, unsigned int depth);
  61
  62 static int validate_nla_bitfield32(const struct nlattr *nla,
  63                                    const u32 valid_flags_mask)
  64 {
  65         const struct nla_bitfield32 *bf = nla_data(nla);
  66
  67         if (!valid_flags_mask)
  68                 return -EINVAL;
  69
  70         /*disallow invalid bit selector */
  71         if (bf->selector & ~valid_flags_mask)
  72                 return -EINVAL;
  73
  74         /*disallow invalid bit values */
  75         if (bf->value & ~valid_flags_mask)
  76                 return -EINVAL;
  77
  78         /*disallow valid bit values that are not selected*/
  79         if (bf->value & ~bf->selector)
  80                 return -EINVAL;
  81
  82         return 0;
  83 }
  84
  85 static int nla_validate_array(const struct nlattr *head, int len, int maxtype,
  86                               const struct nla_policy *policy,
  87                               struct netlink_ext_ack *extack,
  88                               unsigned int validate, unsigned int depth)
  89 {
  90         const struct nlattr *entry;
  91         int rem;
  92
  93         nla_for_each_attr(entry, head, len, rem) {
  94                 int ret;
  95
  96                 if (nla_len(entry) == 0)
  97                         continue;
  98
  99                 if (nla_len(entry) < NLA_HDRLEN) {
 100                         NL_SET_ERR_MSG_ATTR_POL(extack, entry, policy,
 101                                                 "Array element too short");
 102                         return -ERANGE;
 103                 }
 104
 105                 ret = __nla_validate_parse(nla_data(entry), nla_len(entry),
 106                                            maxtype, policy, validate, extack,
 107                                            NULL, depth + 1);
 108                 if (ret < 0)
 109                         return ret;
 110         }
 111
 112         return 0;
 113 }
 114
 115 void nla_get_range_unsigned(const struct nla_policy *pt,
 116                             struct netlink_range_validation *range)
 117 {
 118         WARN_ON_ONCE(pt->validation_type != NLA_VALIDATE_RANGE_PTR &&
 119                      (pt->min < 0 || pt->max < 0));
 120
 121         range->min = 0;
 122
 123         switch (pt->type) {
 124         case NLA_U8:
 125                 range->max = U8_MAX;
 126                 break;
 127         case NLA_U16:
 128         case NLA_BE16:
 129         case NLA_BINARY:
 130                 range->max = U16_MAX;
 131                 break;
 132         case NLA_U32:
 133         case NLA_BE32:
 134                 range->max = U32_MAX;
 135                 break;
 136         case NLA_U64:
 137         case NLA_UINT:
 138         case NLA_MSECS:
 139                 range->max = U64_MAX;
 140                 break;
 141         default:
 142                 WARN_ON_ONCE(1);
 143                 return;
 144         }
 145
 146         switch (pt->validation_type) {
 147         case NLA_VALIDATE_RANGE:
 148         case NLA_VALIDATE_RANGE_WARN_TOO_LONG:
 149                 range->min = pt->min;
 150                 range->max = pt->max;
 151                 break;
 152         case NLA_VALIDATE_RANGE_PTR:
 153                 *range = *pt->range;
 154                 break;
 155         case NLA_VALIDATE_MIN:
 156                 range->min = pt->min;
 157                 break;
 158         case NLA_VALIDATE_MAX:
 159                 range->max = pt->max;
 160                 break;
 161         default:
 162                 break;
 163         }
 164 }
 165
 166 static int nla_validate_range_unsigned(const struct nla_policy *pt,
 167                                        const struct nlattr *nla,
 168                                        struct netlink_ext_ack *extack,
 169                                        unsigned int validate)
 170 {
 171         struct netlink_range_validation range;
 172         u64 value;
 173
 174         switch (pt->type) {
 175         case NLA_U8:
 176                 value = nla_get_u8(nla);
 177                 break;
 178         case NLA_U16:
 179                 value = nla_get_u16(nla);
 180                 break;
 181         case NLA_U32:
 182                 value = nla_get_u32(nla);
 183                 break;
 184         case NLA_U64:
 185                 value = nla_get_u64(nla);
 186                 break;
 187         case NLA_UINT:
 188                 value = nla_get_uint(nla);
 189                 break;
 190         case NLA_MSECS:
 191                 value = nla_get_u64(nla);
 192                 break;
 193         case NLA_BINARY:
 194                 value = nla_len(nla);
 195                 break;
 196         case NLA_BE16:
 197                 value = ntohs(nla_get_be16(nla));
 198                 break;
 199         case NLA_BE32:
 200                 value = ntohl(nla_get_be32(nla));
 201                 break;
 202         default:
 203                 return -EINVAL;
 204         }
 205
 206         nla_get_range_unsigned(pt, &range);
 207
 208         if (pt->validation_type == NLA_VALIDATE_RANGE_WARN_TOO_LONG &&
 209             pt->type == NLA_BINARY && value > range.max) {
 210                 pr_warn_ratelimited("netlink: '%s': attribute type %d has an invalid length.\n",
 211                                     current->comm, pt->type);
 212                 if (validate & NL_VALIDATE_STRICT_ATTRS) {
 213                         NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
 214                                                 "invalid attribute length");
 215                         return -EINVAL;
 216                 }
 217
 218                 /* this assumes min <= max (don't validate against min) */
 219                 return 0;
 220         }
 221
 222         if (value < range.min || value > range.max) {
 223                 bool binary = pt->type == NLA_BINARY;
 224
 225                 if (binary)
 226                         NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
 227                                                 "binary attribute size out of range");
 228                 else
 229                         NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
 230                                                 "integer out of range");
 231
 232                 return -ERANGE;
 233         }
 234
 235         return 0;
 236 }
 237
 238 void nla_get_range_signed(const struct nla_policy *pt,
 239                           struct netlink_range_validation_signed *range)
 240 {
 241         switch (pt->type) {
 242         case NLA_S8:
 243                 range->min = S8_MIN;
 244                 range->max = S8_MAX;
 245                 break;
 246         case NLA_S16:
 247                 range->min = S16_MIN;
 248                 range->max = S16_MAX;
 249                 break;
 250         case NLA_S32:
 251                 range->min = S32_MIN;
 252                 range->max = S32_MAX;
 253                 break;
 254         case NLA_S64:
 255         case NLA_SINT:
 256                 range->min = S64_MIN;
 257                 range->max = S64_MAX;
 258                 break;
 259         default:
 260                 WARN_ON_ONCE(1);
 261                 return;
 262         }
 263
 264         switch (pt->validation_type) {
 265         case NLA_VALIDATE_RANGE:
 266                 range->min = pt->min;
 267                 range->max = pt->max;
 268                 break;
 269         case NLA_VALIDATE_RANGE_PTR:
 270                 *range = *pt->range_signed;
 271                 break;
 272         case NLA_VALIDATE_MIN:
 273                 range->min = pt->min;
 274                 break;
 275         case NLA_VALIDATE_MAX:
 276                 range->max = pt->max;
 277                 break;
 278         default:
 279                 break;
 280         }
 281 }
 282
 283 static int nla_validate_int_range_signed(const struct nla_policy *pt,
 284                                          const struct nlattr *nla,
 285                                          struct netlink_ext_ack *extack)
 286 {
 287         struct netlink_range_validation_signed range;
 288         s64 value;
 289
 290         switch (pt->type) {
 291         case NLA_S8:
 292                 value = nla_get_s8(nla);
 293                 break;
 294         case NLA_S16:
 295                 value = nla_get_s16(nla);
 296                 break;
 297         case NLA_S32:
 298                 value = nla_get_s32(nla);
 299                 break;
 300         case NLA_S64:
 301                 value = nla_get_s64(nla);
 302                 break;
 303         case NLA_SINT:
 304                 value = nla_get_sint(nla);
 305                 break;
 306         default:
 307                 return -EINVAL;
 308         }
 309
 310         nla_get_range_signed(pt, &range);
 311
 312         if (value < range.min || value > range.max) {
 313                 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
 314                                         "integer out of range");
 315                 return -ERANGE;
 316         }
 317
 318         return 0;
 319 }
 320
 321 static int nla_validate_int_range(const struct nla_policy *pt,
 322                                   const struct nlattr *nla,
 323                                   struct netlink_ext_ack *extack,
 324                                   unsigned int validate)
 325 {
 326         switch (pt->type) {
 327         case NLA_U8:
 328         case NLA_U16:
 329         case NLA_U32:
 330         case NLA_U64:
 331         case NLA_UINT:
 332         case NLA_MSECS:
 333         case NLA_BINARY:
 334         case NLA_BE16:
 335         case NLA_BE32:
 336                 return nla_validate_range_unsigned(pt, nla, extack, validate);
 337         case NLA_S8:
 338         case NLA_S16:
 339         case NLA_S32:
 340         case NLA_S64:
 341         case NLA_SINT:
 342                 return nla_validate_int_range_signed(pt, nla, extack);
 343         default:
 344                 WARN_ON(1);
 345                 return -EINVAL;
 346         }
 347 }
 348
 349 static int nla_validate_mask(const struct nla_policy *pt,
 350                              const struct nlattr *nla,
 351                              struct netlink_ext_ack *extack)
 352 {
 353         u64 value;
 354
 355         switch (pt->type) {
 356         case NLA_U8:
 357                 value = nla_get_u8(nla);
 358                 break;
 359         case NLA_U16:
 360                 value = nla_get_u16(nla);
 361                 break;
 362         case NLA_U32:
 363                 value = nla_get_u32(nla);
 364                 break;
 365         case NLA_U64:
 366                 value = nla_get_u64(nla);
 367                 break;
 368         case NLA_UINT:
 369                 value = nla_get_uint(nla);
 370                 break;
 371         case NLA_BE16:
 372                 value = ntohs(nla_get_be16(nla));
 373                 break;
 374         case NLA_BE32:
 375                 value = ntohl(nla_get_be32(nla));
 376                 break;
 377         default:
 378                 return -EINVAL;
 379         }
 380
 381         if (value & ~(u64)pt->mask) {
 382                 NL_SET_ERR_MSG_ATTR(extack, nla, "reserved bit set");
 383                 return -EINVAL;
 384         }
 385
 386         return 0;
 387 }
 388
 389 static int validate_nla(const struct nlattr *nla, int maxtype,
 390                         const struct nla_policy *policy, unsigned int validate,
 391                         struct netlink_ext_ack *extack, unsigned int depth)
 392 {
 393         u16 strict_start_type = policy[0].strict_start_type;
 394         const struct nla_policy *pt;
 395         int minlen = 0, attrlen = nla_len(nla), type = nla_type(nla);
 396         int err = -ERANGE;
 397
 398         if (strict_start_type && type >= strict_start_type)
 399                 validate |= NL_VALIDATE_STRICT;
 400
 401         if (type <= 0 || type > maxtype)
 402                 return 0;
 403
 404         type = array_index_nospec(type, maxtype + 1);
 405         pt = &policy[type];
 406
 407         BUG_ON(pt->type > NLA_TYPE_MAX);
 408
 409         if (nla_attr_len[pt->type] && attrlen != nla_attr_len[pt->type]) {
 410                 pr_warn_ratelimited("netlink: '%s': attribute type %d has an invalid length.\n",
 411                                     current->comm, type);
 412                 if (validate & NL_VALIDATE_STRICT_ATTRS) {
 413                         NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
 414                                                 "invalid attribute length");
 415                         return -EINVAL;
 416                 }
 417         }
 418
 419         if (validate & NL_VALIDATE_NESTED) {
 420                 if ((pt->type == NLA_NESTED || pt->type == NLA_NESTED_ARRAY) &&
 421                     !(nla->nla_type & NLA_F_NESTED)) {
 422                         NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
 423                                                 "NLA_F_NESTED is missing");
 424                         return -EINVAL;
 425                 }
 426                 if (pt->type != NLA_NESTED && pt->type != NLA_NESTED_ARRAY &&
 427                     pt->type != NLA_UNSPEC && (nla->nla_type & NLA_F_NESTED)) {
 428                         NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
 429                                                 "NLA_F_NESTED not expected");
 430                         return -EINVAL;
 431                 }
 432         }
 433
 434         switch (pt->type) {
 435         case NLA_REJECT:
 436                 if (extack && pt->reject_message) {
 437                         NL_SET_BAD_ATTR(extack, nla);
 438                         extack->_msg = pt->reject_message;
 439                         return -EINVAL;
 440                 }
 441                 err = -EINVAL;
 442                 goto out_err;
 443
 444         case NLA_FLAG:
 445                 if (attrlen > 0)
 446                         goto out_err;
 447                 break;
 448
 449         case NLA_SINT:
 450         case NLA_UINT:
 451                 if (attrlen != sizeof(u32) && attrlen != sizeof(u64)) {
 452                         NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
 453                                                 "invalid attribute length");
 454                         return -EINVAL;
 455                 }
 456                 break;
 457
 458         case NLA_BITFIELD32:
 459                 if (attrlen != sizeof(struct nla_bitfield32))
 460                         goto out_err;
 461
 462                 err = validate_nla_bitfield32(nla, pt->bitfield32_valid);
 463                 if (err)
 464                         goto out_err;
 465                 break;
 466
 467         case NLA_NUL_STRING:
 468                 if (pt->len)
 469                         minlen = min_t(int, attrlen, pt->len + 1);
 470                 else
 471                         minlen = attrlen;
 472
 473                 if (!minlen || memchr(nla_data(nla), '\0', minlen) == NULL) {
 474                         err = -EINVAL;
 475                         goto out_err;
 476                 }
 477                 fallthrough;
 478
 479         case NLA_STRING:
 480                 if (attrlen < 1)
 481                         goto out_err;
 482
 483                 if (pt->len) {
 484                         char *buf = nla_data(nla);
 485
 486                         if (buf[attrlen - 1] == '\0')
 487                                 attrlen--;
 488
 489                         if (attrlen > pt->len)
 490                                 goto out_err;
 491                 }
 492                 break;
 493
 494         case NLA_BINARY:
 495                 if (pt->len && attrlen > pt->len)
 496                         goto out_err;
 497                 break;
 498
 499         case NLA_NESTED:
 500                 /* a nested attributes is allowed to be empty; if its not,
 501                  * it must have a size of at least NLA_HDRLEN.
 502                  */
 503                 if (attrlen == 0)
 504                         break;
 505                 if (attrlen < NLA_HDRLEN)
 506                         goto out_err;
 507                 if (pt->nested_policy) {
 508                         err = __nla_validate_parse(nla_data(nla), nla_len(nla),
 509                                                    pt->len, pt->nested_policy,
 510                                                    validate, extack, NULL,
 511                                                    depth + 1);
 512                         if (err < 0) {
 513                                 /*
 514                                  * return directly to preserve the inner
 515                                  * error message/attribute pointer
 516                                  */
 517                                 return err;
 518                         }
 519                 }
 520                 break;
 521         case NLA_NESTED_ARRAY:
 522                 /* a nested array attribute is allowed to be empty; if its not,
 523                  * it must have a size of at least NLA_HDRLEN.
 524                  */
 525                 if (attrlen == 0)
 526                         break;
 527                 if (attrlen < NLA_HDRLEN)
 528                         goto out_err;
 529                 if (pt->nested_policy) {
 530                         int err;
 531
 532                         err = nla_validate_array(nla_data(nla), nla_len(nla),
 533                                                  pt->len, pt->nested_policy,
 534                                                  extack, validate, depth);
 535                         if (err < 0) {
 536                                 /*
 537                                  * return directly to preserve the inner
 538                                  * error message/attribute pointer
 539                                  */
 540                                 return err;
 541                         }
 542                 }
 543                 break;
 544
 545         case NLA_UNSPEC:
 546                 if (validate & NL_VALIDATE_UNSPEC) {
 547                         NL_SET_ERR_MSG_ATTR(extack, nla,
 548                                             "Unsupported attribute");
 549                         return -EINVAL;
 550                 }
 551                 if (attrlen < pt->len)
 552                         goto out_err;
 553                 break;
 554
 555         default:
 556                 if (pt->len)
 557                         minlen = pt->len;
 558                 else
 559                         minlen = nla_attr_minlen[pt->type];
 560
 561                 if (attrlen < minlen)
 562                         goto out_err;
 563         }
 564
 565         /* further validation */
 566         switch (pt->validation_type) {
 567         case NLA_VALIDATE_NONE:
 568                 /* nothing to do */
 569                 break;
 570         case NLA_VALIDATE_RANGE_PTR:
 571         case NLA_VALIDATE_RANGE:
 572         case NLA_VALIDATE_RANGE_WARN_TOO_LONG:
 573         case NLA_VALIDATE_MIN:
 574         case NLA_VALIDATE_MAX:
 575                 err = nla_validate_int_range(pt, nla, extack, validate);
 576                 if (err)
 577                         return err;
 578                 break;
 579         case NLA_VALIDATE_MASK:
 580                 err = nla_validate_mask(pt, nla, extack);
 581                 if (err)
 582                         return err;
 583                 break;
 584         case NLA_VALIDATE_FUNCTION:
 585                 if (pt->validate) {
 586                         err = pt->validate(nla, extack);
 587                         if (err)
 588                                 return err;
 589                 }
 590                 break;
 591         }
 592
 593         return 0;
 594 out_err:
 595         NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
 596                                 "Attribute failed policy validation");
 597         return err;
 598 }
 599
 600 static int __nla_validate_parse(const struct nlattr *head, int len, int maxtype,
 601                                 const struct nla_policy *policy,
 602                                 unsigned int validate,
 603                                 struct netlink_ext_ack *extack,
 604                                 struct nlattr **tb, unsigned int depth)
 605 {
 606         const struct nlattr *nla;
 607         int rem;
 608
 609         if (depth >= MAX_POLICY_RECURSION_DEPTH) {
 610                 NL_SET_ERR_MSG(extack,
 611                                "allowed policy recursion depth exceeded");
 612                 return -EINVAL;
 613         }
 614
 615         if (tb)
 616                 memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));
 617
 618         nla_for_each_attr(nla, head, len, rem) {
 619                 u16 type = nla_type(nla);
 620
 621                 if (type == 0 || type > maxtype) {
 622                         if (validate & NL_VALIDATE_MAXTYPE) {
 623                                 NL_SET_ERR_MSG_ATTR(extack, nla,
 624                                                     "Unknown attribute type");
 625                                 return -EINVAL;
 626                         }
 627                         continue;
 628                 }
 629                 type = array_index_nospec(type, maxtype + 1);
 630                 if (policy) {
 631                         int err = validate_nla(nla, maxtype, policy,
 632                                                validate, extack, depth);
 633
 634                         if (err < 0)
 635                                 return err;
 636                 }
 637
 638                 if (tb)
 639                         tb[type] = (struct nlattr *)nla;
 640         }
 641
 642         if (unlikely(rem > 0)) {
 643                 pr_warn_ratelimited("netlink: %d bytes leftover after parsing attributes in process `%s'.\n",
 644                                     rem, current->comm);
 645                 NL_SET_ERR_MSG(extack, "bytes leftover after parsing attributes");
 646                 if (validate & NL_VALIDATE_TRAILING)
 647                         return -EINVAL;
 648         }
 649
 650         return 0;
 651 }
 652
 653 /**
 654  * __nla_validate - Validate a stream of attributes
 655  * @head: head of attribute stream
 656  * @len: length of attribute stream
 657  * @maxtype: maximum attribute type to be expected
 658  * @policy: validation policy
 659  * @validate: validation strictness
 660  * @extack: extended ACK report struct
 661  *
 662  * Validates all attributes in the specified attribute stream against the
 663  * specified policy. Validation depends on the validate flags passed, see
 664  * &enum netlink_validation for more details on that.
 665  * See documentation of struct nla_policy for more details.
 666  *
 667  * Returns 0 on success or a negative error code.
 668  */
 669 int __nla_validate(const struct nlattr *head, int len, int maxtype,
 670                    const struct nla_policy *policy, unsigned int validate,
 671                    struct netlink_ext_ack *extack)
 672 {
 673         return __nla_validate_parse(head, len, maxtype, policy, validate,
 674                                     extack, NULL, 0);
 675 }
 676 EXPORT_SYMBOL(__nla_validate);
 677
 678 /**
 679  * nla_policy_len - Determine the max. length of a policy
 680  * @p: policy to use
 681  * @n: number of policies
 682  *
 683  * Determines the max. length of the policy.  It is currently used
 684  * to allocated Netlink buffers roughly the size of the actual
 685  * message.
 686  *
 687  * Returns 0 on success or a negative error code.
 688  */
 689 int
 690 nla_policy_len(const struct nla_policy *p, int n)
 691 {
 692         int i, len = 0;
 693
 694         for (i = 0; i < n; i++, p++) {
 695                 if (p->len)
 696                         len += nla_total_size(p->len);
 697                 else if (nla_attr_len[p->type])
 698                         len += nla_total_size(nla_attr_len[p->type]);
 699                 else if (nla_attr_minlen[p->type])
 700                         len += nla_total_size(nla_attr_minlen[p->type]);
 701         }
 702
 703         return len;
 704 }
 705 EXPORT_SYMBOL(nla_policy_len);
 706
 707 /**
 708  * __nla_parse - Parse a stream of attributes into a tb buffer
 709  * @tb: destination array with maxtype+1 elements
 710  * @maxtype: maximum attribute type to be expected
 711  * @head: head of attribute stream
 712  * @len: length of attribute stream
 713  * @policy: validation policy
 714  * @validate: validation strictness
 715  * @extack: extended ACK pointer
 716  *
 717  * Parses a stream of attributes and stores a pointer to each attribute in
 718  * the tb array accessible via the attribute type.
 719  * Validation is controlled by the @validate parameter.
 720  *
 721  * Returns 0 on success or a negative error code.
 722  */
 723 int __nla_parse(struct nlattr **tb, int maxtype,
 724                 const struct nlattr *head, int len,
 725                 const struct nla_policy *policy, unsigned int validate,
 726                 struct netlink_ext_ack *extack)
 727 {
 728         return __nla_validate_parse(head, len, maxtype, policy, validate,
 729                                     extack, tb, 0);
 730 }
 731 EXPORT_SYMBOL(__nla_parse);
 732
 733 /**
 734  * nla_find - Find a specific attribute in a stream of attributes
 735  * @head: head of attribute stream
 736  * @len: length of attribute stream
 737  * @attrtype: type of attribute to look for
 738  *
 739  * Returns the first attribute in the stream matching the specified type.
 740  */
 741 struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype)
 742 {
 743         const struct nlattr *nla;
 744         int rem;
 745
 746         nla_for_each_attr(nla, head, len, rem)
 747                 if (nla_type(nla) == attrtype)
 748                         return (struct nlattr *)nla;
 749
 750         return NULL;
 751 }
 752 EXPORT_SYMBOL(nla_find);
 753
 754 /**
 755  * nla_strscpy - Copy string attribute payload into a sized buffer
 756  * @dst: Where to copy the string to.
 757  * @nla: Attribute to copy the string from.
 758  * @dstsize: Size of destination buffer.
 759  *
 760  * Copies at most dstsize - 1 bytes into the destination buffer.
 761  * Unlike strscpy() the destination buffer is always padded out.
 762  *
 763  * Return:
 764  * * srclen - Returns @nla length (not including the trailing %NUL).
 765  * * -E2BIG - If @dstsize is 0 or greater than U16_MAX or @nla length greater
 766  *            than @dstsize.
 767  */
 768 ssize_t nla_strscpy(char *dst, const struct nlattr *nla, size_t dstsize)
 769 {
 770         size_t srclen = nla_len(nla);
 771         char *src = nla_data(nla);
 772         ssize_t ret;
 773         size_t len;
 774
 775         if (dstsize == 0 || WARN_ON_ONCE(dstsize > U16_MAX))
 776                 return -E2BIG;
 777
 778         if (srclen > 0 && src[srclen - 1] == '\0')
 779                 srclen--;
 780
 781         if (srclen >= dstsize) {
 782                 len = dstsize - 1;
 783                 ret = -E2BIG;
 784         } else {
 785                 len = srclen;
 786                 ret = len;
 787         }
 788
 789         memcpy(dst, src, len);
 790         /* Zero pad end of dst. */
 791         memset(dst + len, 0, dstsize - len);
 792
 793         return ret;
 794 }
 795 EXPORT_SYMBOL(nla_strscpy);
 796
 797 /**
 798  * nla_strdup - Copy string attribute payload into a newly allocated buffer
 799  * @nla: attribute to copy the string from
 800  * @flags: the type of memory to allocate (see kmalloc).
 801  *
 802  * Returns a pointer to the allocated buffer or NULL on error.
 803  */
 804 char *nla_strdup(const struct nlattr *nla, gfp_t flags)
 805 {
 806         size_t srclen = nla_len(nla);
 807         char *src = nla_data(nla), *dst;
 808
 809         if (srclen > 0 && src[srclen - 1] == '\0')
 810                 srclen--;
 811
 812         dst = kmalloc(srclen + 1, flags);
 813         if (dst != NULL) {
 814                 memcpy(dst, src, srclen);
 815                 dst[srclen] = '\0';
 816         }
 817         return dst;
 818 }
 819 EXPORT_SYMBOL(nla_strdup);
 820
 821 /**
 822  * nla_memcpy - Copy a netlink attribute into another memory area
 823  * @dest: where to copy to memcpy
 824  * @src: netlink attribute to copy from
 825  * @count: size of the destination area
 826  *
 827  * Note: The number of bytes copied is limited by the length of
 828  *       attribute's payload. memcpy
 829  *
 830  * Returns the number of bytes copied.
 831  */
 832 int nla_memcpy(void *dest, const struct nlattr *src, int count)
 833 {
 834         int minlen = min_t(int, count, nla_len(src));
 835
 836         memcpy(dest, nla_data(src), minlen);
 837         if (count > minlen)
 838                 memset(dest + minlen, 0, count - minlen);
 839
 840         return minlen;
 841 }
 842 EXPORT_SYMBOL(nla_memcpy);
 843
 844 /**
 845  * nla_memcmp - Compare an attribute with sized memory area
 846  * @nla: netlink attribute
 847  * @data: memory area
 848  * @size: size of memory area
 849  */
 850 int nla_memcmp(const struct nlattr *nla, const void *data,
 851                              size_t size)
 852 {
 853         int d = nla_len(nla) - size;
 854
 855         if (d == 0)
 856                 d = memcmp(nla_data(nla), data, size);
 857
 858         return d;
 859 }
 860 EXPORT_SYMBOL(nla_memcmp);
 861
 862 /**
 863  * nla_strcmp - Compare a string attribute against a string
 864  * @nla: netlink string attribute
 865  * @str: another string
 866  */
 867 int nla_strcmp(const struct nlattr *nla, const char *str)
 868 {
 869         int len = strlen(str);
 870         char *buf = nla_data(nla);
 871         int attrlen = nla_len(nla);
 872         int d;
 873
 874         while (attrlen > 0 && buf[attrlen - 1] == '\0')
 875                 attrlen--;
 876
 877         d = attrlen - len;
 878         if (d == 0)
 879                 d = memcmp(nla_data(nla), str, len);
 880
 881         return d;
 882 }
 883 EXPORT_SYMBOL(nla_strcmp);
 884
 885 #ifdef CONFIG_NET
 886 /**
 887  * __nla_reserve - reserve room for attribute on the skb
 888  * @skb: socket buffer to reserve room on
 889  * @attrtype: attribute type
 890  * @attrlen: length of attribute payload
 891  *
 892  * Adds a netlink attribute header to a socket buffer and reserves
 893  * room for the payload but does not copy it.
 894  *
 895  * The caller is responsible to ensure that the skb provides enough
 896  * tailroom for the attribute header and payload.
 897  */
 898 struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
 899 {
 900         struct nlattr *nla;
 901
 902         nla = skb_put(skb, nla_total_size(attrlen));
 903         nla->nla_type = attrtype;
 904         nla->nla_len = nla_attr_size(attrlen);
 905
 906         memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen));
 907
 908         return nla;
 909 }
 910 EXPORT_SYMBOL(__nla_reserve);
 911
 912 /**
 913  * __nla_reserve_64bit - reserve room for attribute on the skb and align it
 914  * @skb: socket buffer to reserve room on
 915  * @attrtype: attribute type
 916  * @attrlen: length of attribute payload
 917  * @padattr: attribute type for the padding
 918  *
 919  * Adds a netlink attribute header to a socket buffer and reserves
 920  * room for the payload but does not copy it. It also ensure that this
 921  * attribute will have a 64-bit aligned nla_data() area.
 922  *
 923  * The caller is responsible to ensure that the skb provides enough
 924  * tailroom for the attribute header and payload.
 925  */
 926 struct nlattr *__nla_reserve_64bit(struct sk_buff *skb, int attrtype,
 927                                    int attrlen, int padattr)
 928 {
 929         nla_align_64bit(skb, padattr);
 930
 931         return __nla_reserve(skb, attrtype, attrlen);
 932 }
 933 EXPORT_SYMBOL(__nla_reserve_64bit);
 934
 935 /**
 936  * __nla_reserve_nohdr - reserve room for attribute without header
 937  * @skb: socket buffer to reserve room on
 938  * @attrlen: length of attribute payload
 939  *
 940  * Reserves room for attribute payload without a header.
 941  *
 942  * The caller is responsible to ensure that the skb provides enough
 943  * tailroom for the payload.
 944  */
 945 void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
 946 {
 947         return skb_put_zero(skb, NLA_ALIGN(attrlen));
 948 }
 949 EXPORT_SYMBOL(__nla_reserve_nohdr);
 950
 951 /**
 952  * nla_reserve - reserve room for attribute on the skb
 953  * @skb: socket buffer to reserve room on
 954  * @attrtype: attribute type
 955  * @attrlen: length of attribute payload
 956  *
 957  * Adds a netlink attribute header to a socket buffer and reserves
 958  * room for the payload but does not copy it.
 959  *
 960  * Returns NULL if the tailroom of the skb is insufficient to store
 961  * the attribute header and payload.
 962  */
 963 struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
 964 {
 965         if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
 966                 return NULL;
 967
 968         return __nla_reserve(skb, attrtype, attrlen);
 969 }
 970 EXPORT_SYMBOL(nla_reserve);
 971
 972 /**
 973  * nla_reserve_64bit - reserve room for attribute on the skb and align it
 974  * @skb: socket buffer to reserve room on
 975  * @attrtype: attribute type
 976  * @attrlen: length of attribute payload
 977  * @padattr: attribute type for the padding
 978  *
 979  * Adds a netlink attribute header to a socket buffer and reserves
 980  * room for the payload but does not copy it. It also ensure that this
 981  * attribute will have a 64-bit aligned nla_data() area.
 982  *
 983  * Returns NULL if the tailroom of the skb is insufficient to store
 984  * the attribute header and payload.
 985  */
 986 struct nlattr *nla_reserve_64bit(struct sk_buff *skb, int attrtype, int attrlen,
 987                                  int padattr)
 988 {
 989         size_t len;
 990
 991         if (nla_need_padding_for_64bit(skb))
 992                 len = nla_total_size_64bit(attrlen);
 993         else
 994                 len = nla_total_size(attrlen);
 995         if (unlikely(skb_tailroom(skb) < len))
 996                 return NULL;
 997
 998         return __nla_reserve_64bit(skb, attrtype, attrlen, padattr);
 999 }
1000 EXPORT_SYMBOL(nla_reserve_64bit);
1001
1002 /**
1003  * nla_reserve_nohdr - reserve room for attribute without header
1004  * @skb: socket buffer to reserve room on
1005  * @attrlen: length of attribute payload
1006  *
1007  * Reserves room for attribute payload without a header.
1008  *
1009  * Returns NULL if the tailroom of the skb is insufficient to store
1010  * the attribute payload.
1011  */
1012 void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
1013 {
1014         if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
1015                 return NULL;
1016
1017         return __nla_reserve_nohdr(skb, attrlen);
1018 }
1019 EXPORT_SYMBOL(nla_reserve_nohdr);
1020
1021 /**
1022  * __nla_put - Add a netlink attribute to a socket buffer
1023  * @skb: socket buffer to add attribute to
1024  * @attrtype: attribute type
1025  * @attrlen: length of attribute payload
1026  * @data: head of attribute payload
1027  *
1028  * The caller is responsible to ensure that the skb provides enough
1029  * tailroom for the attribute header and payload.
1030  */
1031 void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
1032                              const void *data)
1033 {
1034         struct nlattr *nla;
1035
1036         nla = __nla_reserve(skb, attrtype, attrlen);
1037         memcpy(nla_data(nla), data, attrlen);
1038 }
1039 EXPORT_SYMBOL(__nla_put);
1040
1041 /**
1042  * __nla_put_64bit - Add a netlink attribute to a socket buffer and align it
1043  * @skb: socket buffer to add attribute to
1044  * @attrtype: attribute type
1045  * @attrlen: length of attribute payload
1046  * @data: head of attribute payload
1047  * @padattr: attribute type for the padding
1048  *
1049  * The caller is responsible to ensure that the skb provides enough
1050  * tailroom for the attribute header and payload.
1051  */
1052 void __nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
1053                      const void *data, int padattr)
1054 {
1055         struct nlattr *nla;
1056
1057         nla = __nla_reserve_64bit(skb, attrtype, attrlen, padattr);
1058         memcpy(nla_data(nla), data, attrlen);
1059 }
1060 EXPORT_SYMBOL(__nla_put_64bit);
1061
1062 /**
1063  * __nla_put_nohdr - Add a netlink attribute without header
1064  * @skb: socket buffer to add attribute to
1065  * @attrlen: length of attribute payload
1066  * @data: head of attribute payload
1067  *
1068  * The caller is responsible to ensure that the skb provides enough
1069  * tailroom for the attribute payload.
1070  */
1071 void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
1072 {
1073         void *start;
1074
1075         start = __nla_reserve_nohdr(skb, attrlen);
1076         memcpy(start, data, attrlen);
1077 }
1078 EXPORT_SYMBOL(__nla_put_nohdr);
1079
1080 /**
1081  * nla_put - Add a netlink attribute to a socket buffer
1082  * @skb: socket buffer to add attribute to
1083  * @attrtype: attribute type
1084  * @attrlen: length of attribute payload
1085  * @data: head of attribute payload
1086  *
1087  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1088  * the attribute header and payload.
1089  */
1090 int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
1091 {
1092         if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
1093                 return -EMSGSIZE;
1094
1095         __nla_put(skb, attrtype, attrlen, data);
1096         return 0;
1097 }
1098 EXPORT_SYMBOL(nla_put);
1099
1100 /**
1101  * nla_put_64bit - Add a netlink attribute to a socket buffer and align it
1102  * @skb: socket buffer to add attribute to
1103  * @attrtype: attribute type
1104  * @attrlen: length of attribute payload
1105  * @data: head of attribute payload
1106  * @padattr: attribute type for the padding
1107  *
1108  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1109  * the attribute header and payload.
1110  */
1111 int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
1112                   const void *data, int padattr)
1113 {
1114         size_t len;
1115
1116         if (nla_need_padding_for_64bit(skb))
1117                 len = nla_total_size_64bit(attrlen);
1118         else
1119                 len = nla_total_size(attrlen);
1120         if (unlikely(skb_tailroom(skb) < len))
1121                 return -EMSGSIZE;
1122
1123         __nla_put_64bit(skb, attrtype, attrlen, data, padattr);
1124         return 0;
1125 }
1126 EXPORT_SYMBOL(nla_put_64bit);
1127
1128 /**
1129  * nla_put_nohdr - Add a netlink attribute without header
1130  * @skb: socket buffer to add attribute to
1131  * @attrlen: length of attribute payload
1132  * @data: head of attribute payload
1133  *
1134  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1135  * the attribute payload.
1136  */
1137 int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
1138 {
1139         if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
1140                 return -EMSGSIZE;
1141
1142         __nla_put_nohdr(skb, attrlen, data);
1143         return 0;
1144 }
1145 EXPORT_SYMBOL(nla_put_nohdr);
1146
1147 /**
1148  * nla_append - Add a netlink attribute without header or padding
1149  * @skb: socket buffer to add attribute to
1150  * @attrlen: length of attribute payload
1151  * @data: head of attribute payload
1152  *
1153  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1154  * the attribute payload.
1155  */
1156 int nla_append(struct sk_buff *skb, int attrlen, const void *data)
1157 {
1158         if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
1159                 return -EMSGSIZE;
1160
1161         skb_put_data(skb, data, attrlen);
1162         return 0;
1163 }
1164 EXPORT_SYMBOL(nla_append);
1165 #endif