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
);
362 if (value
& ~(u64
)pt
->mask
) {
363 NL_SET_ERR_MSG_ATTR(extack
, nla
, "reserved bit set");
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
)
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
);
379 if (strict_start_type
&& type
>= strict_start_type
)
380 validate
|= NL_VALIDATE_STRICT
;
382 if (type
<= 0 || type
> maxtype
)
385 type
= array_index_nospec(type
, maxtype
+ 1);
388 BUG_ON(pt
->type
> NLA_TYPE_MAX
);
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");
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");
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");
417 if (extack
&& pt
->reject_message
) {
418 NL_SET_BAD_ATTR(extack
, nla
);
419 extack
->_msg
= pt
->reject_message
;
431 if (attrlen
!= sizeof(struct nla_bitfield32
))
434 err
= validate_nla_bitfield32(nla
, pt
->bitfield32_valid
);
441 minlen
= min_t(int, attrlen
, pt
->len
+ 1);
445 if (!minlen
|| memchr(nla_data(nla
), '\0', minlen
) == NULL
) {
456 char *buf
= nla_data(nla
);
458 if (buf
[attrlen
- 1] == '\0')
461 if (attrlen
> pt
->len
)
467 if (pt
->len
&& attrlen
> pt
->len
)
472 /* a nested attributes is allowed to be empty; if its not,
473 * it must have a size of at least NLA_HDRLEN.
477 if (attrlen
< NLA_HDRLEN
)
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
,
486 * return directly to preserve the inner
487 * error message/attribute pointer
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.
499 if (attrlen
< NLA_HDRLEN
)
501 if (pt
->nested_policy
) {
504 err
= nla_validate_array(nla_data(nla
), nla_len(nla
),
505 pt
->len
, pt
->nested_policy
,
506 extack
, validate
, depth
);
509 * return directly to preserve the inner
510 * error message/attribute pointer
518 if (validate
& NL_VALIDATE_UNSPEC
) {
519 NL_SET_ERR_MSG_ATTR(extack
, nla
,
520 "Unsupported attribute");
523 if (attrlen
< pt
->len
)
531 minlen
= nla_attr_minlen
[pt
->type
];
533 if (attrlen
< minlen
)
537 /* further validation */
538 switch (pt
->validation_type
) {
539 case NLA_VALIDATE_NONE
:
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
);
551 case NLA_VALIDATE_MASK
:
552 err
= nla_validate_mask(pt
, nla
, extack
);
556 case NLA_VALIDATE_FUNCTION
:
558 err
= pt
->validate(nla
, extack
);
567 NL_SET_ERR_MSG_ATTR_POL(extack
, nla
, pt
,
568 "Attribute failed policy validation");
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
)
578 const struct nlattr
*nla
;
581 if (depth
>= MAX_POLICY_RECURSION_DEPTH
) {
582 NL_SET_ERR_MSG(extack
,
583 "allowed policy recursion depth exceeded");
588 memset(tb
, 0, sizeof(struct nlattr
*) * (maxtype
+ 1));
590 nla_for_each_attr(nla
, head
, len
, rem
) {
591 u16 type
= nla_type(nla
);
593 if (type
== 0 || type
> maxtype
) {
594 if (validate
& NL_VALIDATE_MAXTYPE
) {
595 NL_SET_ERR_MSG_ATTR(extack
, nla
,
596 "Unknown attribute type");
601 type
= array_index_nospec(type
, maxtype
+ 1);
603 int err
= validate_nla(nla
, maxtype
, policy
,
604 validate
, extack
, depth
);
611 tb
[type
] = (struct nlattr
*)nla
;
614 if (unlikely(rem
> 0)) {
615 pr_warn_ratelimited("netlink: %d bytes leftover after parsing attributes in process `%s'.\n",
617 NL_SET_ERR_MSG(extack
, "bytes leftover after parsing attributes");
618 if (validate
& NL_VALIDATE_TRAILING
)
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
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.
639 * Returns 0 on success or a negative error code.
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
)
645 return __nla_validate_parse(head
, len
, maxtype
, policy
, validate
,
648 EXPORT_SYMBOL(__nla_validate
);
651 * nla_policy_len - Determine the max. length of a policy
653 * @n: number of policies
655 * Determines the max. length of the policy. It is currently used
656 * to allocated Netlink buffers roughly the size of the actual
659 * Returns 0 on success or a negative error code.
662 nla_policy_len(const struct nla_policy
*p
, int n
)
666 for (i
= 0; i
< n
; i
++, p
++) {
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
]);
677 EXPORT_SYMBOL(nla_policy_len
);
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
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.
693 * Returns 0 on success or a negative error code.
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
)
700 return __nla_validate_parse(head
, len
, maxtype
, policy
, validate
,
703 EXPORT_SYMBOL(__nla_parse
);
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
711 * Returns the first attribute in the stream matching the specified type.
713 struct nlattr
*nla_find(const struct nlattr
*head
, int len
, int attrtype
)
715 const struct nlattr
*nla
;
718 nla_for_each_attr(nla
, head
, len
, rem
)
719 if (nla_type(nla
) == attrtype
)
720 return (struct nlattr
*)nla
;
724 EXPORT_SYMBOL(nla_find
);
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.
732 * Copies at most dstsize - 1 bytes into the destination buffer.
733 * Unlike strlcpy the destination buffer is always padded out.
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
740 ssize_t
nla_strscpy(char *dst
, const struct nlattr
*nla
, size_t dstsize
)
742 size_t srclen
= nla_len(nla
);
743 char *src
= nla_data(nla
);
747 if (dstsize
== 0 || WARN_ON_ONCE(dstsize
> U16_MAX
))
750 if (srclen
> 0 && src
[srclen
- 1] == '\0')
753 if (srclen
>= dstsize
) {
761 memcpy(dst
, src
, len
);
762 /* Zero pad end of dst. */
763 memset(dst
+ len
, 0, dstsize
- len
);
767 EXPORT_SYMBOL(nla_strscpy
);
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).
774 * Returns a pointer to the allocated buffer or NULL on error.
776 char *nla_strdup(const struct nlattr
*nla
, gfp_t flags
)
778 size_t srclen
= nla_len(nla
);
779 char *src
= nla_data(nla
), *dst
;
781 if (srclen
> 0 && src
[srclen
- 1] == '\0')
784 dst
= kmalloc(srclen
+ 1, flags
);
786 memcpy(dst
, src
, srclen
);
791 EXPORT_SYMBOL(nla_strdup
);
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
799 * Note: The number of bytes copied is limited by the length of
800 * attribute's payload. memcpy
802 * Returns the number of bytes copied.
804 int nla_memcpy(void *dest
, const struct nlattr
*src
, int count
)
806 int minlen
= min_t(int, count
, nla_len(src
));
808 memcpy(dest
, nla_data(src
), minlen
);
810 memset(dest
+ minlen
, 0, count
- minlen
);
814 EXPORT_SYMBOL(nla_memcpy
);
817 * nla_memcmp - Compare an attribute with sized memory area
818 * @nla: netlink attribute
820 * @size: size of memory area
822 int nla_memcmp(const struct nlattr
*nla
, const void *data
,
825 int d
= nla_len(nla
) - size
;
828 d
= memcmp(nla_data(nla
), data
, size
);
832 EXPORT_SYMBOL(nla_memcmp
);
835 * nla_strcmp - Compare a string attribute against a string
836 * @nla: netlink string attribute
837 * @str: another string
839 int nla_strcmp(const struct nlattr
*nla
, const char *str
)
841 int len
= strlen(str
);
842 char *buf
= nla_data(nla
);
843 int attrlen
= nla_len(nla
);
846 while (attrlen
> 0 && buf
[attrlen
- 1] == '\0')
851 d
= memcmp(nla_data(nla
), str
, len
);
855 EXPORT_SYMBOL(nla_strcmp
);
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
864 * Adds a netlink attribute header to a socket buffer and reserves
865 * room for the payload but does not copy it.
867 * The caller is responsible to ensure that the skb provides enough
868 * tailroom for the attribute header and payload.
870 struct nlattr
*__nla_reserve(struct sk_buff
*skb
, int attrtype
, int attrlen
)
874 nla
= skb_put(skb
, nla_total_size(attrlen
));
875 nla
->nla_type
= attrtype
;
876 nla
->nla_len
= nla_attr_size(attrlen
);
878 memset((unsigned char *) nla
+ nla
->nla_len
, 0, nla_padlen(attrlen
));
882 EXPORT_SYMBOL(__nla_reserve
);
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
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.
895 * The caller is responsible to ensure that the skb provides enough
896 * tailroom for the attribute header and payload.
898 struct nlattr
*__nla_reserve_64bit(struct sk_buff
*skb
, int attrtype
,
899 int attrlen
, int padattr
)
901 nla_align_64bit(skb
, padattr
);
903 return __nla_reserve(skb
, attrtype
, attrlen
);
905 EXPORT_SYMBOL(__nla_reserve_64bit
);
908 * __nla_reserve_nohdr - reserve room for attribute without header
909 * @skb: socket buffer to reserve room on
910 * @attrlen: length of attribute payload
912 * Reserves room for attribute payload without a header.
914 * The caller is responsible to ensure that the skb provides enough
915 * tailroom for the payload.
917 void *__nla_reserve_nohdr(struct sk_buff
*skb
, int attrlen
)
919 return skb_put_zero(skb
, NLA_ALIGN(attrlen
));
921 EXPORT_SYMBOL(__nla_reserve_nohdr
);
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
929 * Adds a netlink attribute header to a socket buffer and reserves
930 * room for the payload but does not copy it.
932 * Returns NULL if the tailroom of the skb is insufficient to store
933 * the attribute header and payload.
935 struct nlattr
*nla_reserve(struct sk_buff
*skb
, int attrtype
, int attrlen
)
937 if (unlikely(skb_tailroom(skb
) < nla_total_size(attrlen
)))
940 return __nla_reserve(skb
, attrtype
, attrlen
);
942 EXPORT_SYMBOL(nla_reserve
);
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
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.
955 * Returns NULL if the tailroom of the skb is insufficient to store
956 * the attribute header and payload.
958 struct nlattr
*nla_reserve_64bit(struct sk_buff
*skb
, int attrtype
, int attrlen
,
963 if (nla_need_padding_for_64bit(skb
))
964 len
= nla_total_size_64bit(attrlen
);
966 len
= nla_total_size(attrlen
);
967 if (unlikely(skb_tailroom(skb
) < len
))
970 return __nla_reserve_64bit(skb
, attrtype
, attrlen
, padattr
);
972 EXPORT_SYMBOL(nla_reserve_64bit
);
975 * nla_reserve_nohdr - reserve room for attribute without header
976 * @skb: socket buffer to reserve room on
977 * @attrlen: length of attribute payload
979 * Reserves room for attribute payload without a header.
981 * Returns NULL if the tailroom of the skb is insufficient to store
982 * the attribute payload.
984 void *nla_reserve_nohdr(struct sk_buff
*skb
, int attrlen
)
986 if (unlikely(skb_tailroom(skb
) < NLA_ALIGN(attrlen
)))
989 return __nla_reserve_nohdr(skb
, attrlen
);
991 EXPORT_SYMBOL(nla_reserve_nohdr
);
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
1000 * The caller is responsible to ensure that the skb provides enough
1001 * tailroom for the attribute header and payload.
1003 void __nla_put(struct sk_buff
*skb
, int attrtype
, int attrlen
,
1008 nla
= __nla_reserve(skb
, attrtype
, attrlen
);
1009 memcpy(nla_data(nla
), data
, attrlen
);
1011 EXPORT_SYMBOL(__nla_put
);
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
1021 * The caller is responsible to ensure that the skb provides enough
1022 * tailroom for the attribute header and payload.
1024 void __nla_put_64bit(struct sk_buff
*skb
, int attrtype
, int attrlen
,
1025 const void *data
, int padattr
)
1029 nla
= __nla_reserve_64bit(skb
, attrtype
, attrlen
, padattr
);
1030 memcpy(nla_data(nla
), data
, attrlen
);
1032 EXPORT_SYMBOL(__nla_put_64bit
);
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
1040 * The caller is responsible to ensure that the skb provides enough
1041 * tailroom for the attribute payload.
1043 void __nla_put_nohdr(struct sk_buff
*skb
, int attrlen
, const void *data
)
1047 start
= __nla_reserve_nohdr(skb
, attrlen
);
1048 memcpy(start
, data
, attrlen
);
1050 EXPORT_SYMBOL(__nla_put_nohdr
);
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
1059 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1060 * the attribute header and payload.
1062 int nla_put(struct sk_buff
*skb
, int attrtype
, int attrlen
, const void *data
)
1064 if (unlikely(skb_tailroom(skb
) < nla_total_size(attrlen
)))
1067 __nla_put(skb
, attrtype
, attrlen
, data
);
1070 EXPORT_SYMBOL(nla_put
);
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
1080 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1081 * the attribute header and payload.
1083 int nla_put_64bit(struct sk_buff
*skb
, int attrtype
, int attrlen
,
1084 const void *data
, int padattr
)
1088 if (nla_need_padding_for_64bit(skb
))
1089 len
= nla_total_size_64bit(attrlen
);
1091 len
= nla_total_size(attrlen
);
1092 if (unlikely(skb_tailroom(skb
) < len
))
1095 __nla_put_64bit(skb
, attrtype
, attrlen
, data
, padattr
);
1098 EXPORT_SYMBOL(nla_put_64bit
);
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
1106 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1107 * the attribute payload.
1109 int nla_put_nohdr(struct sk_buff
*skb
, int attrlen
, const void *data
)
1111 if (unlikely(skb_tailroom(skb
) < NLA_ALIGN(attrlen
)))
1114 __nla_put_nohdr(skb
, attrlen
, data
);
1117 EXPORT_SYMBOL(nla_put_nohdr
);
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
1125 * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1126 * the attribute payload.
1128 int nla_append(struct sk_buff
*skb
, int attrlen
, const void *data
)
1130 if (unlikely(skb_tailroom(skb
) < NLA_ALIGN(attrlen
)))
1133 skb_put_data(skb
, data
, attrlen
);
1136 EXPORT_SYMBOL(nla_append
);