1 // SPDX-License-Identifier: GPL-2.0
3 * NETLINK Netlink attributes
5 * Authors: Thomas Graf <tgraf@suug.ch>
6 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
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>
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.
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),
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),
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.
54 #define MAX_POLICY_RECURSION_DEPTH 10
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);
62 static int validate_nla_bitfield32(const struct nlattr *nla,
63 const u32 valid_flags_mask)
65 const struct nla_bitfield32 *bf = nla_data(nla);
67 if (!valid_flags_mask)
70 /*disallow invalid bit selector */
71 if (bf->selector & ~valid_flags_mask)
74 /*disallow invalid bit values */
75 if (bf->value & ~valid_flags_mask)
78 /*disallow valid bit values that are not selected*/
79 if (bf->value & ~bf->selector)
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)
90 const struct nlattr *entry;
93 nla_for_each_attr(entry, head, len, rem) {
96 if (nla_len(entry) == 0)
99 if (nla_len(entry) < NLA_HDRLEN) {
100 NL_SET_ERR_MSG_ATTR_POL(extack, entry, policy,
101 "Array element too short");
105 ret = __nla_validate_parse(nla_data(entry), nla_len(entry),
106 maxtype, policy, validate, extack,
115 void nla_get_range_unsigned(const struct nla_policy *pt,
116 struct netlink_range_validation *range)
118 WARN_ON_ONCE(pt->validation_type != NLA_VALIDATE_RANGE_PTR &&
119 (pt->min < 0 || pt->max < 0));
129 range->max = U16_MAX;
132 range->max = U32_MAX;
136 range->max = U64_MAX;
143 switch (pt->validation_type) {
144 case NLA_VALIDATE_RANGE:
145 case NLA_VALIDATE_RANGE_WARN_TOO_LONG:
146 range->min = pt->min;
147 range->max = pt->max;
149 case NLA_VALIDATE_RANGE_PTR:
152 case NLA_VALIDATE_MIN:
153 range->min = pt->min;
155 case NLA_VALIDATE_MAX:
156 range->max = pt->max;
163 static int nla_validate_range_unsigned(const struct nla_policy *pt,
164 const struct nlattr *nla,
165 struct netlink_ext_ack *extack,
166 unsigned int validate)
168 struct netlink_range_validation range;
173 value = nla_get_u8(nla);
176 value = nla_get_u16(nla);
179 value = nla_get_u32(nla);
183 value = nla_get_u64(nla);
186 value = nla_len(nla);
192 nla_get_range_unsigned(pt, &range);
194 if (pt->validation_type == NLA_VALIDATE_RANGE_WARN_TOO_LONG &&
195 pt->type == NLA_BINARY && value > range.max) {
196 pr_warn_ratelimited("netlink: '%s': attribute type %d has an invalid length.\n",
197 current->comm, pt->type);
198 if (validate & NL_VALIDATE_STRICT_ATTRS) {
199 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
200 "invalid attribute length");
204 /* this assumes min <= max (don't validate against min) */
208 if (value < range.min || value > range.max) {
209 bool binary = pt->type == NLA_BINARY;
212 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
213 "binary attribute size out of range");
215 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
216 "integer out of range");
224 void nla_get_range_signed(const struct nla_policy *pt,
225 struct netlink_range_validation_signed *range)
233 range->min = S16_MIN;
234 range->max = S16_MAX;
237 range->min = S32_MIN;
238 range->max = S32_MAX;
241 range->min = S64_MIN;
242 range->max = S64_MAX;
249 switch (pt->validation_type) {
250 case NLA_VALIDATE_RANGE:
251 range->min = pt->min;
252 range->max = pt->max;
254 case NLA_VALIDATE_RANGE_PTR:
255 *range = *pt->range_signed;
257 case NLA_VALIDATE_MIN:
258 range->min = pt->min;
260 case NLA_VALIDATE_MAX:
261 range->max = pt->max;
268 static int nla_validate_int_range_signed(const struct nla_policy *pt,
269 const struct nlattr *nla,
270 struct netlink_ext_ack *extack)
272 struct netlink_range_validation_signed range;
277 value = nla_get_s8(nla);
280 value = nla_get_s16(nla);
283 value = nla_get_s32(nla);
286 value = nla_get_s64(nla);
292 nla_get_range_signed(pt, &range);
294 if (value < range.min || value > range.max) {
295 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
296 "integer out of range");
303 static int nla_validate_int_range(const struct nla_policy *pt,
304 const struct nlattr *nla,
305 struct netlink_ext_ack *extack,
306 unsigned int validate)
315 return nla_validate_range_unsigned(pt, nla, extack, validate);
320 return nla_validate_int_range_signed(pt, nla, extack);
327 static int nla_validate_mask(const struct nla_policy *pt,
328 const struct nlattr *nla,
329 struct netlink_ext_ack *extack)
335 value = nla_get_u8(nla);
338 value = nla_get_u16(nla);
341 value = nla_get_u32(nla);
344 value = nla_get_u64(nla);
350 if (value & ~(u64)pt->mask) {
351 NL_SET_ERR_MSG_ATTR(extack, nla, "reserved bit set");
358 static int validate_nla(const struct nlattr *nla, int maxtype,
359 const struct nla_policy *policy, unsigned int validate,
360 struct netlink_ext_ack *extack, unsigned int depth)
362 u16 strict_start_type = policy[0].strict_start_type;
363 const struct nla_policy *pt;
364 int minlen = 0, attrlen = nla_len(nla), type = nla_type(nla);
367 if (strict_start_type && type >= strict_start_type)
368 validate |= NL_VALIDATE_STRICT;
370 if (type <= 0 || type > maxtype)
373 type = array_index_nospec(type, maxtype + 1);
376 BUG_ON(pt->type > NLA_TYPE_MAX);
378 if (nla_attr_len[pt->type] && attrlen != nla_attr_len[pt->type]) {
379 pr_warn_ratelimited("netlink: '%s': attribute type %d has an invalid length.\n",
380 current->comm, type);
381 if (validate & NL_VALIDATE_STRICT_ATTRS) {
382 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
383 "invalid attribute length");
388 if (validate & NL_VALIDATE_NESTED) {
389 if ((pt->type == NLA_NESTED || pt->type == NLA_NESTED_ARRAY) &&
390 !(nla->nla_type & NLA_F_NESTED)) {
391 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
392 "NLA_F_NESTED is missing");
395 if (pt->type != NLA_NESTED && pt->type != NLA_NESTED_ARRAY &&
396 pt->type != NLA_UNSPEC && (nla->nla_type & NLA_F_NESTED)) {
397 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
398 "NLA_F_NESTED not expected");
405 if (extack && pt->reject_message) {
406 NL_SET_BAD_ATTR(extack, nla);
407 extack->_msg = pt->reject_message;
419 if (attrlen != sizeof(struct nla_bitfield32))
422 err = validate_nla_bitfield32(nla, pt->bitfield32_valid);
429 minlen = min_t(int, attrlen, pt->len + 1);
433 if (!minlen || memchr(nla_data(nla), '\0', minlen) == NULL) {
444 char *buf = nla_data(nla);
446 if (buf[attrlen - 1] == '\0')
449 if (attrlen > pt->len)
455 if (pt->len && attrlen > pt->len)
460 /* a nested attributes is allowed to be empty; if its not,
461 * it must have a size of at least NLA_HDRLEN.
465 if (attrlen < NLA_HDRLEN)
467 if (pt->nested_policy) {
468 err = __nla_validate_parse(nla_data(nla), nla_len(nla),
469 pt->len, pt->nested_policy,
470 validate, extack, NULL,
474 * return directly to preserve the inner
475 * error message/attribute pointer
481 case NLA_NESTED_ARRAY:
482 /* a nested array attribute is allowed to be empty; if its not,
483 * it must have a size of at least NLA_HDRLEN.
487 if (attrlen < NLA_HDRLEN)
489 if (pt->nested_policy) {
492 err = nla_validate_array(nla_data(nla), nla_len(nla),
493 pt->len, pt->nested_policy,
494 extack, validate, depth);
497 * return directly to preserve the inner
498 * error message/attribute pointer
506 if (validate & NL_VALIDATE_UNSPEC) {
507 NL_SET_ERR_MSG_ATTR(extack, nla,
508 "Unsupported attribute");
511 if (attrlen < pt->len)
519 minlen = nla_attr_minlen[pt->type];
521 if (attrlen < minlen)
525 /* further validation */
526 switch (pt->validation_type) {
527 case NLA_VALIDATE_NONE:
530 case NLA_VALIDATE_RANGE_PTR:
531 case NLA_VALIDATE_RANGE:
532 case NLA_VALIDATE_RANGE_WARN_TOO_LONG:
533 case NLA_VALIDATE_MIN:
534 case NLA_VALIDATE_MAX:
535 err = nla_validate_int_range(pt, nla, extack, validate);
539 case NLA_VALIDATE_MASK:
540 err = nla_validate_mask(pt, nla, extack);
544 case NLA_VALIDATE_FUNCTION:
546 err = pt->validate(nla, extack);
555 NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
556 "Attribute failed policy validation");
560 static int __nla_validate_parse(const struct nlattr *head, int len, int maxtype,
561 const struct nla_policy *policy,
562 unsigned int validate,
563 struct netlink_ext_ack *extack,
564 struct nlattr **tb, unsigned int depth)
566 const struct nlattr *nla;
569 if (depth >= MAX_POLICY_RECURSION_DEPTH) {
570 NL_SET_ERR_MSG(extack,
571 "allowed policy recursion depth exceeded");
576 memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));
578 nla_for_each_attr(nla, head, len, rem) {
579 u16 type = nla_type(nla);
581 if (type == 0 || type > maxtype) {
582 if (validate & NL_VALIDATE_MAXTYPE) {
583 NL_SET_ERR_MSG_ATTR(extack, nla,
584 "Unknown attribute type");
589 type = array_index_nospec(type, maxtype + 1);
591 int err = validate_nla(nla, maxtype, policy,
592 validate, extack, depth);
599 tb[type] = (struct nlattr *)nla;
602 if (unlikely(rem > 0)) {
603 pr_warn_ratelimited("netlink: %d bytes leftover after parsing attributes in process `%s'.\n",
605 NL_SET_ERR_MSG(extack, "bytes leftover after parsing attributes");
606 if (validate & NL_VALIDATE_TRAILING)
614 * __nla_validate - Validate a stream of attributes
615 * @head: head of attribute stream
616 * @len: length of attribute stream
617 * @maxtype: maximum attribute type to be expected
618 * @policy: validation policy
619 * @validate: validation strictness
620 * @extack: extended ACK report struct
622 * Validates all attributes in the specified attribute stream against the
623 * specified policy. Validation depends on the validate flags passed, see
624 * &enum netlink_validation for more details on that.
625 * See documenation of struct nla_policy for more details.
627 * Returns 0 on success or a negative error code.
629 int __nla_validate(const struct nlattr *head, int len, int maxtype,
630 const struct nla_policy *policy, unsigned int validate,
631 struct netlink_ext_ack *extack)
633 return __nla_validate_parse(head, len, maxtype, policy, validate,
636 EXPORT_SYMBOL(__nla_validate);
639 * nla_policy_len - Determin the max. length of a policy
640 * @policy: policy to use
641 * @n: number of policies
643 * Determines the max. length of the policy. It is currently used
644 * to allocated Netlink buffers roughly the size of the actual
647 * Returns 0 on success or a negative error code.
650 nla_policy_len(const struct nla_policy *p, int n)
654 for (i = 0; i < n; i++, p++) {
656 len += nla_total_size(p->len);
657 else if (nla_attr_len[p->type])
658 len += nla_total_size(nla_attr_len[p->type]);
659 else if (nla_attr_minlen[p->type])
660 len += nla_total_size(nla_attr_minlen[p->type]);
665 EXPORT_SYMBOL(nla_policy_len);
668 * __nla_parse - Parse a stream of attributes into a tb buffer
669 * @tb: destination array with maxtype+1 elements
670 * @maxtype: maximum attribute type to be expected
671 * @head: head of attribute stream
672 * @len: length of attribute stream
673 * @policy: validation policy
674 * @validate: validation strictness
675 * @extack: extended ACK pointer
677 * Parses a stream of attributes and stores a pointer to each attribute in
678 * the tb array accessible via the attribute type.
679 * Validation is controlled by the @validate parameter.
681 * Returns 0 on success or a negative error code.
683 int __nla_parse(struct nlattr **tb, int maxtype,
684 const struct nlattr *head, int len,
685 const struct nla_policy *policy, unsigned int validate,
686 struct netlink_ext_ack *extack)
688 return __nla_validate_parse(head, len, maxtype, policy, validate,
691 EXPORT_SYMBOL(__nla_parse);
694 * nla_find - Find a specific attribute in a stream of attributes
695 * @head: head of attribute stream
696 * @len: length of attribute stream
697 * @attrtype: type of attribute to look for
699 * Returns the first attribute in the stream matching the specified type.
701 struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype)
703 const struct nlattr *nla;
706 nla_for_each_attr(nla, head, len, rem)
707 if (nla_type(nla) == attrtype)
708 return (struct nlattr *)nla;
712 EXPORT_SYMBOL(nla_find);
715 * nla_strlcpy - Copy string attribute payload into a sized buffer
716 * @dst: where to copy the string to
717 * @nla: attribute to copy the string from
718 * @dstsize: size of destination buffer
720 * Copies at most dstsize - 1 bytes into the destination buffer.
721 * The result is always a valid NUL-terminated string. Unlike
722 * strlcpy the destination buffer is always padded out.
724 * Returns the length of the source buffer.
726 size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize)
728 size_t srclen = nla_len(nla);
729 char *src = nla_data(nla);
731 if (srclen > 0 && src[srclen - 1] == '\0')
735 size_t len = (srclen >= dstsize) ? dstsize - 1 : srclen;
737 memset(dst, 0, dstsize);
738 memcpy(dst, src, len);
743 EXPORT_SYMBOL(nla_strlcpy);
746 * nla_strdup - Copy string attribute payload into a newly allocated buffer
747 * @nla: attribute to copy the string from
748 * @flags: the type of memory to allocate (see kmalloc).
750 * Returns a pointer to the allocated buffer or NULL on error.
752 char *nla_strdup(const struct nlattr *nla, gfp_t flags)
754 size_t srclen = nla_len(nla);
755 char *src = nla_data(nla), *dst;
757 if (srclen > 0 && src[srclen - 1] == '\0')
760 dst = kmalloc(srclen + 1, flags);
762 memcpy(dst, src, srclen);
767 EXPORT_SYMBOL(nla_strdup);
770 * nla_memcpy - Copy a netlink attribute into another memory area
771 * @dest: where to copy to memcpy
772 * @src: netlink attribute to copy from
773 * @count: size of the destination area
775 * Note: The number of bytes copied is limited by the length of
776 * attribute's payload. memcpy
778 * Returns the number of bytes copied.
780 int nla_memcpy(void *dest, const struct nlattr *src, int count)
782 int minlen = min_t(int, count, nla_len(src));
784 memcpy(dest, nla_data(src), minlen);
786 memset(dest + minlen, 0, count - minlen);
790 EXPORT_SYMBOL(nla_memcpy);
793 * nla_memcmp - Compare an attribute with sized memory area
794 * @nla: netlink attribute
796 * @size: size of memory area
798 int nla_memcmp(const struct nlattr *nla, const void *data,
801 int d = nla_len(nla) - size;
804 d = memcmp(nla_data(nla), data, size);
808 EXPORT_SYMBOL(nla_memcmp);
811 * nla_strcmp - Compare a string attribute against a string
812 * @nla: netlink string attribute
813 * @str: another string
815 int nla_strcmp(const struct nlattr *nla, const char *str)
817 int len = strlen(str);
818 char *buf = nla_data(nla);
819 int attrlen = nla_len(nla);
822 while (attrlen > 0 && buf[attrlen - 1] == '\0')
827 d = memcmp(nla_data(nla), str, len);
831 EXPORT_SYMBOL(nla_strcmp);
835 * __nla_reserve - reserve room for attribute on the skb
836 * @skb: socket buffer to reserve room on
837 * @attrtype: attribute type
838 * @attrlen: length of attribute payload
840 * Adds a netlink attribute header to a socket buffer and reserves
841 * room for the payload but does not copy it.
843 * The caller is responsible to ensure that the skb provides enough
844 * tailroom for the attribute header and payload.
846 struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
850 nla = skb_put(skb, nla_total_size(attrlen));
851 nla->nla_type = attrtype;
852 nla->nla_len = nla_attr_size(attrlen);
854 memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen));
858 EXPORT_SYMBOL(__nla_reserve);
861 * __nla_reserve_64bit - reserve room for attribute on the skb and align it
862 * @skb: socket buffer to reserve room on
863 * @attrtype: attribute type
864 * @attrlen: length of attribute payload
865 * @padattr: attribute type for the padding
867 * Adds a netlink attribute header to a socket buffer and reserves
868 * room for the payload but does not copy it. It also ensure that this
869 * attribute will have a 64-bit aligned nla_data() area.
871 * The caller is responsible to ensure that the skb provides enough
872 * tailroom for the attribute header and payload.
874 struct nlattr *__nla_reserve_64bit(struct sk_buff *skb, int attrtype,
875 int attrlen, int padattr)
877 nla_align_64bit(skb, padattr);
879 return __nla_reserve(skb, attrtype, attrlen);
881 EXPORT_SYMBOL(__nla_reserve_64bit);
884 * __nla_reserve_nohdr - reserve room for attribute without header
885 * @skb: socket buffer to reserve room on
886 * @attrlen: length of attribute payload
888 * Reserves room for attribute payload without a header.
890 * The caller is responsible to ensure that the skb provides enough
891 * tailroom for the payload.
893 void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
895 return skb_put_zero(skb, NLA_ALIGN(attrlen));
897 EXPORT_SYMBOL(__nla_reserve_nohdr);
900 * nla_reserve - reserve room for attribute on the skb
901 * @skb: socket buffer to reserve room on
902 * @attrtype: attribute type
903 * @attrlen: length of attribute payload
905 * Adds a netlink attribute header to a socket buffer and reserves
906 * room for the payload but does not copy it.
908 * Returns NULL if the tailroom of the skb is insufficient to store
909 * the attribute header and payload.
911 struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
913 if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
916 return __nla_reserve(skb, attrtype, attrlen);
918 EXPORT_SYMBOL(nla_reserve);
921 * nla_reserve_64bit - reserve room for attribute on the skb and align it
922 * @skb: socket buffer to reserve room on
923 * @attrtype: attribute type
924 * @attrlen: length of attribute payload
925 * @padattr: attribute type for the padding
927 * Adds a netlink attribute header to a socket buffer and reserves
928 * room for the payload but does not copy it. It also ensure that this
929 * attribute will have a 64-bit aligned nla_data() area.
931 * Returns NULL if the tailroom of the skb is insufficient to store
932 * the attribute header and payload.
934 struct nlattr *nla_reserve_64bit(struct sk_buff *skb, int attrtype, int attrlen,
939 if (nla_need_padding_for_64bit(skb))
940 len = nla_total_size_64bit(attrlen);
942 len = nla_total_size(attrlen);
943 if (unlikely(skb_tailroom(skb) < len))
946 return __nla_reserve_64bit(skb, attrtype, attrlen, padattr);
948 EXPORT_SYMBOL(nla_reserve_64bit);
951 * nla_reserve_nohdr - reserve room for attribute without header
952 * @skb: socket buffer to reserve room on
953 * @attrlen: length of attribute payload
955 * Reserves room for attribute payload without a header.
957 * Returns NULL if the tailroom of the skb is insufficient to store
958 * the attribute payload.
960 void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
962 if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
965 return __nla_reserve_nohdr(skb, attrlen);
967 EXPORT_SYMBOL(nla_reserve_nohdr);
970 * __nla_put - Add a netlink attribute to a socket buffer
971 * @skb: socket buffer to add attribute to
972 * @attrtype: attribute type
973 * @attrlen: length of attribute payload
974 * @data: head of attribute payload
976 * The caller is responsible to ensure that the skb provides enough
977 * tailroom for the attribute header and payload.
979 void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
984 nla = __nla_reserve(skb, attrtype, attrlen);
985 memcpy(nla_data(nla), data, attrlen);
987 EXPORT_SYMBOL(__nla_put);
990 * __nla_put_64bit - Add a netlink attribute to a socket buffer and align it
991 * @skb: socket buffer to add attribute to
992 * @attrtype: attribute type
993 * @attrlen: length of attribute payload
994 * @data: head of attribute payload
995 * @padattr: attribute type for the padding
997 * The caller is responsible to ensure that the skb provides enough
998 * tailroom for the attribute header and payload.
1000 void __nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
1001 const void *data, int padattr)
1005 nla = __nla_reserve_64bit(skb, attrtype, attrlen, padattr);
1006 memcpy(nla_data(nla), data, attrlen);
1008 EXPORT_SYMBOL(__nla_put_64bit);
1011 * __nla_put_nohdr - Add a netlink attribute without header
1012 * @skb: socket buffer to add attribute to
1013 * @attrlen: length of attribute payload
1014 * @data: head of attribute payload
1016 * The caller is responsible to ensure that the skb provides enough
1017 * tailroom for the attribute payload.
1019 void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
1023 start = __nla_reserve_nohdr(skb, attrlen);
1024 memcpy(start, data, attrlen);
1026 EXPORT_SYMBOL(__nla_put_nohdr);
1029 * nla_put - Add a netlink attribute to a socket buffer
1030 * @skb: socket buffer to add attribute to
1031 * @attrtype: attribute type
1032 * @attrlen: length of attribute payload
1033 * @data: head of attribute payload
1035 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1036 * the attribute header and payload.
1038 int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
1040 if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
1043 __nla_put(skb, attrtype, attrlen, data);
1046 EXPORT_SYMBOL(nla_put);
1049 * nla_put_64bit - Add a netlink attribute to a socket buffer and align it
1050 * @skb: socket buffer to add attribute to
1051 * @attrtype: attribute type
1052 * @attrlen: length of attribute payload
1053 * @data: head of attribute payload
1054 * @padattr: attribute type for the padding
1056 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1057 * the attribute header and payload.
1059 int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
1060 const void *data, int padattr)
1064 if (nla_need_padding_for_64bit(skb))
1065 len = nla_total_size_64bit(attrlen);
1067 len = nla_total_size(attrlen);
1068 if (unlikely(skb_tailroom(skb) < len))
1071 __nla_put_64bit(skb, attrtype, attrlen, data, padattr);
1074 EXPORT_SYMBOL(nla_put_64bit);
1077 * nla_put_nohdr - Add a netlink attribute without header
1078 * @skb: socket buffer to add attribute to
1079 * @attrlen: length of attribute payload
1080 * @data: head of attribute payload
1082 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1083 * the attribute payload.
1085 int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
1087 if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
1090 __nla_put_nohdr(skb, attrlen, data);
1093 EXPORT_SYMBOL(nla_put_nohdr);
1096 * nla_append - Add a netlink attribute without header or padding
1097 * @skb: socket buffer to add attribute to
1098 * @attrlen: length of attribute payload
1099 * @data: head of attribute payload
1101 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1102 * the attribute payload.
1104 int nla_append(struct sk_buff *skb, int attrlen, const void *data)
1106 if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
1109 skb_put_data(skb, data, attrlen);
1112 EXPORT_SYMBOL(nla_append);