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 default: 359 return -EINVAL; 360 } 361 362 if (value & ~(u64)pt->mask) { 363 NL_SET_ERR_MSG_ATTR(extack, nla, "reserved bit set"); 364 return -EINVAL; 365 } 366 367 return 0; 368 } 369 370 static int validate_nla(const struct nlattr *nla, int maxtype, 371 const struct nla_policy *policy, unsigned int validate, 372 struct netlink_ext_ack *extack, unsigned int depth) 373 { 374 u16 strict_start_type = policy[0].strict_start_type; 375 const struct nla_policy *pt; 376 int minlen = 0, attrlen = nla_len(nla), type = nla_type(nla); 377 int err = -ERANGE; 378 379 if (strict_start_type && type >= strict_start_type) 380 validate |= NL_VALIDATE_STRICT; 381 382 if (type <= 0 || type > maxtype) 383 return 0; 384 385 type = array_index_nospec(type, maxtype + 1); 386 pt = &policy[type]; 387 388 BUG_ON(pt->type > NLA_TYPE_MAX); 389 390 if (nla_attr_len[pt->type] && attrlen != nla_attr_len[pt->type]) { 391 pr_warn_ratelimited("netlink: '%s': attribute type %d has an invalid length.\n", 392 current->comm, type); 393 if (validate & NL_VALIDATE_STRICT_ATTRS) { 394 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt, 395 "invalid attribute length"); 396 return -EINVAL; 397 } 398 } 399 400 if (validate & NL_VALIDATE_NESTED) { 401 if ((pt->type == NLA_NESTED || pt->type == NLA_NESTED_ARRAY) && 402 !(nla->nla_type & NLA_F_NESTED)) { 403 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt, 404 "NLA_F_NESTED is missing"); 405 return -EINVAL; 406 } 407 if (pt->type != NLA_NESTED && pt->type != NLA_NESTED_ARRAY && 408 pt->type != NLA_UNSPEC && (nla->nla_type & NLA_F_NESTED)) { 409 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt, 410 "NLA_F_NESTED not expected"); 411 return -EINVAL; 412 } 413 } 414 415 switch (pt->type) { 416 case NLA_REJECT: 417 if (extack && pt->reject_message) { 418 NL_SET_BAD_ATTR(extack, nla); 419 extack->_msg = pt->reject_message; 420 return -EINVAL; 421 } 422 err = -EINVAL; 423 goto out_err; 424 425 case NLA_FLAG: 426 if (attrlen > 0) 427 goto out_err; 428 break; 429 430 case NLA_BITFIELD32: 431 if (attrlen != sizeof(struct nla_bitfield32)) 432 goto out_err; 433 434 err = validate_nla_bitfield32(nla, pt->bitfield32_valid); 435 if (err) 436 goto out_err; 437 break; 438 439 case NLA_NUL_STRING: 440 if (pt->len) 441 minlen = min_t(int, attrlen, pt->len + 1); 442 else 443 minlen = attrlen; 444 445 if (!minlen || memchr(nla_data(nla), '\0', minlen) == NULL) { 446 err = -EINVAL; 447 goto out_err; 448 } 449 fallthrough; 450 451 case NLA_STRING: 452 if (attrlen < 1) 453 goto out_err; 454 455 if (pt->len) { 456 char *buf = nla_data(nla); 457 458 if (buf[attrlen - 1] == '\0') 459 attrlen--; 460 461 if (attrlen > pt->len) 462 goto out_err; 463 } 464 break; 465 466 case NLA_BINARY: 467 if (pt->len && attrlen > pt->len) 468 goto out_err; 469 break; 470 471 case NLA_NESTED: 472 /* a nested attributes is allowed to be empty; if its not, 473 * it must have a size of at least NLA_HDRLEN. 474 */ 475 if (attrlen == 0) 476 break; 477 if (attrlen < NLA_HDRLEN) 478 goto out_err; 479 if (pt->nested_policy) { 480 err = __nla_validate_parse(nla_data(nla), nla_len(nla), 481 pt->len, pt->nested_policy, 482 validate, extack, NULL, 483 depth + 1); 484 if (err < 0) { 485 /* 486 * return directly to preserve the inner 487 * error message/attribute pointer 488 */ 489 return err; 490 } 491 } 492 break; 493 case NLA_NESTED_ARRAY: 494 /* a nested array attribute is allowed to be empty; if its not, 495 * it must have a size of at least NLA_HDRLEN. 496 */ 497 if (attrlen == 0) 498 break; 499 if (attrlen < NLA_HDRLEN) 500 goto out_err; 501 if (pt->nested_policy) { 502 int err; 503 504 err = nla_validate_array(nla_data(nla), nla_len(nla), 505 pt->len, pt->nested_policy, 506 extack, validate, depth); 507 if (err < 0) { 508 /* 509 * return directly to preserve the inner 510 * error message/attribute pointer 511 */ 512 return err; 513 } 514 } 515 break; 516 517 case NLA_UNSPEC: 518 if (validate & NL_VALIDATE_UNSPEC) { 519 NL_SET_ERR_MSG_ATTR(extack, nla, 520 "Unsupported attribute"); 521 return -EINVAL; 522 } 523 if (attrlen < pt->len) 524 goto out_err; 525 break; 526 527 default: 528 if (pt->len) 529 minlen = pt->len; 530 else 531 minlen = nla_attr_minlen[pt->type]; 532 533 if (attrlen < minlen) 534 goto out_err; 535 } 536 537 /* further validation */ 538 switch (pt->validation_type) { 539 case NLA_VALIDATE_NONE: 540 /* nothing to do */ 541 break; 542 case NLA_VALIDATE_RANGE_PTR: 543 case NLA_VALIDATE_RANGE: 544 case NLA_VALIDATE_RANGE_WARN_TOO_LONG: 545 case NLA_VALIDATE_MIN: 546 case NLA_VALIDATE_MAX: 547 err = nla_validate_int_range(pt, nla, extack, validate); 548 if (err) 549 return err; 550 break; 551 case NLA_VALIDATE_MASK: 552 err = nla_validate_mask(pt, nla, extack); 553 if (err) 554 return err; 555 break; 556 case NLA_VALIDATE_FUNCTION: 557 if (pt->validate) { 558 err = pt->validate(nla, extack); 559 if (err) 560 return err; 561 } 562 break; 563 } 564 565 return 0; 566 out_err: 567 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt, 568 "Attribute failed policy validation"); 569 return err; 570 } 571 572 static int __nla_validate_parse(const struct nlattr *head, int len, int maxtype, 573 const struct nla_policy *policy, 574 unsigned int validate, 575 struct netlink_ext_ack *extack, 576 struct nlattr **tb, unsigned int depth) 577 { 578 const struct nlattr *nla; 579 int rem; 580 581 if (depth >= MAX_POLICY_RECURSION_DEPTH) { 582 NL_SET_ERR_MSG(extack, 583 "allowed policy recursion depth exceeded"); 584 return -EINVAL; 585 } 586 587 if (tb) 588 memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1)); 589 590 nla_for_each_attr(nla, head, len, rem) { 591 u16 type = nla_type(nla); 592 593 if (type == 0 || type > maxtype) { 594 if (validate & NL_VALIDATE_MAXTYPE) { 595 NL_SET_ERR_MSG_ATTR(extack, nla, 596 "Unknown attribute type"); 597 return -EINVAL; 598 } 599 continue; 600 } 601 type = array_index_nospec(type, maxtype + 1); 602 if (policy) { 603 int err = validate_nla(nla, maxtype, policy, 604 validate, extack, depth); 605 606 if (err < 0) 607 return err; 608 } 609 610 if (tb) 611 tb[type] = (struct nlattr *)nla; 612 } 613 614 if (unlikely(rem > 0)) { 615 pr_warn_ratelimited("netlink: %d bytes leftover after parsing attributes in process `%s'.\n", 616 rem, current->comm); 617 NL_SET_ERR_MSG(extack, "bytes leftover after parsing attributes"); 618 if (validate & NL_VALIDATE_TRAILING) 619 return -EINVAL; 620 } 621 622 return 0; 623 } 624 625 /** 626 * __nla_validate - Validate a stream of attributes 627 * @head: head of attribute stream 628 * @len: length of attribute stream 629 * @maxtype: maximum attribute type to be expected 630 * @policy: validation policy 631 * @validate: validation strictness 632 * @extack: extended ACK report struct 633 * 634 * Validates all attributes in the specified attribute stream against the 635 * specified policy. Validation depends on the validate flags passed, see 636 * &enum netlink_validation for more details on that. 637 * See documentation of struct nla_policy for more details. 638 * 639 * Returns 0 on success or a negative error code. 640 */ 641 int __nla_validate(const struct nlattr *head, int len, int maxtype, 642 const struct nla_policy *policy, unsigned int validate, 643 struct netlink_ext_ack *extack) 644 { 645 return __nla_validate_parse(head, len, maxtype, policy, validate, 646 extack, NULL, 0); 647 } 648 EXPORT_SYMBOL(__nla_validate); 649 650 /** 651 * nla_policy_len - Determine the max. length of a policy 652 * @p: policy to use 653 * @n: number of policies 654 * 655 * Determines the max. length of the policy. It is currently used 656 * to allocated Netlink buffers roughly the size of the actual 657 * message. 658 * 659 * Returns 0 on success or a negative error code. 660 */ 661 int 662 nla_policy_len(const struct nla_policy *p, int n) 663 { 664 int i, len = 0; 665 666 for (i = 0; i < n; i++, p++) { 667 if (p->len) 668 len += nla_total_size(p->len); 669 else if (nla_attr_len[p->type]) 670 len += nla_total_size(nla_attr_len[p->type]); 671 else if (nla_attr_minlen[p->type]) 672 len += nla_total_size(nla_attr_minlen[p->type]); 673 } 674 675 return len; 676 } 677 EXPORT_SYMBOL(nla_policy_len); 678 679 /** 680 * __nla_parse - Parse a stream of attributes into a tb buffer 681 * @tb: destination array with maxtype+1 elements 682 * @maxtype: maximum attribute type to be expected 683 * @head: head of attribute stream 684 * @len: length of attribute stream 685 * @policy: validation policy 686 * @validate: validation strictness 687 * @extack: extended ACK pointer 688 * 689 * Parses a stream of attributes and stores a pointer to each attribute in 690 * the tb array accessible via the attribute type. 691 * Validation is controlled by the @validate parameter. 692 * 693 * Returns 0 on success or a negative error code. 694 */ 695 int __nla_parse(struct nlattr **tb, int maxtype, 696 const struct nlattr *head, int len, 697 const struct nla_policy *policy, unsigned int validate, 698 struct netlink_ext_ack *extack) 699 { 700 return __nla_validate_parse(head, len, maxtype, policy, validate, 701 extack, tb, 0); 702 } 703 EXPORT_SYMBOL(__nla_parse); 704 705 /** 706 * nla_find - Find a specific attribute in a stream of attributes 707 * @head: head of attribute stream 708 * @len: length of attribute stream 709 * @attrtype: type of attribute to look for 710 * 711 * Returns the first attribute in the stream matching the specified type. 712 */ 713 struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype) 714 { 715 const struct nlattr *nla; 716 int rem; 717 718 nla_for_each_attr(nla, head, len, rem) 719 if (nla_type(nla) == attrtype) 720 return (struct nlattr *)nla; 721 722 return NULL; 723 } 724 EXPORT_SYMBOL(nla_find); 725 726 /** 727 * nla_strscpy - Copy string attribute payload into a sized buffer 728 * @dst: Where to copy the string to. 729 * @nla: Attribute to copy the string from. 730 * @dstsize: Size of destination buffer. 731 * 732 * Copies at most dstsize - 1 bytes into the destination buffer. 733 * Unlike strlcpy the destination buffer is always padded out. 734 * 735 * Return: 736 * * srclen - Returns @nla length (not including the trailing %NUL). 737 * * -E2BIG - If @dstsize is 0 or greater than U16_MAX or @nla length greater 738 * than @dstsize. 739 */ 740 ssize_t nla_strscpy(char *dst, const struct nlattr *nla, size_t dstsize) 741 { 742 size_t srclen = nla_len(nla); 743 char *src = nla_data(nla); 744 ssize_t ret; 745 size_t len; 746 747 if (dstsize == 0 || WARN_ON_ONCE(dstsize > U16_MAX)) 748 return -E2BIG; 749 750 if (srclen > 0 && src[srclen - 1] == '\0') 751 srclen--; 752 753 if (srclen >= dstsize) { 754 len = dstsize - 1; 755 ret = -E2BIG; 756 } else { 757 len = srclen; 758 ret = len; 759 } 760 761 memcpy(dst, src, len); 762 /* Zero pad end of dst. */ 763 memset(dst + len, 0, dstsize - len); 764 765 return ret; 766 } 767 EXPORT_SYMBOL(nla_strscpy); 768 769 /** 770 * nla_strdup - Copy string attribute payload into a newly allocated buffer 771 * @nla: attribute to copy the string from 772 * @flags: the type of memory to allocate (see kmalloc). 773 * 774 * Returns a pointer to the allocated buffer or NULL on error. 775 */ 776 char *nla_strdup(const struct nlattr *nla, gfp_t flags) 777 { 778 size_t srclen = nla_len(nla); 779 char *src = nla_data(nla), *dst; 780 781 if (srclen > 0 && src[srclen - 1] == '\0') 782 srclen--; 783 784 dst = kmalloc(srclen + 1, flags); 785 if (dst != NULL) { 786 memcpy(dst, src, srclen); 787 dst[srclen] = '\0'; 788 } 789 return dst; 790 } 791 EXPORT_SYMBOL(nla_strdup); 792 793 /** 794 * nla_memcpy - Copy a netlink attribute into another memory area 795 * @dest: where to copy to memcpy 796 * @src: netlink attribute to copy from 797 * @count: size of the destination area 798 * 799 * Note: The number of bytes copied is limited by the length of 800 * attribute's payload. memcpy 801 * 802 * Returns the number of bytes copied. 803 */ 804 int nla_memcpy(void *dest, const struct nlattr *src, int count) 805 { 806 int minlen = min_t(int, count, nla_len(src)); 807 808 memcpy(dest, nla_data(src), minlen); 809 if (count > minlen) 810 memset(dest + minlen, 0, count - minlen); 811 812 return minlen; 813 } 814 EXPORT_SYMBOL(nla_memcpy); 815 816 /** 817 * nla_memcmp - Compare an attribute with sized memory area 818 * @nla: netlink attribute 819 * @data: memory area 820 * @size: size of memory area 821 */ 822 int nla_memcmp(const struct nlattr *nla, const void *data, 823 size_t size) 824 { 825 int d = nla_len(nla) - size; 826 827 if (d == 0) 828 d = memcmp(nla_data(nla), data, size); 829 830 return d; 831 } 832 EXPORT_SYMBOL(nla_memcmp); 833 834 /** 835 * nla_strcmp - Compare a string attribute against a string 836 * @nla: netlink string attribute 837 * @str: another string 838 */ 839 int nla_strcmp(const struct nlattr *nla, const char *str) 840 { 841 int len = strlen(str); 842 char *buf = nla_data(nla); 843 int attrlen = nla_len(nla); 844 int d; 845 846 while (attrlen > 0 && buf[attrlen - 1] == '\0') 847 attrlen--; 848 849 d = attrlen - len; 850 if (d == 0) 851 d = memcmp(nla_data(nla), str, len); 852 853 return d; 854 } 855 EXPORT_SYMBOL(nla_strcmp); 856 857 #ifdef CONFIG_NET 858 /** 859 * __nla_reserve - reserve room for attribute on the skb 860 * @skb: socket buffer to reserve room on 861 * @attrtype: attribute type 862 * @attrlen: length of attribute payload 863 * 864 * Adds a netlink attribute header to a socket buffer and reserves 865 * room for the payload but does not copy it. 866 * 867 * The caller is responsible to ensure that the skb provides enough 868 * tailroom for the attribute header and payload. 869 */ 870 struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen) 871 { 872 struct nlattr *nla; 873 874 nla = skb_put(skb, nla_total_size(attrlen)); 875 nla->nla_type = attrtype; 876 nla->nla_len = nla_attr_size(attrlen); 877 878 memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen)); 879 880 return nla; 881 } 882 EXPORT_SYMBOL(__nla_reserve); 883 884 /** 885 * __nla_reserve_64bit - reserve room for attribute on the skb and align it 886 * @skb: socket buffer to reserve room on 887 * @attrtype: attribute type 888 * @attrlen: length of attribute payload 889 * @padattr: attribute type for the padding 890 * 891 * Adds a netlink attribute header to a socket buffer and reserves 892 * room for the payload but does not copy it. It also ensure that this 893 * attribute will have a 64-bit aligned nla_data() area. 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_64bit(struct sk_buff *skb, int attrtype, 899 int attrlen, int padattr) 900 { 901 nla_align_64bit(skb, padattr); 902 903 return __nla_reserve(skb, attrtype, attrlen); 904 } 905 EXPORT_SYMBOL(__nla_reserve_64bit); 906 907 /** 908 * __nla_reserve_nohdr - reserve room for attribute without header 909 * @skb: socket buffer to reserve room on 910 * @attrlen: length of attribute payload 911 * 912 * Reserves room for attribute payload without a header. 913 * 914 * The caller is responsible to ensure that the skb provides enough 915 * tailroom for the payload. 916 */ 917 void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen) 918 { 919 return skb_put_zero(skb, NLA_ALIGN(attrlen)); 920 } 921 EXPORT_SYMBOL(__nla_reserve_nohdr); 922 923 /** 924 * nla_reserve - reserve room for attribute on the skb 925 * @skb: socket buffer to reserve room on 926 * @attrtype: attribute type 927 * @attrlen: length of attribute payload 928 * 929 * Adds a netlink attribute header to a socket buffer and reserves 930 * room for the payload but does not copy it. 931 * 932 * Returns NULL if the tailroom of the skb is insufficient to store 933 * the attribute header and payload. 934 */ 935 struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen) 936 { 937 if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen))) 938 return NULL; 939 940 return __nla_reserve(skb, attrtype, attrlen); 941 } 942 EXPORT_SYMBOL(nla_reserve); 943 944 /** 945 * nla_reserve_64bit - reserve room for attribute on the skb and align it 946 * @skb: socket buffer to reserve room on 947 * @attrtype: attribute type 948 * @attrlen: length of attribute payload 949 * @padattr: attribute type for the padding 950 * 951 * Adds a netlink attribute header to a socket buffer and reserves 952 * room for the payload but does not copy it. It also ensure that this 953 * attribute will have a 64-bit aligned nla_data() area. 954 * 955 * Returns NULL if the tailroom of the skb is insufficient to store 956 * the attribute header and payload. 957 */ 958 struct nlattr *nla_reserve_64bit(struct sk_buff *skb, int attrtype, int attrlen, 959 int padattr) 960 { 961 size_t len; 962 963 if (nla_need_padding_for_64bit(skb)) 964 len = nla_total_size_64bit(attrlen); 965 else 966 len = nla_total_size(attrlen); 967 if (unlikely(skb_tailroom(skb) < len)) 968 return NULL; 969 970 return __nla_reserve_64bit(skb, attrtype, attrlen, padattr); 971 } 972 EXPORT_SYMBOL(nla_reserve_64bit); 973 974 /** 975 * nla_reserve_nohdr - reserve room for attribute without header 976 * @skb: socket buffer to reserve room on 977 * @attrlen: length of attribute payload 978 * 979 * Reserves room for attribute payload without a header. 980 * 981 * Returns NULL if the tailroom of the skb is insufficient to store 982 * the attribute payload. 983 */ 984 void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen) 985 { 986 if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen))) 987 return NULL; 988 989 return __nla_reserve_nohdr(skb, attrlen); 990 } 991 EXPORT_SYMBOL(nla_reserve_nohdr); 992 993 /** 994 * __nla_put - Add a netlink attribute to a socket buffer 995 * @skb: socket buffer to add attribute to 996 * @attrtype: attribute type 997 * @attrlen: length of attribute payload 998 * @data: head of attribute payload 999 * 1000 * The caller is responsible to ensure that the skb provides enough 1001 * tailroom for the attribute header and payload. 1002 */ 1003 void __nla_put(struct sk_buff *skb, int attrtype, int attrlen, 1004 const void *data) 1005 { 1006 struct nlattr *nla; 1007 1008 nla = __nla_reserve(skb, attrtype, attrlen); 1009 memcpy(nla_data(nla), data, attrlen); 1010 } 1011 EXPORT_SYMBOL(__nla_put); 1012 1013 /** 1014 * __nla_put_64bit - Add a netlink attribute to a socket buffer and align it 1015 * @skb: socket buffer to add attribute to 1016 * @attrtype: attribute type 1017 * @attrlen: length of attribute payload 1018 * @data: head of attribute payload 1019 * @padattr: attribute type for the padding 1020 * 1021 * The caller is responsible to ensure that the skb provides enough 1022 * tailroom for the attribute header and payload. 1023 */ 1024 void __nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen, 1025 const void *data, int padattr) 1026 { 1027 struct nlattr *nla; 1028 1029 nla = __nla_reserve_64bit(skb, attrtype, attrlen, padattr); 1030 memcpy(nla_data(nla), data, attrlen); 1031 } 1032 EXPORT_SYMBOL(__nla_put_64bit); 1033 1034 /** 1035 * __nla_put_nohdr - Add a netlink attribute without header 1036 * @skb: socket buffer to add attribute to 1037 * @attrlen: length of attribute payload 1038 * @data: head of attribute payload 1039 * 1040 * The caller is responsible to ensure that the skb provides enough 1041 * tailroom for the attribute payload. 1042 */ 1043 void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data) 1044 { 1045 void *start; 1046 1047 start = __nla_reserve_nohdr(skb, attrlen); 1048 memcpy(start, data, attrlen); 1049 } 1050 EXPORT_SYMBOL(__nla_put_nohdr); 1051 1052 /** 1053 * nla_put - Add a netlink attribute to a socket buffer 1054 * @skb: socket buffer to add attribute to 1055 * @attrtype: attribute type 1056 * @attrlen: length of attribute payload 1057 * @data: head of attribute payload 1058 * 1059 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store 1060 * the attribute header and payload. 1061 */ 1062 int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data) 1063 { 1064 if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen))) 1065 return -EMSGSIZE; 1066 1067 __nla_put(skb, attrtype, attrlen, data); 1068 return 0; 1069 } 1070 EXPORT_SYMBOL(nla_put); 1071 1072 /** 1073 * nla_put_64bit - Add a netlink attribute to a socket buffer and align it 1074 * @skb: socket buffer to add attribute to 1075 * @attrtype: attribute type 1076 * @attrlen: length of attribute payload 1077 * @data: head of attribute payload 1078 * @padattr: attribute type for the padding 1079 * 1080 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store 1081 * the attribute header and payload. 1082 */ 1083 int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen, 1084 const void *data, int padattr) 1085 { 1086 size_t len; 1087 1088 if (nla_need_padding_for_64bit(skb)) 1089 len = nla_total_size_64bit(attrlen); 1090 else 1091 len = nla_total_size(attrlen); 1092 if (unlikely(skb_tailroom(skb) < len)) 1093 return -EMSGSIZE; 1094 1095 __nla_put_64bit(skb, attrtype, attrlen, data, padattr); 1096 return 0; 1097 } 1098 EXPORT_SYMBOL(nla_put_64bit); 1099 1100 /** 1101 * nla_put_nohdr - Add a netlink attribute without header 1102 * @skb: socket buffer to add attribute to 1103 * @attrlen: length of attribute payload 1104 * @data: head of attribute payload 1105 * 1106 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store 1107 * the attribute payload. 1108 */ 1109 int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data) 1110 { 1111 if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen))) 1112 return -EMSGSIZE; 1113 1114 __nla_put_nohdr(skb, attrlen, data); 1115 return 0; 1116 } 1117 EXPORT_SYMBOL(nla_put_nohdr); 1118 1119 /** 1120 * nla_append - Add a netlink attribute without header or padding 1121 * @skb: socket buffer to add attribute to 1122 * @attrlen: length of attribute payload 1123 * @data: head of attribute payload 1124 * 1125 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store 1126 * the attribute payload. 1127 */ 1128 int nla_append(struct sk_buff *skb, int attrlen, const void *data) 1129 { 1130 if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen))) 1131 return -EMSGSIZE; 1132 1133 skb_put_data(skb, data, attrlen); 1134 return 0; 1135 } 1136 EXPORT_SYMBOL(nla_append); 1137 #endif 1138