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/skbuff.h>
14 #include <linux/string.h>
15 #include <linux/types.h>
16 #include <net/netlink.h>
18 /* For these data types, attribute length should be exactly the given
19 * size. However, to maintain compatibility with broken commands, if the
20 * attribute length does not match the expected size a warning is emitted
21 * to the user that the command is sending invalid data and needs to be fixed.
23 static const u8 nla_attr_len
[NLA_TYPE_MAX
+1] = {
24 [NLA_U8
] = sizeof(u8
),
25 [NLA_U16
] = sizeof(u16
),
26 [NLA_U32
] = sizeof(u32
),
27 [NLA_U64
] = sizeof(u64
),
28 [NLA_S8
] = sizeof(s8
),
29 [NLA_S16
] = sizeof(s16
),
30 [NLA_S32
] = sizeof(s32
),
31 [NLA_S64
] = sizeof(s64
),
34 static const u8 nla_attr_minlen
[NLA_TYPE_MAX
+1] = {
35 [NLA_U8
] = sizeof(u8
),
36 [NLA_U16
] = sizeof(u16
),
37 [NLA_U32
] = sizeof(u32
),
38 [NLA_U64
] = sizeof(u64
),
39 [NLA_MSECS
] = sizeof(u64
),
40 [NLA_NESTED
] = NLA_HDRLEN
,
41 [NLA_S8
] = sizeof(s8
),
42 [NLA_S16
] = sizeof(s16
),
43 [NLA_S32
] = sizeof(s32
),
44 [NLA_S64
] = sizeof(s64
),
48 * Nested policies might refer back to the original
49 * policy in some cases, and userspace could try to
50 * abuse that and recurse by nesting in the right
51 * ways. Limit recursion to avoid this problem.
53 #define MAX_POLICY_RECURSION_DEPTH 10
55 static int __nla_validate_parse(const struct nlattr
*head
, int len
, int maxtype
,
56 const struct nla_policy
*policy
,
57 unsigned int validate
,
58 struct netlink_ext_ack
*extack
,
59 struct nlattr
**tb
, unsigned int depth
);
61 static int validate_nla_bitfield32(const struct nlattr
*nla
,
62 const u32 valid_flags_mask
)
64 const struct nla_bitfield32
*bf
= nla_data(nla
);
66 if (!valid_flags_mask
)
69 /*disallow invalid bit selector */
70 if (bf
->selector
& ~valid_flags_mask
)
73 /*disallow invalid bit values */
74 if (bf
->value
& ~valid_flags_mask
)
77 /*disallow valid bit values that are not selected*/
78 if (bf
->value
& ~bf
->selector
)
84 static int nla_validate_array(const struct nlattr
*head
, int len
, int maxtype
,
85 const struct nla_policy
*policy
,
86 struct netlink_ext_ack
*extack
,
87 unsigned int validate
, unsigned int depth
)
89 const struct nlattr
*entry
;
92 nla_for_each_attr(entry
, head
, len
, rem
) {
95 if (nla_len(entry
) == 0)
98 if (nla_len(entry
) < NLA_HDRLEN
) {
99 NL_SET_ERR_MSG_ATTR_POL(extack
, entry
, policy
,
100 "Array element too short");
104 ret
= __nla_validate_parse(nla_data(entry
), nla_len(entry
),
105 maxtype
, policy
, validate
, extack
,
114 void nla_get_range_unsigned(const struct nla_policy
*pt
,
115 struct netlink_range_validation
*range
)
117 WARN_ON_ONCE(pt
->validation_type
!= NLA_VALIDATE_RANGE_PTR
&&
118 (pt
->min
< 0 || pt
->max
< 0));
128 range
->max
= U16_MAX
;
131 range
->max
= U32_MAX
;
135 range
->max
= U64_MAX
;
142 switch (pt
->validation_type
) {
143 case NLA_VALIDATE_RANGE
:
144 case NLA_VALIDATE_RANGE_WARN_TOO_LONG
:
145 range
->min
= pt
->min
;
146 range
->max
= pt
->max
;
148 case NLA_VALIDATE_RANGE_PTR
:
151 case NLA_VALIDATE_MIN
:
152 range
->min
= pt
->min
;
154 case NLA_VALIDATE_MAX
:
155 range
->max
= pt
->max
;
162 static int nla_validate_range_unsigned(const struct nla_policy
*pt
,
163 const struct nlattr
*nla
,
164 struct netlink_ext_ack
*extack
,
165 unsigned int validate
)
167 struct netlink_range_validation range
;
172 value
= nla_get_u8(nla
);
175 value
= nla_get_u16(nla
);
178 value
= nla_get_u32(nla
);
182 value
= nla_get_u64(nla
);
185 value
= nla_len(nla
);
191 nla_get_range_unsigned(pt
, &range
);
193 if (pt
->validation_type
== NLA_VALIDATE_RANGE_WARN_TOO_LONG
&&
194 pt
->type
== NLA_BINARY
&& value
> range
.max
) {
195 pr_warn_ratelimited("netlink: '%s': attribute type %d has an invalid length.\n",
196 current
->comm
, pt
->type
);
197 if (validate
& NL_VALIDATE_STRICT_ATTRS
) {
198 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
199 "invalid attribute length");
203 /* this assumes min <= max (don't validate against min) */
207 if (value
< range
.min
|| value
> range
.max
) {
208 bool binary
= pt
->type
== NLA_BINARY
;
211 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
212 "binary attribute size out of range");
214 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
215 "integer out of range");
223 void nla_get_range_signed(const struct nla_policy
*pt
,
224 struct netlink_range_validation_signed
*range
)
232 range
->min
= S16_MIN
;
233 range
->max
= S16_MAX
;
236 range
->min
= S32_MIN
;
237 range
->max
= S32_MAX
;
240 range
->min
= S64_MIN
;
241 range
->max
= S64_MAX
;
248 switch (pt
->validation_type
) {
249 case NLA_VALIDATE_RANGE
:
250 range
->min
= pt
->min
;
251 range
->max
= pt
->max
;
253 case NLA_VALIDATE_RANGE_PTR
:
254 *range
= *pt
->range_signed
;
256 case NLA_VALIDATE_MIN
:
257 range
->min
= pt
->min
;
259 case NLA_VALIDATE_MAX
:
260 range
->max
= pt
->max
;
267 static int nla_validate_int_range_signed(const struct nla_policy
*pt
,
268 const struct nlattr
*nla
,
269 struct netlink_ext_ack
*extack
)
271 struct netlink_range_validation_signed range
;
276 value
= nla_get_s8(nla
);
279 value
= nla_get_s16(nla
);
282 value
= nla_get_s32(nla
);
285 value
= nla_get_s64(nla
);
291 nla_get_range_signed(pt
, &range
);
293 if (value
< range
.min
|| value
> range
.max
) {
294 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
295 "integer out of range");
302 static int nla_validate_int_range(const struct nla_policy
*pt
,
303 const struct nlattr
*nla
,
304 struct netlink_ext_ack
*extack
,
305 unsigned int validate
)
314 return nla_validate_range_unsigned(pt
, nla
, extack
, validate
);
319 return nla_validate_int_range_signed(pt
, nla
, extack
);
326 static int nla_validate_mask(const struct nla_policy
*pt
,
327 const struct nlattr
*nla
,
328 struct netlink_ext_ack
*extack
)
334 value
= nla_get_u8(nla
);
337 value
= nla_get_u16(nla
);
340 value
= nla_get_u32(nla
);
343 value
= nla_get_u64(nla
);
349 if (value
& ~(u64
)pt
->mask
) {
350 NL_SET_ERR_MSG_ATTR(extack
, nla
, "reserved bit set");
357 static int validate_nla(const struct nlattr
*nla
, int maxtype
,
358 const struct nla_policy
*policy
, unsigned int validate
,
359 struct netlink_ext_ack
*extack
, unsigned int depth
)
361 u16 strict_start_type
= policy
[0].strict_start_type
;
362 const struct nla_policy
*pt
;
363 int minlen
= 0, attrlen
= nla_len(nla
), type
= nla_type(nla
);
366 if (strict_start_type
&& type
>= strict_start_type
)
367 validate
|= NL_VALIDATE_STRICT
;
369 if (type
<= 0 || type
> maxtype
)
374 BUG_ON(pt
->type
> NLA_TYPE_MAX
);
376 if (nla_attr_len
[pt
->type
] && attrlen
!= nla_attr_len
[pt
->type
]) {
377 pr_warn_ratelimited("netlink: '%s': attribute type %d has an invalid length.\n",
378 current
->comm
, type
);
379 if (validate
& NL_VALIDATE_STRICT_ATTRS
) {
380 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
381 "invalid attribute length");
386 if (validate
& NL_VALIDATE_NESTED
) {
387 if ((pt
->type
== NLA_NESTED
|| pt
->type
== NLA_NESTED_ARRAY
) &&
388 !(nla
->nla_type
& NLA_F_NESTED
)) {
389 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
390 "NLA_F_NESTED is missing");
393 if (pt
->type
!= NLA_NESTED
&& pt
->type
!= NLA_NESTED_ARRAY
&&
394 pt
->type
!= NLA_UNSPEC
&& (nla
->nla_type
& NLA_F_NESTED
)) {
395 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
396 "NLA_F_NESTED not expected");
403 if (extack
&& pt
->reject_message
) {
404 NL_SET_BAD_ATTR(extack
, nla
);
405 extack
->_msg
= pt
->reject_message
;
417 if (attrlen
!= sizeof(struct nla_bitfield32
))
420 err
= validate_nla_bitfield32(nla
, pt
->bitfield32_valid
);
427 minlen
= min_t(int, attrlen
, pt
->len
+ 1);
431 if (!minlen
|| memchr(nla_data(nla
), '\0', minlen
) == NULL
) {
442 char *buf
= nla_data(nla
);
444 if (buf
[attrlen
- 1] == '\0')
447 if (attrlen
> pt
->len
)
453 if (pt
->len
&& attrlen
> pt
->len
)
458 /* a nested attributes is allowed to be empty; if its not,
459 * it must have a size of at least NLA_HDRLEN.
463 if (attrlen
< NLA_HDRLEN
)
465 if (pt
->nested_policy
) {
466 err
= __nla_validate_parse(nla_data(nla
), nla_len(nla
),
467 pt
->len
, pt
->nested_policy
,
468 validate
, extack
, NULL
,
472 * return directly to preserve the inner
473 * error message/attribute pointer
479 case NLA_NESTED_ARRAY
:
480 /* a nested array attribute is allowed to be empty; if its not,
481 * it must have a size of at least NLA_HDRLEN.
485 if (attrlen
< NLA_HDRLEN
)
487 if (pt
->nested_policy
) {
490 err
= nla_validate_array(nla_data(nla
), nla_len(nla
),
491 pt
->len
, pt
->nested_policy
,
492 extack
, validate
, depth
);
495 * return directly to preserve the inner
496 * error message/attribute pointer
504 if (validate
& NL_VALIDATE_UNSPEC
) {
505 NL_SET_ERR_MSG_ATTR(extack
, nla
,
506 "Unsupported attribute");
509 if (attrlen
< pt
->len
)
517 minlen
= nla_attr_minlen
[pt
->type
];
519 if (attrlen
< minlen
)
523 /* further validation */
524 switch (pt
->validation_type
) {
525 case NLA_VALIDATE_NONE
:
528 case NLA_VALIDATE_RANGE_PTR
:
529 case NLA_VALIDATE_RANGE
:
530 case NLA_VALIDATE_RANGE_WARN_TOO_LONG
:
531 case NLA_VALIDATE_MIN
:
532 case NLA_VALIDATE_MAX
:
533 err
= nla_validate_int_range(pt
, nla
, extack
, validate
);
537 case NLA_VALIDATE_MASK
:
538 err
= nla_validate_mask(pt
, nla
, extack
);
542 case NLA_VALIDATE_FUNCTION
:
544 err
= pt
->validate(nla
, extack
);
553 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
554 "Attribute failed policy validation");
558 static int __nla_validate_parse(const struct nlattr
*head
, int len
, int maxtype
,
559 const struct nla_policy
*policy
,
560 unsigned int validate
,
561 struct netlink_ext_ack
*extack
,
562 struct nlattr
**tb
, unsigned int depth
)
564 const struct nlattr
*nla
;
567 if (depth
>= MAX_POLICY_RECURSION_DEPTH
) {
568 NL_SET_ERR_MSG(extack
,
569 "allowed policy recursion depth exceeded");
574 memset(tb
, 0, sizeof(struct nlattr
*) * (maxtype
+ 1));
576 nla_for_each_attr(nla
, head
, len
, rem
) {
577 u16 type
= nla_type(nla
);
579 if (type
== 0 || type
> maxtype
) {
580 if (validate
& NL_VALIDATE_MAXTYPE
) {
581 NL_SET_ERR_MSG_ATTR(extack
, nla
,
582 "Unknown attribute type");
588 int err
= validate_nla(nla
, maxtype
, policy
,
589 validate
, extack
, depth
);
596 tb
[type
] = (struct nlattr
*)nla
;
599 if (unlikely(rem
> 0)) {
600 pr_warn_ratelimited("netlink: %d bytes leftover after parsing attributes in process `%s'.\n",
602 NL_SET_ERR_MSG(extack
, "bytes leftover after parsing attributes");
603 if (validate
& NL_VALIDATE_TRAILING
)
611 * __nla_validate - Validate a stream of attributes
612 * @head: head of attribute stream
613 * @len: length of attribute stream
614 * @maxtype: maximum attribute type to be expected
615 * @policy: validation policy
616 * @validate: validation strictness
617 * @extack: extended ACK report struct
619 * Validates all attributes in the specified attribute stream against the
620 * specified policy. Validation depends on the validate flags passed, see
621 * &enum netlink_validation for more details on that.
622 * See documenation of struct nla_policy for more details.
624 * Returns 0 on success or a negative error code.
626 int __nla_validate(const struct nlattr
*head
, int len
, int maxtype
,
627 const struct nla_policy
*policy
, unsigned int validate
,
628 struct netlink_ext_ack
*extack
)
630 return __nla_validate_parse(head
, len
, maxtype
, policy
, validate
,
633 EXPORT_SYMBOL(__nla_validate
);
636 * nla_policy_len - Determin the max. length of a policy
637 * @policy: policy to use
638 * @n: number of policies
640 * Determines the max. length of the policy. It is currently used
641 * to allocated Netlink buffers roughly the size of the actual
644 * Returns 0 on success or a negative error code.
647 nla_policy_len(const struct nla_policy
*p
, int n
)
651 for (i
= 0; i
< n
; i
++, p
++) {
653 len
+= nla_total_size(p
->len
);
654 else if (nla_attr_len
[p
->type
])
655 len
+= nla_total_size(nla_attr_len
[p
->type
]);
656 else if (nla_attr_minlen
[p
->type
])
657 len
+= nla_total_size(nla_attr_minlen
[p
->type
]);
662 EXPORT_SYMBOL(nla_policy_len
);
665 * __nla_parse - Parse a stream of attributes into a tb buffer
666 * @tb: destination array with maxtype+1 elements
667 * @maxtype: maximum attribute type to be expected
668 * @head: head of attribute stream
669 * @len: length of attribute stream
670 * @policy: validation policy
671 * @validate: validation strictness
672 * @extack: extended ACK pointer
674 * Parses a stream of attributes and stores a pointer to each attribute in
675 * the tb array accessible via the attribute type.
676 * Validation is controlled by the @validate parameter.
678 * Returns 0 on success or a negative error code.
680 int __nla_parse(struct nlattr
**tb
, int maxtype
,
681 const struct nlattr
*head
, int len
,
682 const struct nla_policy
*policy
, unsigned int validate
,
683 struct netlink_ext_ack
*extack
)
685 return __nla_validate_parse(head
, len
, maxtype
, policy
, validate
,
688 EXPORT_SYMBOL(__nla_parse
);
691 * nla_find - Find a specific attribute in a stream of attributes
692 * @head: head of attribute stream
693 * @len: length of attribute stream
694 * @attrtype: type of attribute to look for
696 * Returns the first attribute in the stream matching the specified type.
698 struct nlattr
*nla_find(const struct nlattr
*head
, int len
, int attrtype
)
700 const struct nlattr
*nla
;
703 nla_for_each_attr(nla
, head
, len
, rem
)
704 if (nla_type(nla
) == attrtype
)
705 return (struct nlattr
*)nla
;
709 EXPORT_SYMBOL(nla_find
);
712 * nla_strlcpy - Copy string attribute payload into a sized buffer
713 * @dst: where to copy the string to
714 * @nla: attribute to copy the string from
715 * @dstsize: size of destination buffer
717 * Copies at most dstsize - 1 bytes into the destination buffer.
718 * The result is always a valid NUL-terminated string. Unlike
719 * strlcpy the destination buffer is always padded out.
721 * Returns the length of the source buffer.
723 size_t nla_strlcpy(char *dst
, const struct nlattr
*nla
, size_t dstsize
)
725 size_t srclen
= nla_len(nla
);
726 char *src
= nla_data(nla
);
728 if (srclen
> 0 && src
[srclen
- 1] == '\0')
732 size_t len
= (srclen
>= dstsize
) ? dstsize
- 1 : srclen
;
734 memset(dst
, 0, dstsize
);
735 memcpy(dst
, src
, len
);
740 EXPORT_SYMBOL(nla_strlcpy
);
743 * nla_strdup - Copy string attribute payload into a newly allocated buffer
744 * @nla: attribute to copy the string from
745 * @flags: the type of memory to allocate (see kmalloc).
747 * Returns a pointer to the allocated buffer or NULL on error.
749 char *nla_strdup(const struct nlattr
*nla
, gfp_t flags
)
751 size_t srclen
= nla_len(nla
);
752 char *src
= nla_data(nla
), *dst
;
754 if (srclen
> 0 && src
[srclen
- 1] == '\0')
757 dst
= kmalloc(srclen
+ 1, flags
);
759 memcpy(dst
, src
, srclen
);
764 EXPORT_SYMBOL(nla_strdup
);
767 * nla_memcpy - Copy a netlink attribute into another memory area
768 * @dest: where to copy to memcpy
769 * @src: netlink attribute to copy from
770 * @count: size of the destination area
772 * Note: The number of bytes copied is limited by the length of
773 * attribute's payload. memcpy
775 * Returns the number of bytes copied.
777 int nla_memcpy(void *dest
, const struct nlattr
*src
, int count
)
779 int minlen
= min_t(int, count
, nla_len(src
));
781 memcpy(dest
, nla_data(src
), minlen
);
783 memset(dest
+ minlen
, 0, count
- minlen
);
787 EXPORT_SYMBOL(nla_memcpy
);
790 * nla_memcmp - Compare an attribute with sized memory area
791 * @nla: netlink attribute
793 * @size: size of memory area
795 int nla_memcmp(const struct nlattr
*nla
, const void *data
,
798 int d
= nla_len(nla
) - size
;
801 d
= memcmp(nla_data(nla
), data
, size
);
805 EXPORT_SYMBOL(nla_memcmp
);
808 * nla_strcmp - Compare a string attribute against a string
809 * @nla: netlink string attribute
810 * @str: another string
812 int nla_strcmp(const struct nlattr
*nla
, const char *str
)
814 int len
= strlen(str
);
815 char *buf
= nla_data(nla
);
816 int attrlen
= nla_len(nla
);
819 if (attrlen
> 0 && buf
[attrlen
- 1] == '\0')
824 d
= memcmp(nla_data(nla
), str
, len
);
828 EXPORT_SYMBOL(nla_strcmp
);
832 * __nla_reserve - reserve room for attribute on the skb
833 * @skb: socket buffer to reserve room on
834 * @attrtype: attribute type
835 * @attrlen: length of attribute payload
837 * Adds a netlink attribute header to a socket buffer and reserves
838 * room for the payload but does not copy it.
840 * The caller is responsible to ensure that the skb provides enough
841 * tailroom for the attribute header and payload.
843 struct nlattr
*__nla_reserve(struct sk_buff
*skb
, int attrtype
, int attrlen
)
847 nla
= skb_put(skb
, nla_total_size(attrlen
));
848 nla
->nla_type
= attrtype
;
849 nla
->nla_len
= nla_attr_size(attrlen
);
851 memset((unsigned char *) nla
+ nla
->nla_len
, 0, nla_padlen(attrlen
));
855 EXPORT_SYMBOL(__nla_reserve
);
858 * __nla_reserve_64bit - reserve room for attribute on the skb and align it
859 * @skb: socket buffer to reserve room on
860 * @attrtype: attribute type
861 * @attrlen: length of attribute payload
862 * @padattr: attribute type for the padding
864 * Adds a netlink attribute header to a socket buffer and reserves
865 * room for the payload but does not copy it. It also ensure that this
866 * attribute will have a 64-bit aligned nla_data() area.
868 * The caller is responsible to ensure that the skb provides enough
869 * tailroom for the attribute header and payload.
871 struct nlattr
*__nla_reserve_64bit(struct sk_buff
*skb
, int attrtype
,
872 int attrlen
, int padattr
)
874 nla_align_64bit(skb
, padattr
);
876 return __nla_reserve(skb
, attrtype
, attrlen
);
878 EXPORT_SYMBOL(__nla_reserve_64bit
);
881 * __nla_reserve_nohdr - reserve room for attribute without header
882 * @skb: socket buffer to reserve room on
883 * @attrlen: length of attribute payload
885 * Reserves room for attribute payload without a header.
887 * The caller is responsible to ensure that the skb provides enough
888 * tailroom for the payload.
890 void *__nla_reserve_nohdr(struct sk_buff
*skb
, int attrlen
)
892 return skb_put_zero(skb
, NLA_ALIGN(attrlen
));
894 EXPORT_SYMBOL(__nla_reserve_nohdr
);
897 * nla_reserve - reserve room for attribute on the skb
898 * @skb: socket buffer to reserve room on
899 * @attrtype: attribute type
900 * @attrlen: length of attribute payload
902 * Adds a netlink attribute header to a socket buffer and reserves
903 * room for the payload but does not copy it.
905 * Returns NULL if the tailroom of the skb is insufficient to store
906 * the attribute header and payload.
908 struct nlattr
*nla_reserve(struct sk_buff
*skb
, int attrtype
, int attrlen
)
910 if (unlikely(skb_tailroom(skb
) < nla_total_size(attrlen
)))
913 return __nla_reserve(skb
, attrtype
, attrlen
);
915 EXPORT_SYMBOL(nla_reserve
);
918 * nla_reserve_64bit - reserve room for attribute on the skb and align it
919 * @skb: socket buffer to reserve room on
920 * @attrtype: attribute type
921 * @attrlen: length of attribute payload
922 * @padattr: attribute type for the padding
924 * Adds a netlink attribute header to a socket buffer and reserves
925 * room for the payload but does not copy it. It also ensure that this
926 * attribute will have a 64-bit aligned nla_data() area.
928 * Returns NULL if the tailroom of the skb is insufficient to store
929 * the attribute header and payload.
931 struct nlattr
*nla_reserve_64bit(struct sk_buff
*skb
, int attrtype
, int attrlen
,
936 if (nla_need_padding_for_64bit(skb
))
937 len
= nla_total_size_64bit(attrlen
);
939 len
= nla_total_size(attrlen
);
940 if (unlikely(skb_tailroom(skb
) < len
))
943 return __nla_reserve_64bit(skb
, attrtype
, attrlen
, padattr
);
945 EXPORT_SYMBOL(nla_reserve_64bit
);
948 * nla_reserve_nohdr - reserve room for attribute without header
949 * @skb: socket buffer to reserve room on
950 * @attrlen: length of attribute payload
952 * Reserves room for attribute payload without a header.
954 * Returns NULL if the tailroom of the skb is insufficient to store
955 * the attribute payload.
957 void *nla_reserve_nohdr(struct sk_buff
*skb
, int attrlen
)
959 if (unlikely(skb_tailroom(skb
) < NLA_ALIGN(attrlen
)))
962 return __nla_reserve_nohdr(skb
, attrlen
);
964 EXPORT_SYMBOL(nla_reserve_nohdr
);
967 * __nla_put - Add a netlink attribute to a socket buffer
968 * @skb: socket buffer to add attribute to
969 * @attrtype: attribute type
970 * @attrlen: length of attribute payload
971 * @data: head of attribute payload
973 * The caller is responsible to ensure that the skb provides enough
974 * tailroom for the attribute header and payload.
976 void __nla_put(struct sk_buff
*skb
, int attrtype
, int attrlen
,
981 nla
= __nla_reserve(skb
, attrtype
, attrlen
);
982 memcpy(nla_data(nla
), data
, attrlen
);
984 EXPORT_SYMBOL(__nla_put
);
987 * __nla_put_64bit - Add a netlink attribute to a socket buffer and align it
988 * @skb: socket buffer to add attribute to
989 * @attrtype: attribute type
990 * @attrlen: length of attribute payload
991 * @data: head of attribute payload
992 * @padattr: attribute type for the padding
994 * The caller is responsible to ensure that the skb provides enough
995 * tailroom for the attribute header and payload.
997 void __nla_put_64bit(struct sk_buff
*skb
, int attrtype
, int attrlen
,
998 const void *data
, int padattr
)
1002 nla
= __nla_reserve_64bit(skb
, attrtype
, attrlen
, padattr
);
1003 memcpy(nla_data(nla
), data
, attrlen
);
1005 EXPORT_SYMBOL(__nla_put_64bit
);
1008 * __nla_put_nohdr - Add a netlink attribute without header
1009 * @skb: socket buffer to add attribute to
1010 * @attrlen: length of attribute payload
1011 * @data: head of attribute payload
1013 * The caller is responsible to ensure that the skb provides enough
1014 * tailroom for the attribute payload.
1016 void __nla_put_nohdr(struct sk_buff
*skb
, int attrlen
, const void *data
)
1020 start
= __nla_reserve_nohdr(skb
, attrlen
);
1021 memcpy(start
, data
, attrlen
);
1023 EXPORT_SYMBOL(__nla_put_nohdr
);
1026 * nla_put - Add a netlink attribute to a socket buffer
1027 * @skb: socket buffer to add attribute to
1028 * @attrtype: attribute type
1029 * @attrlen: length of attribute payload
1030 * @data: head of attribute payload
1032 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1033 * the attribute header and payload.
1035 int nla_put(struct sk_buff
*skb
, int attrtype
, int attrlen
, const void *data
)
1037 if (unlikely(skb_tailroom(skb
) < nla_total_size(attrlen
)))
1040 __nla_put(skb
, attrtype
, attrlen
, data
);
1043 EXPORT_SYMBOL(nla_put
);
1046 * nla_put_64bit - Add a netlink attribute to a socket buffer and align it
1047 * @skb: socket buffer to add attribute to
1048 * @attrtype: attribute type
1049 * @attrlen: length of attribute payload
1050 * @data: head of attribute payload
1051 * @padattr: attribute type for the padding
1053 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1054 * the attribute header and payload.
1056 int nla_put_64bit(struct sk_buff
*skb
, int attrtype
, int attrlen
,
1057 const void *data
, int padattr
)
1061 if (nla_need_padding_for_64bit(skb
))
1062 len
= nla_total_size_64bit(attrlen
);
1064 len
= nla_total_size(attrlen
);
1065 if (unlikely(skb_tailroom(skb
) < len
))
1068 __nla_put_64bit(skb
, attrtype
, attrlen
, data
, padattr
);
1071 EXPORT_SYMBOL(nla_put_64bit
);
1074 * nla_put_nohdr - Add a netlink attribute without header
1075 * @skb: socket buffer to add attribute to
1076 * @attrlen: length of attribute payload
1077 * @data: head of attribute payload
1079 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1080 * the attribute payload.
1082 int nla_put_nohdr(struct sk_buff
*skb
, int attrlen
, const void *data
)
1084 if (unlikely(skb_tailroom(skb
) < NLA_ALIGN(attrlen
)))
1087 __nla_put_nohdr(skb
, attrlen
, data
);
1090 EXPORT_SYMBOL(nla_put_nohdr
);
1093 * nla_append - Add a netlink attribute without header or padding
1094 * @skb: socket buffer to add attribute to
1095 * @attrlen: length of attribute payload
1096 * @data: head of attribute payload
1098 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1099 * the attribute payload.
1101 int nla_append(struct sk_buff
*skb
, int attrlen
, const void *data
)
1103 if (unlikely(skb_tailroom(skb
) < NLA_ALIGN(attrlen
)))
1106 skb_put_data(skb
, data
, attrlen
);
1109 EXPORT_SYMBOL(nla_append
);