Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : #ifndef __NET_NETLINK_H
3 : : #define __NET_NETLINK_H
4 : :
5 : : #include <linux/types.h>
6 : : #include <linux/netlink.h>
7 : : #include <linux/jiffies.h>
8 : : #include <linux/in6.h>
9 : :
10 : : /* ========================================================================
11 : : * Netlink Messages and Attributes Interface (As Seen On TV)
12 : : * ------------------------------------------------------------------------
13 : : * Messages Interface
14 : : * ------------------------------------------------------------------------
15 : : *
16 : : * Message Format:
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)-----------------------+
24 : : *
25 : : * Payload Format:
26 : : * <---------------------- nlmsg_len(nlh) --------------------->
27 : : * <------ hdrlen ------> <- nlmsg_attrlen(nlh, hdrlen) ->
28 : : * +----------------------+- - -+--------------------------------+
29 : : * | Family Header | Pad | Attributes |
30 : : * +----------------------+- - -+--------------------------------+
31 : : * nlmsg_attrdata(nlh, hdrlen)---^
32 : : *
33 : : * Data Structures:
34 : : * struct nlmsghdr netlink message header
35 : : *
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
45 : : *
46 : : * Message Sending:
47 : : * nlmsg_multicast() multicast message to several groups
48 : : * nlmsg_unicast() unicast a message to a single socket
49 : : * nlmsg_notify() send notification message
50 : : *
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
55 : : *
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
61 : : *
62 : : * Message Parsing:
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
70 : : *
71 : : * Misc:
72 : : * nlmsg_report() report back to application?
73 : : *
74 : : * ------------------------------------------------------------------------
75 : : * Attributes Interface
76 : : * ------------------------------------------------------------------------
77 : : *
78 : : * Attribute Format:
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)-----------------------------'
87 : : *
88 : : * Data Structures:
89 : : * struct nlattr netlink attribute header
90 : : *
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
97 : : *
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
115 : : *
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
120 : : *
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
125 : : *
126 : : * Attribute Payload Access:
127 : : * nla_data(nla) head of attribute payload
128 : : * nla_len(nla) length of attribute payload
129 : : *
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
141 : : *
142 : : * Attribute Misc:
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
147 : : *
148 : : * Attribute Parsing:
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 : : *=========================================================================
160 : : */
161 : :
162 : : /**
163 : : * Standard attribute types to specify validation policy
164 : : */
165 : : enum {
166 : : NLA_UNSPEC,
167 : : NLA_U8,
168 : : NLA_U16,
169 : : NLA_U32,
170 : : NLA_U64,
171 : : NLA_STRING,
172 : : NLA_FLAG,
173 : : NLA_MSECS,
174 : : NLA_NESTED,
175 : : NLA_NESTED_ARRAY,
176 : : NLA_NUL_STRING,
177 : : NLA_BINARY,
178 : : NLA_S8,
179 : : NLA_S16,
180 : : NLA_S32,
181 : : NLA_S64,
182 : : NLA_BITFIELD32,
183 : : NLA_REJECT,
184 : : NLA_EXACT_LEN,
185 : : NLA_EXACT_LEN_WARN,
186 : : NLA_MIN_LEN,
187 : : __NLA_TYPE_MAX,
188 : : };
189 : :
190 : : #define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
191 : :
192 : : enum nla_policy_validation {
193 : : NLA_VALIDATE_NONE,
194 : : NLA_VALIDATE_RANGE,
195 : : NLA_VALIDATE_MIN,
196 : : NLA_VALIDATE_MAX,
197 : : NLA_VALIDATE_FUNCTION,
198 : : };
199 : :
200 : : /**
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
207 : : *
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.
210 : : *
211 : : * Meaning of `len' field:
212 : : * NLA_STRING Maximum length of string
213 : : * NLA_NUL_STRING Maximum length of string (excluding NUL)
214 : : * NLA_FLAG Unused
215 : : * NLA_BINARY Maximum length of attribute payload
216 : : * NLA_MIN_LEN Minimum length of attribute payload
217 : : * NLA_NESTED,
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.
222 : : * NLA_U8, NLA_U16,
223 : : * NLA_U32, NLA_U64,
224 : : * NLA_S8, NLA_S16,
225 : : * NLA_S32, NLA_S64,
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
230 : : * NLA_REJECT Unused
231 : : * NLA_EXACT_LEN Attribute must have exactly this length, otherwise
232 : : * it is rejected.
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
237 : : *
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
241 : : * flags
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
256 : : *
257 : : * Meaning of `min' and `max' fields, use via NLA_POLICY_MIN, NLA_POLICY_MAX
258 : : * and NLA_POLICY_RANGE:
259 : : * NLA_U8,
260 : : * NLA_U16,
261 : : * NLA_U32,
262 : : * NLA_U64,
263 : : * NLA_S8,
264 : : * NLA_S16,
265 : : * NLA_S32,
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
275 : : *
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
280 : : * NLA_NESTED_ARRAY.
281 : : * All other Unused - but note that it's a union
282 : : *
283 : : * Example:
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 },
289 : : * };
290 : : */
291 : : struct nla_policy {
292 : : u8 type;
293 : : u8 validation_type;
294 : : u16 len;
295 : : union {
296 : : const void *validation_data;
297 : : struct {
298 : : s16 min, max;
299 : : };
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.
307 : : *
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.
312 : : *
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.
318 : : */
319 : : u16 strict_start_type;
320 : : };
321 : : };
322 : :
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, \
325 : : .len = _len }
326 : : #define NLA_POLICY_MIN_LEN(_len) { .type = NLA_MIN_LEN, .len = _len }
327 : :
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)
330 : :
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)
339 : :
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)
351 : :
352 : : #define NLA_POLICY_RANGE(tp, _min, _max) { \
353 : : .type = NLA_ENSURE_INT_TYPE(tp), \
354 : : .validation_type = NLA_VALIDATE_RANGE, \
355 : : .min = _min, \
356 : : .max = _max \
357 : : }
358 : :
359 : : #define NLA_POLICY_MIN(tp, _min) { \
360 : : .type = NLA_ENSURE_INT_TYPE(tp), \
361 : : .validation_type = NLA_VALIDATE_MIN, \
362 : : .min = _min, \
363 : : }
364 : :
365 : : #define NLA_POLICY_MAX(tp, _max) { \
366 : : .type = NLA_ENSURE_INT_TYPE(tp), \
367 : : .validation_type = NLA_VALIDATE_MAX, \
368 : : .max = _max, \
369 : : }
370 : :
371 : : #define NLA_POLICY_VALIDATE_FN(tp, fn, ...) { \
372 : : .type = NLA_ENSURE_NO_VALIDATION_PTR(tp), \
373 : : .validation_type = NLA_VALIDATE_FUNCTION, \
374 : : .validate = fn, \
375 : : .len = __VA_ARGS__ + 0, \
376 : : }
377 : :
378 : : /**
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
385 : : */
386 : : struct nl_info {
387 : : struct nlmsghdr *nlh;
388 : : struct net *nl_net;
389 : : u32 portid;
390 : : u8 skip_notify:1,
391 : : skip_notify_kernel:1;
392 : : };
393 : :
394 : : /**
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.
410 : : */
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),
418 : : };
419 : :
420 : : #define NL_VALIDATE_DEPRECATED_STRICT (NL_VALIDATE_TRAILING |\
421 : : NL_VALIDATE_MAXTYPE)
422 : : #define NL_VALIDATE_STRICT (NL_VALIDATE_TRAILING |\
423 : : NL_VALIDATE_MAXTYPE |\
424 : : NL_VALIDATE_UNSPEC |\
425 : : NL_VALIDATE_STRICT_ATTRS |\
426 : : NL_VALIDATE_NESTED)
427 : :
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);
433 : :
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,
456 : : const void *data);
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);
465 : :
466 : : /**************************************************************************
467 : : * Netlink Messages
468 : : **************************************************************************/
469 : :
470 : : /**
471 : : * nlmsg_msg_size - length of netlink message not including padding
472 : : * @payload: length of message payload
473 : : */
474 : : static inline int nlmsg_msg_size(int payload)
475 : : {
476 : 3 : return NLMSG_HDRLEN + payload;
477 : : }
478 : :
479 : : /**
480 : : * nlmsg_total_size - length of netlink message including padding
481 : : * @payload: length of message payload
482 : : */
483 : : static inline int nlmsg_total_size(int payload)
484 : : {
485 : 3 : return NLMSG_ALIGN(nlmsg_msg_size(payload));
486 : : }
487 : :
488 : : /**
489 : : * nlmsg_padlen - length of padding at the message's tail
490 : : * @payload: length of message payload
491 : : */
492 : : static inline int nlmsg_padlen(int payload)
493 : : {
494 : : return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
495 : : }
496 : :
497 : : /**
498 : : * nlmsg_data - head of message payload
499 : : * @nlh: netlink message header
500 : : */
501 : : static inline void *nlmsg_data(const struct nlmsghdr *nlh)
502 : : {
503 : 3 : return (unsigned char *) nlh + NLMSG_HDRLEN;
504 : : }
505 : :
506 : : /**
507 : : * nlmsg_len - length of message payload
508 : : * @nlh: netlink message header
509 : : */
510 : : static inline int nlmsg_len(const struct nlmsghdr *nlh)
511 : : {
512 : 3 : return nlh->nlmsg_len - NLMSG_HDRLEN;
513 : : }
514 : :
515 : : /**
516 : : * nlmsg_attrdata - head of attributes data
517 : : * @nlh: netlink message header
518 : : * @hdrlen: length of family specific header
519 : : */
520 : : static inline struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh,
521 : : int hdrlen)
522 : : {
523 : : unsigned char *data = nlmsg_data(nlh);
524 : 3 : return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
525 : : }
526 : :
527 : : /**
528 : : * nlmsg_attrlen - length of attributes data
529 : : * @nlh: netlink message header
530 : : * @hdrlen: length of family specific header
531 : : */
532 : : static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
533 : : {
534 : 3 : return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
535 : : }
536 : :
537 : : /**
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
541 : : */
542 : : static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
543 : : {
544 : 3 : return (remaining >= (int) sizeof(struct nlmsghdr) &&
545 : 3 : nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
546 : 3 : nlh->nlmsg_len <= remaining);
547 : : }
548 : :
549 : : /**
550 : : * nlmsg_next - next netlink message in message stream
551 : : * @nlh: netlink message header
552 : : * @remaining: number of bytes remaining in message stream
553 : : *
554 : : * Returns the next netlink message in the message stream and
555 : : * decrements remaining by the size of the current message.
556 : : */
557 : : static inline struct nlmsghdr *
558 : : nlmsg_next(const struct nlmsghdr *nlh, int *remaining)
559 : : {
560 : 3 : int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
561 : :
562 : 3 : *remaining -= totlen;
563 : :
564 : 3 : return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
565 : : }
566 : :
567 : : /**
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
575 : : *
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.
580 : : *
581 : : * Returns 0 on success or a negative error code.
582 : : */
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)
587 : : {
588 : : return __nla_parse(tb, maxtype, head, len, policy,
589 : : NL_VALIDATE_STRICT, extack);
590 : : }
591 : :
592 : : /**
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
600 : : *
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).
605 : : *
606 : : * Returns 0 on success or a negative error code.
607 : : */
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)
612 : : {
613 : 0 : return __nla_parse(tb, maxtype, head, len, policy,
614 : : NL_VALIDATE_LIBERAL, extack);
615 : : }
616 : :
617 : : /**
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
625 : : *
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).
630 : : *
631 : : * Returns 0 on success or a negative error code.
632 : : */
633 : : static inline int nla_parse_deprecated_strict(struct nlattr **tb, int maxtype,
634 : : const struct nlattr *head,
635 : : int len,
636 : : const struct nla_policy *policy,
637 : : struct netlink_ext_ack *extack)
638 : : {
639 : : return __nla_parse(tb, maxtype, head, len, policy,
640 : : NL_VALIDATE_DEPRECATED_STRICT, extack);
641 : : }
642 : :
643 : : /**
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
652 : : *
653 : : * See nla_parse()
654 : : */
655 : 3 : 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)
660 : : {
661 : 3 : if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen)) {
662 : 0 : NL_SET_ERR_MSG(extack, "Invalid header length");
663 : : return -EINVAL;
664 : : }
665 : :
666 : 3 : return __nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
667 : : nlmsg_attrlen(nlh, hdrlen), policy, validate,
668 : : extack);
669 : : }
670 : :
671 : : /**
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
679 : : *
680 : : * See nla_parse()
681 : : */
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)
686 : : {
687 : 0 : return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
688 : : NL_VALIDATE_STRICT, extack);
689 : : }
690 : :
691 : : /**
692 : : * nlmsg_parse_deprecated - parse attributes of a netlink message
693 : : * @nlh: netlink message header
694 : : * @hdrlen: length of family specific header
695 : : * @tb: destination array with maxtype+1 elements
696 : : * @maxtype: maximum attribute type to be expected
697 : : * @extack: extended ACK report struct
698 : : *
699 : : * See nla_parse_deprecated()
700 : : */
701 : : static inline int nlmsg_parse_deprecated(const struct nlmsghdr *nlh, int hdrlen,
702 : : struct nlattr *tb[], int maxtype,
703 : : const struct nla_policy *policy,
704 : : struct netlink_ext_ack *extack)
705 : : {
706 : 3 : return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
707 : : NL_VALIDATE_LIBERAL, extack);
708 : : }
709 : :
710 : : /**
711 : : * nlmsg_parse_deprecated_strict - parse attributes of a netlink message
712 : : * @nlh: netlink message header
713 : : * @hdrlen: length of family specific header
714 : : * @tb: destination array with maxtype+1 elements
715 : : * @maxtype: maximum attribute type to be expected
716 : : * @extack: extended ACK report struct
717 : : *
718 : : * See nla_parse_deprecated_strict()
719 : : */
720 : : static inline int
721 : : nlmsg_parse_deprecated_strict(const struct nlmsghdr *nlh, int hdrlen,
722 : : struct nlattr *tb[], int maxtype,
723 : : const struct nla_policy *policy,
724 : : struct netlink_ext_ack *extack)
725 : : {
726 : 0 : return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
727 : : NL_VALIDATE_DEPRECATED_STRICT, extack);
728 : : }
729 : :
730 : : /**
731 : : * nlmsg_find_attr - find a specific attribute in a netlink message
732 : : * @nlh: netlink message header
733 : : * @hdrlen: length of familiy specific header
734 : : * @attrtype: type of attribute to look for
735 : : *
736 : : * Returns the first attribute which matches the specified type.
737 : : */
738 : 0 : static inline struct nlattr *nlmsg_find_attr(const struct nlmsghdr *nlh,
739 : : int hdrlen, int attrtype)
740 : : {
741 : 0 : return nla_find(nlmsg_attrdata(nlh, hdrlen),
742 : : nlmsg_attrlen(nlh, hdrlen), attrtype);
743 : : }
744 : :
745 : : /**
746 : : * nla_validate_deprecated - Validate a stream of attributes
747 : : * @head: head of attribute stream
748 : : * @len: length of attribute stream
749 : : * @maxtype: maximum attribute type to be expected
750 : : * @policy: validation policy
751 : : * @validate: validation strictness
752 : : * @extack: extended ACK report struct
753 : : *
754 : : * Validates all attributes in the specified attribute stream against the
755 : : * specified policy. Validation is done in liberal mode.
756 : : * See documenation of struct nla_policy for more details.
757 : : *
758 : : * Returns 0 on success or a negative error code.
759 : : */
760 : : static inline int nla_validate_deprecated(const struct nlattr *head, int len,
761 : : int maxtype,
762 : : const struct nla_policy *policy,
763 : : struct netlink_ext_ack *extack)
764 : : {
765 : : return __nla_validate(head, len, maxtype, policy, NL_VALIDATE_LIBERAL,
766 : : extack);
767 : : }
768 : :
769 : : /**
770 : : * nla_validate - Validate a stream of attributes
771 : : * @head: head of attribute stream
772 : : * @len: length of attribute stream
773 : : * @maxtype: maximum attribute type to be expected
774 : : * @policy: validation policy
775 : : * @validate: validation strictness
776 : : * @extack: extended ACK report struct
777 : : *
778 : : * Validates all attributes in the specified attribute stream against the
779 : : * specified policy. Validation is done in strict mode.
780 : : * See documenation of struct nla_policy for more details.
781 : : *
782 : : * Returns 0 on success or a negative error code.
783 : : */
784 : : static inline int nla_validate(const struct nlattr *head, int len, int maxtype,
785 : : const struct nla_policy *policy,
786 : : struct netlink_ext_ack *extack)
787 : : {
788 : : return __nla_validate(head, len, maxtype, policy, NL_VALIDATE_STRICT,
789 : : extack);
790 : : }
791 : :
792 : : /**
793 : : * nlmsg_validate_deprecated - validate a netlink message including attributes
794 : : * @nlh: netlinket message header
795 : : * @hdrlen: length of familiy specific header
796 : : * @maxtype: maximum attribute type to be expected
797 : : * @policy: validation policy
798 : : * @extack: extended ACK report struct
799 : : */
800 : 3 : static inline int nlmsg_validate_deprecated(const struct nlmsghdr *nlh,
801 : : int hdrlen, int maxtype,
802 : : const struct nla_policy *policy,
803 : : struct netlink_ext_ack *extack)
804 : : {
805 : 3 : if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
806 : : return -EINVAL;
807 : :
808 : 3 : return __nla_validate(nlmsg_attrdata(nlh, hdrlen),
809 : : nlmsg_attrlen(nlh, hdrlen), maxtype,
810 : : policy, NL_VALIDATE_LIBERAL, extack);
811 : : }
812 : :
813 : :
814 : :
815 : : /**
816 : : * nlmsg_report - need to report back to application?
817 : : * @nlh: netlink message header
818 : : *
819 : : * Returns 1 if a report back to the application is requested.
820 : : */
821 : : static inline int nlmsg_report(const struct nlmsghdr *nlh)
822 : : {
823 : 3 : return !!(nlh->nlmsg_flags & NLM_F_ECHO);
824 : : }
825 : :
826 : : /**
827 : : * nlmsg_for_each_attr - iterate over a stream of attributes
828 : : * @pos: loop counter, set to current attribute
829 : : * @nlh: netlink message header
830 : : * @hdrlen: length of familiy specific header
831 : : * @rem: initialized to len, holds bytes currently remaining in stream
832 : : */
833 : : #define nlmsg_for_each_attr(pos, nlh, hdrlen, rem) \
834 : : nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
835 : : nlmsg_attrlen(nlh, hdrlen), rem)
836 : :
837 : : /**
838 : : * nlmsg_put - Add a new netlink message to an skb
839 : : * @skb: socket buffer to store message in
840 : : * @portid: netlink PORTID of requesting application
841 : : * @seq: sequence number of message
842 : : * @type: message type
843 : : * @payload: length of message payload
844 : : * @flags: message flags
845 : : *
846 : : * Returns NULL if the tailroom of the skb is insufficient to store
847 : : * the message header and payload.
848 : : */
849 : 3 : static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
850 : : int type, int payload, int flags)
851 : : {
852 : 3 : if (unlikely(skb_tailroom(skb) < nlmsg_total_size(payload)))
853 : : return NULL;
854 : :
855 : 3 : return __nlmsg_put(skb, portid, seq, type, payload, flags);
856 : : }
857 : :
858 : : /**
859 : : * nlmsg_put_answer - Add a new callback based netlink message to an skb
860 : : * @skb: socket buffer to store message in
861 : : * @cb: netlink callback
862 : : * @type: message type
863 : : * @payload: length of message payload
864 : : * @flags: message flags
865 : : *
866 : : * Returns NULL if the tailroom of the skb is insufficient to store
867 : : * the message header and payload.
868 : : */
869 : : static inline struct nlmsghdr *nlmsg_put_answer(struct sk_buff *skb,
870 : : struct netlink_callback *cb,
871 : : int type, int payload,
872 : : int flags)
873 : : {
874 : 3 : return nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
875 : : type, payload, flags);
876 : : }
877 : :
878 : : /**
879 : : * nlmsg_new - Allocate a new netlink message
880 : : * @payload: size of the message payload
881 : : * @flags: the type of memory to allocate.
882 : : *
883 : : * Use NLMSG_DEFAULT_SIZE if the size of the payload isn't known
884 : : * and a good default is needed.
885 : : */
886 : : static inline struct sk_buff *nlmsg_new(size_t payload, gfp_t flags)
887 : : {
888 : 3 : return alloc_skb(nlmsg_total_size(payload), flags);
889 : : }
890 : :
891 : : /**
892 : : * nlmsg_end - Finalize a netlink message
893 : : * @skb: socket buffer the message is stored in
894 : : * @nlh: netlink message header
895 : : *
896 : : * Corrects the netlink message header to include the appeneded
897 : : * attributes. Only necessary if attributes have been added to
898 : : * the message.
899 : : */
900 : : static inline void nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
901 : : {
902 : 3 : nlh->nlmsg_len = skb_tail_pointer(skb) - (unsigned char *)nlh;
903 : : }
904 : :
905 : : /**
906 : : * nlmsg_get_pos - return current position in netlink message
907 : : * @skb: socket buffer the message is stored in
908 : : *
909 : : * Returns a pointer to the current tail of the message.
910 : : */
911 : : static inline void *nlmsg_get_pos(struct sk_buff *skb)
912 : : {
913 : : return skb_tail_pointer(skb);
914 : : }
915 : :
916 : : /**
917 : : * nlmsg_trim - Trim message to a mark
918 : : * @skb: socket buffer the message is stored in
919 : : * @mark: mark to trim to
920 : : *
921 : : * Trims the message to the provided mark.
922 : : */
923 : 1 : static inline void nlmsg_trim(struct sk_buff *skb, const void *mark)
924 : : {
925 : 1 : if (mark) {
926 : 1 : WARN_ON((unsigned char *) mark < skb->data);
927 : 1 : skb_trim(skb, (unsigned char *) mark - skb->data);
928 : : }
929 : 1 : }
930 : :
931 : : /**
932 : : * nlmsg_cancel - Cancel construction of a netlink message
933 : : * @skb: socket buffer the message is stored in
934 : : * @nlh: netlink message header
935 : : *
936 : : * Removes the complete netlink message including all
937 : : * attributes from the socket buffer again.
938 : : */
939 : : static inline void nlmsg_cancel(struct sk_buff *skb, struct nlmsghdr *nlh)
940 : : {
941 : 1 : nlmsg_trim(skb, nlh);
942 : : }
943 : :
944 : : /**
945 : : * nlmsg_free - free a netlink message
946 : : * @skb: socket buffer of netlink message
947 : : */
948 : : static inline void nlmsg_free(struct sk_buff *skb)
949 : : {
950 : 0 : kfree_skb(skb);
951 : : }
952 : :
953 : : /**
954 : : * nlmsg_multicast - multicast a netlink message
955 : : * @sk: netlink socket to spread messages to
956 : : * @skb: netlink message as socket buffer
957 : : * @portid: own netlink portid to avoid sending to yourself
958 : : * @group: multicast group id
959 : : * @flags: allocation flags
960 : : */
961 : : static inline int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,
962 : : u32 portid, unsigned int group, gfp_t flags)
963 : : {
964 : : int err;
965 : :
966 : 3 : NETLINK_CB(skb).dst_group = group;
967 : :
968 : 3 : err = netlink_broadcast(sk, skb, portid, group, flags);
969 : 3 : if (err > 0)
970 : : err = 0;
971 : :
972 : : return err;
973 : : }
974 : :
975 : : /**
976 : : * nlmsg_unicast - unicast a netlink message
977 : : * @sk: netlink socket to spread message to
978 : : * @skb: netlink message as socket buffer
979 : : * @portid: netlink portid of the destination socket
980 : : */
981 : : static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 portid)
982 : : {
983 : : int err;
984 : :
985 : 3 : err = netlink_unicast(sk, skb, portid, MSG_DONTWAIT);
986 : 3 : if (err > 0)
987 : : err = 0;
988 : :
989 : : return err;
990 : : }
991 : :
992 : : /**
993 : : * nlmsg_for_each_msg - iterate over a stream of messages
994 : : * @pos: loop counter, set to current message
995 : : * @head: head of message stream
996 : : * @len: length of message stream
997 : : * @rem: initialized to len, holds bytes currently remaining in stream
998 : : */
999 : : #define nlmsg_for_each_msg(pos, head, len, rem) \
1000 : : for (pos = head, rem = len; \
1001 : : nlmsg_ok(pos, rem); \
1002 : : pos = nlmsg_next(pos, &(rem)))
1003 : :
1004 : : /**
1005 : : * nl_dump_check_consistent - check if sequence is consistent and advertise if not
1006 : : * @cb: netlink callback structure that stores the sequence number
1007 : : * @nlh: netlink message header to write the flag to
1008 : : *
1009 : : * This function checks if the sequence (generation) number changed during dump
1010 : : * and if it did, advertises it in the netlink message header.
1011 : : *
1012 : : * The correct way to use it is to set cb->seq to the generation counter when
1013 : : * all locks for dumping have been acquired, and then call this function for
1014 : : * each message that is generated.
1015 : : *
1016 : : * Note that due to initialisation concerns, 0 is an invalid sequence number
1017 : : * and must not be used by code that uses this functionality.
1018 : : */
1019 : : static inline void
1020 : : nl_dump_check_consistent(struct netlink_callback *cb,
1021 : : struct nlmsghdr *nlh)
1022 : : {
1023 : 3 : if (cb->prev_seq && cb->seq != cb->prev_seq)
1024 : 0 : nlh->nlmsg_flags |= NLM_F_DUMP_INTR;
1025 : 3 : cb->prev_seq = cb->seq;
1026 : : }
1027 : :
1028 : : /**************************************************************************
1029 : : * Netlink Attributes
1030 : : **************************************************************************/
1031 : :
1032 : : /**
1033 : : * nla_attr_size - length of attribute not including padding
1034 : : * @payload: length of payload
1035 : : */
1036 : : static inline int nla_attr_size(int payload)
1037 : : {
1038 : 3 : return NLA_HDRLEN + payload;
1039 : : }
1040 : :
1041 : : /**
1042 : : * nla_total_size - total length of attribute including padding
1043 : : * @payload: length of payload
1044 : : */
1045 : : static inline int nla_total_size(int payload)
1046 : : {
1047 : 3 : return NLA_ALIGN(nla_attr_size(payload));
1048 : : }
1049 : :
1050 : : /**
1051 : : * nla_padlen - length of padding at the tail of attribute
1052 : : * @payload: length of payload
1053 : : */
1054 : : static inline int nla_padlen(int payload)
1055 : : {
1056 : 3 : return nla_total_size(payload) - nla_attr_size(payload);
1057 : : }
1058 : :
1059 : : /**
1060 : : * nla_type - attribute type
1061 : : * @nla: netlink attribute
1062 : : */
1063 : : static inline int nla_type(const struct nlattr *nla)
1064 : : {
1065 : 3 : return nla->nla_type & NLA_TYPE_MASK;
1066 : : }
1067 : :
1068 : : /**
1069 : : * nla_data - head of payload
1070 : : * @nla: netlink attribute
1071 : : */
1072 : : static inline void *nla_data(const struct nlattr *nla)
1073 : : {
1074 : 3 : return (char *) nla + NLA_HDRLEN;
1075 : : }
1076 : :
1077 : : /**
1078 : : * nla_len - length of payload
1079 : : * @nla: netlink attribute
1080 : : */
1081 : : static inline int nla_len(const struct nlattr *nla)
1082 : : {
1083 : 3 : return nla->nla_len - NLA_HDRLEN;
1084 : : }
1085 : :
1086 : : /**
1087 : : * nla_ok - check if the netlink attribute fits into the remaining bytes
1088 : : * @nla: netlink attribute
1089 : : * @remaining: number of bytes remaining in attribute stream
1090 : : */
1091 : : static inline int nla_ok(const struct nlattr *nla, int remaining)
1092 : : {
1093 : 3 : return remaining >= (int) sizeof(*nla) &&
1094 : 3 : nla->nla_len >= sizeof(*nla) &&
1095 : 3 : nla->nla_len <= remaining;
1096 : : }
1097 : :
1098 : : /**
1099 : : * nla_next - next netlink attribute in attribute stream
1100 : : * @nla: netlink attribute
1101 : : * @remaining: number of bytes remaining in attribute stream
1102 : : *
1103 : : * Returns the next netlink attribute in the attribute stream and
1104 : : * decrements remaining by the size of the current attribute.
1105 : : */
1106 : : static inline struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
1107 : : {
1108 : 3 : unsigned int totlen = NLA_ALIGN(nla->nla_len);
1109 : :
1110 : 3 : *remaining -= totlen;
1111 : 3 : return (struct nlattr *) ((char *) nla + totlen);
1112 : : }
1113 : :
1114 : : /**
1115 : : * nla_find_nested - find attribute in a set of nested attributes
1116 : : * @nla: attribute containing the nested attributes
1117 : : * @attrtype: type of attribute to look for
1118 : : *
1119 : : * Returns the first attribute which matches the specified type.
1120 : : */
1121 : : static inline struct nlattr *
1122 : 0 : nla_find_nested(const struct nlattr *nla, int attrtype)
1123 : : {
1124 : 0 : return nla_find(nla_data(nla), nla_len(nla), attrtype);
1125 : : }
1126 : :
1127 : : /**
1128 : : * nla_parse_nested - parse nested attributes
1129 : : * @tb: destination array with maxtype+1 elements
1130 : : * @maxtype: maximum attribute type to be expected
1131 : : * @nla: attribute containing the nested attributes
1132 : : * @policy: validation policy
1133 : : * @extack: extended ACK report struct
1134 : : *
1135 : : * See nla_parse()
1136 : : */
1137 : 0 : static inline int nla_parse_nested(struct nlattr *tb[], int maxtype,
1138 : : const struct nlattr *nla,
1139 : : const struct nla_policy *policy,
1140 : : struct netlink_ext_ack *extack)
1141 : : {
1142 : 0 : if (!(nla->nla_type & NLA_F_NESTED)) {
1143 : 0 : NL_SET_ERR_MSG_ATTR(extack, nla, "NLA_F_NESTED is missing");
1144 : : return -EINVAL;
1145 : : }
1146 : :
1147 : 0 : return __nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy,
1148 : : NL_VALIDATE_STRICT, extack);
1149 : : }
1150 : :
1151 : : /**
1152 : : * nla_parse_nested_deprecated - parse nested attributes
1153 : : * @tb: destination array with maxtype+1 elements
1154 : : * @maxtype: maximum attribute type to be expected
1155 : : * @nla: attribute containing the nested attributes
1156 : : * @policy: validation policy
1157 : : * @extack: extended ACK report struct
1158 : : *
1159 : : * See nla_parse_deprecated()
1160 : : */
1161 : 0 : static inline int nla_parse_nested_deprecated(struct nlattr *tb[], int maxtype,
1162 : : const struct nlattr *nla,
1163 : : const struct nla_policy *policy,
1164 : : struct netlink_ext_ack *extack)
1165 : : {
1166 : 3 : return __nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy,
1167 : : NL_VALIDATE_LIBERAL, extack);
1168 : : }
1169 : :
1170 : : /**
1171 : : * nla_put_u8 - Add a u8 netlink attribute to a socket buffer
1172 : : * @skb: socket buffer to add attribute to
1173 : : * @attrtype: attribute type
1174 : : * @value: numeric value
1175 : : */
1176 : : static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
1177 : : {
1178 : : /* temporary variables to work around GCC PR81715 with asan-stack=1 */
1179 : 3 : u8 tmp = value;
1180 : :
1181 : 3 : return nla_put(skb, attrtype, sizeof(u8), &tmp);
1182 : : }
1183 : :
1184 : : /**
1185 : : * nla_put_u16 - Add a u16 netlink attribute to a socket buffer
1186 : : * @skb: socket buffer to add attribute to
1187 : : * @attrtype: attribute type
1188 : : * @value: numeric value
1189 : : */
1190 : : static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
1191 : : {
1192 : 3 : u16 tmp = value;
1193 : :
1194 : 3 : return nla_put(skb, attrtype, sizeof(u16), &tmp);
1195 : : }
1196 : :
1197 : : /**
1198 : : * nla_put_be16 - Add a __be16 netlink attribute to a socket buffer
1199 : : * @skb: socket buffer to add attribute to
1200 : : * @attrtype: attribute type
1201 : : * @value: numeric value
1202 : : */
1203 : : static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value)
1204 : : {
1205 : 0 : __be16 tmp = value;
1206 : :
1207 : 0 : return nla_put(skb, attrtype, sizeof(__be16), &tmp);
1208 : : }
1209 : :
1210 : : /**
1211 : : * nla_put_net16 - Add 16-bit network byte order netlink attribute to a socket buffer
1212 : : * @skb: socket buffer to add attribute to
1213 : : * @attrtype: attribute type
1214 : : * @value: numeric value
1215 : : */
1216 : : static inline int nla_put_net16(struct sk_buff *skb, int attrtype, __be16 value)
1217 : : {
1218 : : __be16 tmp = value;
1219 : :
1220 : : return nla_put_be16(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
1221 : : }
1222 : :
1223 : : /**
1224 : : * nla_put_le16 - Add a __le16 netlink attribute to a socket buffer
1225 : : * @skb: socket buffer to add attribute to
1226 : : * @attrtype: attribute type
1227 : : * @value: numeric value
1228 : : */
1229 : : static inline int nla_put_le16(struct sk_buff *skb, int attrtype, __le16 value)
1230 : : {
1231 : : __le16 tmp = value;
1232 : :
1233 : : return nla_put(skb, attrtype, sizeof(__le16), &tmp);
1234 : : }
1235 : :
1236 : : /**
1237 : : * nla_put_u32 - Add a u32 netlink attribute to a socket buffer
1238 : : * @skb: socket buffer to add attribute to
1239 : : * @attrtype: attribute type
1240 : : * @value: numeric value
1241 : : */
1242 : : static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
1243 : : {
1244 : 3 : u32 tmp = value;
1245 : :
1246 : 3 : return nla_put(skb, attrtype, sizeof(u32), &tmp);
1247 : : }
1248 : :
1249 : : /**
1250 : : * nla_put_be32 - Add a __be32 netlink attribute to a socket buffer
1251 : : * @skb: socket buffer to add attribute to
1252 : : * @attrtype: attribute type
1253 : : * @value: numeric value
1254 : : */
1255 : : static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value)
1256 : : {
1257 : 3 : __be32 tmp = value;
1258 : :
1259 : 3 : return nla_put(skb, attrtype, sizeof(__be32), &tmp);
1260 : : }
1261 : :
1262 : : /**
1263 : : * nla_put_net32 - Add 32-bit network byte order netlink attribute to a socket buffer
1264 : : * @skb: socket buffer to add attribute to
1265 : : * @attrtype: attribute type
1266 : : * @value: numeric value
1267 : : */
1268 : : static inline int nla_put_net32(struct sk_buff *skb, int attrtype, __be32 value)
1269 : : {
1270 : : __be32 tmp = value;
1271 : :
1272 : : return nla_put_be32(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
1273 : : }
1274 : :
1275 : : /**
1276 : : * nla_put_le32 - Add a __le32 netlink attribute to a socket buffer
1277 : : * @skb: socket buffer to add attribute to
1278 : : * @attrtype: attribute type
1279 : : * @value: numeric value
1280 : : */
1281 : : static inline int nla_put_le32(struct sk_buff *skb, int attrtype, __le32 value)
1282 : : {
1283 : : __le32 tmp = value;
1284 : :
1285 : : return nla_put(skb, attrtype, sizeof(__le32), &tmp);
1286 : : }
1287 : :
1288 : : /**
1289 : : * nla_put_u64_64bit - Add a u64 netlink attribute to a skb and align it
1290 : : * @skb: socket buffer to add attribute to
1291 : : * @attrtype: attribute type
1292 : : * @value: numeric value
1293 : : * @padattr: attribute type for the padding
1294 : : */
1295 : : static inline int nla_put_u64_64bit(struct sk_buff *skb, int attrtype,
1296 : : u64 value, int padattr)
1297 : : {
1298 : 0 : u64 tmp = value;
1299 : :
1300 : 0 : return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
1301 : : }
1302 : :
1303 : : /**
1304 : : * nla_put_be64 - Add a __be64 netlink attribute to a socket buffer and align it
1305 : : * @skb: socket buffer to add attribute to
1306 : : * @attrtype: attribute type
1307 : : * @value: numeric value
1308 : : * @padattr: attribute type for the padding
1309 : : */
1310 : : static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value,
1311 : : int padattr)
1312 : : {
1313 : 0 : __be64 tmp = value;
1314 : :
1315 : 0 : return nla_put_64bit(skb, attrtype, sizeof(__be64), &tmp, padattr);
1316 : : }
1317 : :
1318 : : /**
1319 : : * nla_put_net64 - Add 64-bit network byte order nlattr to a skb and align it
1320 : : * @skb: socket buffer to add attribute to
1321 : : * @attrtype: attribute type
1322 : : * @value: numeric value
1323 : : * @padattr: attribute type for the padding
1324 : : */
1325 : : static inline int nla_put_net64(struct sk_buff *skb, int attrtype, __be64 value,
1326 : : int padattr)
1327 : : {
1328 : : __be64 tmp = value;
1329 : :
1330 : : return nla_put_be64(skb, attrtype | NLA_F_NET_BYTEORDER, tmp,
1331 : : padattr);
1332 : : }
1333 : :
1334 : : /**
1335 : : * nla_put_le64 - Add a __le64 netlink attribute to a socket buffer and align it
1336 : : * @skb: socket buffer to add attribute to
1337 : : * @attrtype: attribute type
1338 : : * @value: numeric value
1339 : : * @padattr: attribute type for the padding
1340 : : */
1341 : : static inline int nla_put_le64(struct sk_buff *skb, int attrtype, __le64 value,
1342 : : int padattr)
1343 : : {
1344 : : __le64 tmp = value;
1345 : :
1346 : : return nla_put_64bit(skb, attrtype, sizeof(__le64), &tmp, padattr);
1347 : : }
1348 : :
1349 : : /**
1350 : : * nla_put_s8 - Add a s8 netlink attribute to a socket buffer
1351 : : * @skb: socket buffer to add attribute to
1352 : : * @attrtype: attribute type
1353 : : * @value: numeric value
1354 : : */
1355 : : static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value)
1356 : : {
1357 : 0 : s8 tmp = value;
1358 : :
1359 : 0 : return nla_put(skb, attrtype, sizeof(s8), &tmp);
1360 : : }
1361 : :
1362 : : /**
1363 : : * nla_put_s16 - Add a s16 netlink attribute to a socket buffer
1364 : : * @skb: socket buffer to add attribute to
1365 : : * @attrtype: attribute type
1366 : : * @value: numeric value
1367 : : */
1368 : : static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value)
1369 : : {
1370 : : s16 tmp = value;
1371 : :
1372 : : return nla_put(skb, attrtype, sizeof(s16), &tmp);
1373 : : }
1374 : :
1375 : : /**
1376 : : * nla_put_s32 - Add a s32 netlink attribute to a socket buffer
1377 : : * @skb: socket buffer to add attribute to
1378 : : * @attrtype: attribute type
1379 : : * @value: numeric value
1380 : : */
1381 : : static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value)
1382 : : {
1383 : 3 : s32 tmp = value;
1384 : :
1385 : 3 : return nla_put(skb, attrtype, sizeof(s32), &tmp);
1386 : : }
1387 : :
1388 : : /**
1389 : : * nla_put_s64 - Add a s64 netlink attribute to a socket buffer and align it
1390 : : * @skb: socket buffer to add attribute to
1391 : : * @attrtype: attribute type
1392 : : * @value: numeric value
1393 : : * @padattr: attribute type for the padding
1394 : : */
1395 : : static inline int nla_put_s64(struct sk_buff *skb, int attrtype, s64 value,
1396 : : int padattr)
1397 : : {
1398 : : s64 tmp = value;
1399 : :
1400 : : return nla_put_64bit(skb, attrtype, sizeof(s64), &tmp, padattr);
1401 : : }
1402 : :
1403 : : /**
1404 : : * nla_put_string - Add a string netlink attribute to a socket buffer
1405 : : * @skb: socket buffer to add attribute to
1406 : : * @attrtype: attribute type
1407 : : * @str: NUL terminated string
1408 : : */
1409 : 3 : static inline int nla_put_string(struct sk_buff *skb, int attrtype,
1410 : : const char *str)
1411 : : {
1412 : 3 : return nla_put(skb, attrtype, strlen(str) + 1, str);
1413 : : }
1414 : :
1415 : : /**
1416 : : * nla_put_flag - Add a flag netlink attribute to a socket buffer
1417 : : * @skb: socket buffer to add attribute to
1418 : : * @attrtype: attribute type
1419 : : */
1420 : : static inline int nla_put_flag(struct sk_buff *skb, int attrtype)
1421 : : {
1422 : 0 : return nla_put(skb, attrtype, 0, NULL);
1423 : : }
1424 : :
1425 : : /**
1426 : : * nla_put_msecs - Add a msecs netlink attribute to a skb and align it
1427 : : * @skb: socket buffer to add attribute to
1428 : : * @attrtype: attribute type
1429 : : * @njiffies: number of jiffies to convert to msecs
1430 : : * @padattr: attribute type for the padding
1431 : : */
1432 : 0 : static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
1433 : : unsigned long njiffies, int padattr)
1434 : : {
1435 : 0 : u64 tmp = jiffies_to_msecs(njiffies);
1436 : :
1437 : 0 : return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
1438 : : }
1439 : :
1440 : : /**
1441 : : * nla_put_in_addr - Add an IPv4 address netlink attribute to a socket
1442 : : * buffer
1443 : : * @skb: socket buffer to add attribute to
1444 : : * @attrtype: attribute type
1445 : : * @addr: IPv4 address
1446 : : */
1447 : : static inline int nla_put_in_addr(struct sk_buff *skb, int attrtype,
1448 : : __be32 addr)
1449 : : {
1450 : : __be32 tmp = addr;
1451 : :
1452 : : return nla_put_be32(skb, attrtype, tmp);
1453 : : }
1454 : :
1455 : : /**
1456 : : * nla_put_in6_addr - Add an IPv6 address netlink attribute to a socket
1457 : : * buffer
1458 : : * @skb: socket buffer to add attribute to
1459 : : * @attrtype: attribute type
1460 : : * @addr: IPv6 address
1461 : : */
1462 : : static inline int nla_put_in6_addr(struct sk_buff *skb, int attrtype,
1463 : : const struct in6_addr *addr)
1464 : : {
1465 : 3 : return nla_put(skb, attrtype, sizeof(*addr), addr);
1466 : : }
1467 : :
1468 : : /**
1469 : : * nla_get_u32 - return payload of u32 attribute
1470 : : * @nla: u32 netlink attribute
1471 : : */
1472 : : static inline u32 nla_get_u32(const struct nlattr *nla)
1473 : : {
1474 : 3 : return *(u32 *) nla_data(nla);
1475 : : }
1476 : :
1477 : : /**
1478 : : * nla_get_be32 - return payload of __be32 attribute
1479 : : * @nla: __be32 netlink attribute
1480 : : */
1481 : : static inline __be32 nla_get_be32(const struct nlattr *nla)
1482 : : {
1483 : 3 : return *(__be32 *) nla_data(nla);
1484 : : }
1485 : :
1486 : : /**
1487 : : * nla_get_le32 - return payload of __le32 attribute
1488 : : * @nla: __le32 netlink attribute
1489 : : */
1490 : : static inline __le32 nla_get_le32(const struct nlattr *nla)
1491 : : {
1492 : : return *(__le32 *) nla_data(nla);
1493 : : }
1494 : :
1495 : : /**
1496 : : * nla_get_u16 - return payload of u16 attribute
1497 : : * @nla: u16 netlink attribute
1498 : : */
1499 : : static inline u16 nla_get_u16(const struct nlattr *nla)
1500 : : {
1501 : 0 : return *(u16 *) nla_data(nla);
1502 : : }
1503 : :
1504 : : /**
1505 : : * nla_get_be16 - return payload of __be16 attribute
1506 : : * @nla: __be16 netlink attribute
1507 : : */
1508 : : static inline __be16 nla_get_be16(const struct nlattr *nla)
1509 : : {
1510 : 0 : return *(__be16 *) nla_data(nla);
1511 : : }
1512 : :
1513 : : /**
1514 : : * nla_get_le16 - return payload of __le16 attribute
1515 : : * @nla: __le16 netlink attribute
1516 : : */
1517 : : static inline __le16 nla_get_le16(const struct nlattr *nla)
1518 : : {
1519 : : return *(__le16 *) nla_data(nla);
1520 : : }
1521 : :
1522 : : /**
1523 : : * nla_get_u8 - return payload of u8 attribute
1524 : : * @nla: u8 netlink attribute
1525 : : */
1526 : : static inline u8 nla_get_u8(const struct nlattr *nla)
1527 : : {
1528 : 3 : return *(u8 *) nla_data(nla);
1529 : : }
1530 : :
1531 : : /**
1532 : : * nla_get_u64 - return payload of u64 attribute
1533 : : * @nla: u64 netlink attribute
1534 : : */
1535 : : static inline u64 nla_get_u64(const struct nlattr *nla)
1536 : : {
1537 : : u64 tmp;
1538 : :
1539 : 0 : nla_memcpy(&tmp, nla, sizeof(tmp));
1540 : :
1541 : 0 : return tmp;
1542 : : }
1543 : :
1544 : : /**
1545 : : * nla_get_be64 - return payload of __be64 attribute
1546 : : * @nla: __be64 netlink attribute
1547 : : */
1548 : : static inline __be64 nla_get_be64(const struct nlattr *nla)
1549 : : {
1550 : : __be64 tmp;
1551 : :
1552 : 0 : nla_memcpy(&tmp, nla, sizeof(tmp));
1553 : :
1554 : 0 : return tmp;
1555 : : }
1556 : :
1557 : : /**
1558 : : * nla_get_le64 - return payload of __le64 attribute
1559 : : * @nla: __le64 netlink attribute
1560 : : */
1561 : : static inline __le64 nla_get_le64(const struct nlattr *nla)
1562 : : {
1563 : : return *(__le64 *) nla_data(nla);
1564 : : }
1565 : :
1566 : : /**
1567 : : * nla_get_s32 - return payload of s32 attribute
1568 : : * @nla: s32 netlink attribute
1569 : : */
1570 : : static inline s32 nla_get_s32(const struct nlattr *nla)
1571 : : {
1572 : 0 : return *(s32 *) nla_data(nla);
1573 : : }
1574 : :
1575 : : /**
1576 : : * nla_get_s16 - return payload of s16 attribute
1577 : : * @nla: s16 netlink attribute
1578 : : */
1579 : : static inline s16 nla_get_s16(const struct nlattr *nla)
1580 : : {
1581 : 0 : return *(s16 *) nla_data(nla);
1582 : : }
1583 : :
1584 : : /**
1585 : : * nla_get_s8 - return payload of s8 attribute
1586 : : * @nla: s8 netlink attribute
1587 : : */
1588 : : static inline s8 nla_get_s8(const struct nlattr *nla)
1589 : : {
1590 : 0 : return *(s8 *) nla_data(nla);
1591 : : }
1592 : :
1593 : : /**
1594 : : * nla_get_s64 - return payload of s64 attribute
1595 : : * @nla: s64 netlink attribute
1596 : : */
1597 : : static inline s64 nla_get_s64(const struct nlattr *nla)
1598 : : {
1599 : : s64 tmp;
1600 : :
1601 : 0 : nla_memcpy(&tmp, nla, sizeof(tmp));
1602 : :
1603 : 0 : return tmp;
1604 : : }
1605 : :
1606 : : /**
1607 : : * nla_get_flag - return payload of flag attribute
1608 : : * @nla: flag netlink attribute
1609 : : */
1610 : : static inline int nla_get_flag(const struct nlattr *nla)
1611 : : {
1612 : 0 : return !!nla;
1613 : : }
1614 : :
1615 : : /**
1616 : : * nla_get_msecs - return payload of msecs attribute
1617 : : * @nla: msecs netlink attribute
1618 : : *
1619 : : * Returns the number of milliseconds in jiffies.
1620 : : */
1621 : 0 : static inline unsigned long nla_get_msecs(const struct nlattr *nla)
1622 : : {
1623 : : u64 msecs = nla_get_u64(nla);
1624 : :
1625 : 0 : return msecs_to_jiffies((unsigned long) msecs);
1626 : : }
1627 : :
1628 : : /**
1629 : : * nla_get_in_addr - return payload of IPv4 address attribute
1630 : : * @nla: IPv4 address netlink attribute
1631 : : */
1632 : : static inline __be32 nla_get_in_addr(const struct nlattr *nla)
1633 : : {
1634 : 3 : return *(__be32 *) nla_data(nla);
1635 : : }
1636 : :
1637 : : /**
1638 : : * nla_get_in6_addr - return payload of IPv6 address attribute
1639 : : * @nla: IPv6 address netlink attribute
1640 : : */
1641 : 1 : static inline struct in6_addr nla_get_in6_addr(const struct nlattr *nla)
1642 : : {
1643 : : struct in6_addr tmp;
1644 : :
1645 : 1 : nla_memcpy(&tmp, nla, sizeof(tmp));
1646 : 1 : return tmp;
1647 : : }
1648 : :
1649 : : /**
1650 : : * nla_get_bitfield32 - return payload of 32 bitfield attribute
1651 : : * @nla: nla_bitfield32 attribute
1652 : : */
1653 : : static inline struct nla_bitfield32 nla_get_bitfield32(const struct nlattr *nla)
1654 : : {
1655 : : struct nla_bitfield32 tmp;
1656 : :
1657 : 0 : nla_memcpy(&tmp, nla, sizeof(tmp));
1658 : 0 : return tmp;
1659 : : }
1660 : :
1661 : : /**
1662 : : * nla_memdup - duplicate attribute memory (kmemdup)
1663 : : * @src: netlink attribute to duplicate from
1664 : : * @gfp: GFP mask
1665 : : */
1666 : : static inline void *nla_memdup(const struct nlattr *src, gfp_t gfp)
1667 : : {
1668 : 0 : return kmemdup(nla_data(src), nla_len(src), gfp);
1669 : : }
1670 : :
1671 : : /**
1672 : : * nla_nest_start_noflag - Start a new level of nested attributes
1673 : : * @skb: socket buffer to add attributes to
1674 : : * @attrtype: attribute type of container
1675 : : *
1676 : : * This function exists for backward compatibility to use in APIs which never
1677 : : * marked their nest attributes with NLA_F_NESTED flag. New APIs should use
1678 : : * nla_nest_start() which sets the flag.
1679 : : *
1680 : : * Returns the container attribute or NULL on error
1681 : : */
1682 : : static inline struct nlattr *nla_nest_start_noflag(struct sk_buff *skb,
1683 : : int attrtype)
1684 : : {
1685 : : struct nlattr *start = (struct nlattr *)skb_tail_pointer(skb);
1686 : :
1687 : 3 : if (nla_put(skb, attrtype, 0, NULL) < 0)
1688 : : return NULL;
1689 : :
1690 : : return start;
1691 : : }
1692 : :
1693 : : /**
1694 : : * nla_nest_start - Start a new level of nested attributes, with NLA_F_NESTED
1695 : : * @skb: socket buffer to add attributes to
1696 : : * @attrtype: attribute type of container
1697 : : *
1698 : : * Unlike nla_nest_start_noflag(), mark the nest attribute with NLA_F_NESTED
1699 : : * flag. This is the preferred function to use in new code.
1700 : : *
1701 : : * Returns the container attribute or NULL on error
1702 : : */
1703 : 0 : static inline struct nlattr *nla_nest_start(struct sk_buff *skb, int attrtype)
1704 : : {
1705 : 0 : return nla_nest_start_noflag(skb, attrtype | NLA_F_NESTED);
1706 : : }
1707 : :
1708 : : /**
1709 : : * nla_nest_end - Finalize nesting of attributes
1710 : : * @skb: socket buffer the attributes are stored in
1711 : : * @start: container attribute
1712 : : *
1713 : : * Corrects the container attribute header to include the all
1714 : : * appeneded attributes.
1715 : : *
1716 : : * Returns the total data length of the skb.
1717 : : */
1718 : : static inline int nla_nest_end(struct sk_buff *skb, struct nlattr *start)
1719 : : {
1720 : 3 : start->nla_len = skb_tail_pointer(skb) - (unsigned char *)start;
1721 : 0 : return skb->len;
1722 : : }
1723 : :
1724 : : /**
1725 : : * nla_nest_cancel - Cancel nesting of attributes
1726 : : * @skb: socket buffer the message is stored in
1727 : : * @start: container attribute
1728 : : *
1729 : : * Removes the container attribute and including all nested
1730 : : * attributes. Returns -EMSGSIZE
1731 : : */
1732 : : static inline void nla_nest_cancel(struct sk_buff *skb, struct nlattr *start)
1733 : : {
1734 : 1 : nlmsg_trim(skb, start);
1735 : : }
1736 : :
1737 : : /**
1738 : : * nla_validate_nested - Validate a stream of nested attributes
1739 : : * @start: container attribute
1740 : : * @maxtype: maximum attribute type to be expected
1741 : : * @policy: validation policy
1742 : : * @validate: validation strictness
1743 : : * @extack: extended ACK report struct
1744 : : *
1745 : : * Validates all attributes in the nested attribute stream against the
1746 : : * specified policy. Attributes with a type exceeding maxtype will be
1747 : : * ignored. See documenation of struct nla_policy for more details.
1748 : : *
1749 : : * Returns 0 on success or a negative error code.
1750 : : */
1751 : : static inline int __nla_validate_nested(const struct nlattr *start, int maxtype,
1752 : : const struct nla_policy *policy,
1753 : : unsigned int validate,
1754 : : struct netlink_ext_ack *extack)
1755 : : {
1756 : 0 : return __nla_validate(nla_data(start), nla_len(start), maxtype, policy,
1757 : : validate, extack);
1758 : : }
1759 : :
1760 : : static inline int
1761 : : nl80211_validate_nested(const struct nlattr *start, int maxtype,
1762 : : const struct nla_policy *policy,
1763 : : struct netlink_ext_ack *extack)
1764 : : {
1765 : : return __nla_validate_nested(start, maxtype, policy,
1766 : : NL_VALIDATE_STRICT, extack);
1767 : : }
1768 : :
1769 : : static inline int
1770 : : nla_validate_nested_deprecated(const struct nlattr *start, int maxtype,
1771 : : const struct nla_policy *policy,
1772 : : struct netlink_ext_ack *extack)
1773 : : {
1774 : : return __nla_validate_nested(start, maxtype, policy,
1775 : : NL_VALIDATE_LIBERAL, extack);
1776 : : }
1777 : :
1778 : : /**
1779 : : * nla_need_padding_for_64bit - test 64-bit alignment of the next attribute
1780 : : * @skb: socket buffer the message is stored in
1781 : : *
1782 : : * Return true if padding is needed to align the next attribute (nla_data()) to
1783 : : * a 64-bit aligned area.
1784 : : */
1785 : : static inline bool nla_need_padding_for_64bit(struct sk_buff *skb)
1786 : : {
1787 : : #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1788 : : /* The nlattr header is 4 bytes in size, that's why we test
1789 : : * if the skb->data _is_ aligned. A NOP attribute, plus
1790 : : * nlattr header for next attribute, will make nla_data()
1791 : : * 8-byte aligned.
1792 : : */
1793 : : if (IS_ALIGNED((unsigned long)skb_tail_pointer(skb), 8))
1794 : : return true;
1795 : : #endif
1796 : : return false;
1797 : : }
1798 : :
1799 : : /**
1800 : : * nla_align_64bit - 64-bit align the nla_data() of next attribute
1801 : : * @skb: socket buffer the message is stored in
1802 : : * @padattr: attribute type for the padding
1803 : : *
1804 : : * Conditionally emit a padding netlink attribute in order to make
1805 : : * the next attribute we emit have a 64-bit aligned nla_data() area.
1806 : : * This will only be done in architectures which do not have
1807 : : * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS defined.
1808 : : *
1809 : : * Returns zero on success or a negative error code.
1810 : : */
1811 : : static inline int nla_align_64bit(struct sk_buff *skb, int padattr)
1812 : : {
1813 : : if (nla_need_padding_for_64bit(skb) &&
1814 : : !nla_reserve(skb, padattr, 0))
1815 : : return -EMSGSIZE;
1816 : :
1817 : : return 0;
1818 : : }
1819 : :
1820 : : /**
1821 : : * nla_total_size_64bit - total length of attribute including padding
1822 : : * @payload: length of payload
1823 : : */
1824 : : static inline int nla_total_size_64bit(int payload)
1825 : : {
1826 : 0 : return NLA_ALIGN(nla_attr_size(payload))
1827 : : #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1828 : : + NLA_ALIGN(nla_attr_size(0))
1829 : : #endif
1830 : : ;
1831 : : }
1832 : :
1833 : : /**
1834 : : * nla_for_each_attr - iterate over a stream of attributes
1835 : : * @pos: loop counter, set to current attribute
1836 : : * @head: head of attribute stream
1837 : : * @len: length of attribute stream
1838 : : * @rem: initialized to len, holds bytes currently remaining in stream
1839 : : */
1840 : : #define nla_for_each_attr(pos, head, len, rem) \
1841 : : for (pos = head, rem = len; \
1842 : : nla_ok(pos, rem); \
1843 : : pos = nla_next(pos, &(rem)))
1844 : :
1845 : : /**
1846 : : * nla_for_each_nested - iterate over nested attributes
1847 : : * @pos: loop counter, set to current attribute
1848 : : * @nla: attribute containing the nested attributes
1849 : : * @rem: initialized to len, holds bytes currently remaining in stream
1850 : : */
1851 : : #define nla_for_each_nested(pos, nla, rem) \
1852 : : nla_for_each_attr(pos, nla_data(nla), nla_len(nla), rem)
1853 : :
1854 : : /**
1855 : : * nla_is_last - Test if attribute is last in stream
1856 : : * @nla: attribute to test
1857 : : * @rem: bytes remaining in stream
1858 : : */
1859 : : static inline bool nla_is_last(const struct nlattr *nla, int rem)
1860 : : {
1861 : : return nla->nla_len == rem;
1862 : : }
1863 : :
1864 : : #endif
|
