blob: 67c57d6942e34c391673f24a5bbf37e44adf50f0 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001/* SPDX-License-Identifier: GPL-2.0 */
Thomas Grafbfa83a92005-11-10 02:25:51 +01002#ifndef __NET_NETLINK_H
3#define __NET_NETLINK_H
4
5#include <linux/types.h>
6#include <linux/netlink.h>
Al Virod7fe0f22006-12-03 23:15:30 -05007#include <linux/jiffies.h>
Jiri Benc930345e2015-03-29 16:59:25 +02008#include <linux/in6.h>
Thomas Grafbfa83a92005-11-10 02:25:51 +01009
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()
Justin P. Mattock1dc8d8c2010-06-21 13:45:42 -070040 * nlmsg_end() finalize netlink message
Thomas Graffe4944e2006-08-04 23:03:05 -070041 * nlmsg_get_pos() return current position in message
42 * nlmsg_trim() trim part of message
Thomas Grafbfa83a92005-11-10 02:25:51 +010043 * 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
Thomas Grafd387f6a2006-08-15 00:31:06 -070049 * nlmsg_notify() send notification message
Thomas Grafbfa83a92005-11-10 02:25:51 +010050 *
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 *
Thomas Graf97676b62006-08-15 00:31:41 -070071 * Misc:
72 * nlmsg_report() report back to application?
73 *
Thomas Grafbfa83a92005-11-10 02:25:51 +010074 * ------------------------------------------------------------------------
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:
Pierre Ynardd1ec3b72007-10-10 21:09:48 -070089 * struct nlattr netlink attribute header
Thomas Grafbfa83a92005-11-10 02:25:51 +010090 *
91 * Attribute Construction:
Thomas Graffe4944e2006-08-04 23:03:05 -070092 * nla_reserve(skb, type, len) reserve room for an attribute
93 * nla_reserve_nohdr(skb, len) reserve room for an attribute w/o hdr
Thomas Grafbfa83a92005-11-10 02:25:51 +010094 * nla_put(skb, type, len, data) add attribute to skb
Thomas Graffe4944e2006-08-04 23:03:05 -070095 * nla_put_nohdr(skb, len, data) add attribute w/o hdr
Patrick McHardy01480e12008-01-22 22:10:59 -080096 * nla_append(skb, len, data) append data to skb
Thomas Grafbfa83a92005-11-10 02:25:51 +010097 *
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
Rolf Eike Beer26837012017-07-13 16:46:43 +0200102 * nla_put_u64_64bit(skb, type,
103 * value, padattr) add u64 attribute to skb
Jiri Pirko4778e0b2012-07-27 06:28:52 +0000104 * 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
Nicolas Dichtel756a2f52016-04-22 17:31:20 +0200107 * nla_put_s64(skb, type, value,
108 * padattr) add s64 attribute to skb
Thomas Grafbfa83a92005-11-10 02:25:51 +0100109 * nla_put_string(skb, type, str) add string attribute to skb
110 * nla_put_flag(skb, type) add flag attribute to skb
Nicolas Dichtel2175d872016-04-22 17:31:21 +0200111 * nla_put_msecs(skb, type, jiffies,
112 * padattr) add msecs attribute to skb
Jiri Benc930345e2015-03-29 16:59:25 +0200113 * 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
Thomas Grafbfa83a92005-11-10 02:25:51 +0100115 *
Thomas Grafbfa83a92005-11-10 02:25:51 +0100116 * 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
Jiri Pirko4778e0b2012-07-27 06:28:52 +0000135 * 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
Thomas Grafbfa83a92005-11-10 02:25:51 +0100139 * 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
Paul Moore4fe5d5c2006-09-25 15:54:03 -0700152 * nla_validate_nested() validate a stream of nested attributes
Thomas Grafbfa83a92005-11-10 02:25:51 +0100153 * nla_find() find attribute in stream of attributes
Thomas Graffe4944e2006-08-04 23:03:05 -0700154 * nla_find_nested() find attribute in nested attributes
Thomas Grafbfa83a92005-11-10 02:25:51 +0100155 * nla_parse() parse and validate stream of attrs
Johannes Berg43955a42018-09-26 22:19:42 +0200156 * nla_parse_nested() parse nested attributes
Thomas Grafbfa83a92005-11-10 02:25:51 +0100157 * nla_for_each_attr() loop over all attributes
Paul Moore22acb192006-09-25 15:53:37 -0700158 * nla_for_each_nested() loop over the nested attributes
Thomas Grafbfa83a92005-11-10 02:25:51 +0100159 *=========================================================================
160 */
161
162 /**
163 * Standard attribute types to specify validation policy
164 */
165enum {
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,
Johannes Berg1501d132018-09-26 11:15:34 +0200175 NLA_NESTED_ARRAY,
Thomas Grafa5531a52006-08-26 20:11:47 -0700176 NLA_NUL_STRING,
Johannes Bergd30045a2007-03-23 11:37:48 -0700177 NLA_BINARY,
Jiri Pirko4778e0b2012-07-27 06:28:52 +0000178 NLA_S8,
179 NLA_S16,
180 NLA_S32,
181 NLA_S64,
Jamal Hadi Salim64c83d82017-07-30 13:24:49 -0400182 NLA_BITFIELD32,
Johannes Berg568b7422018-09-17 11:57:28 +0200183 NLA_REJECT,
Johannes Bergb60b87f2018-09-17 11:57:29 +0200184 NLA_EXACT_LEN,
185 NLA_EXACT_LEN_WARN,
Johannes Berg6f455f52019-04-26 14:07:27 +0200186 NLA_MIN_LEN,
Thomas Grafbfa83a92005-11-10 02:25:51 +0100187 __NLA_TYPE_MAX,
188};
189
190#define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
191
Johannes Berg3e48be02018-09-27 11:28:35 +0200192enum nla_policy_validation {
193 NLA_VALIDATE_NONE,
194 NLA_VALIDATE_RANGE,
195 NLA_VALIDATE_MIN,
196 NLA_VALIDATE_MAX,
Johannes Berg33188bd2018-09-27 11:28:36 +0200197 NLA_VALIDATE_FUNCTION,
Johannes Berg3e48be02018-09-27 11:28:35 +0200198};
199
Thomas Grafbfa83a92005-11-10 02:25:51 +0100200/**
201 * struct nla_policy - attribute validation policy
202 * @type: Type of attribute or NLA_UNSPEC
Johannes Berg3e48be02018-09-27 11:28:35 +0200203 * @validation_type: type of attribute validation done in addition to
Johannes Berg33188bd2018-09-27 11:28:36 +0200204 * type-specific validation (e.g. range, function call), see
Johannes Berg3e48be02018-09-27 11:28:35 +0200205 * &enum nla_policy_validation
Thomas Grafa5531a52006-08-26 20:11:47 -0700206 * @len: Type specific length of payload
Thomas Grafbfa83a92005-11-10 02:25:51 +0100207 *
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 *
Thomas Grafa5531a52006-08-26 20:11:47 -0700211 * 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
Johannes Bergd30045a2007-03-23 11:37:48 -0700215 * NLA_BINARY Maximum length of attribute payload
Johannes Berg6f455f52019-04-26 14:07:27 +0200216 * NLA_MIN_LEN Minimum length of attribute payload
Johannes Berg1501d132018-09-26 11:15:34 +0200217 * NLA_NESTED,
218 * NLA_NESTED_ARRAY Length verification is done by checking len of
Johannes Berg9a659a352018-09-26 11:15:33 +0200219 * 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.
Johannes Berg4b6cc722011-11-03 00:10:05 +0000222 * NLA_U8, NLA_U16,
223 * NLA_U32, NLA_U64,
Jiri Pirko4778e0b2012-07-27 06:28:52 +0000224 * NLA_S8, NLA_S16,
225 * NLA_S32, NLA_S64,
Johannes Berg4b6cc722011-11-03 00:10:05 +0000226 * NLA_MSECS Leaving the length field zero will verify the
227 * given type fits, using it verifies minimum length
228 * just like "All other"
Johannes Berg568b7422018-09-17 11:57:28 +0200229 * NLA_BITFIELD32 Unused
230 * NLA_REJECT Unused
Johannes Bergb60b87f2018-09-17 11:57:29 +0200231 * 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.
Johannes Berg6f455f52019-04-26 14:07:27 +0200235 * NLA_MIN_LEN Minimum length of attribute payload
Johannes Berg4b6cc722011-11-03 00:10:05 +0000236 * All other Minimum length of attribute payload
Thomas Grafa5531a52006-08-26 20:11:47 -0700237 *
Johannes Berg568b7422018-09-17 11:57:28 +0200238 * 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.
Johannes Berg9a659a352018-09-26 11:15:33 +0200245 * 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.
Johannes Berg1501d132018-09-26 11:15:34 +0200249 * 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.
Johannes Berg3e48be02018-09-27 11:28:35 +0200255 * 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
Johannes Berg568b7422018-09-17 11:57:28 +0200275 *
Johannes Berg33188bd2018-09-27 11:28:36 +0200276 * 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 *
Thomas Grafbfa83a92005-11-10 02:25:51 +0100283 * Example:
Alexey Dobriyanb54452b2010-02-18 08:14:31 +0000284 * static const struct nla_policy my_policy[ATTR_MAX+1] = {
Thomas Grafbfa83a92005-11-10 02:25:51 +0100285 * [ATTR_FOO] = { .type = NLA_U16 },
Johannes Bergd30045a2007-03-23 11:37:48 -0700286 * [ATTR_BAR] = { .type = NLA_STRING, .len = BARSIZ },
Johannes Berg6f455f52019-04-26 14:07:27 +0200287 * [ATTR_BAZ] = { .type = NLA_EXACT_LEN, .len = sizeof(struct mystruct) },
Jamal Hadi Salim64c83d82017-07-30 13:24:49 -0400288 * [ATTR_GOO] = { .type = NLA_BITFIELD32, .validation_data = &myvalidflags },
Thomas Grafbfa83a92005-11-10 02:25:51 +0100289 * };
290 */
291struct nla_policy {
Johannes Berg3e48be02018-09-27 11:28:35 +0200292 u8 type;
293 u8 validation_type;
Thomas Grafa5531a52006-08-26 20:11:47 -0700294 u16 len;
Johannes Berg3e48be02018-09-27 11:28:35 +0200295 union {
296 const void *validation_data;
297 struct {
298 s16 min, max;
299 };
Johannes Berg33188bd2018-09-27 11:28:36 +0200300 int (*validate)(const struct nlattr *attr,
301 struct netlink_ext_ack *extack);
Johannes Berg56738f42019-04-26 14:07:30 +0200302 /* 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;
Johannes Berg3e48be02018-09-27 11:28:35 +0200320 };
Thomas Grafbfa83a92005-11-10 02:25:51 +0100321};
322
Johannes Bergb60b87f2018-09-17 11:57:29 +0200323#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 }
Johannes Berg6f455f52019-04-26 14:07:27 +0200326#define NLA_POLICY_MIN_LEN(_len) { .type = NLA_MIN_LEN, .len = _len }
Johannes Bergb60b87f2018-09-17 11:57:29 +0200327
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
Johannes Berg23323282019-01-25 10:08:28 +0100331#define _NLA_POLICY_NESTED(maxattr, policy) \
Johannes Berg9a659a352018-09-26 11:15:33 +0200332 { .type = NLA_NESTED, .validation_data = policy, .len = maxattr }
Johannes Berg23323282019-01-25 10:08:28 +0100333#define _NLA_POLICY_NESTED_ARRAY(maxattr, policy) \
Johannes Berg1501d132018-09-26 11:15:34 +0200334 { .type = NLA_NESTED_ARRAY, .validation_data = policy, .len = maxattr }
Johannes Berg23323282019-01-25 10:08:28 +0100335#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)
Johannes Berg9a659a352018-09-26 11:15:33 +0200339
Johannes Berg5886d932018-10-12 12:53:00 +0200340#define __NLA_ENSURE(condition) BUILD_BUG_ON_ZERO(!(condition))
Johannes Berg3e48be02018-09-27 11:28:35 +0200341#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)
Johannes Berg33188bd2018-09-27 11:28:36 +0200346#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)
Johannes Berg3e48be02018-09-27 11:28:35 +0200351
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
Johannes Berg33188bd2018-09-27 11:28:36 +0200371#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
Thomas Graf4e902c52006-08-17 18:14:52 -0700378/**
379 * struct nl_info - netlink source information
380 * @nlh: Netlink message header of original request
Ido Schimmel3de205c2019-06-18 18:12:43 +0300381 * @nl_net: Network namespace
Eric W. Biederman15e47302012-09-07 20:12:54 +0000382 * @portid: Netlink PORTID of requesting application
Ido Schimmel3de205c2019-06-18 18:12:43 +0300383 * @skip_notify: Skip netlink notifications to user space
Ido Schimmelc82481f2019-06-18 18:12:44 +0300384 * @skip_notify_kernel: Skip selected in-kernel notifications
Thomas Graf4e902c52006-08-17 18:14:52 -0700385 */
386struct nl_info {
387 struct nlmsghdr *nlh;
Denis V. Lunev4d1169c2008-01-10 03:26:13 -0800388 struct net *nl_net;
Eric W. Biederman15e47302012-09-07 20:12:54 +0000389 u32 portid;
Ido Schimmelc82481f2019-06-18 18:12:44 +0300390 u8 skip_notify:1,
391 skip_notify_kernel:1;
Thomas Graf4e902c52006-08-17 18:14:52 -0700392};
393
Johannes Berg8cb08172019-04-26 14:07:28 +0200394/**
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.)
Michal Kubecekb424e432019-05-02 16:15:10 +0200408 * @NL_VALIDATE_NESTED: Check that NLA_F_NESTED is set for NLA_NESTED(_ARRAY)
409 * and unset for other policies.
Johannes Berg8cb08172019-04-26 14:07:28 +0200410 */
411enum 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),
Michal Kubecekb424e432019-05-02 16:15:10 +0200417 NL_VALIDATE_NESTED = BIT(4),
Johannes Berg8cb08172019-04-26 14:07:28 +0200418};
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 |\
Michal Kubecekb424e432019-05-02 16:15:10 +0200425 NL_VALIDATE_STRICT_ATTRS |\
426 NL_VALIDATE_NESTED)
Johannes Berg8cb08172019-04-26 14:07:28 +0200427
Joe Perches4f690532013-09-21 10:22:50 -0700428int netlink_rcv_skb(struct sk_buff *skb,
Johannes Berg2d4bc932017-04-12 14:34:04 +0200429 int (*cb)(struct sk_buff *, struct nlmsghdr *,
430 struct netlink_ext_ack *));
Joe Perches4f690532013-09-21 10:22:50 -0700431int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid,
432 unsigned int group, int report, gfp_t flags);
Thomas Graf82ace472005-11-10 02:25:53 +0100433
Johannes Berg8cb08172019-04-26 14:07:28 +0200434int __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);
437int __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);
Joe Perches4f690532013-09-21 10:22:50 -0700440int nla_policy_len(const struct nla_policy *, int);
441struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype);
442size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize);
Phil Sutter2cf0c8b2017-07-27 16:56:40 +0200443char *nla_strdup(const struct nlattr *nla, gfp_t flags);
Joe Perches4f690532013-09-21 10:22:50 -0700444int nla_memcpy(void *dest, const struct nlattr *src, int count);
445int nla_memcmp(const struct nlattr *nla, const void *data, size_t size);
446int nla_strcmp(const struct nlattr *nla, const char *str);
447struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
Nicolas Dichtel089bf1a2016-04-21 18:58:24 +0200448struct nlattr *__nla_reserve_64bit(struct sk_buff *skb, int attrtype,
449 int attrlen, int padattr);
Joe Perches4f690532013-09-21 10:22:50 -0700450void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
451struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
Nicolas Dichtel089bf1a2016-04-21 18:58:24 +0200452struct nlattr *nla_reserve_64bit(struct sk_buff *skb, int attrtype,
453 int attrlen, int padattr);
Joe Perches4f690532013-09-21 10:22:50 -0700454void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
455void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
456 const void *data);
Nicolas Dichtel089bf1a2016-04-21 18:58:24 +0200457void __nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
458 const void *data, int padattr);
Joe Perches4f690532013-09-21 10:22:50 -0700459void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
460int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
Nicolas Dichtel089bf1a2016-04-21 18:58:24 +0200461int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
462 const void *data, int padattr);
Joe Perches4f690532013-09-21 10:22:50 -0700463int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
464int nla_append(struct sk_buff *skb, int attrlen, const void *data);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100465
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 */
474static inline int nlmsg_msg_size(int payload)
475{
476 return NLMSG_HDRLEN + payload;
477}
478
479/**
480 * nlmsg_total_size - length of netlink message including padding
481 * @payload: length of message payload
482 */
483static inline int nlmsg_total_size(int payload)
484{
485 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 */
492static 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
Justin P. Mattock70f23fd2011-05-10 10:16:21 +0200499 * @nlh: netlink message header
Thomas Grafbfa83a92005-11-10 02:25:51 +0100500 */
501static inline void *nlmsg_data(const struct nlmsghdr *nlh)
502{
503 return (unsigned char *) nlh + NLMSG_HDRLEN;
504}
505
506/**
507 * nlmsg_len - length of message payload
508 * @nlh: netlink message header
509 */
510static inline int nlmsg_len(const struct nlmsghdr *nlh)
511{
512 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 */
520static inline struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh,
521 int hdrlen)
522{
523 unsigned char *data = nlmsg_data(nlh);
524 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 */
532static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
533{
534 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 */
542static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
543{
Vegard Nossum619e8032008-12-25 17:21:17 -0800544 return (remaining >= (int) sizeof(struct nlmsghdr) &&
Thomas Grafbfa83a92005-11-10 02:25:51 +0100545 nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
546 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 */
Jan Engelhardt36546542010-11-16 09:52:32 -0800557static inline struct nlmsghdr *
558nlmsg_next(const struct nlmsghdr *nlh, int *remaining)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100559{
560 int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
561
562 *remaining -= totlen;
563
564 return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
565}
566
567/**
Johannes Berg3de64402019-04-26 14:07:29 +0200568 * 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 */
583static 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/**
Johannes Berg8cb08172019-04-26 14:07:28 +0200593 * 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 */
608static 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 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 */
633static 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
Thomas Grafbfa83a92005-11-10 02:25:51 +0100645 * @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
Johannes Berg8cb08172019-04-26 14:07:28 +0200650 * @validate: validation strictness
Johannes Bergfceb6432017-04-12 14:34:07 +0200651 * @extack: extended ACK report struct
Thomas Grafbfa83a92005-11-10 02:25:51 +0100652 *
653 * See nla_parse()
654 */
Johannes Berg8cb08172019-04-26 14:07:28 +0200655static 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 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen)) {
662 NL_SET_ERR_MSG(extack, "Invalid header length");
663 return -EINVAL;
664 }
665
666 return __nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
667 nlmsg_attrlen(nlh, hdrlen), policy, validate,
668 extack);
669}
670
671/**
Johannes Berg3de64402019-04-26 14:07:29 +0200672 * 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 */
682static 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{
David Ahernd00ee642019-08-12 13:07:07 -0700687 return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
688 NL_VALIDATE_STRICT, extack);
Johannes Berg3de64402019-04-26 14:07:29 +0200689}
690
691/**
Johannes Berg8cb08172019-04-26 14:07:28 +0200692 * 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 */
701static 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 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 */
720static inline int
721nlmsg_parse_deprecated_strict(const struct nlmsghdr *nlh, int hdrlen,
Thomas Grafbfa83a92005-11-10 02:25:51 +0100722 struct nlattr *tb[], int maxtype,
Johannes Bergfceb6432017-04-12 14:34:07 +0200723 const struct nla_policy *policy,
724 struct netlink_ext_ack *extack)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100725{
Johannes Berg8cb08172019-04-26 14:07:28 +0200726 return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
727 NL_VALIDATE_DEPRECATED_STRICT, extack);
David Aherna5f6cba2018-10-07 20:16:25 -0700728}
729
Thomas Grafbfa83a92005-11-10 02:25:51 +0100730/**
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 */
Nelson Elhage6b8c92b2010-11-03 16:35:40 +0000738static inline struct nlattr *nlmsg_find_attr(const struct nlmsghdr *nlh,
Thomas Grafbfa83a92005-11-10 02:25:51 +0100739 int hdrlen, int attrtype)
740{
741 return nla_find(nlmsg_attrdata(nlh, hdrlen),
742 nlmsg_attrlen(nlh, hdrlen), attrtype);
743}
744
745/**
Johannes Berg8cb08172019-04-26 14:07:28 +0200746 * 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 */
760static 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
Johannes Berg3de64402019-04-26 14:07:29 +0200769/**
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 */
784static 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}
Johannes Berg8cb08172019-04-26 14:07:28 +0200791
792/**
793 * nlmsg_validate_deprecated - validate a netlink message including attributes
Thomas Grafbfa83a92005-11-10 02:25:51 +0100794 * @nlh: netlinket message header
795 * @hdrlen: length of familiy specific header
796 * @maxtype: maximum attribute type to be expected
797 * @policy: validation policy
Johannes Bergfceb6432017-04-12 14:34:07 +0200798 * @extack: extended ACK report struct
Thomas Grafbfa83a92005-11-10 02:25:51 +0100799 */
Johannes Berg8cb08172019-04-26 14:07:28 +0200800static 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)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100804{
805 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
806 return -EINVAL;
807
Johannes Berg8cb08172019-04-26 14:07:28 +0200808 return __nla_validate(nlmsg_attrdata(nlh, hdrlen),
809 nlmsg_attrlen(nlh, hdrlen), maxtype,
810 policy, NL_VALIDATE_LIBERAL, extack);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100811}
812
Johannes Berg8cb08172019-04-26 14:07:28 +0200813
814
Thomas Grafbfa83a92005-11-10 02:25:51 +0100815/**
Thomas Graf97676b62006-08-15 00:31:41 -0700816 * 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 */
Patrick McHardy3a6c2b42009-08-25 16:07:40 +0200821static inline int nlmsg_report(const struct nlmsghdr *nlh)
Thomas Graf97676b62006-08-15 00:31:41 -0700822{
823 return !!(nlh->nlmsg_flags & NLM_F_ECHO);
824}
825
826/**
Thomas Grafbfa83a92005-11-10 02:25:51 +0100827 * 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
Thomas Grafbfa83a92005-11-10 02:25:51 +0100837/**
838 * nlmsg_put - Add a new netlink message to an skb
839 * @skb: socket buffer to store message in
Nicolas Dichtel2c6ba4b2014-10-16 15:47:51 +0200840 * @portid: netlink PORTID of requesting application
Thomas Grafbfa83a92005-11-10 02:25:51 +0100841 * @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 */
Eric W. Biederman15e47302012-09-07 20:12:54 +0000849static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
Thomas Grafbfa83a92005-11-10 02:25:51 +0100850 int type, int payload, int flags)
851{
852 if (unlikely(skb_tailroom(skb) < nlmsg_total_size(payload)))
853 return NULL;
854
Eric W. Biederman15e47302012-09-07 20:12:54 +0000855 return __nlmsg_put(skb, portid, seq, type, payload, flags);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100856}
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 */
869static inline struct nlmsghdr *nlmsg_put_answer(struct sk_buff *skb,
870 struct netlink_callback *cb,
871 int type, int payload,
872 int flags)
873{
Eric W. Biederman15e47302012-09-07 20:12:54 +0000874 return nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
Thomas Grafbfa83a92005-11-10 02:25:51 +0100875 type, payload, flags);
876}
877
878/**
879 * nlmsg_new - Allocate a new netlink message
Thomas Graf339bf982006-11-10 14:10:15 -0800880 * @payload: size of the message payload
Thomas Graffe4944e2006-08-04 23:03:05 -0700881 * @flags: the type of memory to allocate.
Thomas Grafbfa83a92005-11-10 02:25:51 +0100882 *
Thomas Graf339bf982006-11-10 14:10:15 -0800883 * Use NLMSG_DEFAULT_SIZE if the size of the payload isn't known
884 * and a good default is needed.
Thomas Grafbfa83a92005-11-10 02:25:51 +0100885 */
Thomas Graf339bf982006-11-10 14:10:15 -0800886static inline struct sk_buff *nlmsg_new(size_t payload, gfp_t flags)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100887{
Thomas Graf339bf982006-11-10 14:10:15 -0800888 return alloc_skb(nlmsg_total_size(payload), flags);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100889}
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.
Thomas Grafbfa83a92005-11-10 02:25:51 +0100899 */
Johannes Berg053c0952015-01-16 22:09:00 +0100900static inline void nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100901{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700902 nlh->nlmsg_len = skb_tail_pointer(skb) - (unsigned char *)nlh;
Thomas Grafbfa83a92005-11-10 02:25:51 +0100903}
904
905/**
Thomas Graffe4944e2006-08-04 23:03:05 -0700906 * 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 */
911static inline void *nlmsg_get_pos(struct sk_buff *skb)
912{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700913 return skb_tail_pointer(skb);
Thomas Graffe4944e2006-08-04 23:03:05 -0700914}
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 *
Thomas Grafbc3ed282008-06-03 16:36:54 -0700921 * Trims the message to the provided mark.
Thomas Graffe4944e2006-08-04 23:03:05 -0700922 */
Thomas Grafbc3ed282008-06-03 16:36:54 -0700923static inline void nlmsg_trim(struct sk_buff *skb, const void *mark)
Thomas Graffe4944e2006-08-04 23:03:05 -0700924{
Thomas Graf149118d2015-01-06 01:04:21 +0100925 if (mark) {
926 WARN_ON((unsigned char *) mark < skb->data);
Thomas Graffe4944e2006-08-04 23:03:05 -0700927 skb_trim(skb, (unsigned char *) mark - skb->data);
Thomas Graf149118d2015-01-06 01:04:21 +0100928 }
Thomas Graffe4944e2006-08-04 23:03:05 -0700929}
930
931/**
Thomas Grafbfa83a92005-11-10 02:25:51 +0100932 * 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
Thomas Grafbc3ed282008-06-03 16:36:54 -0700937 * attributes from the socket buffer again.
Thomas Grafbfa83a92005-11-10 02:25:51 +0100938 */
Thomas Grafbc3ed282008-06-03 16:36:54 -0700939static inline void nlmsg_cancel(struct sk_buff *skb, struct nlmsghdr *nlh)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100940{
Thomas Grafbc3ed282008-06-03 16:36:54 -0700941 nlmsg_trim(skb, nlh);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100942}
943
944/**
945 * nlmsg_free - free a netlink message
946 * @skb: socket buffer of netlink message
947 */
948static inline void nlmsg_free(struct sk_buff *skb)
949{
950 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
Eric W. Biederman15e47302012-09-07 20:12:54 +0000957 * @portid: own netlink portid to avoid sending to yourself
Thomas Grafbfa83a92005-11-10 02:25:51 +0100958 * @group: multicast group id
Thomas Grafd387f6a2006-08-15 00:31:06 -0700959 * @flags: allocation flags
Thomas Grafbfa83a92005-11-10 02:25:51 +0100960 */
961static inline int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000962 u32 portid, unsigned int group, gfp_t flags)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100963{
964 int err;
965
966 NETLINK_CB(skb).dst_group = group;
967
Eric W. Biederman15e47302012-09-07 20:12:54 +0000968 err = netlink_broadcast(sk, skb, portid, group, flags);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100969 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
Eric W. Biederman15e47302012-09-07 20:12:54 +0000979 * @portid: netlink portid of the destination socket
Thomas Grafbfa83a92005-11-10 02:25:51 +0100980 */
Eric W. Biederman15e47302012-09-07 20:12:54 +0000981static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 portid)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100982{
983 int err;
984
Eric W. Biederman15e47302012-09-07 20:12:54 +0000985 err = netlink_unicast(sk, skb, portid, MSG_DONTWAIT);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100986 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
Johannes Berg670dc282011-06-20 13:40:46 +02001004/**
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 */
1019static inline void
1020nl_dump_check_consistent(struct netlink_callback *cb,
1021 struct nlmsghdr *nlh)
1022{
1023 if (cb->prev_seq && cb->seq != cb->prev_seq)
1024 nlh->nlmsg_flags |= NLM_F_DUMP_INTR;
1025 cb->prev_seq = cb->seq;
1026}
1027
Thomas Grafbfa83a92005-11-10 02:25:51 +01001028/**************************************************************************
1029 * Netlink Attributes
1030 **************************************************************************/
1031
1032/**
1033 * nla_attr_size - length of attribute not including padding
1034 * @payload: length of payload
1035 */
1036static inline int nla_attr_size(int payload)
1037{
1038 return NLA_HDRLEN + payload;
1039}
1040
1041/**
1042 * nla_total_size - total length of attribute including padding
1043 * @payload: length of payload
1044 */
1045static inline int nla_total_size(int payload)
1046{
1047 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 */
1054static inline int nla_padlen(int payload)
1055{
1056 return nla_total_size(payload) - nla_attr_size(payload);
1057}
1058
1059/**
Thomas Graf8f4c1f92007-09-12 14:44:36 +02001060 * nla_type - attribute type
1061 * @nla: netlink attribute
1062 */
1063static inline int nla_type(const struct nlattr *nla)
1064{
1065 return nla->nla_type & NLA_TYPE_MASK;
1066}
1067
1068/**
Thomas Grafbfa83a92005-11-10 02:25:51 +01001069 * nla_data - head of payload
1070 * @nla: netlink attribute
1071 */
1072static inline void *nla_data(const struct nlattr *nla)
1073{
1074 return (char *) nla + NLA_HDRLEN;
1075}
1076
1077/**
1078 * nla_len - length of payload
1079 * @nla: netlink attribute
1080 */
1081static inline int nla_len(const struct nlattr *nla)
1082{
1083 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 */
1091static inline int nla_ok(const struct nlattr *nla, int remaining)
1092{
Alexey Dobriyan3e1ed982016-12-13 22:30:15 +03001093 return remaining >= (int) sizeof(*nla) &&
1094 nla->nla_len >= sizeof(*nla) &&
Thomas Grafbfa83a92005-11-10 02:25:51 +01001095 nla->nla_len <= remaining;
1096}
1097
1098/**
Pierre Ynardd1ec3b72007-10-10 21:09:48 -07001099 * nla_next - next netlink attribute in attribute stream
Thomas Grafbfa83a92005-11-10 02:25:51 +01001100 * @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 */
1106static inline struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
1107{
Alexey Dobriyan3b2c75d32016-11-19 03:54:35 +03001108 unsigned int totlen = NLA_ALIGN(nla->nla_len);
Thomas Grafbfa83a92005-11-10 02:25:51 +01001109
1110 *remaining -= totlen;
1111 return (struct nlattr *) ((char *) nla + totlen);
1112}
1113
1114/**
Thomas Graffe4944e2006-08-04 23:03:05 -07001115 * 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 */
Jan Engelhardt36546542010-11-16 09:52:32 -08001121static inline struct nlattr *
1122nla_find_nested(const struct nlattr *nla, int attrtype)
Thomas Graffe4944e2006-08-04 23:03:05 -07001123{
1124 return nla_find(nla_data(nla), nla_len(nla), attrtype);
1125}
1126
1127/**
Johannes Berg3de64402019-04-26 14:07:29 +02001128 * 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 */
1137static 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{
Michal Kubecekb424e432019-05-02 16:15:10 +02001142 if (!(nla->nla_type & NLA_F_NESTED)) {
1143 NL_SET_ERR_MSG_ATTR(extack, nla, "NLA_F_NESTED is missing");
1144 return -EINVAL;
1145 }
1146
Johannes Berg3de64402019-04-26 14:07:29 +02001147 return __nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy,
1148 NL_VALIDATE_STRICT, extack);
1149}
1150
1151/**
Johannes Berg8cb08172019-04-26 14:07:28 +02001152 * nla_parse_nested_deprecated - parse nested attributes
Thomas Grafbfa83a92005-11-10 02:25:51 +01001153 * @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
Johannes Bergfceb6432017-04-12 14:34:07 +02001157 * @extack: extended ACK report struct
Thomas Grafbfa83a92005-11-10 02:25:51 +01001158 *
Johannes Berg8cb08172019-04-26 14:07:28 +02001159 * See nla_parse_deprecated()
Thomas Grafbfa83a92005-11-10 02:25:51 +01001160 */
Johannes Berg8cb08172019-04-26 14:07:28 +02001161static 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)
Thomas Grafbfa83a92005-11-10 02:25:51 +01001165{
Johannes Berg8cb08172019-04-26 14:07:28 +02001166 return __nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy,
1167 NL_VALIDATE_LIBERAL, extack);
Thomas Grafbfa83a92005-11-10 02:25:51 +01001168}
Patrick McHardy1092cb22007-06-25 13:49:35 -07001169
1170/**
Pierre Ynardd1ec3b72007-10-10 21:09:48 -07001171 * nla_put_u8 - Add a u8 netlink attribute to a socket buffer
Thomas Grafbfa83a92005-11-10 02:25:51 +01001172 * @skb: socket buffer to add attribute to
1173 * @attrtype: attribute type
1174 * @value: numeric value
1175 */
1176static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
1177{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001178 /* temporary variables to work around GCC PR81715 with asan-stack=1 */
1179 u8 tmp = value;
1180
1181 return nla_put(skb, attrtype, sizeof(u8), &tmp);
Thomas Grafbfa83a92005-11-10 02:25:51 +01001182}
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 */
1190static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
1191{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001192 u16 tmp = value;
1193
1194 return nla_put(skb, attrtype, sizeof(u16), &tmp);
Thomas Grafbfa83a92005-11-10 02:25:51 +01001195}
1196
1197/**
David S. Miller569a8fc2012-03-29 23:18:53 -04001198 * 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 */
1203static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value)
1204{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001205 __be16 tmp = value;
1206
1207 return nla_put(skb, attrtype, sizeof(__be16), &tmp);
David S. Miller569a8fc2012-03-29 23:18:53 -04001208}
1209
1210/**
David S. Miller6c1dd3b2012-04-01 19:11:31 -04001211 * 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 */
1216static inline int nla_put_net16(struct sk_buff *skb, int attrtype, __be16 value)
1217{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001218 __be16 tmp = value;
1219
1220 return nla_put_be16(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
David S. Miller6c1dd3b2012-04-01 19:11:31 -04001221}
1222
1223/**
David S. Miller24c410d2012-04-01 20:14:27 -04001224 * 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 */
1229static inline int nla_put_le16(struct sk_buff *skb, int attrtype, __le16 value)
1230{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001231 __le16 tmp = value;
1232
1233 return nla_put(skb, attrtype, sizeof(__le16), &tmp);
David S. Miller24c410d2012-04-01 20:14:27 -04001234}
1235
1236/**
Thomas Grafbfa83a92005-11-10 02:25:51 +01001237 * 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 */
1242static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
1243{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001244 u32 tmp = value;
1245
1246 return nla_put(skb, attrtype, sizeof(u32), &tmp);
Thomas Grafbfa83a92005-11-10 02:25:51 +01001247}
1248
1249/**
David S. Miller569a8fc2012-03-29 23:18:53 -04001250 * 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 */
1255static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value)
1256{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001257 __be32 tmp = value;
1258
1259 return nla_put(skb, attrtype, sizeof(__be32), &tmp);
David S. Miller569a8fc2012-03-29 23:18:53 -04001260}
1261
1262/**
David S. Miller6c1dd3b2012-04-01 19:11:31 -04001263 * 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 */
1268static inline int nla_put_net32(struct sk_buff *skb, int attrtype, __be32 value)
1269{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001270 __be32 tmp = value;
1271
1272 return nla_put_be32(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
David S. Miller6c1dd3b2012-04-01 19:11:31 -04001273}
1274
1275/**
David S. Miller24c410d2012-04-01 20:14:27 -04001276 * 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 */
1281static inline int nla_put_le32(struct sk_buff *skb, int attrtype, __le32 value)
1282{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001283 __le32 tmp = value;
1284
1285 return nla_put(skb, attrtype, sizeof(__le32), &tmp);
David S. Miller24c410d2012-04-01 20:14:27 -04001286}
1287
1288/**
Nicolas Dichtel73520782016-04-22 17:31:22 +02001289 * 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 */
1295static inline int nla_put_u64_64bit(struct sk_buff *skb, int attrtype,
1296 u64 value, int padattr)
1297{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001298 u64 tmp = value;
1299
1300 return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
Nicolas Dichtel73520782016-04-22 17:31:22 +02001301}
1302
1303/**
Nicolas Dichtelb46f6de2016-04-22 17:31:18 +02001304 * nla_put_be64 - Add a __be64 netlink attribute to a socket buffer and align it
David S. Miller569a8fc2012-03-29 23:18:53 -04001305 * @skb: socket buffer to add attribute to
1306 * @attrtype: attribute type
1307 * @value: numeric value
Nicolas Dichtelb46f6de2016-04-22 17:31:18 +02001308 * @padattr: attribute type for the padding
David S. Miller569a8fc2012-03-29 23:18:53 -04001309 */
Nicolas Dichtelb46f6de2016-04-22 17:31:18 +02001310static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value,
1311 int padattr)
1312{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001313 __be64 tmp = value;
1314
1315 return nla_put_64bit(skb, attrtype, sizeof(__be64), &tmp, padattr);
Nicolas Dichtelb46f6de2016-04-22 17:31:18 +02001316}
1317
David S. Miller569a8fc2012-03-29 23:18:53 -04001318/**
Nicolas Dichtele9bbe892016-04-22 17:31:19 +02001319 * nla_put_net64 - Add 64-bit network byte order nlattr to a skb and align it
David S. Miller6c1dd3b2012-04-01 19:11:31 -04001320 * @skb: socket buffer to add attribute to
1321 * @attrtype: attribute type
1322 * @value: numeric value
Nicolas Dichtele9bbe892016-04-22 17:31:19 +02001323 * @padattr: attribute type for the padding
David S. Miller6c1dd3b2012-04-01 19:11:31 -04001324 */
Nicolas Dichtele9bbe892016-04-22 17:31:19 +02001325static inline int nla_put_net64(struct sk_buff *skb, int attrtype, __be64 value,
1326 int padattr)
David S. Miller6c1dd3b2012-04-01 19:11:31 -04001327{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001328 __be64 tmp = value;
1329
1330 return nla_put_be64(skb, attrtype | NLA_F_NET_BYTEORDER, tmp,
Nicolas Dichtele9bbe892016-04-22 17:31:19 +02001331 padattr);
David S. Miller6c1dd3b2012-04-01 19:11:31 -04001332}
1333
1334/**
Nicolas Dichtele74791222016-04-22 17:31:17 +02001335 * nla_put_le64 - Add a __le64 netlink attribute to a socket buffer and align it
David S. Miller24c410d2012-04-01 20:14:27 -04001336 * @skb: socket buffer to add attribute to
1337 * @attrtype: attribute type
1338 * @value: numeric value
Nicolas Dichtele74791222016-04-22 17:31:17 +02001339 * @padattr: attribute type for the padding
David S. Miller24c410d2012-04-01 20:14:27 -04001340 */
Nicolas Dichtele74791222016-04-22 17:31:17 +02001341static inline int nla_put_le64(struct sk_buff *skb, int attrtype, __le64 value,
1342 int padattr)
David S. Miller24c410d2012-04-01 20:14:27 -04001343{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001344 __le64 tmp = value;
1345
1346 return nla_put_64bit(skb, attrtype, sizeof(__le64), &tmp, padattr);
David S. Miller24c410d2012-04-01 20:14:27 -04001347}
1348
1349/**
Jiri Pirko4778e0b2012-07-27 06:28:52 +00001350 * 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 */
1355static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value)
1356{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001357 s8 tmp = value;
1358
1359 return nla_put(skb, attrtype, sizeof(s8), &tmp);
Jiri Pirko4778e0b2012-07-27 06:28:52 +00001360}
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 */
1368static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value)
1369{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001370 s16 tmp = value;
1371
1372 return nla_put(skb, attrtype, sizeof(s16), &tmp);
Jiri Pirko4778e0b2012-07-27 06:28:52 +00001373}
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 */
1381static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value)
1382{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001383 s32 tmp = value;
1384
1385 return nla_put(skb, attrtype, sizeof(s32), &tmp);
Jiri Pirko4778e0b2012-07-27 06:28:52 +00001386}
1387
1388/**
Nicolas Dichtel756a2f52016-04-22 17:31:20 +02001389 * nla_put_s64 - Add a s64 netlink attribute to a socket buffer and align it
Jiri Pirko4778e0b2012-07-27 06:28:52 +00001390 * @skb: socket buffer to add attribute to
1391 * @attrtype: attribute type
1392 * @value: numeric value
Nicolas Dichtel756a2f52016-04-22 17:31:20 +02001393 * @padattr: attribute type for the padding
Jiri Pirko4778e0b2012-07-27 06:28:52 +00001394 */
Nicolas Dichtel756a2f52016-04-22 17:31:20 +02001395static inline int nla_put_s64(struct sk_buff *skb, int attrtype, s64 value,
1396 int padattr)
Jiri Pirko4778e0b2012-07-27 06:28:52 +00001397{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001398 s64 tmp = value;
1399
1400 return nla_put_64bit(skb, attrtype, sizeof(s64), &tmp, padattr);
Jiri Pirko4778e0b2012-07-27 06:28:52 +00001401}
1402
1403/**
Thomas Grafbfa83a92005-11-10 02:25:51 +01001404 * 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 */
1409static inline int nla_put_string(struct sk_buff *skb, int attrtype,
1410 const char *str)
1411{
1412 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 */
1420static inline int nla_put_flag(struct sk_buff *skb, int attrtype)
1421{
1422 return nla_put(skb, attrtype, 0, NULL);
1423}
1424
1425/**
Nicolas Dichtel2175d872016-04-22 17:31:21 +02001426 * nla_put_msecs - Add a msecs netlink attribute to a skb and align it
Thomas Grafbfa83a92005-11-10 02:25:51 +01001427 * @skb: socket buffer to add attribute to
1428 * @attrtype: attribute type
Mark Rustadd87de1f2014-07-25 02:18:17 -07001429 * @njiffies: number of jiffies to convert to msecs
Nicolas Dichtel2175d872016-04-22 17:31:21 +02001430 * @padattr: attribute type for the padding
Thomas Grafbfa83a92005-11-10 02:25:51 +01001431 */
1432static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
Nicolas Dichtel2175d872016-04-22 17:31:21 +02001433 unsigned long njiffies, int padattr)
Thomas Grafbfa83a92005-11-10 02:25:51 +01001434{
Mark Rustadd87de1f2014-07-25 02:18:17 -07001435 u64 tmp = jiffies_to_msecs(njiffies);
Nicolas Dichtel2175d872016-04-22 17:31:21 +02001436
1437 return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
Thomas Grafbfa83a92005-11-10 02:25:51 +01001438}
1439
Thomas Grafbfa83a92005-11-10 02:25:51 +01001440/**
Jiri Benc930345e2015-03-29 16:59:25 +02001441 * 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 */
1447static inline int nla_put_in_addr(struct sk_buff *skb, int attrtype,
1448 __be32 addr)
1449{
Arnd Bergmannb4391db2017-09-22 23:29:19 +02001450 __be32 tmp = addr;
1451
1452 return nla_put_be32(skb, attrtype, tmp);
Jiri Benc930345e2015-03-29 16:59:25 +02001453}
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 */
1462static inline int nla_put_in6_addr(struct sk_buff *skb, int attrtype,
1463 const struct in6_addr *addr)
1464{
1465 return nla_put(skb, attrtype, sizeof(*addr), addr);
1466}
1467
1468/**
Jiri Pirko8953b072020-03-28 16:37:42 +01001469 * nla_put_bitfield32 - Add a bitfield32 netlink attribute to a socket buffer
1470 * @skb: socket buffer to add attribute to
1471 * @attrtype: attribute type
1472 * @value: value carrying bits
1473 * @selector: selector of valid bits
1474 */
1475static inline int nla_put_bitfield32(struct sk_buff *skb, int attrtype,
1476 __u32 value, __u32 selector)
1477{
1478 struct nla_bitfield32 tmp = { value, selector, };
1479
1480 return nla_put(skb, attrtype, sizeof(tmp), &tmp);
1481}
1482
1483/**
Thomas Grafbfa83a92005-11-10 02:25:51 +01001484 * nla_get_u32 - return payload of u32 attribute
1485 * @nla: u32 netlink attribute
1486 */
Patrick McHardyb057efd2008-10-28 11:59:11 -07001487static inline u32 nla_get_u32(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +01001488{
1489 return *(u32 *) nla_data(nla);
1490}
1491
1492/**
Al Viro00012e52006-09-26 22:14:41 -07001493 * nla_get_be32 - return payload of __be32 attribute
1494 * @nla: __be32 netlink attribute
1495 */
Patrick McHardyb057efd2008-10-28 11:59:11 -07001496static inline __be32 nla_get_be32(const struct nlattr *nla)
Al Viro00012e52006-09-26 22:14:41 -07001497{
1498 return *(__be32 *) nla_data(nla);
1499}
1500
1501/**
Alexander Aringc648a012015-09-28 09:00:23 +02001502 * nla_get_le32 - return payload of __le32 attribute
1503 * @nla: __le32 netlink attribute
1504 */
1505static inline __le32 nla_get_le32(const struct nlattr *nla)
1506{
1507 return *(__le32 *) nla_data(nla);
1508}
1509
1510/**
Thomas Grafbfa83a92005-11-10 02:25:51 +01001511 * nla_get_u16 - return payload of u16 attribute
1512 * @nla: u16 netlink attribute
1513 */
Patrick McHardyb057efd2008-10-28 11:59:11 -07001514static inline u16 nla_get_u16(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +01001515{
1516 return *(u16 *) nla_data(nla);
1517}
1518
1519/**
Patrick McHardy838965b2007-12-17 22:29:26 -08001520 * nla_get_be16 - return payload of __be16 attribute
1521 * @nla: __be16 netlink attribute
1522 */
Patrick McHardyb057efd2008-10-28 11:59:11 -07001523static inline __be16 nla_get_be16(const struct nlattr *nla)
Patrick McHardy838965b2007-12-17 22:29:26 -08001524{
1525 return *(__be16 *) nla_data(nla);
1526}
1527
1528/**
Thomas Graf4a89c252006-11-24 17:14:51 -08001529 * nla_get_le16 - return payload of __le16 attribute
1530 * @nla: __le16 netlink attribute
1531 */
Patrick McHardyb057efd2008-10-28 11:59:11 -07001532static inline __le16 nla_get_le16(const struct nlattr *nla)
Thomas Graf4a89c252006-11-24 17:14:51 -08001533{
1534 return *(__le16 *) nla_data(nla);
1535}
1536
1537/**
Thomas Grafbfa83a92005-11-10 02:25:51 +01001538 * nla_get_u8 - return payload of u8 attribute
1539 * @nla: u8 netlink attribute
1540 */
Patrick McHardyb057efd2008-10-28 11:59:11 -07001541static inline u8 nla_get_u8(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +01001542{
1543 return *(u8 *) nla_data(nla);
1544}
1545
1546/**
1547 * nla_get_u64 - return payload of u64 attribute
1548 * @nla: u64 netlink attribute
1549 */
Patrick McHardyb057efd2008-10-28 11:59:11 -07001550static inline u64 nla_get_u64(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +01001551{
1552 u64 tmp;
1553
1554 nla_memcpy(&tmp, nla, sizeof(tmp));
1555
1556 return tmp;
1557}
1558
1559/**
Pablo Neira Ayusoa17c8592009-05-27 17:50:35 +02001560 * nla_get_be64 - return payload of __be64 attribute
1561 * @nla: __be64 netlink attribute
1562 */
1563static inline __be64 nla_get_be64(const struct nlattr *nla)
1564{
Pablo Neira Ayusof5d410f2010-03-16 13:30:44 +00001565 __be64 tmp;
1566
1567 nla_memcpy(&tmp, nla, sizeof(tmp));
1568
1569 return tmp;
Pablo Neira Ayusoa17c8592009-05-27 17:50:35 +02001570}
1571
1572/**
Alexander Aringc648a012015-09-28 09:00:23 +02001573 * nla_get_le64 - return payload of __le64 attribute
1574 * @nla: __le64 netlink attribute
1575 */
1576static inline __le64 nla_get_le64(const struct nlattr *nla)
1577{
1578 return *(__le64 *) nla_data(nla);
1579}
1580
1581/**
Jiri Pirko4778e0b2012-07-27 06:28:52 +00001582 * nla_get_s32 - return payload of s32 attribute
1583 * @nla: s32 netlink attribute
1584 */
1585static inline s32 nla_get_s32(const struct nlattr *nla)
1586{
1587 return *(s32 *) nla_data(nla);
1588}
1589
1590/**
1591 * nla_get_s16 - return payload of s16 attribute
1592 * @nla: s16 netlink attribute
1593 */
1594static inline s16 nla_get_s16(const struct nlattr *nla)
1595{
1596 return *(s16 *) nla_data(nla);
1597}
1598
1599/**
1600 * nla_get_s8 - return payload of s8 attribute
1601 * @nla: s8 netlink attribute
1602 */
1603static inline s8 nla_get_s8(const struct nlattr *nla)
1604{
1605 return *(s8 *) nla_data(nla);
1606}
1607
1608/**
1609 * nla_get_s64 - return payload of s64 attribute
1610 * @nla: s64 netlink attribute
1611 */
1612static inline s64 nla_get_s64(const struct nlattr *nla)
1613{
1614 s64 tmp;
1615
1616 nla_memcpy(&tmp, nla, sizeof(tmp));
1617
1618 return tmp;
1619}
1620
1621/**
Thomas Grafbfa83a92005-11-10 02:25:51 +01001622 * nla_get_flag - return payload of flag attribute
1623 * @nla: flag netlink attribute
1624 */
Patrick McHardyb057efd2008-10-28 11:59:11 -07001625static inline int nla_get_flag(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +01001626{
1627 return !!nla;
1628}
1629
1630/**
1631 * nla_get_msecs - return payload of msecs attribute
1632 * @nla: msecs netlink attribute
1633 *
1634 * Returns the number of milliseconds in jiffies.
1635 */
Patrick McHardyb057efd2008-10-28 11:59:11 -07001636static inline unsigned long nla_get_msecs(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +01001637{
1638 u64 msecs = nla_get_u64(nla);
1639
1640 return msecs_to_jiffies((unsigned long) msecs);
1641}
1642
1643/**
Jiri Benc67b61f62015-03-29 16:59:26 +02001644 * nla_get_in_addr - return payload of IPv4 address attribute
1645 * @nla: IPv4 address netlink attribute
1646 */
1647static inline __be32 nla_get_in_addr(const struct nlattr *nla)
1648{
1649 return *(__be32 *) nla_data(nla);
1650}
1651
1652/**
1653 * nla_get_in6_addr - return payload of IPv6 address attribute
1654 * @nla: IPv6 address netlink attribute
1655 */
1656static inline struct in6_addr nla_get_in6_addr(const struct nlattr *nla)
1657{
1658 struct in6_addr tmp;
1659
1660 nla_memcpy(&tmp, nla, sizeof(tmp));
1661 return tmp;
1662}
1663
1664/**
Jamal Hadi Salim64c83d82017-07-30 13:24:49 -04001665 * nla_get_bitfield32 - return payload of 32 bitfield attribute
1666 * @nla: nla_bitfield32 attribute
1667 */
1668static inline struct nla_bitfield32 nla_get_bitfield32(const struct nlattr *nla)
1669{
1670 struct nla_bitfield32 tmp;
1671
1672 nla_memcpy(&tmp, nla, sizeof(tmp));
1673 return tmp;
1674}
1675
1676/**
Thomas Grafb15ca182016-10-26 10:53:16 +02001677 * nla_memdup - duplicate attribute memory (kmemdup)
1678 * @src: netlink attribute to duplicate from
1679 * @gfp: GFP mask
1680 */
1681static inline void *nla_memdup(const struct nlattr *src, gfp_t gfp)
1682{
1683 return kmemdup(nla_data(src), nla_len(src), gfp);
1684}
1685
1686/**
Michal Kubecekae0be8d2019-04-26 11:13:06 +02001687 * nla_nest_start_noflag - Start a new level of nested attributes
Thomas Grafbfa83a92005-11-10 02:25:51 +01001688 * @skb: socket buffer to add attributes to
1689 * @attrtype: attribute type of container
1690 *
Michal Kubecekae0be8d2019-04-26 11:13:06 +02001691 * This function exists for backward compatibility to use in APIs which never
1692 * marked their nest attributes with NLA_F_NESTED flag. New APIs should use
1693 * nla_nest_start() which sets the flag.
1694 *
1695 * Returns the container attribute or NULL on error
Thomas Grafbfa83a92005-11-10 02:25:51 +01001696 */
Michal Kubecekae0be8d2019-04-26 11:13:06 +02001697static inline struct nlattr *nla_nest_start_noflag(struct sk_buff *skb,
1698 int attrtype)
Thomas Grafbfa83a92005-11-10 02:25:51 +01001699{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001700 struct nlattr *start = (struct nlattr *)skb_tail_pointer(skb);
Thomas Grafbfa83a92005-11-10 02:25:51 +01001701
1702 if (nla_put(skb, attrtype, 0, NULL) < 0)
1703 return NULL;
1704
1705 return start;
1706}
1707
1708/**
Michal Kubecekae0be8d2019-04-26 11:13:06 +02001709 * nla_nest_start - Start a new level of nested attributes, with NLA_F_NESTED
1710 * @skb: socket buffer to add attributes to
1711 * @attrtype: attribute type of container
1712 *
1713 * Unlike nla_nest_start_noflag(), mark the nest attribute with NLA_F_NESTED
1714 * flag. This is the preferred function to use in new code.
1715 *
1716 * Returns the container attribute or NULL on error
1717 */
1718static inline struct nlattr *nla_nest_start(struct sk_buff *skb, int attrtype)
1719{
1720 return nla_nest_start_noflag(skb, attrtype | NLA_F_NESTED);
1721}
1722
1723/**
Thomas Grafbfa83a92005-11-10 02:25:51 +01001724 * nla_nest_end - Finalize nesting of attributes
Pierre Ynardd1ec3b72007-10-10 21:09:48 -07001725 * @skb: socket buffer the attributes are stored in
Thomas Grafbfa83a92005-11-10 02:25:51 +01001726 * @start: container attribute
1727 *
1728 * Corrects the container attribute header to include the all
1729 * appeneded attributes.
1730 *
1731 * Returns the total data length of the skb.
1732 */
1733static inline int nla_nest_end(struct sk_buff *skb, struct nlattr *start)
1734{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001735 start->nla_len = skb_tail_pointer(skb) - (unsigned char *)start;
Thomas Grafbfa83a92005-11-10 02:25:51 +01001736 return skb->len;
1737}
1738
1739/**
1740 * nla_nest_cancel - Cancel nesting of attributes
1741 * @skb: socket buffer the message is stored in
1742 * @start: container attribute
1743 *
1744 * Removes the container attribute and including all nested
Thomas Grafbc3ed282008-06-03 16:36:54 -07001745 * attributes. Returns -EMSGSIZE
Thomas Grafbfa83a92005-11-10 02:25:51 +01001746 */
Thomas Grafbc3ed282008-06-03 16:36:54 -07001747static inline void nla_nest_cancel(struct sk_buff *skb, struct nlattr *start)
Thomas Grafbfa83a92005-11-10 02:25:51 +01001748{
Thomas Grafbc3ed282008-06-03 16:36:54 -07001749 nlmsg_trim(skb, start);
Thomas Grafbfa83a92005-11-10 02:25:51 +01001750}
1751
1752/**
Michal Kubecek32d51092019-12-11 10:58:19 +01001753 * __nla_validate_nested - Validate a stream of nested attributes
Paul Moore4fe5d5c2006-09-25 15:54:03 -07001754 * @start: container attribute
1755 * @maxtype: maximum attribute type to be expected
1756 * @policy: validation policy
Johannes Berg8cb08172019-04-26 14:07:28 +02001757 * @validate: validation strictness
Johannes Bergfceb6432017-04-12 14:34:07 +02001758 * @extack: extended ACK report struct
Paul Moore4fe5d5c2006-09-25 15:54:03 -07001759 *
1760 * Validates all attributes in the nested attribute stream against the
1761 * specified policy. Attributes with a type exceeding maxtype will be
1762 * ignored. See documenation of struct nla_policy for more details.
1763 *
1764 * Returns 0 on success or a negative error code.
1765 */
Johannes Berg8cb08172019-04-26 14:07:28 +02001766static inline int __nla_validate_nested(const struct nlattr *start, int maxtype,
1767 const struct nla_policy *policy,
1768 unsigned int validate,
1769 struct netlink_ext_ack *extack)
Paul Moore4fe5d5c2006-09-25 15:54:03 -07001770{
Johannes Berg8cb08172019-04-26 14:07:28 +02001771 return __nla_validate(nla_data(start), nla_len(start), maxtype, policy,
1772 validate, extack);
1773}
1774
1775static inline int
Michal Kubecek32d51092019-12-11 10:58:19 +01001776nla_validate_nested(const struct nlattr *start, int maxtype,
1777 const struct nla_policy *policy,
1778 struct netlink_ext_ack *extack)
Johannes Berg901bb982019-05-28 10:56:03 +02001779{
1780 return __nla_validate_nested(start, maxtype, policy,
1781 NL_VALIDATE_STRICT, extack);
1782}
1783
1784static inline int
Johannes Berg8cb08172019-04-26 14:07:28 +02001785nla_validate_nested_deprecated(const struct nlattr *start, int maxtype,
1786 const struct nla_policy *policy,
1787 struct netlink_ext_ack *extack)
1788{
1789 return __nla_validate_nested(start, maxtype, policy,
1790 NL_VALIDATE_LIBERAL, extack);
Paul Moore4fe5d5c2006-09-25 15:54:03 -07001791}
1792
1793/**
Nicolas Dichtel089bf1a2016-04-21 18:58:24 +02001794 * nla_need_padding_for_64bit - test 64-bit alignment of the next attribute
1795 * @skb: socket buffer the message is stored in
1796 *
1797 * Return true if padding is needed to align the next attribute (nla_data()) to
1798 * a 64-bit aligned area.
1799 */
1800static inline bool nla_need_padding_for_64bit(struct sk_buff *skb)
1801{
1802#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1803 /* The nlattr header is 4 bytes in size, that's why we test
1804 * if the skb->data _is_ aligned. A NOP attribute, plus
1805 * nlattr header for next attribute, will make nla_data()
1806 * 8-byte aligned.
1807 */
1808 if (IS_ALIGNED((unsigned long)skb_tail_pointer(skb), 8))
1809 return true;
1810#endif
1811 return false;
1812}
1813
1814/**
David S. Miller35c58452016-04-19 19:49:29 -04001815 * nla_align_64bit - 64-bit align the nla_data() of next attribute
1816 * @skb: socket buffer the message is stored in
1817 * @padattr: attribute type for the padding
1818 *
1819 * Conditionally emit a padding netlink attribute in order to make
1820 * the next attribute we emit have a 64-bit aligned nla_data() area.
1821 * This will only be done in architectures which do not have
Eric Dumazetcca1d812016-04-20 07:31:31 -07001822 * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS defined.
David S. Miller35c58452016-04-19 19:49:29 -04001823 *
1824 * Returns zero on success or a negative error code.
1825 */
1826static inline int nla_align_64bit(struct sk_buff *skb, int padattr)
1827{
Nicolas Dichtel089bf1a2016-04-21 18:58:24 +02001828 if (nla_need_padding_for_64bit(skb) &&
Eric Dumazetcca1d812016-04-20 07:31:31 -07001829 !nla_reserve(skb, padattr, 0))
1830 return -EMSGSIZE;
Nicolas Dichtel089bf1a2016-04-21 18:58:24 +02001831
David S. Miller35c58452016-04-19 19:49:29 -04001832 return 0;
1833}
1834
1835/**
1836 * nla_total_size_64bit - total length of attribute including padding
1837 * @payload: length of payload
1838 */
1839static inline int nla_total_size_64bit(int payload)
1840{
1841 return NLA_ALIGN(nla_attr_size(payload))
Eric Dumazetcca1d812016-04-20 07:31:31 -07001842#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
David S. Miller35c58452016-04-19 19:49:29 -04001843 + NLA_ALIGN(nla_attr_size(0))
1844#endif
1845 ;
1846}
1847
1848/**
Thomas Grafbfa83a92005-11-10 02:25:51 +01001849 * nla_for_each_attr - iterate over a stream of attributes
1850 * @pos: loop counter, set to current attribute
1851 * @head: head of attribute stream
1852 * @len: length of attribute stream
1853 * @rem: initialized to len, holds bytes currently remaining in stream
1854 */
1855#define nla_for_each_attr(pos, head, len, rem) \
1856 for (pos = head, rem = len; \
1857 nla_ok(pos, rem); \
1858 pos = nla_next(pos, &(rem)))
1859
Thomas Graffe4944e2006-08-04 23:03:05 -07001860/**
1861 * nla_for_each_nested - iterate over nested attributes
1862 * @pos: loop counter, set to current attribute
1863 * @nla: attribute containing the nested attributes
1864 * @rem: initialized to len, holds bytes currently remaining in stream
1865 */
1866#define nla_for_each_nested(pos, nla, rem) \
1867 nla_for_each_attr(pos, nla_data(nla), nla_len(nla), rem)
1868
Simon Horman941d8eb2014-10-27 16:12:16 +09001869/**
1870 * nla_is_last - Test if attribute is last in stream
1871 * @nla: attribute to test
1872 * @rem: bytes remaining in stream
1873 */
1874static inline bool nla_is_last(const struct nlattr *nla, int rem)
1875{
1876 return nla->nla_len == rem;
1877}
1878
Thomas Grafbfa83a92005-11-10 02:25:51 +01001879#endif