xref: /linux/include/net/netlink.h (revision f3d9478b2ce468c3115b02ecae7e975990697f15)
1 #ifndef __NET_NETLINK_H
2 #define __NET_NETLINK_H
3 
4 #include <linux/types.h>
5 #include <linux/netlink.h>
6 
7 /* ========================================================================
8  *         Netlink Messages and Attributes Interface (As Seen On TV)
9  * ------------------------------------------------------------------------
10  *                          Messages Interface
11  * ------------------------------------------------------------------------
12  *
13  * Message Format:
14  *    <--- nlmsg_total_size(payload)  --->
15  *    <-- nlmsg_msg_size(payload) ->
16  *   +----------+- - -+-------------+- - -+-------- - -
17  *   | nlmsghdr | Pad |   Payload   | Pad | nlmsghdr
18  *   +----------+- - -+-------------+- - -+-------- - -
19  *   nlmsg_data(nlh)---^                   ^
20  *   nlmsg_next(nlh)-----------------------+
21  *
22  * Payload Format:
23  *    <---------------------- nlmsg_len(nlh) --------------------->
24  *    <------ hdrlen ------>       <- nlmsg_attrlen(nlh, hdrlen) ->
25  *   +----------------------+- - -+--------------------------------+
26  *   |     Family Header    | Pad |           Attributes           |
27  *   +----------------------+- - -+--------------------------------+
28  *   nlmsg_attrdata(nlh, hdrlen)---^
29  *
30  * Data Structures:
31  *   struct nlmsghdr			netlink message header
32  *
33  * Message Construction:
34  *   nlmsg_new()			create a new netlink message
35  *   nlmsg_put()			add a netlink message to an skb
36  *   nlmsg_put_answer()			callback based nlmsg_put()
37  *   nlmsg_end()			finanlize netlink message
38  *   nlmsg_cancel()			cancel message construction
39  *   nlmsg_free()			free a netlink message
40  *
41  * Message Sending:
42  *   nlmsg_multicast()			multicast message to several groups
43  *   nlmsg_unicast()			unicast a message to a single socket
44  *
45  * Message Length Calculations:
46  *   nlmsg_msg_size(payload)		length of message w/o padding
47  *   nlmsg_total_size(payload)		length of message w/ padding
48  *   nlmsg_padlen(payload)		length of padding at tail
49  *
50  * Message Payload Access:
51  *   nlmsg_data(nlh)			head of message payload
52  *   nlmsg_len(nlh)			length of message payload
53  *   nlmsg_attrdata(nlh, hdrlen)	head of attributes data
54  *   nlmsg_attrlen(nlh, hdrlen)		length of attributes data
55  *
56  * Message Parsing:
57  *   nlmsg_ok(nlh, remaining)		does nlh fit into remaining bytes?
58  *   nlmsg_next(nlh, remaining)		get next netlink message
59  *   nlmsg_parse()			parse attributes of a message
60  *   nlmsg_find_attr()			find an attribute in a message
61  *   nlmsg_for_each_msg()		loop over all messages
62  *   nlmsg_validate()			validate netlink message incl. attrs
63  *   nlmsg_for_each_attr()		loop over all attributes
64  *
65  * ------------------------------------------------------------------------
66  *                          Attributes Interface
67  * ------------------------------------------------------------------------
68  *
69  * Attribute Format:
70  *    <------- nla_total_size(payload) ------->
71  *    <---- nla_attr_size(payload) ----->
72  *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
73  *   |  Header  | Pad |     Payload      | Pad |  Header
74  *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
75  *                     <- nla_len(nla) ->      ^
76  *   nla_data(nla)----^                        |
77  *   nla_next(nla)-----------------------------'
78  *
79  * Data Structures:
80  *   struct nlattr			netlink attribtue header
81  *
82  * Attribute Construction:
83  *   nla_reserve(skb, type, len)	reserve skb tailroom for an attribute
84  *   nla_put(skb, type, len, data)	add attribute to skb
85  *
86  * Attribute Construction for Basic Types:
87  *   nla_put_u8(skb, type, value)	add u8 attribute to skb
88  *   nla_put_u16(skb, type, value)	add u16 attribute to skb
89  *   nla_put_u32(skb, type, value)	add u32 attribute to skb
90  *   nla_put_u64(skb, type, value)	add u64 attribute to skb
91  *   nla_put_string(skb, type, str)	add string attribute to skb
92  *   nla_put_flag(skb, type)		add flag attribute to skb
93  *   nla_put_msecs(skb, type, jiffies)	add msecs attribute to skb
94  *
95  * Exceptions Based Attribute Construction:
96  *   NLA_PUT(skb, type, len, data)	add attribute to skb
97  *   NLA_PUT_U8(skb, type, value)	add u8 attribute to skb
98  *   NLA_PUT_U16(skb, type, value)	add u16 attribute to skb
99  *   NLA_PUT_U32(skb, type, value)	add u32 attribute to skb
100  *   NLA_PUT_U64(skb, type, value)	add u64 attribute to skb
101  *   NLA_PUT_STRING(skb, type, str)	add string attribute to skb
102  *   NLA_PUT_FLAG(skb, type)		add flag attribute to skb
103  *   NLA_PUT_MSECS(skb, type, jiffies)	add msecs attribute to skb
104  *
105  *   The meaning of these functions is equal to their lower case
106  *   variants but they jump to the label nla_put_failure in case
107  *   of a failure.
108  *
109  * Nested Attributes Construction:
110  *   nla_nest_start(skb, type)		start a nested attribute
111  *   nla_nest_end(skb, nla)		finalize a nested attribute
112  *   nla_nest_cancel(skb, nla)		cancel nested attribute construction
113  *
114  * Attribute Length Calculations:
115  *   nla_attr_size(payload)		length of attribute w/o padding
116  *   nla_total_size(payload)		length of attribute w/ padding
117  *   nla_padlen(payload)		length of padding
118  *
119  * Attribute Payload Access:
120  *   nla_data(nla)			head of attribute payload
121  *   nla_len(nla)			length of attribute payload
122  *
123  * Attribute Payload Access for Basic Types:
124  *   nla_get_u8(nla)			get payload for a u8 attribute
125  *   nla_get_u16(nla)			get payload for a u16 attribute
126  *   nla_get_u32(nla)			get payload for a u32 attribute
127  *   nla_get_u64(nla)			get payload for a u64 attribute
128  *   nla_get_flag(nla)			return 1 if flag is true
129  *   nla_get_msecs(nla)			get payload for a msecs attribute
130  *
131  * Attribute Misc:
132  *   nla_memcpy(dest, nla, count)	copy attribute into memory
133  *   nla_memcmp(nla, data, size)	compare attribute with memory area
134  *   nla_strlcpy(dst, nla, size)	copy attribute to a sized string
135  *   nla_strcmp(nla, str)		compare attribute with string
136  *
137  * Attribute Parsing:
138  *   nla_ok(nla, remaining)		does nla fit into remaining bytes?
139  *   nla_next(nla, remaining)		get next netlink attribute
140  *   nla_validate()			validate a stream of attributes
141  *   nla_find()				find attribute in stream of attributes
142  *   nla_parse()			parse and validate stream of attrs
143  *   nla_parse_nested()			parse nested attribuets
144  *   nla_for_each_attr()		loop over all attributes
145  *=========================================================================
146  */
147 
148  /**
149   * Standard attribute types to specify validation policy
150   */
151 enum {
152 	NLA_UNSPEC,
153 	NLA_U8,
154 	NLA_U16,
155 	NLA_U32,
156 	NLA_U64,
157 	NLA_STRING,
158 	NLA_FLAG,
159 	NLA_MSECS,
160 	NLA_NESTED,
161 	__NLA_TYPE_MAX,
162 };
163 
164 #define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
165 
166 /**
167  * struct nla_policy - attribute validation policy
168  * @type: Type of attribute or NLA_UNSPEC
169  * @minlen: Minimal length of payload required to be available
170  *
171  * Policies are defined as arrays of this struct, the array must be
172  * accessible by attribute type up to the highest identifier to be expected.
173  *
174  * Example:
175  * static struct nla_policy my_policy[ATTR_MAX+1] __read_mostly = {
176  * 	[ATTR_FOO] = { .type = NLA_U16 },
177  *	[ATTR_BAR] = { .type = NLA_STRING },
178  *	[ATTR_BAZ] = { .minlen = sizeof(struct mystruct) },
179  * };
180  */
181 struct nla_policy {
182 	u16		type;
183 	u16		minlen;
184 };
185 
186 extern void		netlink_run_queue(struct sock *sk, unsigned int *qlen,
187 					  int (*cb)(struct sk_buff *,
188 						    struct nlmsghdr *, int *));
189 extern void		netlink_queue_skip(struct nlmsghdr *nlh,
190 					   struct sk_buff *skb);
191 
192 extern int		nla_validate(struct nlattr *head, int len, int maxtype,
193 				     struct nla_policy *policy);
194 extern int		nla_parse(struct nlattr *tb[], int maxtype,
195 				  struct nlattr *head, int len,
196 				  struct nla_policy *policy);
197 extern struct nlattr *	nla_find(struct nlattr *head, int len, int attrtype);
198 extern size_t		nla_strlcpy(char *dst, const struct nlattr *nla,
199 				    size_t dstsize);
200 extern int		nla_memcpy(void *dest, struct nlattr *src, int count);
201 extern int		nla_memcmp(const struct nlattr *nla, const void *data,
202 				   size_t size);
203 extern int		nla_strcmp(const struct nlattr *nla, const char *str);
204 extern struct nlattr *	__nla_reserve(struct sk_buff *skb, int attrtype,
205 				      int attrlen);
206 extern struct nlattr *	nla_reserve(struct sk_buff *skb, int attrtype,
207 				    int attrlen);
208 extern void		__nla_put(struct sk_buff *skb, int attrtype,
209 				  int attrlen, const void *data);
210 extern int		nla_put(struct sk_buff *skb, int attrtype,
211 				int attrlen, const void *data);
212 
213 /**************************************************************************
214  * Netlink Messages
215  **************************************************************************/
216 
217 /**
218  * nlmsg_msg_size - length of netlink message not including padding
219  * @payload: length of message payload
220  */
221 static inline int nlmsg_msg_size(int payload)
222 {
223 	return NLMSG_HDRLEN + payload;
224 }
225 
226 /**
227  * nlmsg_total_size - length of netlink message including padding
228  * @payload: length of message payload
229  */
230 static inline int nlmsg_total_size(int payload)
231 {
232 	return NLMSG_ALIGN(nlmsg_msg_size(payload));
233 }
234 
235 /**
236  * nlmsg_padlen - length of padding at the message's tail
237  * @payload: length of message payload
238  */
239 static inline int nlmsg_padlen(int payload)
240 {
241 	return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
242 }
243 
244 /**
245  * nlmsg_data - head of message payload
246  * @nlh: netlink messsage header
247  */
248 static inline void *nlmsg_data(const struct nlmsghdr *nlh)
249 {
250 	return (unsigned char *) nlh + NLMSG_HDRLEN;
251 }
252 
253 /**
254  * nlmsg_len - length of message payload
255  * @nlh: netlink message header
256  */
257 static inline int nlmsg_len(const struct nlmsghdr *nlh)
258 {
259 	return nlh->nlmsg_len - NLMSG_HDRLEN;
260 }
261 
262 /**
263  * nlmsg_attrdata - head of attributes data
264  * @nlh: netlink message header
265  * @hdrlen: length of family specific header
266  */
267 static inline struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh,
268 					    int hdrlen)
269 {
270 	unsigned char *data = nlmsg_data(nlh);
271 	return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
272 }
273 
274 /**
275  * nlmsg_attrlen - length of attributes data
276  * @nlh: netlink message header
277  * @hdrlen: length of family specific header
278  */
279 static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
280 {
281 	return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
282 }
283 
284 /**
285  * nlmsg_ok - check if the netlink message fits into the remaining bytes
286  * @nlh: netlink message header
287  * @remaining: number of bytes remaining in message stream
288  */
289 static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
290 {
291 	return (remaining >= sizeof(struct nlmsghdr) &&
292 		nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
293 		nlh->nlmsg_len <= remaining);
294 }
295 
296 /**
297  * nlmsg_next - next netlink message in message stream
298  * @nlh: netlink message header
299  * @remaining: number of bytes remaining in message stream
300  *
301  * Returns the next netlink message in the message stream and
302  * decrements remaining by the size of the current message.
303  */
304 static inline struct nlmsghdr *nlmsg_next(struct nlmsghdr *nlh, int *remaining)
305 {
306 	int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
307 
308 	*remaining -= totlen;
309 
310 	return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
311 }
312 
313 /**
314  * nlmsg_parse - parse attributes of a netlink message
315  * @nlh: netlink message header
316  * @hdrlen: length of family specific header
317  * @tb: destination array with maxtype+1 elements
318  * @maxtype: maximum attribute type to be expected
319  * @policy: validation policy
320  *
321  * See nla_parse()
322  */
323 static inline int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen,
324 			      struct nlattr *tb[], int maxtype,
325 			      struct nla_policy *policy)
326 {
327 	if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
328 		return -EINVAL;
329 
330 	return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
331 			 nlmsg_attrlen(nlh, hdrlen), policy);
332 }
333 
334 /**
335  * nlmsg_find_attr - find a specific attribute in a netlink message
336  * @nlh: netlink message header
337  * @hdrlen: length of familiy specific header
338  * @attrtype: type of attribute to look for
339  *
340  * Returns the first attribute which matches the specified type.
341  */
342 static inline struct nlattr *nlmsg_find_attr(struct nlmsghdr *nlh,
343 					     int hdrlen, int attrtype)
344 {
345 	return nla_find(nlmsg_attrdata(nlh, hdrlen),
346 			nlmsg_attrlen(nlh, hdrlen), attrtype);
347 }
348 
349 /**
350  * nlmsg_validate - validate a netlink message including attributes
351  * @nlh: netlinket message header
352  * @hdrlen: length of familiy specific header
353  * @maxtype: maximum attribute type to be expected
354  * @policy: validation policy
355  */
356 static inline int nlmsg_validate(struct nlmsghdr *nlh, int hdrlen, int maxtype,
357 				 struct nla_policy *policy)
358 {
359 	if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
360 		return -EINVAL;
361 
362 	return nla_validate(nlmsg_attrdata(nlh, hdrlen),
363 			    nlmsg_attrlen(nlh, hdrlen), maxtype, policy);
364 }
365 
366 /**
367  * nlmsg_for_each_attr - iterate over a stream of attributes
368  * @pos: loop counter, set to current attribute
369  * @nlh: netlink message header
370  * @hdrlen: length of familiy specific header
371  * @rem: initialized to len, holds bytes currently remaining in stream
372  */
373 #define nlmsg_for_each_attr(pos, nlh, hdrlen, rem) \
374 	nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
375 			  nlmsg_attrlen(nlh, hdrlen), rem)
376 
377 #if 0
378 /* FIXME: Enable once all users have been converted */
379 
380 /**
381  * __nlmsg_put - Add a new netlink message to an skb
382  * @skb: socket buffer to store message in
383  * @pid: netlink process id
384  * @seq: sequence number of message
385  * @type: message type
386  * @payload: length of message payload
387  * @flags: message flags
388  *
389  * The caller is responsible to ensure that the skb provides enough
390  * tailroom for both the netlink header and payload.
391  */
392 static inline struct nlmsghdr *__nlmsg_put(struct sk_buff *skb, u32 pid,
393 					   u32 seq, int type, int payload,
394 					   int flags)
395 {
396 	struct nlmsghdr *nlh;
397 
398 	nlh = (struct nlmsghdr *) skb_put(skb, nlmsg_total_size(payload));
399 	nlh->nlmsg_type = type;
400 	nlh->nlmsg_len = nlmsg_msg_size(payload);
401 	nlh->nlmsg_flags = flags;
402 	nlh->nlmsg_pid = pid;
403 	nlh->nlmsg_seq = seq;
404 
405 	memset((unsigned char *) nlmsg_data(nlh) + payload, 0,
406 	       nlmsg_padlen(payload));
407 
408 	return nlh;
409 }
410 #endif
411 
412 /**
413  * nlmsg_put - Add a new netlink message to an skb
414  * @skb: socket buffer to store message in
415  * @pid: netlink process id
416  * @seq: sequence number of message
417  * @type: message type
418  * @payload: length of message payload
419  * @flags: message flags
420  *
421  * Returns NULL if the tailroom of the skb is insufficient to store
422  * the message header and payload.
423  */
424 static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq,
425 					 int type, int payload, int flags)
426 {
427 	if (unlikely(skb_tailroom(skb) < nlmsg_total_size(payload)))
428 		return NULL;
429 
430 	return __nlmsg_put(skb, pid, seq, type, payload, flags);
431 }
432 
433 /**
434  * nlmsg_put_answer - Add a new callback based netlink message to an skb
435  * @skb: socket buffer to store message in
436  * @cb: netlink callback
437  * @type: message type
438  * @payload: length of message payload
439  * @flags: message flags
440  *
441  * Returns NULL if the tailroom of the skb is insufficient to store
442  * the message header and payload.
443  */
444 static inline struct nlmsghdr *nlmsg_put_answer(struct sk_buff *skb,
445 						struct netlink_callback *cb,
446 						int type, int payload,
447 						int flags)
448 {
449 	return nlmsg_put(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
450 			 type, payload, flags);
451 }
452 
453 /**
454  * nlmsg_new - Allocate a new netlink message
455  * @size: maximum size of message
456  *
457  * Use NLMSG_GOODSIZE if size isn't know and you need a good default size.
458  */
459 static inline struct sk_buff *nlmsg_new(int size)
460 {
461 	return alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
462 }
463 
464 /**
465  * nlmsg_end - Finalize a netlink message
466  * @skb: socket buffer the message is stored in
467  * @nlh: netlink message header
468  *
469  * Corrects the netlink message header to include the appeneded
470  * attributes. Only necessary if attributes have been added to
471  * the message.
472  *
473  * Returns the total data length of the skb.
474  */
475 static inline int nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
476 {
477 	nlh->nlmsg_len = skb->tail - (unsigned char *) nlh;
478 
479 	return skb->len;
480 }
481 
482 /**
483  * nlmsg_cancel - Cancel construction of a netlink message
484  * @skb: socket buffer the message is stored in
485  * @nlh: netlink message header
486  *
487  * Removes the complete netlink message including all
488  * attributes from the socket buffer again. Returns -1.
489  */
490 static inline int nlmsg_cancel(struct sk_buff *skb, struct nlmsghdr *nlh)
491 {
492 	skb_trim(skb, (unsigned char *) nlh - skb->data);
493 
494 	return -1;
495 }
496 
497 /**
498  * nlmsg_free - free a netlink message
499  * @skb: socket buffer of netlink message
500  */
501 static inline void nlmsg_free(struct sk_buff *skb)
502 {
503 	kfree_skb(skb);
504 }
505 
506 /**
507  * nlmsg_multicast - multicast a netlink message
508  * @sk: netlink socket to spread messages to
509  * @skb: netlink message as socket buffer
510  * @pid: own netlink pid to avoid sending to yourself
511  * @group: multicast group id
512  */
513 static inline int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,
514 				  u32 pid, unsigned int group)
515 {
516 	int err;
517 
518 	NETLINK_CB(skb).dst_group = group;
519 
520 	err = netlink_broadcast(sk, skb, pid, group, GFP_KERNEL);
521 	if (err > 0)
522 		err = 0;
523 
524 	return err;
525 }
526 
527 /**
528  * nlmsg_unicast - unicast a netlink message
529  * @sk: netlink socket to spread message to
530  * @skb: netlink message as socket buffer
531  * @pid: netlink pid of the destination socket
532  */
533 static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 pid)
534 {
535 	int err;
536 
537 	err = netlink_unicast(sk, skb, pid, MSG_DONTWAIT);
538 	if (err > 0)
539 		err = 0;
540 
541 	return err;
542 }
543 
544 /**
545  * nlmsg_for_each_msg - iterate over a stream of messages
546  * @pos: loop counter, set to current message
547  * @head: head of message stream
548  * @len: length of message stream
549  * @rem: initialized to len, holds bytes currently remaining in stream
550  */
551 #define nlmsg_for_each_msg(pos, head, len, rem) \
552 	for (pos = head, rem = len; \
553 	     nlmsg_ok(pos, rem); \
554 	     pos = nlmsg_next(pos, &(rem)))
555 
556 /**************************************************************************
557  * Netlink Attributes
558  **************************************************************************/
559 
560 /**
561  * nla_attr_size - length of attribute not including padding
562  * @payload: length of payload
563  */
564 static inline int nla_attr_size(int payload)
565 {
566 	return NLA_HDRLEN + payload;
567 }
568 
569 /**
570  * nla_total_size - total length of attribute including padding
571  * @payload: length of payload
572  */
573 static inline int nla_total_size(int payload)
574 {
575 	return NLA_ALIGN(nla_attr_size(payload));
576 }
577 
578 /**
579  * nla_padlen - length of padding at the tail of attribute
580  * @payload: length of payload
581  */
582 static inline int nla_padlen(int payload)
583 {
584 	return nla_total_size(payload) - nla_attr_size(payload);
585 }
586 
587 /**
588  * nla_data - head of payload
589  * @nla: netlink attribute
590  */
591 static inline void *nla_data(const struct nlattr *nla)
592 {
593 	return (char *) nla + NLA_HDRLEN;
594 }
595 
596 /**
597  * nla_len - length of payload
598  * @nla: netlink attribute
599  */
600 static inline int nla_len(const struct nlattr *nla)
601 {
602 	return nla->nla_len - NLA_HDRLEN;
603 }
604 
605 /**
606  * nla_ok - check if the netlink attribute fits into the remaining bytes
607  * @nla: netlink attribute
608  * @remaining: number of bytes remaining in attribute stream
609  */
610 static inline int nla_ok(const struct nlattr *nla, int remaining)
611 {
612 	return remaining >= sizeof(*nla) &&
613 	       nla->nla_len >= sizeof(*nla) &&
614 	       nla->nla_len <= remaining;
615 }
616 
617 /**
618  * nla_next - next netlink attribte in attribute stream
619  * @nla: netlink attribute
620  * @remaining: number of bytes remaining in attribute stream
621  *
622  * Returns the next netlink attribute in the attribute stream and
623  * decrements remaining by the size of the current attribute.
624  */
625 static inline struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
626 {
627 	int totlen = NLA_ALIGN(nla->nla_len);
628 
629 	*remaining -= totlen;
630 	return (struct nlattr *) ((char *) nla + totlen);
631 }
632 
633 /**
634  * nla_parse_nested - parse nested attributes
635  * @tb: destination array with maxtype+1 elements
636  * @maxtype: maximum attribute type to be expected
637  * @nla: attribute containing the nested attributes
638  * @policy: validation policy
639  *
640  * See nla_parse()
641  */
642 static inline int nla_parse_nested(struct nlattr *tb[], int maxtype,
643 				   struct nlattr *nla,
644 				   struct nla_policy *policy)
645 {
646 	return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
647 }
648 /**
649  * nla_put_u8 - Add a u16 netlink attribute to a socket buffer
650  * @skb: socket buffer to add attribute to
651  * @attrtype: attribute type
652  * @value: numeric value
653  */
654 static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
655 {
656 	return nla_put(skb, attrtype, sizeof(u8), &value);
657 }
658 
659 /**
660  * nla_put_u16 - Add a u16 netlink attribute to a socket buffer
661  * @skb: socket buffer to add attribute to
662  * @attrtype: attribute type
663  * @value: numeric value
664  */
665 static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
666 {
667 	return nla_put(skb, attrtype, sizeof(u16), &value);
668 }
669 
670 /**
671  * nla_put_u32 - Add a u32 netlink attribute to a socket buffer
672  * @skb: socket buffer to add attribute to
673  * @attrtype: attribute type
674  * @value: numeric value
675  */
676 static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
677 {
678 	return nla_put(skb, attrtype, sizeof(u32), &value);
679 }
680 
681 /**
682  * nla_put_64 - Add a u64 netlink attribute to a socket buffer
683  * @skb: socket buffer to add attribute to
684  * @attrtype: attribute type
685  * @value: numeric value
686  */
687 static inline int nla_put_u64(struct sk_buff *skb, int attrtype, u64 value)
688 {
689 	return nla_put(skb, attrtype, sizeof(u64), &value);
690 }
691 
692 /**
693  * nla_put_string - Add a string netlink attribute to a socket buffer
694  * @skb: socket buffer to add attribute to
695  * @attrtype: attribute type
696  * @str: NUL terminated string
697  */
698 static inline int nla_put_string(struct sk_buff *skb, int attrtype,
699 				 const char *str)
700 {
701 	return nla_put(skb, attrtype, strlen(str) + 1, str);
702 }
703 
704 /**
705  * nla_put_flag - Add a flag netlink attribute to a socket buffer
706  * @skb: socket buffer to add attribute to
707  * @attrtype: attribute type
708  */
709 static inline int nla_put_flag(struct sk_buff *skb, int attrtype)
710 {
711 	return nla_put(skb, attrtype, 0, NULL);
712 }
713 
714 /**
715  * nla_put_msecs - Add a msecs netlink attribute to a socket buffer
716  * @skb: socket buffer to add attribute to
717  * @attrtype: attribute type
718  * @jiffies: number of msecs in jiffies
719  */
720 static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
721 				unsigned long jiffies)
722 {
723 	u64 tmp = jiffies_to_msecs(jiffies);
724 	return nla_put(skb, attrtype, sizeof(u64), &tmp);
725 }
726 
727 #define NLA_PUT(skb, attrtype, attrlen, data) \
728 	do { \
729 		if (nla_put(skb, attrtype, attrlen, data) < 0) \
730 			goto nla_put_failure; \
731 	} while(0)
732 
733 #define NLA_PUT_TYPE(skb, type, attrtype, value) \
734 	do { \
735 		type __tmp = value; \
736 		NLA_PUT(skb, attrtype, sizeof(type), &__tmp); \
737 	} while(0)
738 
739 #define NLA_PUT_U8(skb, attrtype, value) \
740 	NLA_PUT_TYPE(skb, u8, attrtype, value)
741 
742 #define NLA_PUT_U16(skb, attrtype, value) \
743 	NLA_PUT_TYPE(skb, u16, attrtype, value)
744 
745 #define NLA_PUT_U32(skb, attrtype, value) \
746 	NLA_PUT_TYPE(skb, u32, attrtype, value)
747 
748 #define NLA_PUT_U64(skb, attrtype, value) \
749 	NLA_PUT_TYPE(skb, u64, attrtype, value)
750 
751 #define NLA_PUT_STRING(skb, attrtype, value) \
752 	NLA_PUT(skb, attrtype, strlen(value) + 1, value)
753 
754 #define NLA_PUT_FLAG(skb, attrtype, value) \
755 	NLA_PUT(skb, attrtype, 0, NULL)
756 
757 #define NLA_PUT_MSECS(skb, attrtype, jiffies) \
758 	NLA_PUT_U64(skb, attrtype, jiffies_to_msecs(jiffies))
759 
760 /**
761  * nla_get_u32 - return payload of u32 attribute
762  * @nla: u32 netlink attribute
763  */
764 static inline u32 nla_get_u32(struct nlattr *nla)
765 {
766 	return *(u32 *) nla_data(nla);
767 }
768 
769 /**
770  * nla_get_u16 - return payload of u16 attribute
771  * @nla: u16 netlink attribute
772  */
773 static inline u16 nla_get_u16(struct nlattr *nla)
774 {
775 	return *(u16 *) nla_data(nla);
776 }
777 
778 /**
779  * nla_get_u8 - return payload of u8 attribute
780  * @nla: u8 netlink attribute
781  */
782 static inline u8 nla_get_u8(struct nlattr *nla)
783 {
784 	return *(u8 *) nla_data(nla);
785 }
786 
787 /**
788  * nla_get_u64 - return payload of u64 attribute
789  * @nla: u64 netlink attribute
790  */
791 static inline u64 nla_get_u64(struct nlattr *nla)
792 {
793 	u64 tmp;
794 
795 	nla_memcpy(&tmp, nla, sizeof(tmp));
796 
797 	return tmp;
798 }
799 
800 /**
801  * nla_get_flag - return payload of flag attribute
802  * @nla: flag netlink attribute
803  */
804 static inline int nla_get_flag(struct nlattr *nla)
805 {
806 	return !!nla;
807 }
808 
809 /**
810  * nla_get_msecs - return payload of msecs attribute
811  * @nla: msecs netlink attribute
812  *
813  * Returns the number of milliseconds in jiffies.
814  */
815 static inline unsigned long nla_get_msecs(struct nlattr *nla)
816 {
817 	u64 msecs = nla_get_u64(nla);
818 
819 	return msecs_to_jiffies((unsigned long) msecs);
820 }
821 
822 /**
823  * nla_nest_start - Start a new level of nested attributes
824  * @skb: socket buffer to add attributes to
825  * @attrtype: attribute type of container
826  *
827  * Returns the container attribute
828  */
829 static inline struct nlattr *nla_nest_start(struct sk_buff *skb, int attrtype)
830 {
831 	struct nlattr *start = (struct nlattr *) skb->tail;
832 
833 	if (nla_put(skb, attrtype, 0, NULL) < 0)
834 		return NULL;
835 
836 	return start;
837 }
838 
839 /**
840  * nla_nest_end - Finalize nesting of attributes
841  * @skb: socket buffer the attribtues are stored in
842  * @start: container attribute
843  *
844  * Corrects the container attribute header to include the all
845  * appeneded attributes.
846  *
847  * Returns the total data length of the skb.
848  */
849 static inline int nla_nest_end(struct sk_buff *skb, struct nlattr *start)
850 {
851 	start->nla_len = skb->tail - (unsigned char *) start;
852 	return skb->len;
853 }
854 
855 /**
856  * nla_nest_cancel - Cancel nesting of attributes
857  * @skb: socket buffer the message is stored in
858  * @start: container attribute
859  *
860  * Removes the container attribute and including all nested
861  * attributes. Returns -1.
862  */
863 static inline int nla_nest_cancel(struct sk_buff *skb, struct nlattr *start)
864 {
865 	if (start)
866 		skb_trim(skb, (unsigned char *) start - skb->data);
867 
868 	return -1;
869 }
870 
871 /**
872  * nla_for_each_attr - iterate over a stream of attributes
873  * @pos: loop counter, set to current attribute
874  * @head: head of attribute stream
875  * @len: length of attribute stream
876  * @rem: initialized to len, holds bytes currently remaining in stream
877  */
878 #define nla_for_each_attr(pos, head, len, rem) \
879 	for (pos = head, rem = len; \
880 	     nla_ok(pos, rem); \
881 	     pos = nla_next(pos, &(rem)))
882 
883 #endif
884