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