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_COMPAT,
176 	NLA_NUL_STRING,
177 	NLA_BINARY,
178 	NLA_S8,
179 	NLA_S16,
180 	NLA_S32,
181 	NLA_S64,
182 	NLA_BITFIELD32,
183 	__NLA_TYPE_MAX,
184 };
185 
186 #define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
187 
188 /**
189  * struct nla_policy - attribute validation policy
190  * @type: Type of attribute or NLA_UNSPEC
191  * @len: Type specific length of payload
192  *
193  * Policies are defined as arrays of this struct, the array must be
194  * accessible by attribute type up to the highest identifier to be expected.
195  *
196  * Meaning of `len' field:
197  *    NLA_STRING           Maximum length of string
198  *    NLA_NUL_STRING       Maximum length of string (excluding NUL)
199  *    NLA_FLAG             Unused
200  *    NLA_BINARY           Maximum length of attribute payload
201  *    NLA_NESTED           Don't use `len' field -- length verification is
202  *                         done by checking len of nested header (or empty)
203  *    NLA_NESTED_COMPAT    Minimum length of structure payload
204  *    NLA_U8, NLA_U16,
205  *    NLA_U32, NLA_U64,
206  *    NLA_S8, NLA_S16,
207  *    NLA_S32, NLA_S64,
208  *    NLA_MSECS            Leaving the length field zero will verify the
209  *                         given type fits, using it verifies minimum length
210  *                         just like "All other"
211  *    NLA_BITFIELD32      A 32-bit bitmap/bitselector attribute
212  *    All other            Minimum length of attribute payload
213  *
214  * Example:
215  * static const struct nla_policy my_policy[ATTR_MAX+1] = {
216  * 	[ATTR_FOO] = { .type = NLA_U16 },
217  *	[ATTR_BAR] = { .type = NLA_STRING, .len = BARSIZ },
218  *	[ATTR_BAZ] = { .len = sizeof(struct mystruct) },
219  *	[ATTR_GOO] = { .type = NLA_BITFIELD32, .validation_data = &myvalidflags },
220  * };
221  */
222 struct nla_policy {
223 	u16		type;
224 	u16		len;
225 	void            *validation_data;
226 };
227 
228 /**
229  * struct nl_info - netlink source information
230  * @nlh: Netlink message header of original request
231  * @portid: Netlink PORTID of requesting application
232  */
233 struct nl_info {
234 	struct nlmsghdr		*nlh;
235 	struct net		*nl_net;
236 	u32			portid;
237 	bool			skip_notify;
238 };
239 
240 int netlink_rcv_skb(struct sk_buff *skb,
241 		    int (*cb)(struct sk_buff *, struct nlmsghdr *,
242 			      struct netlink_ext_ack *));
243 int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid,
244 		 unsigned int group, int report, gfp_t flags);
245 
246 int nla_validate(const struct nlattr *head, int len, int maxtype,
247 		 const struct nla_policy *policy,
248 		 struct netlink_ext_ack *extack);
249 int nla_parse(struct nlattr **tb, int maxtype, const struct nlattr *head,
250 	      int len, const struct nla_policy *policy,
251 	      struct netlink_ext_ack *extack);
252 int nla_policy_len(const struct nla_policy *, int);
253 struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype);
254 size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize);
255 char *nla_strdup(const struct nlattr *nla, gfp_t flags);
256 int nla_memcpy(void *dest, const struct nlattr *src, int count);
257 int nla_memcmp(const struct nlattr *nla, const void *data, size_t size);
258 int nla_strcmp(const struct nlattr *nla, const char *str);
259 struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
260 struct nlattr *__nla_reserve_64bit(struct sk_buff *skb, int attrtype,
261 				   int attrlen, int padattr);
262 void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
263 struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
264 struct nlattr *nla_reserve_64bit(struct sk_buff *skb, int attrtype,
265 				 int attrlen, int padattr);
266 void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
267 void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
268 	       const void *data);
269 void __nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
270 		     const void *data, int padattr);
271 void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
272 int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
273 int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
274 		  const void *data, int padattr);
275 int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
276 int nla_append(struct sk_buff *skb, int attrlen, const void *data);
277 
278 /**************************************************************************
279  * Netlink Messages
280  **************************************************************************/
281 
282 /**
283  * nlmsg_msg_size - length of netlink message not including padding
284  * @payload: length of message payload
285  */
nlmsg_msg_size(int payload)286 static inline int nlmsg_msg_size(int payload)
287 {
288 	return NLMSG_HDRLEN + payload;
289 }
290 
291 /**
292  * nlmsg_total_size - length of netlink message including padding
293  * @payload: length of message payload
294  */
nlmsg_total_size(int payload)295 static inline int nlmsg_total_size(int payload)
296 {
297 	return NLMSG_ALIGN(nlmsg_msg_size(payload));
298 }
299 
300 /**
301  * nlmsg_padlen - length of padding at the message's tail
302  * @payload: length of message payload
303  */
nlmsg_padlen(int payload)304 static inline int nlmsg_padlen(int payload)
305 {
306 	return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
307 }
308 
309 /**
310  * nlmsg_data - head of message payload
311  * @nlh: netlink message header
312  */
nlmsg_data(const struct nlmsghdr * nlh)313 static inline void *nlmsg_data(const struct nlmsghdr *nlh)
314 {
315 	return (unsigned char *) nlh + NLMSG_HDRLEN;
316 }
317 
318 /**
319  * nlmsg_len - length of message payload
320  * @nlh: netlink message header
321  */
nlmsg_len(const struct nlmsghdr * nlh)322 static inline int nlmsg_len(const struct nlmsghdr *nlh)
323 {
324 	return nlh->nlmsg_len - NLMSG_HDRLEN;
325 }
326 
327 /**
328  * nlmsg_attrdata - head of attributes data
329  * @nlh: netlink message header
330  * @hdrlen: length of family specific header
331  */
nlmsg_attrdata(const struct nlmsghdr * nlh,int hdrlen)332 static inline struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh,
333 					    int hdrlen)
334 {
335 	unsigned char *data = nlmsg_data(nlh);
336 	return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
337 }
338 
339 /**
340  * nlmsg_attrlen - length of attributes data
341  * @nlh: netlink message header
342  * @hdrlen: length of family specific header
343  */
nlmsg_attrlen(const struct nlmsghdr * nlh,int hdrlen)344 static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
345 {
346 	return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
347 }
348 
349 /**
350  * nlmsg_ok - check if the netlink message fits into the remaining bytes
351  * @nlh: netlink message header
352  * @remaining: number of bytes remaining in message stream
353  */
nlmsg_ok(const struct nlmsghdr * nlh,int remaining)354 static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
355 {
356 	return (remaining >= (int) sizeof(struct nlmsghdr) &&
357 		nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
358 		nlh->nlmsg_len <= remaining);
359 }
360 
361 /**
362  * nlmsg_next - next netlink message in message stream
363  * @nlh: netlink message header
364  * @remaining: number of bytes remaining in message stream
365  *
366  * Returns the next netlink message in the message stream and
367  * decrements remaining by the size of the current message.
368  */
369 static inline struct nlmsghdr *
nlmsg_next(const struct nlmsghdr * nlh,int * remaining)370 nlmsg_next(const struct nlmsghdr *nlh, int *remaining)
371 {
372 	int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
373 
374 	*remaining -= totlen;
375 
376 	return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
377 }
378 
379 /**
380  * nlmsg_parse - parse attributes of a netlink message
381  * @nlh: netlink message header
382  * @hdrlen: length of family specific header
383  * @tb: destination array with maxtype+1 elements
384  * @maxtype: maximum attribute type to be expected
385  * @policy: validation policy
386  * @extack: extended ACK report struct
387  *
388  * See nla_parse()
389  */
nlmsg_parse(const struct nlmsghdr * nlh,int hdrlen,struct nlattr * tb[],int maxtype,const struct nla_policy * policy,struct netlink_ext_ack * extack)390 static inline int nlmsg_parse(const struct nlmsghdr *nlh, int hdrlen,
391 			      struct nlattr *tb[], int maxtype,
392 			      const struct nla_policy *policy,
393 			      struct netlink_ext_ack *extack)
394 {
395 	if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
396 		return -EINVAL;
397 
398 	return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
399 			 nlmsg_attrlen(nlh, hdrlen), policy, extack);
400 }
401 
402 /**
403  * nlmsg_find_attr - find a specific attribute in a netlink message
404  * @nlh: netlink message header
405  * @hdrlen: length of familiy specific header
406  * @attrtype: type of attribute to look for
407  *
408  * Returns the first attribute which matches the specified type.
409  */
nlmsg_find_attr(const struct nlmsghdr * nlh,int hdrlen,int attrtype)410 static inline struct nlattr *nlmsg_find_attr(const struct nlmsghdr *nlh,
411 					     int hdrlen, int attrtype)
412 {
413 	return nla_find(nlmsg_attrdata(nlh, hdrlen),
414 			nlmsg_attrlen(nlh, hdrlen), attrtype);
415 }
416 
417 /**
418  * nlmsg_validate - validate a netlink message including attributes
419  * @nlh: netlinket message header
420  * @hdrlen: length of familiy specific header
421  * @maxtype: maximum attribute type to be expected
422  * @policy: validation policy
423  * @extack: extended ACK report struct
424  */
nlmsg_validate(const struct nlmsghdr * nlh,int hdrlen,int maxtype,const struct nla_policy * policy,struct netlink_ext_ack * extack)425 static inline int nlmsg_validate(const struct nlmsghdr *nlh,
426 				 int hdrlen, int maxtype,
427 				 const struct nla_policy *policy,
428 				 struct netlink_ext_ack *extack)
429 {
430 	if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
431 		return -EINVAL;
432 
433 	return nla_validate(nlmsg_attrdata(nlh, hdrlen),
434 			    nlmsg_attrlen(nlh, hdrlen), maxtype, policy,
435 			    extack);
436 }
437 
438 /**
439  * nlmsg_report - need to report back to application?
440  * @nlh: netlink message header
441  *
442  * Returns 1 if a report back to the application is requested.
443  */
nlmsg_report(const struct nlmsghdr * nlh)444 static inline int nlmsg_report(const struct nlmsghdr *nlh)
445 {
446 	return !!(nlh->nlmsg_flags & NLM_F_ECHO);
447 }
448 
449 /**
450  * nlmsg_for_each_attr - iterate over a stream of attributes
451  * @pos: loop counter, set to current attribute
452  * @nlh: netlink message header
453  * @hdrlen: length of familiy specific header
454  * @rem: initialized to len, holds bytes currently remaining in stream
455  */
456 #define nlmsg_for_each_attr(pos, nlh, hdrlen, rem) \
457 	nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
458 			  nlmsg_attrlen(nlh, hdrlen), rem)
459 
460 /**
461  * nlmsg_put - Add a new netlink message to an skb
462  * @skb: socket buffer to store message in
463  * @portid: netlink PORTID of requesting application
464  * @seq: sequence number of message
465  * @type: message type
466  * @payload: length of message payload
467  * @flags: message flags
468  *
469  * Returns NULL if the tailroom of the skb is insufficient to store
470  * the message header and payload.
471  */
nlmsg_put(struct sk_buff * skb,u32 portid,u32 seq,int type,int payload,int flags)472 static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
473 					 int type, int payload, int flags)
474 {
475 	if (unlikely(skb_tailroom(skb) < nlmsg_total_size(payload)))
476 		return NULL;
477 
478 	return __nlmsg_put(skb, portid, seq, type, payload, flags);
479 }
480 
481 /**
482  * nlmsg_put_answer - Add a new callback based netlink message to an skb
483  * @skb: socket buffer to store message in
484  * @cb: netlink callback
485  * @type: message type
486  * @payload: length of message payload
487  * @flags: message flags
488  *
489  * Returns NULL if the tailroom of the skb is insufficient to store
490  * the message header and payload.
491  */
nlmsg_put_answer(struct sk_buff * skb,struct netlink_callback * cb,int type,int payload,int flags)492 static inline struct nlmsghdr *nlmsg_put_answer(struct sk_buff *skb,
493 						struct netlink_callback *cb,
494 						int type, int payload,
495 						int flags)
496 {
497 	return nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
498 			 type, payload, flags);
499 }
500 
501 /**
502  * nlmsg_new - Allocate a new netlink message
503  * @payload: size of the message payload
504  * @flags: the type of memory to allocate.
505  *
506  * Use NLMSG_DEFAULT_SIZE if the size of the payload isn't known
507  * and a good default is needed.
508  */
nlmsg_new(size_t payload,gfp_t flags)509 static inline struct sk_buff *nlmsg_new(size_t payload, gfp_t flags)
510 {
511 	return alloc_skb(nlmsg_total_size(payload), flags);
512 }
513 
514 /**
515  * nlmsg_end - Finalize a netlink message
516  * @skb: socket buffer the message is stored in
517  * @nlh: netlink message header
518  *
519  * Corrects the netlink message header to include the appeneded
520  * attributes. Only necessary if attributes have been added to
521  * the message.
522  */
nlmsg_end(struct sk_buff * skb,struct nlmsghdr * nlh)523 static inline void nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
524 {
525 	nlh->nlmsg_len = skb_tail_pointer(skb) - (unsigned char *)nlh;
526 }
527 
528 /**
529  * nlmsg_get_pos - return current position in netlink message
530  * @skb: socket buffer the message is stored in
531  *
532  * Returns a pointer to the current tail of the message.
533  */
nlmsg_get_pos(struct sk_buff * skb)534 static inline void *nlmsg_get_pos(struct sk_buff *skb)
535 {
536 	return skb_tail_pointer(skb);
537 }
538 
539 /**
540  * nlmsg_trim - Trim message to a mark
541  * @skb: socket buffer the message is stored in
542  * @mark: mark to trim to
543  *
544  * Trims the message to the provided mark.
545  */
nlmsg_trim(struct sk_buff * skb,const void * mark)546 static inline void nlmsg_trim(struct sk_buff *skb, const void *mark)
547 {
548 	if (mark) {
549 		WARN_ON((unsigned char *) mark < skb->data);
550 		skb_trim(skb, (unsigned char *) mark - skb->data);
551 	}
552 }
553 
554 /**
555  * nlmsg_cancel - Cancel construction of a netlink message
556  * @skb: socket buffer the message is stored in
557  * @nlh: netlink message header
558  *
559  * Removes the complete netlink message including all
560  * attributes from the socket buffer again.
561  */
nlmsg_cancel(struct sk_buff * skb,struct nlmsghdr * nlh)562 static inline void nlmsg_cancel(struct sk_buff *skb, struct nlmsghdr *nlh)
563 {
564 	nlmsg_trim(skb, nlh);
565 }
566 
567 /**
568  * nlmsg_free - free a netlink message
569  * @skb: socket buffer of netlink message
570  */
nlmsg_free(struct sk_buff * skb)571 static inline void nlmsg_free(struct sk_buff *skb)
572 {
573 	kfree_skb(skb);
574 }
575 
576 /**
577  * nlmsg_multicast - multicast a netlink message
578  * @sk: netlink socket to spread messages to
579  * @skb: netlink message as socket buffer
580  * @portid: own netlink portid to avoid sending to yourself
581  * @group: multicast group id
582  * @flags: allocation flags
583  */
nlmsg_multicast(struct sock * sk,struct sk_buff * skb,u32 portid,unsigned int group,gfp_t flags)584 static inline int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,
585 				  u32 portid, unsigned int group, gfp_t flags)
586 {
587 	int err;
588 
589 	NETLINK_CB(skb).dst_group = group;
590 
591 	err = netlink_broadcast(sk, skb, portid, group, flags);
592 	if (err > 0)
593 		err = 0;
594 
595 	return err;
596 }
597 
598 /**
599  * nlmsg_unicast - unicast a netlink message
600  * @sk: netlink socket to spread message to
601  * @skb: netlink message as socket buffer
602  * @portid: netlink portid of the destination socket
603  */
nlmsg_unicast(struct sock * sk,struct sk_buff * skb,u32 portid)604 static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 portid)
605 {
606 	int err;
607 
608 	err = netlink_unicast(sk, skb, portid, MSG_DONTWAIT);
609 	if (err > 0)
610 		err = 0;
611 
612 	return err;
613 }
614 
615 /**
616  * nlmsg_for_each_msg - iterate over a stream of messages
617  * @pos: loop counter, set to current message
618  * @head: head of message stream
619  * @len: length of message stream
620  * @rem: initialized to len, holds bytes currently remaining in stream
621  */
622 #define nlmsg_for_each_msg(pos, head, len, rem) \
623 	for (pos = head, rem = len; \
624 	     nlmsg_ok(pos, rem); \
625 	     pos = nlmsg_next(pos, &(rem)))
626 
627 /**
628  * nl_dump_check_consistent - check if sequence is consistent and advertise if not
629  * @cb: netlink callback structure that stores the sequence number
630  * @nlh: netlink message header to write the flag to
631  *
632  * This function checks if the sequence (generation) number changed during dump
633  * and if it did, advertises it in the netlink message header.
634  *
635  * The correct way to use it is to set cb->seq to the generation counter when
636  * all locks for dumping have been acquired, and then call this function for
637  * each message that is generated.
638  *
639  * Note that due to initialisation concerns, 0 is an invalid sequence number
640  * and must not be used by code that uses this functionality.
641  */
642 static inline void
nl_dump_check_consistent(struct netlink_callback * cb,struct nlmsghdr * nlh)643 nl_dump_check_consistent(struct netlink_callback *cb,
644 			 struct nlmsghdr *nlh)
645 {
646 	if (cb->prev_seq && cb->seq != cb->prev_seq)
647 		nlh->nlmsg_flags |= NLM_F_DUMP_INTR;
648 	cb->prev_seq = cb->seq;
649 }
650 
651 /**************************************************************************
652  * Netlink Attributes
653  **************************************************************************/
654 
655 /**
656  * nla_attr_size - length of attribute not including padding
657  * @payload: length of payload
658  */
nla_attr_size(int payload)659 static inline int nla_attr_size(int payload)
660 {
661 	return NLA_HDRLEN + payload;
662 }
663 
664 /**
665  * nla_total_size - total length of attribute including padding
666  * @payload: length of payload
667  */
nla_total_size(int payload)668 static inline int nla_total_size(int payload)
669 {
670 	return NLA_ALIGN(nla_attr_size(payload));
671 }
672 
673 /**
674  * nla_padlen - length of padding at the tail of attribute
675  * @payload: length of payload
676  */
nla_padlen(int payload)677 static inline int nla_padlen(int payload)
678 {
679 	return nla_total_size(payload) - nla_attr_size(payload);
680 }
681 
682 /**
683  * nla_type - attribute type
684  * @nla: netlink attribute
685  */
nla_type(const struct nlattr * nla)686 static inline int nla_type(const struct nlattr *nla)
687 {
688 	return nla->nla_type & NLA_TYPE_MASK;
689 }
690 
691 /**
692  * nla_data - head of payload
693  * @nla: netlink attribute
694  */
nla_data(const struct nlattr * nla)695 static inline void *nla_data(const struct nlattr *nla)
696 {
697 	return (char *) nla + NLA_HDRLEN;
698 }
699 
700 /**
701  * nla_len - length of payload
702  * @nla: netlink attribute
703  */
nla_len(const struct nlattr * nla)704 static inline int nla_len(const struct nlattr *nla)
705 {
706 	return nla->nla_len - NLA_HDRLEN;
707 }
708 
709 /**
710  * nla_ok - check if the netlink attribute fits into the remaining bytes
711  * @nla: netlink attribute
712  * @remaining: number of bytes remaining in attribute stream
713  */
nla_ok(const struct nlattr * nla,int remaining)714 static inline int nla_ok(const struct nlattr *nla, int remaining)
715 {
716 	return remaining >= (int) sizeof(*nla) &&
717 	       nla->nla_len >= sizeof(*nla) &&
718 	       nla->nla_len <= remaining;
719 }
720 
721 /**
722  * nla_next - next netlink attribute in attribute stream
723  * @nla: netlink attribute
724  * @remaining: number of bytes remaining in attribute stream
725  *
726  * Returns the next netlink attribute in the attribute stream and
727  * decrements remaining by the size of the current attribute.
728  */
nla_next(const struct nlattr * nla,int * remaining)729 static inline struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
730 {
731 	unsigned int totlen = NLA_ALIGN(nla->nla_len);
732 
733 	*remaining -= totlen;
734 	return (struct nlattr *) ((char *) nla + totlen);
735 }
736 
737 /**
738  * nla_find_nested - find attribute in a set of nested attributes
739  * @nla: attribute containing the nested attributes
740  * @attrtype: type of attribute to look for
741  *
742  * Returns the first attribute which matches the specified type.
743  */
744 static inline struct nlattr *
nla_find_nested(const struct nlattr * nla,int attrtype)745 nla_find_nested(const struct nlattr *nla, int attrtype)
746 {
747 	return nla_find(nla_data(nla), nla_len(nla), attrtype);
748 }
749 
750 /**
751  * nla_parse_nested - parse nested attributes
752  * @tb: destination array with maxtype+1 elements
753  * @maxtype: maximum attribute type to be expected
754  * @nla: attribute containing the nested attributes
755  * @policy: validation policy
756  * @extack: extended ACK report struct
757  *
758  * See nla_parse()
759  */
nla_parse_nested(struct nlattr * tb[],int maxtype,const struct nlattr * nla,const struct nla_policy * policy,struct netlink_ext_ack * extack)760 static inline int nla_parse_nested(struct nlattr *tb[], int maxtype,
761 				   const struct nlattr *nla,
762 				   const struct nla_policy *policy,
763 				   struct netlink_ext_ack *extack)
764 {
765 	return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy,
766 			 extack);
767 }
768 
769 /**
770  * nla_put_u8 - Add a u8 netlink attribute to a socket buffer
771  * @skb: socket buffer to add attribute to
772  * @attrtype: attribute type
773  * @value: numeric value
774  */
nla_put_u8(struct sk_buff * skb,int attrtype,u8 value)775 static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
776 {
777 	/* temporary variables to work around GCC PR81715 with asan-stack=1 */
778 	u8 tmp = value;
779 
780 	return nla_put(skb, attrtype, sizeof(u8), &tmp);
781 }
782 
783 /**
784  * nla_put_u16 - Add a u16 netlink attribute to a socket buffer
785  * @skb: socket buffer to add attribute to
786  * @attrtype: attribute type
787  * @value: numeric value
788  */
nla_put_u16(struct sk_buff * skb,int attrtype,u16 value)789 static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
790 {
791 	u16 tmp = value;
792 
793 	return nla_put(skb, attrtype, sizeof(u16), &tmp);
794 }
795 
796 /**
797  * nla_put_be16 - Add a __be16 netlink attribute to a socket buffer
798  * @skb: socket buffer to add attribute to
799  * @attrtype: attribute type
800  * @value: numeric value
801  */
nla_put_be16(struct sk_buff * skb,int attrtype,__be16 value)802 static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value)
803 {
804 	__be16 tmp = value;
805 
806 	return nla_put(skb, attrtype, sizeof(__be16), &tmp);
807 }
808 
809 /**
810  * nla_put_net16 - Add 16-bit network byte order netlink attribute to a socket buffer
811  * @skb: socket buffer to add attribute to
812  * @attrtype: attribute type
813  * @value: numeric value
814  */
nla_put_net16(struct sk_buff * skb,int attrtype,__be16 value)815 static inline int nla_put_net16(struct sk_buff *skb, int attrtype, __be16 value)
816 {
817 	__be16 tmp = value;
818 
819 	return nla_put_be16(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
820 }
821 
822 /**
823  * nla_put_le16 - Add a __le16 netlink attribute to a socket buffer
824  * @skb: socket buffer to add attribute to
825  * @attrtype: attribute type
826  * @value: numeric value
827  */
nla_put_le16(struct sk_buff * skb,int attrtype,__le16 value)828 static inline int nla_put_le16(struct sk_buff *skb, int attrtype, __le16 value)
829 {
830 	__le16 tmp = value;
831 
832 	return nla_put(skb, attrtype, sizeof(__le16), &tmp);
833 }
834 
835 /**
836  * nla_put_u32 - Add a u32 netlink attribute to a socket buffer
837  * @skb: socket buffer to add attribute to
838  * @attrtype: attribute type
839  * @value: numeric value
840  */
nla_put_u32(struct sk_buff * skb,int attrtype,u32 value)841 static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
842 {
843 	u32 tmp = value;
844 
845 	return nla_put(skb, attrtype, sizeof(u32), &tmp);
846 }
847 
848 /**
849  * nla_put_be32 - Add a __be32 netlink attribute to a socket buffer
850  * @skb: socket buffer to add attribute to
851  * @attrtype: attribute type
852  * @value: numeric value
853  */
nla_put_be32(struct sk_buff * skb,int attrtype,__be32 value)854 static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value)
855 {
856 	__be32 tmp = value;
857 
858 	return nla_put(skb, attrtype, sizeof(__be32), &tmp);
859 }
860 
861 /**
862  * nla_put_net32 - Add 32-bit network byte order netlink attribute to a socket buffer
863  * @skb: socket buffer to add attribute to
864  * @attrtype: attribute type
865  * @value: numeric value
866  */
nla_put_net32(struct sk_buff * skb,int attrtype,__be32 value)867 static inline int nla_put_net32(struct sk_buff *skb, int attrtype, __be32 value)
868 {
869 	__be32 tmp = value;
870 
871 	return nla_put_be32(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
872 }
873 
874 /**
875  * nla_put_le32 - Add a __le32 netlink attribute to a socket buffer
876  * @skb: socket buffer to add attribute to
877  * @attrtype: attribute type
878  * @value: numeric value
879  */
nla_put_le32(struct sk_buff * skb,int attrtype,__le32 value)880 static inline int nla_put_le32(struct sk_buff *skb, int attrtype, __le32 value)
881 {
882 	__le32 tmp = value;
883 
884 	return nla_put(skb, attrtype, sizeof(__le32), &tmp);
885 }
886 
887 /**
888  * nla_put_u64_64bit - Add a u64 netlink attribute to a skb and align it
889  * @skb: socket buffer to add attribute to
890  * @attrtype: attribute type
891  * @value: numeric value
892  * @padattr: attribute type for the padding
893  */
nla_put_u64_64bit(struct sk_buff * skb,int attrtype,u64 value,int padattr)894 static inline int nla_put_u64_64bit(struct sk_buff *skb, int attrtype,
895 				    u64 value, int padattr)
896 {
897 	u64 tmp = value;
898 
899 	return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
900 }
901 
902 /**
903  * nla_put_be64 - Add a __be64 netlink attribute to a socket buffer and align it
904  * @skb: socket buffer to add attribute to
905  * @attrtype: attribute type
906  * @value: numeric value
907  * @padattr: attribute type for the padding
908  */
nla_put_be64(struct sk_buff * skb,int attrtype,__be64 value,int padattr)909 static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value,
910 			       int padattr)
911 {
912 	__be64 tmp = value;
913 
914 	return nla_put_64bit(skb, attrtype, sizeof(__be64), &tmp, padattr);
915 }
916 
917 /**
918  * nla_put_net64 - Add 64-bit network byte order nlattr to a skb and align it
919  * @skb: socket buffer to add attribute to
920  * @attrtype: attribute type
921  * @value: numeric value
922  * @padattr: attribute type for the padding
923  */
nla_put_net64(struct sk_buff * skb,int attrtype,__be64 value,int padattr)924 static inline int nla_put_net64(struct sk_buff *skb, int attrtype, __be64 value,
925 				int padattr)
926 {
927 	__be64 tmp = value;
928 
929 	return nla_put_be64(skb, attrtype | NLA_F_NET_BYTEORDER, tmp,
930 			    padattr);
931 }
932 
933 /**
934  * nla_put_le64 - Add a __le64 netlink attribute to a socket buffer and align it
935  * @skb: socket buffer to add attribute to
936  * @attrtype: attribute type
937  * @value: numeric value
938  * @padattr: attribute type for the padding
939  */
nla_put_le64(struct sk_buff * skb,int attrtype,__le64 value,int padattr)940 static inline int nla_put_le64(struct sk_buff *skb, int attrtype, __le64 value,
941 			       int padattr)
942 {
943 	__le64 tmp = value;
944 
945 	return nla_put_64bit(skb, attrtype, sizeof(__le64), &tmp, padattr);
946 }
947 
948 /**
949  * nla_put_s8 - Add a s8 netlink attribute to a socket buffer
950  * @skb: socket buffer to add attribute to
951  * @attrtype: attribute type
952  * @value: numeric value
953  */
nla_put_s8(struct sk_buff * skb,int attrtype,s8 value)954 static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value)
955 {
956 	s8 tmp = value;
957 
958 	return nla_put(skb, attrtype, sizeof(s8), &tmp);
959 }
960 
961 /**
962  * nla_put_s16 - Add a s16 netlink attribute to a socket buffer
963  * @skb: socket buffer to add attribute to
964  * @attrtype: attribute type
965  * @value: numeric value
966  */
nla_put_s16(struct sk_buff * skb,int attrtype,s16 value)967 static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value)
968 {
969 	s16 tmp = value;
970 
971 	return nla_put(skb, attrtype, sizeof(s16), &tmp);
972 }
973 
974 /**
975  * nla_put_s32 - Add a s32 netlink attribute to a socket buffer
976  * @skb: socket buffer to add attribute to
977  * @attrtype: attribute type
978  * @value: numeric value
979  */
nla_put_s32(struct sk_buff * skb,int attrtype,s32 value)980 static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value)
981 {
982 	s32 tmp = value;
983 
984 	return nla_put(skb, attrtype, sizeof(s32), &tmp);
985 }
986 
987 /**
988  * nla_put_s64 - Add a s64 netlink attribute to a socket buffer and align it
989  * @skb: socket buffer to add attribute to
990  * @attrtype: attribute type
991  * @value: numeric value
992  * @padattr: attribute type for the padding
993  */
nla_put_s64(struct sk_buff * skb,int attrtype,s64 value,int padattr)994 static inline int nla_put_s64(struct sk_buff *skb, int attrtype, s64 value,
995 			      int padattr)
996 {
997 	s64 tmp = value;
998 
999 	return nla_put_64bit(skb, attrtype, sizeof(s64), &tmp, padattr);
1000 }
1001 
1002 /**
1003  * nla_put_string - Add a string netlink attribute to a socket buffer
1004  * @skb: socket buffer to add attribute to
1005  * @attrtype: attribute type
1006  * @str: NUL terminated string
1007  */
nla_put_string(struct sk_buff * skb,int attrtype,const char * str)1008 static inline int nla_put_string(struct sk_buff *skb, int attrtype,
1009 				 const char *str)
1010 {
1011 	return nla_put(skb, attrtype, strlen(str) + 1, str);
1012 }
1013 
1014 /**
1015  * nla_put_flag - Add a flag netlink attribute to a socket buffer
1016  * @skb: socket buffer to add attribute to
1017  * @attrtype: attribute type
1018  */
nla_put_flag(struct sk_buff * skb,int attrtype)1019 static inline int nla_put_flag(struct sk_buff *skb, int attrtype)
1020 {
1021 	return nla_put(skb, attrtype, 0, NULL);
1022 }
1023 
1024 /**
1025  * nla_put_msecs - Add a msecs netlink attribute to a skb and align it
1026  * @skb: socket buffer to add attribute to
1027  * @attrtype: attribute type
1028  * @njiffies: number of jiffies to convert to msecs
1029  * @padattr: attribute type for the padding
1030  */
nla_put_msecs(struct sk_buff * skb,int attrtype,unsigned long njiffies,int padattr)1031 static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
1032 				unsigned long njiffies, int padattr)
1033 {
1034 	u64 tmp = jiffies_to_msecs(njiffies);
1035 
1036 	return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
1037 }
1038 
1039 /**
1040  * nla_put_in_addr - Add an IPv4 address netlink attribute to a socket
1041  * buffer
1042  * @skb: socket buffer to add attribute to
1043  * @attrtype: attribute type
1044  * @addr: IPv4 address
1045  */
nla_put_in_addr(struct sk_buff * skb,int attrtype,__be32 addr)1046 static inline int nla_put_in_addr(struct sk_buff *skb, int attrtype,
1047 				  __be32 addr)
1048 {
1049 	__be32 tmp = addr;
1050 
1051 	return nla_put_be32(skb, attrtype, tmp);
1052 }
1053 
1054 /**
1055  * nla_put_in6_addr - Add an IPv6 address netlink attribute to a socket
1056  * buffer
1057  * @skb: socket buffer to add attribute to
1058  * @attrtype: attribute type
1059  * @addr: IPv6 address
1060  */
nla_put_in6_addr(struct sk_buff * skb,int attrtype,const struct in6_addr * addr)1061 static inline int nla_put_in6_addr(struct sk_buff *skb, int attrtype,
1062 				   const struct in6_addr *addr)
1063 {
1064 	return nla_put(skb, attrtype, sizeof(*addr), addr);
1065 }
1066 
1067 /**
1068  * nla_get_u32 - return payload of u32 attribute
1069  * @nla: u32 netlink attribute
1070  */
nla_get_u32(const struct nlattr * nla)1071 static inline u32 nla_get_u32(const struct nlattr *nla)
1072 {
1073 	return *(u32 *) nla_data(nla);
1074 }
1075 
1076 /**
1077  * nla_get_be32 - return payload of __be32 attribute
1078  * @nla: __be32 netlink attribute
1079  */
nla_get_be32(const struct nlattr * nla)1080 static inline __be32 nla_get_be32(const struct nlattr *nla)
1081 {
1082 	return *(__be32 *) nla_data(nla);
1083 }
1084 
1085 /**
1086  * nla_get_le32 - return payload of __le32 attribute
1087  * @nla: __le32 netlink attribute
1088  */
nla_get_le32(const struct nlattr * nla)1089 static inline __le32 nla_get_le32(const struct nlattr *nla)
1090 {
1091 	return *(__le32 *) nla_data(nla);
1092 }
1093 
1094 /**
1095  * nla_get_u16 - return payload of u16 attribute
1096  * @nla: u16 netlink attribute
1097  */
nla_get_u16(const struct nlattr * nla)1098 static inline u16 nla_get_u16(const struct nlattr *nla)
1099 {
1100 	return *(u16 *) nla_data(nla);
1101 }
1102 
1103 /**
1104  * nla_get_be16 - return payload of __be16 attribute
1105  * @nla: __be16 netlink attribute
1106  */
nla_get_be16(const struct nlattr * nla)1107 static inline __be16 nla_get_be16(const struct nlattr *nla)
1108 {
1109 	return *(__be16 *) nla_data(nla);
1110 }
1111 
1112 /**
1113  * nla_get_le16 - return payload of __le16 attribute
1114  * @nla: __le16 netlink attribute
1115  */
nla_get_le16(const struct nlattr * nla)1116 static inline __le16 nla_get_le16(const struct nlattr *nla)
1117 {
1118 	return *(__le16 *) nla_data(nla);
1119 }
1120 
1121 /**
1122  * nla_get_u8 - return payload of u8 attribute
1123  * @nla: u8 netlink attribute
1124  */
nla_get_u8(const struct nlattr * nla)1125 static inline u8 nla_get_u8(const struct nlattr *nla)
1126 {
1127 	return *(u8 *) nla_data(nla);
1128 }
1129 
1130 /**
1131  * nla_get_u64 - return payload of u64 attribute
1132  * @nla: u64 netlink attribute
1133  */
nla_get_u64(const struct nlattr * nla)1134 static inline u64 nla_get_u64(const struct nlattr *nla)
1135 {
1136 	u64 tmp;
1137 
1138 	nla_memcpy(&tmp, nla, sizeof(tmp));
1139 
1140 	return tmp;
1141 }
1142 
1143 /**
1144  * nla_get_be64 - return payload of __be64 attribute
1145  * @nla: __be64 netlink attribute
1146  */
nla_get_be64(const struct nlattr * nla)1147 static inline __be64 nla_get_be64(const struct nlattr *nla)
1148 {
1149 	__be64 tmp;
1150 
1151 	nla_memcpy(&tmp, nla, sizeof(tmp));
1152 
1153 	return tmp;
1154 }
1155 
1156 /**
1157  * nla_get_le64 - return payload of __le64 attribute
1158  * @nla: __le64 netlink attribute
1159  */
nla_get_le64(const struct nlattr * nla)1160 static inline __le64 nla_get_le64(const struct nlattr *nla)
1161 {
1162 	return *(__le64 *) nla_data(nla);
1163 }
1164 
1165 /**
1166  * nla_get_s32 - return payload of s32 attribute
1167  * @nla: s32 netlink attribute
1168  */
nla_get_s32(const struct nlattr * nla)1169 static inline s32 nla_get_s32(const struct nlattr *nla)
1170 {
1171 	return *(s32 *) nla_data(nla);
1172 }
1173 
1174 /**
1175  * nla_get_s16 - return payload of s16 attribute
1176  * @nla: s16 netlink attribute
1177  */
nla_get_s16(const struct nlattr * nla)1178 static inline s16 nla_get_s16(const struct nlattr *nla)
1179 {
1180 	return *(s16 *) nla_data(nla);
1181 }
1182 
1183 /**
1184  * nla_get_s8 - return payload of s8 attribute
1185  * @nla: s8 netlink attribute
1186  */
nla_get_s8(const struct nlattr * nla)1187 static inline s8 nla_get_s8(const struct nlattr *nla)
1188 {
1189 	return *(s8 *) nla_data(nla);
1190 }
1191 
1192 /**
1193  * nla_get_s64 - return payload of s64 attribute
1194  * @nla: s64 netlink attribute
1195  */
nla_get_s64(const struct nlattr * nla)1196 static inline s64 nla_get_s64(const struct nlattr *nla)
1197 {
1198 	s64 tmp;
1199 
1200 	nla_memcpy(&tmp, nla, sizeof(tmp));
1201 
1202 	return tmp;
1203 }
1204 
1205 /**
1206  * nla_get_flag - return payload of flag attribute
1207  * @nla: flag netlink attribute
1208  */
nla_get_flag(const struct nlattr * nla)1209 static inline int nla_get_flag(const struct nlattr *nla)
1210 {
1211 	return !!nla;
1212 }
1213 
1214 /**
1215  * nla_get_msecs - return payload of msecs attribute
1216  * @nla: msecs netlink attribute
1217  *
1218  * Returns the number of milliseconds in jiffies.
1219  */
nla_get_msecs(const struct nlattr * nla)1220 static inline unsigned long nla_get_msecs(const struct nlattr *nla)
1221 {
1222 	u64 msecs = nla_get_u64(nla);
1223 
1224 	return msecs_to_jiffies((unsigned long) msecs);
1225 }
1226 
1227 /**
1228  * nla_get_in_addr - return payload of IPv4 address attribute
1229  * @nla: IPv4 address netlink attribute
1230  */
nla_get_in_addr(const struct nlattr * nla)1231 static inline __be32 nla_get_in_addr(const struct nlattr *nla)
1232 {
1233 	return *(__be32 *) nla_data(nla);
1234 }
1235 
1236 /**
1237  * nla_get_in6_addr - return payload of IPv6 address attribute
1238  * @nla: IPv6 address netlink attribute
1239  */
nla_get_in6_addr(const struct nlattr * nla)1240 static inline struct in6_addr nla_get_in6_addr(const struct nlattr *nla)
1241 {
1242 	struct in6_addr tmp;
1243 
1244 	nla_memcpy(&tmp, nla, sizeof(tmp));
1245 	return tmp;
1246 }
1247 
1248 /**
1249  * nla_get_bitfield32 - return payload of 32 bitfield attribute
1250  * @nla: nla_bitfield32 attribute
1251  */
nla_get_bitfield32(const struct nlattr * nla)1252 static inline struct nla_bitfield32 nla_get_bitfield32(const struct nlattr *nla)
1253 {
1254 	struct nla_bitfield32 tmp;
1255 
1256 	nla_memcpy(&tmp, nla, sizeof(tmp));
1257 	return tmp;
1258 }
1259 
1260 /**
1261  * nla_memdup - duplicate attribute memory (kmemdup)
1262  * @src: netlink attribute to duplicate from
1263  * @gfp: GFP mask
1264  */
nla_memdup(const struct nlattr * src,gfp_t gfp)1265 static inline void *nla_memdup(const struct nlattr *src, gfp_t gfp)
1266 {
1267 	return kmemdup(nla_data(src), nla_len(src), gfp);
1268 }
1269 
1270 /**
1271  * nla_nest_start - Start a new level of nested attributes
1272  * @skb: socket buffer to add attributes to
1273  * @attrtype: attribute type of container
1274  *
1275  * Returns the container attribute
1276  */
nla_nest_start(struct sk_buff * skb,int attrtype)1277 static inline struct nlattr *nla_nest_start(struct sk_buff *skb, int attrtype)
1278 {
1279 	struct nlattr *start = (struct nlattr *)skb_tail_pointer(skb);
1280 
1281 	if (nla_put(skb, attrtype, 0, NULL) < 0)
1282 		return NULL;
1283 
1284 	return start;
1285 }
1286 
1287 /**
1288  * nla_nest_end - Finalize nesting of attributes
1289  * @skb: socket buffer the attributes are stored in
1290  * @start: container attribute
1291  *
1292  * Corrects the container attribute header to include the all
1293  * appeneded attributes.
1294  *
1295  * Returns the total data length of the skb.
1296  */
nla_nest_end(struct sk_buff * skb,struct nlattr * start)1297 static inline int nla_nest_end(struct sk_buff *skb, struct nlattr *start)
1298 {
1299 	start->nla_len = skb_tail_pointer(skb) - (unsigned char *)start;
1300 	return skb->len;
1301 }
1302 
1303 /**
1304  * nla_nest_cancel - Cancel nesting of attributes
1305  * @skb: socket buffer the message is stored in
1306  * @start: container attribute
1307  *
1308  * Removes the container attribute and including all nested
1309  * attributes. Returns -EMSGSIZE
1310  */
nla_nest_cancel(struct sk_buff * skb,struct nlattr * start)1311 static inline void nla_nest_cancel(struct sk_buff *skb, struct nlattr *start)
1312 {
1313 	nlmsg_trim(skb, start);
1314 }
1315 
1316 /**
1317  * nla_validate_nested - Validate a stream of nested attributes
1318  * @start: container attribute
1319  * @maxtype: maximum attribute type to be expected
1320  * @policy: validation policy
1321  * @extack: extended ACK report struct
1322  *
1323  * Validates all attributes in the nested attribute stream against the
1324  * specified policy. Attributes with a type exceeding maxtype will be
1325  * ignored. See documenation of struct nla_policy for more details.
1326  *
1327  * Returns 0 on success or a negative error code.
1328  */
nla_validate_nested(const struct nlattr * start,int maxtype,const struct nla_policy * policy,struct netlink_ext_ack * extack)1329 static inline int nla_validate_nested(const struct nlattr *start, int maxtype,
1330 				      const struct nla_policy *policy,
1331 				      struct netlink_ext_ack *extack)
1332 {
1333 	return nla_validate(nla_data(start), nla_len(start), maxtype, policy,
1334 			    extack);
1335 }
1336 
1337 /**
1338  * nla_need_padding_for_64bit - test 64-bit alignment of the next attribute
1339  * @skb: socket buffer the message is stored in
1340  *
1341  * Return true if padding is needed to align the next attribute (nla_data()) to
1342  * a 64-bit aligned area.
1343  */
nla_need_padding_for_64bit(struct sk_buff * skb)1344 static inline bool nla_need_padding_for_64bit(struct sk_buff *skb)
1345 {
1346 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1347 	/* The nlattr header is 4 bytes in size, that's why we test
1348 	 * if the skb->data _is_ aligned.  A NOP attribute, plus
1349 	 * nlattr header for next attribute, will make nla_data()
1350 	 * 8-byte aligned.
1351 	 */
1352 	if (IS_ALIGNED((unsigned long)skb_tail_pointer(skb), 8))
1353 		return true;
1354 #endif
1355 	return false;
1356 }
1357 
1358 /**
1359  * nla_align_64bit - 64-bit align the nla_data() of next attribute
1360  * @skb: socket buffer the message is stored in
1361  * @padattr: attribute type for the padding
1362  *
1363  * Conditionally emit a padding netlink attribute in order to make
1364  * the next attribute we emit have a 64-bit aligned nla_data() area.
1365  * This will only be done in architectures which do not have
1366  * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS defined.
1367  *
1368  * Returns zero on success or a negative error code.
1369  */
nla_align_64bit(struct sk_buff * skb,int padattr)1370 static inline int nla_align_64bit(struct sk_buff *skb, int padattr)
1371 {
1372 	if (nla_need_padding_for_64bit(skb) &&
1373 	    !nla_reserve(skb, padattr, 0))
1374 		return -EMSGSIZE;
1375 
1376 	return 0;
1377 }
1378 
1379 /**
1380  * nla_total_size_64bit - total length of attribute including padding
1381  * @payload: length of payload
1382  */
nla_total_size_64bit(int payload)1383 static inline int nla_total_size_64bit(int payload)
1384 {
1385 	return NLA_ALIGN(nla_attr_size(payload))
1386 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1387 		+ NLA_ALIGN(nla_attr_size(0))
1388 #endif
1389 		;
1390 }
1391 
1392 /**
1393  * nla_for_each_attr - iterate over a stream of attributes
1394  * @pos: loop counter, set to current attribute
1395  * @head: head of attribute stream
1396  * @len: length of attribute stream
1397  * @rem: initialized to len, holds bytes currently remaining in stream
1398  */
1399 #define nla_for_each_attr(pos, head, len, rem) \
1400 	for (pos = head, rem = len; \
1401 	     nla_ok(pos, rem); \
1402 	     pos = nla_next(pos, &(rem)))
1403 
1404 /**
1405  * nla_for_each_nested - iterate over nested attributes
1406  * @pos: loop counter, set to current attribute
1407  * @nla: attribute containing the nested attributes
1408  * @rem: initialized to len, holds bytes currently remaining in stream
1409  */
1410 #define nla_for_each_nested(pos, nla, rem) \
1411 	nla_for_each_attr(pos, nla_data(nla), nla_len(nla), rem)
1412 
1413 /**
1414  * nla_is_last - Test if attribute is last in stream
1415  * @nla: attribute to test
1416  * @rem: bytes remaining in stream
1417  */
nla_is_last(const struct nlattr * nla,int rem)1418 static inline bool nla_is_last(const struct nlattr *nla, int rem)
1419 {
1420 	return nla->nla_len == rem;
1421 }
1422 
1423 #endif
1424