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));
130 range
->max
= U16_MAX
;
134 range
->max
= U32_MAX
;
138 range
->max
= U64_MAX
;
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
;
151 case NLA_VALIDATE_RANGE_PTR
:
154 case NLA_VALIDATE_MIN
:
155 range
->min
= pt
->min
;
157 case NLA_VALIDATE_MAX
:
158 range
->max
= pt
->max
;
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
)
170 struct netlink_range_validation range
;
175 value
= nla_get_u8(nla
);
178 value
= nla_get_u16(nla
);
181 value
= nla_get_u32(nla
);
184 value
= nla_get_u64(nla
);
187 value
= nla_get_u64(nla
);
190 value
= nla_len(nla
);
193 value
= ntohs(nla_get_be16(nla
));
196 value
= ntohl(nla_get_be32(nla
));
202 nla_get_range_unsigned(pt
, &range
);
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");
214 /* this assumes min <= max (don't validate against min) */
218 if (value
< range
.min
|| value
> range
.max
) {
219 bool binary
= pt
->type
== NLA_BINARY
;
222 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
223 "binary attribute size out of range");
225 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
226 "integer out of range");
234 void nla_get_range_signed(const struct nla_policy
*pt
,
235 struct netlink_range_validation_signed
*range
)
243 range
->min
= S16_MIN
;
244 range
->max
= S16_MAX
;
247 range
->min
= S32_MIN
;
248 range
->max
= S32_MAX
;
251 range
->min
= S64_MIN
;
252 range
->max
= S64_MAX
;
259 switch (pt
->validation_type
) {
260 case NLA_VALIDATE_RANGE
:
261 range
->min
= pt
->min
;
262 range
->max
= pt
->max
;
264 case NLA_VALIDATE_RANGE_PTR
:
265 *range
= *pt
->range_signed
;
267 case NLA_VALIDATE_MIN
:
268 range
->min
= pt
->min
;
270 case NLA_VALIDATE_MAX
:
271 range
->max
= pt
->max
;
278 static int nla_validate_int_range_signed(const struct nla_policy
*pt
,
279 const struct nlattr
*nla
,
280 struct netlink_ext_ack
*extack
)
282 struct netlink_range_validation_signed range
;
287 value
= nla_get_s8(nla
);
290 value
= nla_get_s16(nla
);
293 value
= nla_get_s32(nla
);
296 value
= nla_get_s64(nla
);
302 nla_get_range_signed(pt
, &range
);
304 if (value
< range
.min
|| value
> range
.max
) {
305 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
306 "integer out of range");
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
)
327 return nla_validate_range_unsigned(pt
, nla
, extack
, validate
);
332 return nla_validate_int_range_signed(pt
, nla
, extack
);
339 static int nla_validate_mask(const struct nla_policy
*pt
,
340 const struct nlattr
*nla
,
341 struct netlink_ext_ack
*extack
)
347 value
= nla_get_u8(nla
);
350 value
= nla_get_u16(nla
);
353 value
= nla_get_u32(nla
);
356 value
= nla_get_u64(nla
);
359 value
= ntohs(nla_get_be16(nla
));
362 value
= ntohl(nla_get_be32(nla
));
368 if (value
& ~(u64
)pt
->mask
) {
369 NL_SET_ERR_MSG_ATTR(extack
, nla
, "reserved bit set");
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
)
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
);
385 if (strict_start_type
&& type
>= strict_start_type
)
386 validate
|= NL_VALIDATE_STRICT
;
388 if (type
<= 0 || type
> maxtype
)
391 type
= array_index_nospec(type
, maxtype
+ 1);
394 BUG_ON(pt
->type
> NLA_TYPE_MAX
);
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");
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");
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");
423 if (extack
&& pt
->reject_message
) {
424 NL_SET_BAD_ATTR(extack
, nla
);
425 extack
->_msg
= pt
->reject_message
;
437 if (attrlen
!= sizeof(struct nla_bitfield32
))
440 err
= validate_nla_bitfield32(nla
, pt
->bitfield32_valid
);
447 minlen
= min_t(int, attrlen
, pt
->len
+ 1);
451 if (!minlen
|| memchr(nla_data(nla
), '\0', minlen
) == NULL
) {
462 char *buf
= nla_data(nla
);
464 if (buf
[attrlen
- 1] == '\0')
467 if (attrlen
> pt
->len
)
473 if (pt
->len
&& attrlen
> pt
->len
)
478 /* a nested attributes is allowed to be empty; if its not,
479 * it must have a size of at least NLA_HDRLEN.
483 if (attrlen
< NLA_HDRLEN
)
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
,
492 * return directly to preserve the inner
493 * error message/attribute pointer
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.
505 if (attrlen
< NLA_HDRLEN
)
507 if (pt
->nested_policy
) {
510 err
= nla_validate_array(nla_data(nla
), nla_len(nla
),
511 pt
->len
, pt
->nested_policy
,
512 extack
, validate
, depth
);
515 * return directly to preserve the inner
516 * error message/attribute pointer
524 if (validate
& NL_VALIDATE_UNSPEC
) {
525 NL_SET_ERR_MSG_ATTR(extack
, nla
,
526 "Unsupported attribute");
529 if (attrlen
< pt
->len
)
537 minlen
= nla_attr_minlen
[pt
->type
];
539 if (attrlen
< minlen
)
543 /* further validation */
544 switch (pt
->validation_type
) {
545 case NLA_VALIDATE_NONE
:
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
);
557 case NLA_VALIDATE_MASK
:
558 err
= nla_validate_mask(pt
, nla
, extack
);
562 case NLA_VALIDATE_FUNCTION
:
564 err
= pt
->validate(nla
, extack
);
573 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
574 "Attribute failed policy validation");
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
)
584 const struct nlattr
*nla
;
587 if (depth
>= MAX_POLICY_RECURSION_DEPTH
) {
588 NL_SET_ERR_MSG(extack
,
589 "allowed policy recursion depth exceeded");
594 memset(tb
, 0, sizeof(struct nlattr
*) * (maxtype
+ 1));
596 nla_for_each_attr(nla
, head
, len
, rem
) {
597 u16 type
= nla_type(nla
);
599 if (type
== 0 || type
> maxtype
) {
600 if (validate
& NL_VALIDATE_MAXTYPE
) {
601 NL_SET_ERR_MSG_ATTR(extack
, nla
,
602 "Unknown attribute type");
607 type
= array_index_nospec(type
, maxtype
+ 1);
609 int err
= validate_nla(nla
, maxtype
, policy
,
610 validate
, extack
, depth
);
617 tb
[type
] = (struct nlattr
*)nla
;
620 if (unlikely(rem
> 0)) {
621 pr_warn_ratelimited("netlink: %d bytes leftover after parsing attributes in process `%s'.\n",
623 NL_SET_ERR_MSG(extack
, "bytes leftover after parsing attributes");
624 if (validate
& NL_VALIDATE_TRAILING
)
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
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.
645 * Returns 0 on success or a negative error code.
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
)
651 return __nla_validate_parse(head
, len
, maxtype
, policy
, validate
,
654 EXPORT_SYMBOL(__nla_validate
);
657 * nla_policy_len - Determine the max. length of a policy
659 * @n: number of policies
661 * Determines the max. length of the policy. It is currently used
662 * to allocated Netlink buffers roughly the size of the actual
665 * Returns 0 on success or a negative error code.
668 nla_policy_len(const struct nla_policy
*p
, int n
)
672 for (i
= 0; i
< n
; i
++, p
++) {
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
]);
683 EXPORT_SYMBOL(nla_policy_len
);
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
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.
699 * Returns 0 on success or a negative error code.
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
)
706 return __nla_validate_parse(head
, len
, maxtype
, policy
, validate
,
709 EXPORT_SYMBOL(__nla_parse
);
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
717 * Returns the first attribute in the stream matching the specified type.
719 struct nlattr
*nla_find(const struct nlattr
*head
, int len
, int attrtype
)
721 const struct nlattr
*nla
;
724 nla_for_each_attr(nla
, head
, len
, rem
)
725 if (nla_type(nla
) == attrtype
)
726 return (struct nlattr
*)nla
;
730 EXPORT_SYMBOL(nla_find
);
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.
738 * Copies at most dstsize - 1 bytes into the destination buffer.
739 * Unlike strlcpy the destination buffer is always padded out.
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
746 ssize_t
nla_strscpy(char *dst
, const struct nlattr
*nla
, size_t dstsize
)
748 size_t srclen
= nla_len(nla
);
749 char *src
= nla_data(nla
);
753 if (dstsize
== 0 || WARN_ON_ONCE(dstsize
> U16_MAX
))
756 if (srclen
> 0 && src
[srclen
- 1] == '\0')
759 if (srclen
>= dstsize
) {
767 memcpy(dst
, src
, len
);
768 /* Zero pad end of dst. */
769 memset(dst
+ len
, 0, dstsize
- len
);
773 EXPORT_SYMBOL(nla_strscpy
);
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).
780 * Returns a pointer to the allocated buffer or NULL on error.
782 char *nla_strdup(const struct nlattr
*nla
, gfp_t flags
)
784 size_t srclen
= nla_len(nla
);
785 char *src
= nla_data(nla
), *dst
;
787 if (srclen
> 0 && src
[srclen
- 1] == '\0')
790 dst
= kmalloc(srclen
+ 1, flags
);
792 memcpy(dst
, src
, srclen
);
797 EXPORT_SYMBOL(nla_strdup
);
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
805 * Note: The number of bytes copied is limited by the length of
806 * attribute's payload. memcpy
808 * Returns the number of bytes copied.
810 int nla_memcpy(void *dest
, const struct nlattr
*src
, int count
)
812 int minlen
= min_t(int, count
, nla_len(src
));
814 memcpy(dest
, nla_data(src
), minlen
);
816 memset(dest
+ minlen
, 0, count
- minlen
);
820 EXPORT_SYMBOL(nla_memcpy
);
823 * nla_memcmp - Compare an attribute with sized memory area
824 * @nla: netlink attribute
826 * @size: size of memory area
828 int nla_memcmp(const struct nlattr
*nla
, const void *data
,
831 int d
= nla_len(nla
) - size
;
834 d
= memcmp(nla_data(nla
), data
, size
);
838 EXPORT_SYMBOL(nla_memcmp
);
841 * nla_strcmp - Compare a string attribute against a string
842 * @nla: netlink string attribute
843 * @str: another string
845 int nla_strcmp(const struct nlattr
*nla
, const char *str
)
847 int len
= strlen(str
);
848 char *buf
= nla_data(nla
);
849 int attrlen
= nla_len(nla
);
852 while (attrlen
> 0 && buf
[attrlen
- 1] == '\0')
857 d
= memcmp(nla_data(nla
), str
, len
);
861 EXPORT_SYMBOL(nla_strcmp
);
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
870 * Adds a netlink attribute header to a socket buffer and reserves
871 * room for the payload but does not copy it.
873 * The caller is responsible to ensure that the skb provides enough
874 * tailroom for the attribute header and payload.
876 struct nlattr
*__nla_reserve(struct sk_buff
*skb
, int attrtype
, int attrlen
)
880 nla
= skb_put(skb
, nla_total_size(attrlen
));
881 nla
->nla_type
= attrtype
;
882 nla
->nla_len
= nla_attr_size(attrlen
);
884 memset((unsigned char *) nla
+ nla
->nla_len
, 0, nla_padlen(attrlen
));
888 EXPORT_SYMBOL(__nla_reserve
);
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
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.
901 * The caller is responsible to ensure that the skb provides enough
902 * tailroom for the attribute header and payload.
904 struct nlattr
*__nla_reserve_64bit(struct sk_buff
*skb
, int attrtype
,
905 int attrlen
, int padattr
)
907 nla_align_64bit(skb
, padattr
);
909 return __nla_reserve(skb
, attrtype
, attrlen
);
911 EXPORT_SYMBOL(__nla_reserve_64bit
);
914 * __nla_reserve_nohdr - reserve room for attribute without header
915 * @skb: socket buffer to reserve room on
916 * @attrlen: length of attribute payload
918 * Reserves room for attribute payload without a header.
920 * The caller is responsible to ensure that the skb provides enough
921 * tailroom for the payload.
923 void *__nla_reserve_nohdr(struct sk_buff
*skb
, int attrlen
)
925 return skb_put_zero(skb
, NLA_ALIGN(attrlen
));
927 EXPORT_SYMBOL(__nla_reserve_nohdr
);
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
935 * Adds a netlink attribute header to a socket buffer and reserves
936 * room for the payload but does not copy it.
938 * Returns NULL if the tailroom of the skb is insufficient to store
939 * the attribute header and payload.
941 struct nlattr
*nla_reserve(struct sk_buff
*skb
, int attrtype
, int attrlen
)
943 if (unlikely(skb_tailroom(skb
) < nla_total_size(attrlen
)))
946 return __nla_reserve(skb
, attrtype
, attrlen
);
948 EXPORT_SYMBOL(nla_reserve
);
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
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.
961 * Returns NULL if the tailroom of the skb is insufficient to store
962 * the attribute header and payload.
964 struct nlattr
*nla_reserve_64bit(struct sk_buff
*skb
, int attrtype
, int attrlen
,
969 if (nla_need_padding_for_64bit(skb
))
970 len
= nla_total_size_64bit(attrlen
);
972 len
= nla_total_size(attrlen
);
973 if (unlikely(skb_tailroom(skb
) < len
))
976 return __nla_reserve_64bit(skb
, attrtype
, attrlen
, padattr
);
978 EXPORT_SYMBOL(nla_reserve_64bit
);
981 * nla_reserve_nohdr - reserve room for attribute without header
982 * @skb: socket buffer to reserve room on
983 * @attrlen: length of attribute payload
985 * Reserves room for attribute payload without a header.
987 * Returns NULL if the tailroom of the skb is insufficient to store
988 * the attribute payload.
990 void *nla_reserve_nohdr(struct sk_buff
*skb
, int attrlen
)
992 if (unlikely(skb_tailroom(skb
) < NLA_ALIGN(attrlen
)))
995 return __nla_reserve_nohdr(skb
, attrlen
);
997 EXPORT_SYMBOL(nla_reserve_nohdr
);
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
1006 * The caller is responsible to ensure that the skb provides enough
1007 * tailroom for the attribute header and payload.
1009 void __nla_put(struct sk_buff
*skb
, int attrtype
, int attrlen
,
1014 nla
= __nla_reserve(skb
, attrtype
, attrlen
);
1015 memcpy(nla_data(nla
), data
, attrlen
);
1017 EXPORT_SYMBOL(__nla_put
);
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
1027 * The caller is responsible to ensure that the skb provides enough
1028 * tailroom for the attribute header and payload.
1030 void __nla_put_64bit(struct sk_buff
*skb
, int attrtype
, int attrlen
,
1031 const void *data
, int padattr
)
1035 nla
= __nla_reserve_64bit(skb
, attrtype
, attrlen
, padattr
);
1036 memcpy(nla_data(nla
), data
, attrlen
);
1038 EXPORT_SYMBOL(__nla_put_64bit
);
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
1046 * The caller is responsible to ensure that the skb provides enough
1047 * tailroom for the attribute payload.
1049 void __nla_put_nohdr(struct sk_buff
*skb
, int attrlen
, const void *data
)
1053 start
= __nla_reserve_nohdr(skb
, attrlen
);
1054 memcpy(start
, data
, attrlen
);
1056 EXPORT_SYMBOL(__nla_put_nohdr
);
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
1065 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1066 * the attribute header and payload.
1068 int nla_put(struct sk_buff
*skb
, int attrtype
, int attrlen
, const void *data
)
1070 if (unlikely(skb_tailroom(skb
) < nla_total_size(attrlen
)))
1073 __nla_put(skb
, attrtype
, attrlen
, data
);
1076 EXPORT_SYMBOL(nla_put
);
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
1086 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1087 * the attribute header and payload.
1089 int nla_put_64bit(struct sk_buff
*skb
, int attrtype
, int attrlen
,
1090 const void *data
, int padattr
)
1094 if (nla_need_padding_for_64bit(skb
))
1095 len
= nla_total_size_64bit(attrlen
);
1097 len
= nla_total_size(attrlen
);
1098 if (unlikely(skb_tailroom(skb
) < len
))
1101 __nla_put_64bit(skb
, attrtype
, attrlen
, data
, padattr
);
1104 EXPORT_SYMBOL(nla_put_64bit
);
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
1112 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1113 * the attribute payload.
1115 int nla_put_nohdr(struct sk_buff
*skb
, int attrlen
, const void *data
)
1117 if (unlikely(skb_tailroom(skb
) < NLA_ALIGN(attrlen
)))
1120 __nla_put_nohdr(skb
, attrlen
, data
);
1123 EXPORT_SYMBOL(nla_put_nohdr
);
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
1131 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1132 * the attribute payload.
1134 int nla_append(struct sk_buff
*skb
, int attrlen
, const void *data
)
1136 if (unlikely(skb_tailroom(skb
) < NLA_ALIGN(attrlen
)))
1139 skb_put_data(skb
, data
, attrlen
);
1142 EXPORT_SYMBOL(nla_append
);