1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __NET_NETLINK_H
3 #define __NET_NETLINK_H
5 #include <linux/types.h>
6 #include <linux/netlink.h>
7 #include <linux/jiffies.h>
10 /* ========================================================================
11 * Netlink Messages and Attributes Interface (As Seen On TV)
12 * ------------------------------------------------------------------------
14 * ------------------------------------------------------------------------
17 * <--- nlmsg_total_size(payload) --->
18 * <-- nlmsg_msg_size(payload) ->
19 * +----------+- - -+-------------+- - -+-------- - -
20 * | nlmsghdr | Pad | Payload | Pad | nlmsghdr
21 * +----------+- - -+-------------+- - -+-------- - -
22 * nlmsg_data(nlh)---^ ^
23 * nlmsg_next(nlh)-----------------------+
26 * <---------------------- nlmsg_len(nlh) --------------------->
27 * <------ hdrlen ------> <- nlmsg_attrlen(nlh, hdrlen) ->
28 * +----------------------+- - -+--------------------------------+
29 * | Family Header | Pad | Attributes |
30 * +----------------------+- - -+--------------------------------+
31 * nlmsg_attrdata(nlh, hdrlen)---^
34 * struct nlmsghdr netlink message header
36 * Message Construction:
37 * nlmsg_new() create a new netlink message
38 * nlmsg_put() add a netlink message to an skb
39 * nlmsg_put_answer() callback based nlmsg_put()
40 * nlmsg_end() finalize netlink message
41 * nlmsg_get_pos() return current position in message
42 * nlmsg_trim() trim part of message
43 * nlmsg_cancel() cancel message construction
44 * nlmsg_free() free a netlink message
47 * nlmsg_multicast() multicast message to several groups
48 * nlmsg_unicast() unicast a message to a single socket
49 * nlmsg_notify() send notification message
51 * Message Length Calculations:
52 * nlmsg_msg_size(payload) length of message w/o padding
53 * nlmsg_total_size(payload) length of message w/ padding
54 * nlmsg_padlen(payload) length of padding at tail
56 * Message Payload Access:
57 * nlmsg_data(nlh) head of message payload
58 * nlmsg_len(nlh) length of message payload
59 * nlmsg_attrdata(nlh, hdrlen) head of attributes data
60 * nlmsg_attrlen(nlh, hdrlen) length of attributes data
63 * nlmsg_ok(nlh, remaining) does nlh fit into remaining bytes?
64 * nlmsg_next(nlh, remaining) get next netlink message
65 * nlmsg_parse() parse attributes of a message
66 * nlmsg_find_attr() find an attribute in a message
67 * nlmsg_for_each_msg() loop over all messages
68 * nlmsg_validate() validate netlink message incl. attrs
69 * nlmsg_for_each_attr() loop over all attributes
72 * nlmsg_report() report back to application?
74 * ------------------------------------------------------------------------
75 * Attributes Interface
76 * ------------------------------------------------------------------------
79 * <------- nla_total_size(payload) ------->
80 * <---- nla_attr_size(payload) ----->
81 * +----------+- - -+- - - - - - - - - +- - -+-------- - -
82 * | Header | Pad | Payload | Pad | Header
83 * +----------+- - -+- - - - - - - - - +- - -+-------- - -
84 * <- nla_len(nla) -> ^
85 * nla_data(nla)----^ |
86 * nla_next(nla)-----------------------------'
89 * struct nlattr netlink attribute header
91 * Attribute Construction:
92 * nla_reserve(skb, type, len) reserve room for an attribute
93 * nla_reserve_nohdr(skb, len) reserve room for an attribute w/o hdr
94 * nla_put(skb, type, len, data) add attribute to skb
95 * nla_put_nohdr(skb, len, data) add attribute w/o hdr
96 * nla_append(skb, len, data) append data to skb
98 * Attribute Construction for Basic Types:
99 * nla_put_u8(skb, type, value) add u8 attribute to skb
100 * nla_put_u16(skb, type, value) add u16 attribute to skb
101 * nla_put_u32(skb, type, value) add u32 attribute to skb
102 * nla_put_u64_64bit(skb, type,
103 * value, padattr) add u64 attribute to skb
104 * nla_put_s8(skb, type, value) add s8 attribute to skb
105 * nla_put_s16(skb, type, value) add s16 attribute to skb
106 * nla_put_s32(skb, type, value) add s32 attribute to skb
107 * nla_put_s64(skb, type, value,
108 * padattr) add s64 attribute to skb
109 * nla_put_string(skb, type, str) add string attribute to skb
110 * nla_put_flag(skb, type) add flag attribute to skb
111 * nla_put_msecs(skb, type, jiffies,
112 * padattr) add msecs attribute to skb
113 * nla_put_in_addr(skb, type, addr) add IPv4 address attribute to skb
114 * nla_put_in6_addr(skb, type, addr) add IPv6 address attribute to skb
116 * Nested Attributes Construction:
117 * nla_nest_start(skb, type) start a nested attribute
118 * nla_nest_end(skb, nla) finalize a nested attribute
119 * nla_nest_cancel(skb, nla) cancel nested attribute construction
121 * Attribute Length Calculations:
122 * nla_attr_size(payload) length of attribute w/o padding
123 * nla_total_size(payload) length of attribute w/ padding
124 * nla_padlen(payload) length of padding
126 * Attribute Payload Access:
127 * nla_data(nla) head of attribute payload
128 * nla_len(nla) length of attribute payload
130 * Attribute Payload Access for Basic Types:
131 * nla_get_u8(nla) get payload for a u8 attribute
132 * nla_get_u16(nla) get payload for a u16 attribute
133 * nla_get_u32(nla) get payload for a u32 attribute
134 * nla_get_u64(nla) get payload for a u64 attribute
135 * nla_get_s8(nla) get payload for a s8 attribute
136 * nla_get_s16(nla) get payload for a s16 attribute
137 * nla_get_s32(nla) get payload for a s32 attribute
138 * nla_get_s64(nla) get payload for a s64 attribute
139 * nla_get_flag(nla) return 1 if flag is true
140 * nla_get_msecs(nla) get payload for a msecs attribute
143 * nla_memcpy(dest, nla, count) copy attribute into memory
144 * nla_memcmp(nla, data, size) compare attribute with memory area
145 * nla_strlcpy(dst, nla, size) copy attribute to a sized string
146 * nla_strcmp(nla, str) compare attribute with string
149 * nla_ok(nla, remaining) does nla fit into remaining bytes?
150 * nla_next(nla, remaining) get next netlink attribute
151 * nla_validate() validate a stream of attributes
152 * nla_validate_nested() validate a stream of nested attributes
153 * nla_find() find attribute in stream of attributes
154 * nla_find_nested() find attribute in nested attributes
155 * nla_parse() parse and validate stream of attrs
156 * nla_parse_nested() parse nested attributes
157 * nla_for_each_attr() loop over all attributes
158 * nla_for_each_nested() loop over the nested attributes
159 *=========================================================================
163 * Standard attribute types to specify validation policy
190 #define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
192 enum nla_policy_validation
{
197 NLA_VALIDATE_FUNCTION
,
201 * struct nla_policy - attribute validation policy
202 * @type: Type of attribute or NLA_UNSPEC
203 * @validation_type: type of attribute validation done in addition to
204 * type-specific validation (e.g. range, function call), see
205 * &enum nla_policy_validation
206 * @len: Type specific length of payload
208 * Policies are defined as arrays of this struct, the array must be
209 * accessible by attribute type up to the highest identifier to be expected.
211 * Meaning of `len' field:
212 * NLA_STRING Maximum length of string
213 * NLA_NUL_STRING Maximum length of string (excluding NUL)
215 * NLA_BINARY Maximum length of attribute payload
216 * NLA_MIN_LEN Minimum length of attribute payload
218 * NLA_NESTED_ARRAY Length verification is done by checking len of
219 * nested header (or empty); len field is used if
220 * validation_data is also used, for the max attr
221 * number in the nested policy.
226 * NLA_MSECS Leaving the length field zero will verify the
227 * given type fits, using it verifies minimum length
228 * just like "All other"
229 * NLA_BITFIELD32 Unused
231 * NLA_EXACT_LEN Attribute must have exactly this length, otherwise
233 * NLA_EXACT_LEN_WARN Attribute should have exactly this length, a warning
234 * is logged if it is longer, shorter is rejected.
235 * NLA_MIN_LEN Minimum length of attribute payload
236 * All other Minimum length of attribute payload
238 * Meaning of `validation_data' field:
239 * NLA_BITFIELD32 This is a 32-bit bitmap/bitselector attribute and
240 * validation data must point to a u32 value of valid
242 * NLA_REJECT This attribute is always rejected and validation data
243 * may point to a string to report as the error instead
244 * of the generic one in extended ACK.
245 * NLA_NESTED Points to a nested policy to validate, must also set
246 * `len' to the max attribute number.
247 * Note that nla_parse() will validate, but of course not
248 * parse, the nested sub-policies.
249 * NLA_NESTED_ARRAY Points to a nested policy to validate, must also set
250 * `len' to the max attribute number. The difference to
251 * NLA_NESTED is the structure - NLA_NESTED has the
252 * nested attributes directly inside, while an array has
253 * the nested attributes at another level down and the
254 * attributes directly in the nesting don't matter.
255 * All other Unused - but note that it's a union
257 * Meaning of `min' and `max' fields, use via NLA_POLICY_MIN, NLA_POLICY_MAX
258 * and NLA_POLICY_RANGE:
266 * NLA_S64 These are used depending on the validation_type
267 * field, if that is min/max/range then the minimum,
268 * maximum and both are used (respectively) to check
269 * the value of the integer attribute.
270 * Note that in the interest of code simplicity and
271 * struct size both limits are s16, so you cannot
272 * enforce a range that doesn't fall within the range
273 * of s16 - do that as usual in the code instead.
274 * All other Unused - but note that it's a union
276 * Meaning of `validate' field, use via NLA_POLICY_VALIDATE_FN:
277 * NLA_BINARY Validation function called for the attribute,
278 * not compatible with use of the validation_data
279 * as in NLA_BITFIELD32, NLA_REJECT, NLA_NESTED and
281 * All other Unused - but note that it's a union
284 * static const struct nla_policy my_policy[ATTR_MAX+1] = {
285 * [ATTR_FOO] = { .type = NLA_U16 },
286 * [ATTR_BAR] = { .type = NLA_STRING, .len = BARSIZ },
287 * [ATTR_BAZ] = { .type = NLA_EXACT_LEN, .len = sizeof(struct mystruct) },
288 * [ATTR_GOO] = { .type = NLA_BITFIELD32, .validation_data = &myvalidflags },
296 const void *validation_data
;
300 int (*validate
)(const struct nlattr
*attr
,
301 struct netlink_ext_ack
*extack
);
302 /* This entry is special, and used for the attribute at index 0
303 * only, and specifies special data about the policy, namely it
304 * specifies the "boundary type" where strict length validation
305 * starts for any attribute types >= this value, also, strict
306 * nesting validation starts here.
308 * Additionally, it means that NLA_UNSPEC is actually NLA_REJECT
309 * for any types >= this, so need to use NLA_MIN_LEN to get the
310 * previous pure { .len = xyz } behaviour. The advantage of this
311 * is that types not specified in the policy will be rejected.
313 * For completely new families it should be set to 1 so that the
314 * validation is enforced for all attributes. For existing ones
315 * it should be set at least when new attributes are added to
316 * the enum used by the policy, and be set to the new value that
317 * was added to enforce strict validation from thereon.
319 u16 strict_start_type
;
323 #define NLA_POLICY_EXACT_LEN(_len) { .type = NLA_EXACT_LEN, .len = _len }
324 #define NLA_POLICY_EXACT_LEN_WARN(_len) { .type = NLA_EXACT_LEN_WARN, \
326 #define NLA_POLICY_MIN_LEN(_len) { .type = NLA_MIN_LEN, .len = _len }
328 #define NLA_POLICY_ETH_ADDR NLA_POLICY_EXACT_LEN(ETH_ALEN)
329 #define NLA_POLICY_ETH_ADDR_COMPAT NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN)
331 #define _NLA_POLICY_NESTED(maxattr, policy) \
332 { .type = NLA_NESTED, .validation_data = policy, .len = maxattr }
333 #define _NLA_POLICY_NESTED_ARRAY(maxattr, policy) \
334 { .type = NLA_NESTED_ARRAY, .validation_data = policy, .len = maxattr }
335 #define NLA_POLICY_NESTED(policy) \
336 _NLA_POLICY_NESTED(ARRAY_SIZE(policy) - 1, policy)
337 #define NLA_POLICY_NESTED_ARRAY(policy) \
338 _NLA_POLICY_NESTED_ARRAY(ARRAY_SIZE(policy) - 1, policy)
340 #define __NLA_ENSURE(condition) BUILD_BUG_ON_ZERO(!(condition))
341 #define NLA_ENSURE_INT_TYPE(tp) \
342 (__NLA_ENSURE(tp == NLA_S8 || tp == NLA_U8 || \
343 tp == NLA_S16 || tp == NLA_U16 || \
344 tp == NLA_S32 || tp == NLA_U32 || \
345 tp == NLA_S64 || tp == NLA_U64) + tp)
346 #define NLA_ENSURE_NO_VALIDATION_PTR(tp) \
347 (__NLA_ENSURE(tp != NLA_BITFIELD32 && \
348 tp != NLA_REJECT && \
349 tp != NLA_NESTED && \
350 tp != NLA_NESTED_ARRAY) + tp)
352 #define NLA_POLICY_RANGE(tp, _min, _max) { \
353 .type = NLA_ENSURE_INT_TYPE(tp), \
354 .validation_type = NLA_VALIDATE_RANGE, \
359 #define NLA_POLICY_MIN(tp, _min) { \
360 .type = NLA_ENSURE_INT_TYPE(tp), \
361 .validation_type = NLA_VALIDATE_MIN, \
365 #define NLA_POLICY_MAX(tp, _max) { \
366 .type = NLA_ENSURE_INT_TYPE(tp), \
367 .validation_type = NLA_VALIDATE_MAX, \
371 #define NLA_POLICY_VALIDATE_FN(tp, fn, ...) { \
372 .type = NLA_ENSURE_NO_VALIDATION_PTR(tp), \
373 .validation_type = NLA_VALIDATE_FUNCTION, \
375 .len = __VA_ARGS__ + 0, \
379 * struct nl_info - netlink source information
380 * @nlh: Netlink message header of original request
381 * @nl_net: Network namespace
382 * @portid: Netlink PORTID of requesting application
383 * @skip_notify: Skip netlink notifications to user space
384 * @skip_notify_kernel: Skip selected in-kernel notifications
387 struct nlmsghdr
*nlh
;
391 skip_notify_kernel
:1;
395 * enum netlink_validation - netlink message/attribute validation levels
396 * @NL_VALIDATE_LIBERAL: Old-style "be liberal" validation, not caring about
397 * extra data at the end of the message, attributes being longer than
398 * they should be, or unknown attributes being present.
399 * @NL_VALIDATE_TRAILING: Reject junk data encountered after attribute parsing.
400 * @NL_VALIDATE_MAXTYPE: Reject attributes > max type; Together with _TRAILING
401 * this is equivalent to the old nla_parse_strict()/nlmsg_parse_strict().
402 * @NL_VALIDATE_UNSPEC: Reject attributes with NLA_UNSPEC in the policy.
403 * This can safely be set by the kernel when the given policy has no
404 * NLA_UNSPEC anymore, and can thus be used to ensure policy entries
405 * are enforced going forward.
406 * @NL_VALIDATE_STRICT_ATTRS: strict attribute policy parsing (e.g.
407 * U8, U16, U32 must have exact size, etc.)
408 * @NL_VALIDATE_NESTED: Check that NLA_F_NESTED is set for NLA_NESTED(_ARRAY)
409 * and unset for other policies.
411 enum netlink_validation
{
412 NL_VALIDATE_LIBERAL
= 0,
413 NL_VALIDATE_TRAILING
= BIT(0),
414 NL_VALIDATE_MAXTYPE
= BIT(1),
415 NL_VALIDATE_UNSPEC
= BIT(2),
416 NL_VALIDATE_STRICT_ATTRS
= BIT(3),
417 NL_VALIDATE_NESTED
= BIT(4),
420 #define NL_VALIDATE_DEPRECATED_STRICT (NL_VALIDATE_TRAILING |\
422 #define NL_VALIDATE_STRICT (NL_VALIDATE_TRAILING |\
423 NL_VALIDATE_MAXTYPE |\
424 NL_VALIDATE_UNSPEC |\
425 NL_VALIDATE_STRICT_ATTRS |\
428 int netlink_rcv_skb(struct sk_buff
*skb
,
429 int (*cb
)(struct sk_buff
*, struct nlmsghdr
*,
430 struct netlink_ext_ack
*));
431 int nlmsg_notify(struct sock
*sk
, struct sk_buff
*skb
, u32 portid
,
432 unsigned int group
, int report
, gfp_t flags
);
434 int __nla_validate(const struct nlattr
*head
, int len
, int maxtype
,
435 const struct nla_policy
*policy
, unsigned int validate
,
436 struct netlink_ext_ack
*extack
);
437 int __nla_parse(struct nlattr
**tb
, int maxtype
, const struct nlattr
*head
,
438 int len
, const struct nla_policy
*policy
, unsigned int validate
,
439 struct netlink_ext_ack
*extack
);
440 int nla_policy_len(const struct nla_policy
*, int);
441 struct nlattr
*nla_find(const struct nlattr
*head
, int len
, int attrtype
);
442 size_t nla_strlcpy(char *dst
, const struct nlattr
*nla
, size_t dstsize
);
443 char *nla_strdup(const struct nlattr
*nla
, gfp_t flags
);
444 int nla_memcpy(void *dest
, const struct nlattr
*src
, int count
);
445 int nla_memcmp(const struct nlattr
*nla
, const void *data
, size_t size
);
446 int nla_strcmp(const struct nlattr
*nla
, const char *str
);
447 struct nlattr
*__nla_reserve(struct sk_buff
*skb
, int attrtype
, int attrlen
);
448 struct nlattr
*__nla_reserve_64bit(struct sk_buff
*skb
, int attrtype
,
449 int attrlen
, int padattr
);
450 void *__nla_reserve_nohdr(struct sk_buff
*skb
, int attrlen
);
451 struct nlattr
*nla_reserve(struct sk_buff
*skb
, int attrtype
, int attrlen
);
452 struct nlattr
*nla_reserve_64bit(struct sk_buff
*skb
, int attrtype
,
453 int attrlen
, int padattr
);
454 void *nla_reserve_nohdr(struct sk_buff
*skb
, int attrlen
);
455 void __nla_put(struct sk_buff
*skb
, int attrtype
, int attrlen
,
457 void __nla_put_64bit(struct sk_buff
*skb
, int attrtype
, int attrlen
,
458 const void *data
, int padattr
);
459 void __nla_put_nohdr(struct sk_buff
*skb
, int attrlen
, const void *data
);
460 int nla_put(struct sk_buff
*skb
, int attrtype
, int attrlen
, const void *data
);
461 int nla_put_64bit(struct sk_buff
*skb
, int attrtype
, int attrlen
,
462 const void *data
, int padattr
);
463 int nla_put_nohdr(struct sk_buff
*skb
, int attrlen
, const void *data
);
464 int nla_append(struct sk_buff
*skb
, int attrlen
, const void *data
);
466 /**************************************************************************
468 **************************************************************************/
471 * nlmsg_msg_size - length of netlink message not including padding
472 * @payload: length of message payload
474 static inline int nlmsg_msg_size(int payload
)
476 return NLMSG_HDRLEN
+ payload
;
480 * nlmsg_total_size - length of netlink message including padding
481 * @payload: length of message payload
483 static inline int nlmsg_total_size(int payload
)
485 return NLMSG_ALIGN(nlmsg_msg_size(payload
));
489 * nlmsg_padlen - length of padding at the message's tail
490 * @payload: length of message payload
492 static inline int nlmsg_padlen(int payload
)
494 return nlmsg_total_size(payload
) - nlmsg_msg_size(payload
);
498 * nlmsg_data - head of message payload
499 * @nlh: netlink message header
501 static inline void *nlmsg_data(const struct nlmsghdr
*nlh
)
503 return (unsigned char *) nlh
+ NLMSG_HDRLEN
;
507 * nlmsg_len - length of message payload
508 * @nlh: netlink message header
510 static inline int nlmsg_len(const struct nlmsghdr
*nlh
)
512 return nlh
->nlmsg_len
- NLMSG_HDRLEN
;
516 * nlmsg_attrdata - head of attributes data
517 * @nlh: netlink message header
518 * @hdrlen: length of family specific header
520 static inline struct nlattr
*nlmsg_attrdata(const struct nlmsghdr
*nlh
,
523 unsigned char *data
= nlmsg_data(nlh
);
524 return (struct nlattr
*) (data
+ NLMSG_ALIGN(hdrlen
));
528 * nlmsg_attrlen - length of attributes data
529 * @nlh: netlink message header
530 * @hdrlen: length of family specific header
532 static inline int nlmsg_attrlen(const struct nlmsghdr
*nlh
, int hdrlen
)
534 return nlmsg_len(nlh
) - NLMSG_ALIGN(hdrlen
);
538 * nlmsg_ok - check if the netlink message fits into the remaining bytes
539 * @nlh: netlink message header
540 * @remaining: number of bytes remaining in message stream
542 static inline int nlmsg_ok(const struct nlmsghdr
*nlh
, int remaining
)
544 return (remaining
>= (int) sizeof(struct nlmsghdr
) &&
545 nlh
->nlmsg_len
>= sizeof(struct nlmsghdr
) &&
546 nlh
->nlmsg_len
<= remaining
);
550 * nlmsg_next - next netlink message in message stream
551 * @nlh: netlink message header
552 * @remaining: number of bytes remaining in message stream
554 * Returns the next netlink message in the message stream and
555 * decrements remaining by the size of the current message.
557 static inline struct nlmsghdr
*
558 nlmsg_next(const struct nlmsghdr
*nlh
, int *remaining
)
560 int totlen
= NLMSG_ALIGN(nlh
->nlmsg_len
);
562 *remaining
-= totlen
;
564 return (struct nlmsghdr
*) ((unsigned char *) nlh
+ totlen
);
568 * nla_parse - Parse a stream of attributes into a tb buffer
569 * @tb: destination array with maxtype+1 elements
570 * @maxtype: maximum attribute type to be expected
571 * @head: head of attribute stream
572 * @len: length of attribute stream
573 * @policy: validation policy
574 * @extack: extended ACK pointer
576 * Parses a stream of attributes and stores a pointer to each attribute in
577 * the tb array accessible via the attribute type. Attributes with a type
578 * exceeding maxtype will be rejected, policy must be specified, attributes
579 * will be validated in the strictest way possible.
581 * Returns 0 on success or a negative error code.
583 static inline int nla_parse(struct nlattr
**tb
, int maxtype
,
584 const struct nlattr
*head
, int len
,
585 const struct nla_policy
*policy
,
586 struct netlink_ext_ack
*extack
)
588 return __nla_parse(tb
, maxtype
, head
, len
, policy
,
589 NL_VALIDATE_STRICT
, extack
);
593 * nla_parse_deprecated - Parse a stream of attributes into a tb buffer
594 * @tb: destination array with maxtype+1 elements
595 * @maxtype: maximum attribute type to be expected
596 * @head: head of attribute stream
597 * @len: length of attribute stream
598 * @policy: validation policy
599 * @extack: extended ACK pointer
601 * Parses a stream of attributes and stores a pointer to each attribute in
602 * the tb array accessible via the attribute type. Attributes with a type
603 * exceeding maxtype will be ignored and attributes from the policy are not
604 * always strictly validated (only for new attributes).
606 * Returns 0 on success or a negative error code.
608 static inline int nla_parse_deprecated(struct nlattr
**tb
, int maxtype
,
609 const struct nlattr
*head
, int len
,
610 const struct nla_policy
*policy
,
611 struct netlink_ext_ack
*extack
)
613 return __nla_parse(tb
, maxtype
, head
, len
, policy
,
614 NL_VALIDATE_LIBERAL
, extack
);
618 * nla_parse_deprecated_strict - Parse a stream of attributes into a tb buffer
619 * @tb: destination array with maxtype+1 elements
620 * @maxtype: maximum attribute type to be expected
621 * @head: head of attribute stream
622 * @len: length of attribute stream
623 * @policy: validation policy
624 * @extack: extended ACK pointer
626 * Parses a stream of attributes and stores a pointer to each attribute in
627 * the tb array accessible via the attribute type. Attributes with a type
628 * exceeding maxtype will be rejected as well as trailing data, but the
629 * policy is not completely strictly validated (only for new attributes).
631 * Returns 0 on success or a negative error code.
633 static inline int nla_parse_deprecated_strict(struct nlattr
**tb
, int maxtype
,
634 const struct nlattr
*head
,
636 const struct nla_policy
*policy
,
637 struct netlink_ext_ack
*extack
)
639 return __nla_parse(tb
, maxtype
, head
, len
, policy
,
640 NL_VALIDATE_DEPRECATED_STRICT
, extack
);
644 * __nlmsg_parse - parse attributes of a netlink message
645 * @nlh: netlink message header
646 * @hdrlen: length of family specific header
647 * @tb: destination array with maxtype+1 elements
648 * @maxtype: maximum attribute type to be expected
649 * @policy: validation policy
650 * @validate: validation strictness
651 * @extack: extended ACK report struct
655 static inline int __nlmsg_parse(const struct nlmsghdr
*nlh
, int hdrlen
,
656 struct nlattr
*tb
[], int maxtype
,
657 const struct nla_policy
*policy
,
658 unsigned int validate
,
659 struct netlink_ext_ack
*extack
)
661 if (nlh
->nlmsg_len
< nlmsg_msg_size(hdrlen
)) {
662 NL_SET_ERR_MSG(extack
, "Invalid header length");
666 return __nla_parse(tb
, maxtype
, nlmsg_attrdata(nlh
, hdrlen
),
667 nlmsg_attrlen(nlh
, hdrlen
), policy
, validate
,
672 * nlmsg_parse - parse attributes of a netlink message
673 * @nlh: netlink message header
674 * @hdrlen: length of family specific header
675 * @tb: destination array with maxtype+1 elements
676 * @maxtype: maximum attribute type to be expected
677 * @validate: validation strictness
678 * @extack: extended ACK report struct
682 static inline int nlmsg_parse(const struct nlmsghdr
*nlh
, int hdrlen
,
683 struct nlattr
*tb
[], int maxtype
,
684 const struct nla_policy
*policy
,
685 struct netlink_ext_ack
*extack
)
687 return __nla_parse(tb
, maxtype
, nlmsg_attrdata(nlh
, hdrlen
),
688 nlmsg_attrlen(nlh
, hdrlen
), policy
,
689 NL_VALIDATE_STRICT
, extack
);
693 * nlmsg_parse_deprecated - parse attributes of a netlink message
694 * @nlh: netlink message header
695 * @hdrlen: length of family specific header
696 * @tb: destination array with maxtype+1 elements
697 * @maxtype: maximum attribute type to be expected
698 * @extack: extended ACK report struct
700 * See nla_parse_deprecated()
702 static inline int nlmsg_parse_deprecated(const struct nlmsghdr
*nlh
, int hdrlen
,
703 struct nlattr
*tb
[], int maxtype
,
704 const struct nla_policy
*policy
,
705 struct netlink_ext_ack
*extack
)
707 return __nlmsg_parse(nlh
, hdrlen
, tb
, maxtype
, policy
,
708 NL_VALIDATE_LIBERAL
, extack
);
712 * nlmsg_parse_deprecated_strict - parse attributes of a netlink message
713 * @nlh: netlink message header
714 * @hdrlen: length of family specific header
715 * @tb: destination array with maxtype+1 elements
716 * @maxtype: maximum attribute type to be expected
717 * @extack: extended ACK report struct
719 * See nla_parse_deprecated_strict()
722 nlmsg_parse_deprecated_strict(const struct nlmsghdr
*nlh
, int hdrlen
,
723 struct nlattr
*tb
[], int maxtype
,
724 const struct nla_policy
*policy
,
725 struct netlink_ext_ack
*extack
)
727 return __nlmsg_parse(nlh
, hdrlen
, tb
, maxtype
, policy
,
728 NL_VALIDATE_DEPRECATED_STRICT
, extack
);
732 * nlmsg_find_attr - find a specific attribute in a netlink message
733 * @nlh: netlink message header
734 * @hdrlen: length of familiy specific header
735 * @attrtype: type of attribute to look for
737 * Returns the first attribute which matches the specified type.
739 static inline struct nlattr
*nlmsg_find_attr(const struct nlmsghdr
*nlh
,
740 int hdrlen
, int attrtype
)
742 return nla_find(nlmsg_attrdata(nlh
, hdrlen
),
743 nlmsg_attrlen(nlh
, hdrlen
), attrtype
);
747 * nla_validate_deprecated - Validate a stream of attributes
748 * @head: head of attribute stream
749 * @len: length of attribute stream
750 * @maxtype: maximum attribute type to be expected
751 * @policy: validation policy
752 * @validate: validation strictness
753 * @extack: extended ACK report struct
755 * Validates all attributes in the specified attribute stream against the
756 * specified policy. Validation is done in liberal mode.
757 * See documenation of struct nla_policy for more details.
759 * Returns 0 on success or a negative error code.
761 static inline int nla_validate_deprecated(const struct nlattr
*head
, int len
,
763 const struct nla_policy
*policy
,
764 struct netlink_ext_ack
*extack
)
766 return __nla_validate(head
, len
, maxtype
, policy
, NL_VALIDATE_LIBERAL
,
771 * nla_validate - Validate a stream of attributes
772 * @head: head of attribute stream
773 * @len: length of attribute stream
774 * @maxtype: maximum attribute type to be expected
775 * @policy: validation policy
776 * @validate: validation strictness
777 * @extack: extended ACK report struct
779 * Validates all attributes in the specified attribute stream against the
780 * specified policy. Validation is done in strict mode.
781 * See documenation of struct nla_policy for more details.
783 * Returns 0 on success or a negative error code.
785 static inline int nla_validate(const struct nlattr
*head
, int len
, int maxtype
,
786 const struct nla_policy
*policy
,
787 struct netlink_ext_ack
*extack
)
789 return __nla_validate(head
, len
, maxtype
, policy
, NL_VALIDATE_STRICT
,
794 * nlmsg_validate_deprecated - validate a netlink message including attributes
795 * @nlh: netlinket message header
796 * @hdrlen: length of familiy specific header
797 * @maxtype: maximum attribute type to be expected
798 * @policy: validation policy
799 * @extack: extended ACK report struct
801 static inline int nlmsg_validate_deprecated(const struct nlmsghdr
*nlh
,
802 int hdrlen
, int maxtype
,
803 const struct nla_policy
*policy
,
804 struct netlink_ext_ack
*extack
)
806 if (nlh
->nlmsg_len
< nlmsg_msg_size(hdrlen
))
809 return __nla_validate(nlmsg_attrdata(nlh
, hdrlen
),
810 nlmsg_attrlen(nlh
, hdrlen
), maxtype
,
811 policy
, NL_VALIDATE_LIBERAL
, extack
);
817 * nlmsg_report - need to report back to application?
818 * @nlh: netlink message header
820 * Returns 1 if a report back to the application is requested.
822 static inline int nlmsg_report(const struct nlmsghdr
*nlh
)
824 return !!(nlh
->nlmsg_flags
& NLM_F_ECHO
);
828 * nlmsg_for_each_attr - iterate over a stream of attributes
829 * @pos: loop counter, set to current attribute
830 * @nlh: netlink message header
831 * @hdrlen: length of familiy specific header
832 * @rem: initialized to len, holds bytes currently remaining in stream
834 #define nlmsg_for_each_attr(pos, nlh, hdrlen, rem) \
835 nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
836 nlmsg_attrlen(nlh, hdrlen), rem)
839 * nlmsg_put - Add a new netlink message to an skb
840 * @skb: socket buffer to store message in
841 * @portid: netlink PORTID of requesting application
842 * @seq: sequence number of message
843 * @type: message type
844 * @payload: length of message payload
845 * @flags: message flags
847 * Returns NULL if the tailroom of the skb is insufficient to store
848 * the message header and payload.
850 static inline struct nlmsghdr
*nlmsg_put(struct sk_buff
*skb
, u32 portid
, u32 seq
,
851 int type
, int payload
, int flags
)
853 if (unlikely(skb_tailroom(skb
) < nlmsg_total_size(payload
)))
856 return __nlmsg_put(skb
, portid
, seq
, type
, payload
, flags
);
860 * nlmsg_put_answer - Add a new callback based netlink message to an skb
861 * @skb: socket buffer to store message in
862 * @cb: netlink callback
863 * @type: message type
864 * @payload: length of message payload
865 * @flags: message flags
867 * Returns NULL if the tailroom of the skb is insufficient to store
868 * the message header and payload.
870 static inline struct nlmsghdr
*nlmsg_put_answer(struct sk_buff
*skb
,
871 struct netlink_callback
*cb
,
872 int type
, int payload
,
875 return nlmsg_put(skb
, NETLINK_CB(cb
->skb
).portid
, cb
->nlh
->nlmsg_seq
,
876 type
, payload
, flags
);
880 * nlmsg_new - Allocate a new netlink message
881 * @payload: size of the message payload
882 * @flags: the type of memory to allocate.
884 * Use NLMSG_DEFAULT_SIZE if the size of the payload isn't known
885 * and a good default is needed.
887 static inline struct sk_buff
*nlmsg_new(size_t payload
, gfp_t flags
)
889 return alloc_skb(nlmsg_total_size(payload
), flags
);
893 * nlmsg_end - Finalize a netlink message
894 * @skb: socket buffer the message is stored in
895 * @nlh: netlink message header
897 * Corrects the netlink message header to include the appeneded
898 * attributes. Only necessary if attributes have been added to
901 static inline void nlmsg_end(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
903 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - (unsigned char *)nlh
;
907 * nlmsg_get_pos - return current position in netlink message
908 * @skb: socket buffer the message is stored in
910 * Returns a pointer to the current tail of the message.
912 static inline void *nlmsg_get_pos(struct sk_buff
*skb
)
914 return skb_tail_pointer(skb
);
918 * nlmsg_trim - Trim message to a mark
919 * @skb: socket buffer the message is stored in
920 * @mark: mark to trim to
922 * Trims the message to the provided mark.
924 static inline void nlmsg_trim(struct sk_buff
*skb
, const void *mark
)
927 WARN_ON((unsigned char *) mark
< skb
->data
);
928 skb_trim(skb
, (unsigned char *) mark
- skb
->data
);
933 * nlmsg_cancel - Cancel construction of a netlink message
934 * @skb: socket buffer the message is stored in
935 * @nlh: netlink message header
937 * Removes the complete netlink message including all
938 * attributes from the socket buffer again.
940 static inline void nlmsg_cancel(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
942 nlmsg_trim(skb
, nlh
);
946 * nlmsg_free - free a netlink message
947 * @skb: socket buffer of netlink message
949 static inline void nlmsg_free(struct sk_buff
*skb
)
955 * nlmsg_multicast - multicast a netlink message
956 * @sk: netlink socket to spread messages to
957 * @skb: netlink message as socket buffer
958 * @portid: own netlink portid to avoid sending to yourself
959 * @group: multicast group id
960 * @flags: allocation flags
962 static inline int nlmsg_multicast(struct sock
*sk
, struct sk_buff
*skb
,
963 u32 portid
, unsigned int group
, gfp_t flags
)
967 NETLINK_CB(skb
).dst_group
= group
;
969 err
= netlink_broadcast(sk
, skb
, portid
, group
, flags
);
977 * nlmsg_unicast - unicast a netlink message
978 * @sk: netlink socket to spread message to
979 * @skb: netlink message as socket buffer
980 * @portid: netlink portid of the destination socket
982 static inline int nlmsg_unicast(struct sock
*sk
, struct sk_buff
*skb
, u32 portid
)
986 err
= netlink_unicast(sk
, skb
, portid
, MSG_DONTWAIT
);
994 * nlmsg_for_each_msg - iterate over a stream of messages
995 * @pos: loop counter, set to current message
996 * @head: head of message stream
997 * @len: length of message stream
998 * @rem: initialized to len, holds bytes currently remaining in stream
1000 #define nlmsg_for_each_msg(pos, head, len, rem) \
1001 for (pos = head, rem = len; \
1002 nlmsg_ok(pos, rem); \
1003 pos = nlmsg_next(pos, &(rem)))
1006 * nl_dump_check_consistent - check if sequence is consistent and advertise if not
1007 * @cb: netlink callback structure that stores the sequence number
1008 * @nlh: netlink message header to write the flag to
1010 * This function checks if the sequence (generation) number changed during dump
1011 * and if it did, advertises it in the netlink message header.
1013 * The correct way to use it is to set cb->seq to the generation counter when
1014 * all locks for dumping have been acquired, and then call this function for
1015 * each message that is generated.
1017 * Note that due to initialisation concerns, 0 is an invalid sequence number
1018 * and must not be used by code that uses this functionality.
1021 nl_dump_check_consistent(struct netlink_callback
*cb
,
1022 struct nlmsghdr
*nlh
)
1024 if (cb
->prev_seq
&& cb
->seq
!= cb
->prev_seq
)
1025 nlh
->nlmsg_flags
|= NLM_F_DUMP_INTR
;
1026 cb
->prev_seq
= cb
->seq
;
1029 /**************************************************************************
1030 * Netlink Attributes
1031 **************************************************************************/
1034 * nla_attr_size - length of attribute not including padding
1035 * @payload: length of payload
1037 static inline int nla_attr_size(int payload
)
1039 return NLA_HDRLEN
+ payload
;
1043 * nla_total_size - total length of attribute including padding
1044 * @payload: length of payload
1046 static inline int nla_total_size(int payload
)
1048 return NLA_ALIGN(nla_attr_size(payload
));
1052 * nla_padlen - length of padding at the tail of attribute
1053 * @payload: length of payload
1055 static inline int nla_padlen(int payload
)
1057 return nla_total_size(payload
) - nla_attr_size(payload
);
1061 * nla_type - attribute type
1062 * @nla: netlink attribute
1064 static inline int nla_type(const struct nlattr
*nla
)
1066 return nla
->nla_type
& NLA_TYPE_MASK
;
1070 * nla_data - head of payload
1071 * @nla: netlink attribute
1073 static inline void *nla_data(const struct nlattr
*nla
)
1075 return (char *) nla
+ NLA_HDRLEN
;
1079 * nla_len - length of payload
1080 * @nla: netlink attribute
1082 static inline int nla_len(const struct nlattr
*nla
)
1084 return nla
->nla_len
- NLA_HDRLEN
;
1088 * nla_ok - check if the netlink attribute fits into the remaining bytes
1089 * @nla: netlink attribute
1090 * @remaining: number of bytes remaining in attribute stream
1092 static inline int nla_ok(const struct nlattr
*nla
, int remaining
)
1094 return remaining
>= (int) sizeof(*nla
) &&
1095 nla
->nla_len
>= sizeof(*nla
) &&
1096 nla
->nla_len
<= remaining
;
1100 * nla_next - next netlink attribute in attribute stream
1101 * @nla: netlink attribute
1102 * @remaining: number of bytes remaining in attribute stream
1104 * Returns the next netlink attribute in the attribute stream and
1105 * decrements remaining by the size of the current attribute.
1107 static inline struct nlattr
*nla_next(const struct nlattr
*nla
, int *remaining
)
1109 unsigned int totlen
= NLA_ALIGN(nla
->nla_len
);
1111 *remaining
-= totlen
;
1112 return (struct nlattr
*) ((char *) nla
+ totlen
);
1116 * nla_find_nested - find attribute in a set of nested attributes
1117 * @nla: attribute containing the nested attributes
1118 * @attrtype: type of attribute to look for
1120 * Returns the first attribute which matches the specified type.
1122 static inline struct nlattr
*
1123 nla_find_nested(const struct nlattr
*nla
, int attrtype
)
1125 return nla_find(nla_data(nla
), nla_len(nla
), attrtype
);
1129 * nla_parse_nested - parse nested attributes
1130 * @tb: destination array with maxtype+1 elements
1131 * @maxtype: maximum attribute type to be expected
1132 * @nla: attribute containing the nested attributes
1133 * @policy: validation policy
1134 * @extack: extended ACK report struct
1138 static inline int nla_parse_nested(struct nlattr
*tb
[], int maxtype
,
1139 const struct nlattr
*nla
,
1140 const struct nla_policy
*policy
,
1141 struct netlink_ext_ack
*extack
)
1143 if (!(nla
->nla_type
& NLA_F_NESTED
)) {
1144 NL_SET_ERR_MSG_ATTR(extack
, nla
, "NLA_F_NESTED is missing");
1148 return __nla_parse(tb
, maxtype
, nla_data(nla
), nla_len(nla
), policy
,
1149 NL_VALIDATE_STRICT
, extack
);
1153 * nla_parse_nested_deprecated - parse nested attributes
1154 * @tb: destination array with maxtype+1 elements
1155 * @maxtype: maximum attribute type to be expected
1156 * @nla: attribute containing the nested attributes
1157 * @policy: validation policy
1158 * @extack: extended ACK report struct
1160 * See nla_parse_deprecated()
1162 static inline int nla_parse_nested_deprecated(struct nlattr
*tb
[], int maxtype
,
1163 const struct nlattr
*nla
,
1164 const struct nla_policy
*policy
,
1165 struct netlink_ext_ack
*extack
)
1167 return __nla_parse(tb
, maxtype
, nla_data(nla
), nla_len(nla
), policy
,
1168 NL_VALIDATE_LIBERAL
, extack
);
1172 * nla_put_u8 - Add a u8 netlink attribute to a socket buffer
1173 * @skb: socket buffer to add attribute to
1174 * @attrtype: attribute type
1175 * @value: numeric value
1177 static inline int nla_put_u8(struct sk_buff
*skb
, int attrtype
, u8 value
)
1179 /* temporary variables to work around GCC PR81715 with asan-stack=1 */
1182 return nla_put(skb
, attrtype
, sizeof(u8
), &tmp
);
1186 * nla_put_u16 - Add a u16 netlink attribute to a socket buffer
1187 * @skb: socket buffer to add attribute to
1188 * @attrtype: attribute type
1189 * @value: numeric value
1191 static inline int nla_put_u16(struct sk_buff
*skb
, int attrtype
, u16 value
)
1195 return nla_put(skb
, attrtype
, sizeof(u16
), &tmp
);
1199 * nla_put_be16 - Add a __be16 netlink attribute to a socket buffer
1200 * @skb: socket buffer to add attribute to
1201 * @attrtype: attribute type
1202 * @value: numeric value
1204 static inline int nla_put_be16(struct sk_buff
*skb
, int attrtype
, __be16 value
)
1208 return nla_put(skb
, attrtype
, sizeof(__be16
), &tmp
);
1212 * nla_put_net16 - Add 16-bit network byte order netlink attribute to a socket buffer
1213 * @skb: socket buffer to add attribute to
1214 * @attrtype: attribute type
1215 * @value: numeric value
1217 static inline int nla_put_net16(struct sk_buff
*skb
, int attrtype
, __be16 value
)
1221 return nla_put_be16(skb
, attrtype
| NLA_F_NET_BYTEORDER
, tmp
);
1225 * nla_put_le16 - Add a __le16 netlink attribute to a socket buffer
1226 * @skb: socket buffer to add attribute to
1227 * @attrtype: attribute type
1228 * @value: numeric value
1230 static inline int nla_put_le16(struct sk_buff
*skb
, int attrtype
, __le16 value
)
1234 return nla_put(skb
, attrtype
, sizeof(__le16
), &tmp
);
1238 * nla_put_u32 - Add a u32 netlink attribute to a socket buffer
1239 * @skb: socket buffer to add attribute to
1240 * @attrtype: attribute type
1241 * @value: numeric value
1243 static inline int nla_put_u32(struct sk_buff
*skb
, int attrtype
, u32 value
)
1247 return nla_put(skb
, attrtype
, sizeof(u32
), &tmp
);
1251 * nla_put_be32 - Add a __be32 netlink attribute to a socket buffer
1252 * @skb: socket buffer to add attribute to
1253 * @attrtype: attribute type
1254 * @value: numeric value
1256 static inline int nla_put_be32(struct sk_buff
*skb
, int attrtype
, __be32 value
)
1260 return nla_put(skb
, attrtype
, sizeof(__be32
), &tmp
);
1264 * nla_put_net32 - Add 32-bit network byte order netlink attribute to a socket buffer
1265 * @skb: socket buffer to add attribute to
1266 * @attrtype: attribute type
1267 * @value: numeric value
1269 static inline int nla_put_net32(struct sk_buff
*skb
, int attrtype
, __be32 value
)
1273 return nla_put_be32(skb
, attrtype
| NLA_F_NET_BYTEORDER
, tmp
);
1277 * nla_put_le32 - Add a __le32 netlink attribute to a socket buffer
1278 * @skb: socket buffer to add attribute to
1279 * @attrtype: attribute type
1280 * @value: numeric value
1282 static inline int nla_put_le32(struct sk_buff
*skb
, int attrtype
, __le32 value
)
1286 return nla_put(skb
, attrtype
, sizeof(__le32
), &tmp
);
1290 * nla_put_u64_64bit - Add a u64 netlink attribute to a skb and align it
1291 * @skb: socket buffer to add attribute to
1292 * @attrtype: attribute type
1293 * @value: numeric value
1294 * @padattr: attribute type for the padding
1296 static inline int nla_put_u64_64bit(struct sk_buff
*skb
, int attrtype
,
1297 u64 value
, int padattr
)
1301 return nla_put_64bit(skb
, attrtype
, sizeof(u64
), &tmp
, padattr
);
1305 * nla_put_be64 - Add a __be64 netlink attribute to a socket buffer and align it
1306 * @skb: socket buffer to add attribute to
1307 * @attrtype: attribute type
1308 * @value: numeric value
1309 * @padattr: attribute type for the padding
1311 static inline int nla_put_be64(struct sk_buff
*skb
, int attrtype
, __be64 value
,
1316 return nla_put_64bit(skb
, attrtype
, sizeof(__be64
), &tmp
, padattr
);
1320 * nla_put_net64 - Add 64-bit network byte order nlattr to a skb and align it
1321 * @skb: socket buffer to add attribute to
1322 * @attrtype: attribute type
1323 * @value: numeric value
1324 * @padattr: attribute type for the padding
1326 static inline int nla_put_net64(struct sk_buff
*skb
, int attrtype
, __be64 value
,
1331 return nla_put_be64(skb
, attrtype
| NLA_F_NET_BYTEORDER
, tmp
,
1336 * nla_put_le64 - Add a __le64 netlink attribute to a socket buffer and align it
1337 * @skb: socket buffer to add attribute to
1338 * @attrtype: attribute type
1339 * @value: numeric value
1340 * @padattr: attribute type for the padding
1342 static inline int nla_put_le64(struct sk_buff
*skb
, int attrtype
, __le64 value
,
1347 return nla_put_64bit(skb
, attrtype
, sizeof(__le64
), &tmp
, padattr
);
1351 * nla_put_s8 - Add a s8 netlink attribute to a socket buffer
1352 * @skb: socket buffer to add attribute to
1353 * @attrtype: attribute type
1354 * @value: numeric value
1356 static inline int nla_put_s8(struct sk_buff
*skb
, int attrtype
, s8 value
)
1360 return nla_put(skb
, attrtype
, sizeof(s8
), &tmp
);
1364 * nla_put_s16 - Add a s16 netlink attribute to a socket buffer
1365 * @skb: socket buffer to add attribute to
1366 * @attrtype: attribute type
1367 * @value: numeric value
1369 static inline int nla_put_s16(struct sk_buff
*skb
, int attrtype
, s16 value
)
1373 return nla_put(skb
, attrtype
, sizeof(s16
), &tmp
);
1377 * nla_put_s32 - Add a s32 netlink attribute to a socket buffer
1378 * @skb: socket buffer to add attribute to
1379 * @attrtype: attribute type
1380 * @value: numeric value
1382 static inline int nla_put_s32(struct sk_buff
*skb
, int attrtype
, s32 value
)
1386 return nla_put(skb
, attrtype
, sizeof(s32
), &tmp
);
1390 * nla_put_s64 - Add a s64 netlink attribute to a socket buffer and align it
1391 * @skb: socket buffer to add attribute to
1392 * @attrtype: attribute type
1393 * @value: numeric value
1394 * @padattr: attribute type for the padding
1396 static inline int nla_put_s64(struct sk_buff
*skb
, int attrtype
, s64 value
,
1401 return nla_put_64bit(skb
, attrtype
, sizeof(s64
), &tmp
, padattr
);
1405 * nla_put_string - Add a string netlink attribute to a socket buffer
1406 * @skb: socket buffer to add attribute to
1407 * @attrtype: attribute type
1408 * @str: NUL terminated string
1410 static inline int nla_put_string(struct sk_buff
*skb
, int attrtype
,
1413 return nla_put(skb
, attrtype
, strlen(str
) + 1, str
);
1417 * nla_put_flag - Add a flag netlink attribute to a socket buffer
1418 * @skb: socket buffer to add attribute to
1419 * @attrtype: attribute type
1421 static inline int nla_put_flag(struct sk_buff
*skb
, int attrtype
)
1423 return nla_put(skb
, attrtype
, 0, NULL
);
1427 * nla_put_msecs - Add a msecs netlink attribute to a skb and align it
1428 * @skb: socket buffer to add attribute to
1429 * @attrtype: attribute type
1430 * @njiffies: number of jiffies to convert to msecs
1431 * @padattr: attribute type for the padding
1433 static inline int nla_put_msecs(struct sk_buff
*skb
, int attrtype
,
1434 unsigned long njiffies
, int padattr
)
1436 u64 tmp
= jiffies_to_msecs(njiffies
);
1438 return nla_put_64bit(skb
, attrtype
, sizeof(u64
), &tmp
, padattr
);
1442 * nla_put_in_addr - Add an IPv4 address netlink attribute to a socket
1444 * @skb: socket buffer to add attribute to
1445 * @attrtype: attribute type
1446 * @addr: IPv4 address
1448 static inline int nla_put_in_addr(struct sk_buff
*skb
, int attrtype
,
1453 return nla_put_be32(skb
, attrtype
, tmp
);
1457 * nla_put_in6_addr - Add an IPv6 address netlink attribute to a socket
1459 * @skb: socket buffer to add attribute to
1460 * @attrtype: attribute type
1461 * @addr: IPv6 address
1463 static inline int nla_put_in6_addr(struct sk_buff
*skb
, int attrtype
,
1464 const struct in6_addr
*addr
)
1466 return nla_put(skb
, attrtype
, sizeof(*addr
), addr
);
1470 * nla_get_u32 - return payload of u32 attribute
1471 * @nla: u32 netlink attribute
1473 static inline u32
nla_get_u32(const struct nlattr
*nla
)
1475 return *(u32
*) nla_data(nla
);
1479 * nla_get_be32 - return payload of __be32 attribute
1480 * @nla: __be32 netlink attribute
1482 static inline __be32
nla_get_be32(const struct nlattr
*nla
)
1484 return *(__be32
*) nla_data(nla
);
1488 * nla_get_le32 - return payload of __le32 attribute
1489 * @nla: __le32 netlink attribute
1491 static inline __le32
nla_get_le32(const struct nlattr
*nla
)
1493 return *(__le32
*) nla_data(nla
);
1497 * nla_get_u16 - return payload of u16 attribute
1498 * @nla: u16 netlink attribute
1500 static inline u16
nla_get_u16(const struct nlattr
*nla
)
1502 return *(u16
*) nla_data(nla
);
1506 * nla_get_be16 - return payload of __be16 attribute
1507 * @nla: __be16 netlink attribute
1509 static inline __be16
nla_get_be16(const struct nlattr
*nla
)
1511 return *(__be16
*) nla_data(nla
);
1515 * nla_get_le16 - return payload of __le16 attribute
1516 * @nla: __le16 netlink attribute
1518 static inline __le16
nla_get_le16(const struct nlattr
*nla
)
1520 return *(__le16
*) nla_data(nla
);
1524 * nla_get_u8 - return payload of u8 attribute
1525 * @nla: u8 netlink attribute
1527 static inline u8
nla_get_u8(const struct nlattr
*nla
)
1529 return *(u8
*) nla_data(nla
);
1533 * nla_get_u64 - return payload of u64 attribute
1534 * @nla: u64 netlink attribute
1536 static inline u64
nla_get_u64(const struct nlattr
*nla
)
1540 nla_memcpy(&tmp
, nla
, sizeof(tmp
));
1546 * nla_get_be64 - return payload of __be64 attribute
1547 * @nla: __be64 netlink attribute
1549 static inline __be64
nla_get_be64(const struct nlattr
*nla
)
1553 nla_memcpy(&tmp
, nla
, sizeof(tmp
));
1559 * nla_get_le64 - return payload of __le64 attribute
1560 * @nla: __le64 netlink attribute
1562 static inline __le64
nla_get_le64(const struct nlattr
*nla
)
1564 return *(__le64
*) nla_data(nla
);
1568 * nla_get_s32 - return payload of s32 attribute
1569 * @nla: s32 netlink attribute
1571 static inline s32
nla_get_s32(const struct nlattr
*nla
)
1573 return *(s32
*) nla_data(nla
);
1577 * nla_get_s16 - return payload of s16 attribute
1578 * @nla: s16 netlink attribute
1580 static inline s16
nla_get_s16(const struct nlattr
*nla
)
1582 return *(s16
*) nla_data(nla
);
1586 * nla_get_s8 - return payload of s8 attribute
1587 * @nla: s8 netlink attribute
1589 static inline s8
nla_get_s8(const struct nlattr
*nla
)
1591 return *(s8
*) nla_data(nla
);
1595 * nla_get_s64 - return payload of s64 attribute
1596 * @nla: s64 netlink attribute
1598 static inline s64
nla_get_s64(const struct nlattr
*nla
)
1602 nla_memcpy(&tmp
, nla
, sizeof(tmp
));
1608 * nla_get_flag - return payload of flag attribute
1609 * @nla: flag netlink attribute
1611 static inline int nla_get_flag(const struct nlattr
*nla
)
1617 * nla_get_msecs - return payload of msecs attribute
1618 * @nla: msecs netlink attribute
1620 * Returns the number of milliseconds in jiffies.
1622 static inline unsigned long nla_get_msecs(const struct nlattr
*nla
)
1624 u64 msecs
= nla_get_u64(nla
);
1626 return msecs_to_jiffies((unsigned long) msecs
);
1630 * nla_get_in_addr - return payload of IPv4 address attribute
1631 * @nla: IPv4 address netlink attribute
1633 static inline __be32
nla_get_in_addr(const struct nlattr
*nla
)
1635 return *(__be32
*) nla_data(nla
);
1639 * nla_get_in6_addr - return payload of IPv6 address attribute
1640 * @nla: IPv6 address netlink attribute
1642 static inline struct in6_addr
nla_get_in6_addr(const struct nlattr
*nla
)
1644 struct in6_addr tmp
;
1646 nla_memcpy(&tmp
, nla
, sizeof(tmp
));
1651 * nla_get_bitfield32 - return payload of 32 bitfield attribute
1652 * @nla: nla_bitfield32 attribute
1654 static inline struct nla_bitfield32
nla_get_bitfield32(const struct nlattr
*nla
)
1656 struct nla_bitfield32 tmp
;
1658 nla_memcpy(&tmp
, nla
, sizeof(tmp
));
1663 * nla_memdup - duplicate attribute memory (kmemdup)
1664 * @src: netlink attribute to duplicate from
1667 static inline void *nla_memdup(const struct nlattr
*src
, gfp_t gfp
)
1669 return kmemdup(nla_data(src
), nla_len(src
), gfp
);
1673 * nla_nest_start_noflag - Start a new level of nested attributes
1674 * @skb: socket buffer to add attributes to
1675 * @attrtype: attribute type of container
1677 * This function exists for backward compatibility to use in APIs which never
1678 * marked their nest attributes with NLA_F_NESTED flag. New APIs should use
1679 * nla_nest_start() which sets the flag.
1681 * Returns the container attribute or NULL on error
1683 static inline struct nlattr
*nla_nest_start_noflag(struct sk_buff
*skb
,
1686 struct nlattr
*start
= (struct nlattr
*)skb_tail_pointer(skb
);
1688 if (nla_put(skb
, attrtype
, 0, NULL
) < 0)
1695 * nla_nest_start - Start a new level of nested attributes, with NLA_F_NESTED
1696 * @skb: socket buffer to add attributes to
1697 * @attrtype: attribute type of container
1699 * Unlike nla_nest_start_noflag(), mark the nest attribute with NLA_F_NESTED
1700 * flag. This is the preferred function to use in new code.
1702 * Returns the container attribute or NULL on error
1704 static inline struct nlattr
*nla_nest_start(struct sk_buff
*skb
, int attrtype
)
1706 return nla_nest_start_noflag(skb
, attrtype
| NLA_F_NESTED
);
1710 * nla_nest_end - Finalize nesting of attributes
1711 * @skb: socket buffer the attributes are stored in
1712 * @start: container attribute
1714 * Corrects the container attribute header to include the all
1715 * appeneded attributes.
1717 * Returns the total data length of the skb.
1719 static inline int nla_nest_end(struct sk_buff
*skb
, struct nlattr
*start
)
1721 start
->nla_len
= skb_tail_pointer(skb
) - (unsigned char *)start
;
1726 * nla_nest_cancel - Cancel nesting of attributes
1727 * @skb: socket buffer the message is stored in
1728 * @start: container attribute
1730 * Removes the container attribute and including all nested
1731 * attributes. Returns -EMSGSIZE
1733 static inline void nla_nest_cancel(struct sk_buff
*skb
, struct nlattr
*start
)
1735 nlmsg_trim(skb
, start
);
1739 * nla_validate_nested - Validate a stream of nested attributes
1740 * @start: container attribute
1741 * @maxtype: maximum attribute type to be expected
1742 * @policy: validation policy
1743 * @validate: validation strictness
1744 * @extack: extended ACK report struct
1746 * Validates all attributes in the nested attribute stream against the
1747 * specified policy. Attributes with a type exceeding maxtype will be
1748 * ignored. See documenation of struct nla_policy for more details.
1750 * Returns 0 on success or a negative error code.
1752 static inline int __nla_validate_nested(const struct nlattr
*start
, int maxtype
,
1753 const struct nla_policy
*policy
,
1754 unsigned int validate
,
1755 struct netlink_ext_ack
*extack
)
1757 return __nla_validate(nla_data(start
), nla_len(start
), maxtype
, policy
,
1762 nl80211_validate_nested(const struct nlattr
*start
, int maxtype
,
1763 const struct nla_policy
*policy
,
1764 struct netlink_ext_ack
*extack
)
1766 return __nla_validate_nested(start
, maxtype
, policy
,
1767 NL_VALIDATE_STRICT
, extack
);
1771 nla_validate_nested_deprecated(const struct nlattr
*start
, int maxtype
,
1772 const struct nla_policy
*policy
,
1773 struct netlink_ext_ack
*extack
)
1775 return __nla_validate_nested(start
, maxtype
, policy
,
1776 NL_VALIDATE_LIBERAL
, extack
);
1780 * nla_need_padding_for_64bit - test 64-bit alignment of the next attribute
1781 * @skb: socket buffer the message is stored in
1783 * Return true if padding is needed to align the next attribute (nla_data()) to
1784 * a 64-bit aligned area.
1786 static inline bool nla_need_padding_for_64bit(struct sk_buff
*skb
)
1788 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1789 /* The nlattr header is 4 bytes in size, that's why we test
1790 * if the skb->data _is_ aligned. A NOP attribute, plus
1791 * nlattr header for next attribute, will make nla_data()
1794 if (IS_ALIGNED((unsigned long)skb_tail_pointer(skb
), 8))
1801 * nla_align_64bit - 64-bit align the nla_data() of next attribute
1802 * @skb: socket buffer the message is stored in
1803 * @padattr: attribute type for the padding
1805 * Conditionally emit a padding netlink attribute in order to make
1806 * the next attribute we emit have a 64-bit aligned nla_data() area.
1807 * This will only be done in architectures which do not have
1808 * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS defined.
1810 * Returns zero on success or a negative error code.
1812 static inline int nla_align_64bit(struct sk_buff
*skb
, int padattr
)
1814 if (nla_need_padding_for_64bit(skb
) &&
1815 !nla_reserve(skb
, padattr
, 0))
1822 * nla_total_size_64bit - total length of attribute including padding
1823 * @payload: length of payload
1825 static inline int nla_total_size_64bit(int payload
)
1827 return NLA_ALIGN(nla_attr_size(payload
))
1828 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1829 + NLA_ALIGN(nla_attr_size(0))
1835 * nla_for_each_attr - iterate over a stream of attributes
1836 * @pos: loop counter, set to current attribute
1837 * @head: head of attribute stream
1838 * @len: length of attribute stream
1839 * @rem: initialized to len, holds bytes currently remaining in stream
1841 #define nla_for_each_attr(pos, head, len, rem) \
1842 for (pos = head, rem = len; \
1844 pos = nla_next(pos, &(rem)))
1847 * nla_for_each_nested - iterate over nested attributes
1848 * @pos: loop counter, set to current attribute
1849 * @nla: attribute containing the nested attributes
1850 * @rem: initialized to len, holds bytes currently remaining in stream
1852 #define nla_for_each_nested(pos, nla, rem) \
1853 nla_for_each_attr(pos, nla_data(nla), nla_len(nla), rem)
1856 * nla_is_last - Test if attribute is last in stream
1857 * @nla: attribute to test
1858 * @rem: bytes remaining in stream
1860 static inline bool nla_is_last(const struct nlattr
*nla
, int rem
)
1862 return nla
->nla_len
== rem
;