blob: 373f1a900cf4784abf1f4e71791f501e222dfe3f [file] [log] [blame]
Thomas Grafbfa83a92005-11-10 02:25:51 +01001#ifndef __NET_NETLINK_H
2#define __NET_NETLINK_H
3
4#include <linux/types.h>
5#include <linux/netlink.h>
Al Virod7fe0f22006-12-03 23:15:30 -05006#include <linux/jiffies.h>
Thomas Grafbfa83a92005-11-10 02:25:51 +01007
8/* ========================================================================
9 * Netlink Messages and Attributes Interface (As Seen On TV)
10 * ------------------------------------------------------------------------
11 * Messages Interface
12 * ------------------------------------------------------------------------
13 *
14 * Message Format:
15 * <--- nlmsg_total_size(payload) --->
16 * <-- nlmsg_msg_size(payload) ->
17 * +----------+- - -+-------------+- - -+-------- - -
18 * | nlmsghdr | Pad | Payload | Pad | nlmsghdr
19 * +----------+- - -+-------------+- - -+-------- - -
20 * nlmsg_data(nlh)---^ ^
21 * nlmsg_next(nlh)-----------------------+
22 *
23 * Payload Format:
24 * <---------------------- nlmsg_len(nlh) --------------------->
25 * <------ hdrlen ------> <- nlmsg_attrlen(nlh, hdrlen) ->
26 * +----------------------+- - -+--------------------------------+
27 * | Family Header | Pad | Attributes |
28 * +----------------------+- - -+--------------------------------+
29 * nlmsg_attrdata(nlh, hdrlen)---^
30 *
31 * Data Structures:
32 * struct nlmsghdr netlink message header
33 *
34 * Message Construction:
35 * nlmsg_new() create a new netlink message
36 * nlmsg_put() add a netlink message to an skb
37 * nlmsg_put_answer() callback based nlmsg_put()
Justin P. Mattock1dc8d8c2010-06-21 13:45:42 -070038 * nlmsg_end() finalize netlink message
Thomas Graffe4944e2006-08-04 23:03:05 -070039 * nlmsg_get_pos() return current position in message
40 * nlmsg_trim() trim part of message
Thomas Grafbfa83a92005-11-10 02:25:51 +010041 * nlmsg_cancel() cancel message construction
42 * nlmsg_free() free a netlink message
43 *
44 * Message Sending:
45 * nlmsg_multicast() multicast message to several groups
46 * nlmsg_unicast() unicast a message to a single socket
Thomas Grafd387f6a2006-08-15 00:31:06 -070047 * nlmsg_notify() send notification message
Thomas Grafbfa83a92005-11-10 02:25:51 +010048 *
49 * Message Length Calculations:
50 * nlmsg_msg_size(payload) length of message w/o padding
51 * nlmsg_total_size(payload) length of message w/ padding
52 * nlmsg_padlen(payload) length of padding at tail
53 *
54 * Message Payload Access:
55 * nlmsg_data(nlh) head of message payload
56 * nlmsg_len(nlh) length of message payload
57 * nlmsg_attrdata(nlh, hdrlen) head of attributes data
58 * nlmsg_attrlen(nlh, hdrlen) length of attributes data
59 *
60 * Message Parsing:
61 * nlmsg_ok(nlh, remaining) does nlh fit into remaining bytes?
62 * nlmsg_next(nlh, remaining) get next netlink message
63 * nlmsg_parse() parse attributes of a message
64 * nlmsg_find_attr() find an attribute in a message
65 * nlmsg_for_each_msg() loop over all messages
66 * nlmsg_validate() validate netlink message incl. attrs
67 * nlmsg_for_each_attr() loop over all attributes
68 *
Thomas Graf97676b62006-08-15 00:31:41 -070069 * Misc:
70 * nlmsg_report() report back to application?
71 *
Thomas Grafbfa83a92005-11-10 02:25:51 +010072 * ------------------------------------------------------------------------
73 * Attributes Interface
74 * ------------------------------------------------------------------------
75 *
76 * Attribute Format:
77 * <------- nla_total_size(payload) ------->
78 * <---- nla_attr_size(payload) ----->
79 * +----------+- - -+- - - - - - - - - +- - -+-------- - -
80 * | Header | Pad | Payload | Pad | Header
81 * +----------+- - -+- - - - - - - - - +- - -+-------- - -
82 * <- nla_len(nla) -> ^
83 * nla_data(nla)----^ |
84 * nla_next(nla)-----------------------------'
85 *
86 * Data Structures:
Pierre Ynardd1ec3b72007-10-10 21:09:48 -070087 * struct nlattr netlink attribute header
Thomas Grafbfa83a92005-11-10 02:25:51 +010088 *
89 * Attribute Construction:
Thomas Graffe4944e2006-08-04 23:03:05 -070090 * nla_reserve(skb, type, len) reserve room for an attribute
91 * nla_reserve_nohdr(skb, len) reserve room for an attribute w/o hdr
Thomas Grafbfa83a92005-11-10 02:25:51 +010092 * nla_put(skb, type, len, data) add attribute to skb
Thomas Graffe4944e2006-08-04 23:03:05 -070093 * nla_put_nohdr(skb, len, data) add attribute w/o hdr
Patrick McHardy01480e12008-01-22 22:10:59 -080094 * nla_append(skb, len, data) append data to skb
Thomas Grafbfa83a92005-11-10 02:25:51 +010095 *
96 * Attribute Construction for Basic Types:
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 * Exceptions Based Attribute Construction:
106 * NLA_PUT(skb, type, len, data) add attribute to skb
107 * NLA_PUT_U8(skb, type, value) add u8 attribute to skb
108 * NLA_PUT_U16(skb, type, value) add u16 attribute to skb
109 * NLA_PUT_U32(skb, type, value) add u32 attribute to skb
110 * NLA_PUT_U64(skb, type, value) add u64 attribute to skb
111 * NLA_PUT_STRING(skb, type, str) add string attribute to skb
112 * NLA_PUT_FLAG(skb, type) add flag attribute to skb
113 * NLA_PUT_MSECS(skb, type, jiffies) add msecs attribute to skb
114 *
115 * The meaning of these functions is equal to their lower case
116 * variants but they jump to the label nla_put_failure in case
117 * of a failure.
118 *
119 * Nested Attributes Construction:
120 * nla_nest_start(skb, type) start a nested attribute
121 * nla_nest_end(skb, nla) finalize a nested attribute
122 * nla_nest_cancel(skb, nla) cancel nested attribute construction
123 *
124 * Attribute Length Calculations:
125 * nla_attr_size(payload) length of attribute w/o padding
126 * nla_total_size(payload) length of attribute w/ padding
127 * nla_padlen(payload) length of padding
128 *
129 * Attribute Payload Access:
130 * nla_data(nla) head of attribute payload
131 * nla_len(nla) length of attribute payload
132 *
133 * Attribute Payload Access for Basic Types:
134 * nla_get_u8(nla) get payload for a u8 attribute
135 * nla_get_u16(nla) get payload for a u16 attribute
136 * nla_get_u32(nla) get payload for a u32 attribute
137 * nla_get_u64(nla) get payload for a u64 attribute
138 * nla_get_flag(nla) return 1 if flag is true
139 * nla_get_msecs(nla) get payload for a msecs attribute
140 *
141 * Attribute Misc:
142 * nla_memcpy(dest, nla, count) copy attribute into memory
143 * nla_memcmp(nla, data, size) compare attribute with memory area
144 * nla_strlcpy(dst, nla, size) copy attribute to a sized string
145 * nla_strcmp(nla, str) compare attribute with string
146 *
147 * Attribute Parsing:
148 * nla_ok(nla, remaining) does nla fit into remaining bytes?
149 * nla_next(nla, remaining) get next netlink attribute
150 * nla_validate() validate a stream of attributes
Paul Moore4fe5d5c2006-09-25 15:54:03 -0700151 * nla_validate_nested() validate a stream of nested attributes
Thomas Grafbfa83a92005-11-10 02:25:51 +0100152 * nla_find() find attribute in stream of attributes
Thomas Graffe4944e2006-08-04 23:03:05 -0700153 * nla_find_nested() find attribute in nested attributes
Thomas Grafbfa83a92005-11-10 02:25:51 +0100154 * nla_parse() parse and validate stream of attrs
155 * nla_parse_nested() parse nested attribuets
156 * nla_for_each_attr() loop over all attributes
Paul Moore22acb192006-09-25 15:53:37 -0700157 * nla_for_each_nested() loop over the nested attributes
Thomas Grafbfa83a92005-11-10 02:25:51 +0100158 *=========================================================================
159 */
160
161 /**
162 * Standard attribute types to specify validation policy
163 */
164enum {
165 NLA_UNSPEC,
166 NLA_U8,
167 NLA_U16,
168 NLA_U32,
169 NLA_U64,
170 NLA_STRING,
171 NLA_FLAG,
172 NLA_MSECS,
173 NLA_NESTED,
Patrick McHardy1092cb22007-06-25 13:49:35 -0700174 NLA_NESTED_COMPAT,
Thomas Grafa5531a52006-08-26 20:11:47 -0700175 NLA_NUL_STRING,
Johannes Bergd30045a2007-03-23 11:37:48 -0700176 NLA_BINARY,
Thomas Grafbfa83a92005-11-10 02:25:51 +0100177 __NLA_TYPE_MAX,
178};
179
180#define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
181
182/**
183 * struct nla_policy - attribute validation policy
184 * @type: Type of attribute or NLA_UNSPEC
Thomas Grafa5531a52006-08-26 20:11:47 -0700185 * @len: Type specific length of payload
Thomas Grafbfa83a92005-11-10 02:25:51 +0100186 *
187 * Policies are defined as arrays of this struct, the array must be
188 * accessible by attribute type up to the highest identifier to be expected.
189 *
Thomas Grafa5531a52006-08-26 20:11:47 -0700190 * Meaning of `len' field:
191 * NLA_STRING Maximum length of string
192 * NLA_NUL_STRING Maximum length of string (excluding NUL)
193 * NLA_FLAG Unused
Johannes Bergd30045a2007-03-23 11:37:48 -0700194 * NLA_BINARY Maximum length of attribute payload
Patrick McHardy1092cb22007-06-25 13:49:35 -0700195 * NLA_NESTED_COMPAT Exact length of structure payload
Thomas Grafa5531a52006-08-26 20:11:47 -0700196 * All other Exact length of attribute payload
197 *
Thomas Grafbfa83a92005-11-10 02:25:51 +0100198 * Example:
Alexey Dobriyanb54452b2010-02-18 08:14:31 +0000199 * static const struct nla_policy my_policy[ATTR_MAX+1] = {
Thomas Grafbfa83a92005-11-10 02:25:51 +0100200 * [ATTR_FOO] = { .type = NLA_U16 },
Johannes Bergd30045a2007-03-23 11:37:48 -0700201 * [ATTR_BAR] = { .type = NLA_STRING, .len = BARSIZ },
Thomas Grafa5531a52006-08-26 20:11:47 -0700202 * [ATTR_BAZ] = { .len = sizeof(struct mystruct) },
Thomas Grafbfa83a92005-11-10 02:25:51 +0100203 * };
204 */
205struct nla_policy {
206 u16 type;
Thomas Grafa5531a52006-08-26 20:11:47 -0700207 u16 len;
Thomas Grafbfa83a92005-11-10 02:25:51 +0100208};
209
Thomas Graf4e902c52006-08-17 18:14:52 -0700210/**
211 * struct nl_info - netlink source information
212 * @nlh: Netlink message header of original request
213 * @pid: Netlink PID of requesting application
214 */
215struct nl_info {
216 struct nlmsghdr *nlh;
Denis V. Lunev4d1169c2008-01-10 03:26:13 -0800217 struct net *nl_net;
Thomas Graf4e902c52006-08-17 18:14:52 -0700218 u32 pid;
219};
220
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -0700221extern int netlink_rcv_skb(struct sk_buff *skb,
222 int (*cb)(struct sk_buff *,
223 struct nlmsghdr *));
Thomas Graf97676b62006-08-15 00:31:41 -0700224extern int nlmsg_notify(struct sock *sk, struct sk_buff *skb,
225 u32 pid, unsigned int group, int report,
226 gfp_t flags);
Thomas Graf82ace472005-11-10 02:25:53 +0100227
Jan Engelhardt36546542010-11-16 09:52:32 -0800228extern int nla_validate(const struct nlattr *head,
229 int len, int maxtype,
Patrick McHardyef7c79e2007-06-05 12:38:30 -0700230 const struct nla_policy *policy);
Jan Engelhardt36546542010-11-16 09:52:32 -0800231extern int nla_parse(struct nlattr **tb, int maxtype,
232 const struct nlattr *head, int len,
Patrick McHardyef7c79e2007-06-05 12:38:30 -0700233 const struct nla_policy *policy);
Holger Eitzenbergere487eb92009-03-25 18:26:30 +0100234extern int nla_policy_len(const struct nla_policy *, int);
Jan Engelhardt36546542010-11-16 09:52:32 -0800235extern struct nlattr * nla_find(const struct nlattr *head,
236 int len, int attrtype);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100237extern size_t nla_strlcpy(char *dst, const struct nlattr *nla,
238 size_t dstsize);
Patrick McHardyb057efd2008-10-28 11:59:11 -0700239extern int nla_memcpy(void *dest, const struct nlattr *src, int count);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100240extern int nla_memcmp(const struct nlattr *nla, const void *data,
241 size_t size);
242extern int nla_strcmp(const struct nlattr *nla, const char *str);
243extern struct nlattr * __nla_reserve(struct sk_buff *skb, int attrtype,
244 int attrlen);
Thomas Graffe4944e2006-08-04 23:03:05 -0700245extern void * __nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100246extern struct nlattr * nla_reserve(struct sk_buff *skb, int attrtype,
247 int attrlen);
Thomas Graffe4944e2006-08-04 23:03:05 -0700248extern void * nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100249extern void __nla_put(struct sk_buff *skb, int attrtype,
250 int attrlen, const void *data);
Thomas Graffe4944e2006-08-04 23:03:05 -0700251extern void __nla_put_nohdr(struct sk_buff *skb, int attrlen,
252 const void *data);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100253extern int nla_put(struct sk_buff *skb, int attrtype,
254 int attrlen, const void *data);
Thomas Graffe4944e2006-08-04 23:03:05 -0700255extern int nla_put_nohdr(struct sk_buff *skb, int attrlen,
256 const void *data);
Patrick McHardy01480e12008-01-22 22:10:59 -0800257extern int nla_append(struct sk_buff *skb, int attrlen,
258 const void *data);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100259
260/**************************************************************************
261 * Netlink Messages
262 **************************************************************************/
263
264/**
265 * nlmsg_msg_size - length of netlink message not including padding
266 * @payload: length of message payload
267 */
268static inline int nlmsg_msg_size(int payload)
269{
270 return NLMSG_HDRLEN + payload;
271}
272
273/**
274 * nlmsg_total_size - length of netlink message including padding
275 * @payload: length of message payload
276 */
277static inline int nlmsg_total_size(int payload)
278{
279 return NLMSG_ALIGN(nlmsg_msg_size(payload));
280}
281
282/**
283 * nlmsg_padlen - length of padding at the message's tail
284 * @payload: length of message payload
285 */
286static inline int nlmsg_padlen(int payload)
287{
288 return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
289}
290
291/**
292 * nlmsg_data - head of message payload
293 * @nlh: netlink messsage header
294 */
295static inline void *nlmsg_data(const struct nlmsghdr *nlh)
296{
297 return (unsigned char *) nlh + NLMSG_HDRLEN;
298}
299
300/**
301 * nlmsg_len - length of message payload
302 * @nlh: netlink message header
303 */
304static inline int nlmsg_len(const struct nlmsghdr *nlh)
305{
306 return nlh->nlmsg_len - NLMSG_HDRLEN;
307}
308
309/**
310 * nlmsg_attrdata - head of attributes data
311 * @nlh: netlink message header
312 * @hdrlen: length of family specific header
313 */
314static inline struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh,
315 int hdrlen)
316{
317 unsigned char *data = nlmsg_data(nlh);
318 return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
319}
320
321/**
322 * nlmsg_attrlen - length of attributes data
323 * @nlh: netlink message header
324 * @hdrlen: length of family specific header
325 */
326static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
327{
328 return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
329}
330
331/**
332 * nlmsg_ok - check if the netlink message fits into the remaining bytes
333 * @nlh: netlink message header
334 * @remaining: number of bytes remaining in message stream
335 */
336static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
337{
Vegard Nossum619e8032008-12-25 17:21:17 -0800338 return (remaining >= (int) sizeof(struct nlmsghdr) &&
Thomas Grafbfa83a92005-11-10 02:25:51 +0100339 nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
340 nlh->nlmsg_len <= remaining);
341}
342
343/**
344 * nlmsg_next - next netlink message in message stream
345 * @nlh: netlink message header
346 * @remaining: number of bytes remaining in message stream
347 *
348 * Returns the next netlink message in the message stream and
349 * decrements remaining by the size of the current message.
350 */
Jan Engelhardt36546542010-11-16 09:52:32 -0800351static inline struct nlmsghdr *
352nlmsg_next(const struct nlmsghdr *nlh, int *remaining)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100353{
354 int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
355
356 *remaining -= totlen;
357
358 return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
359}
360
361/**
362 * nlmsg_parse - parse attributes of a netlink message
363 * @nlh: netlink message header
364 * @hdrlen: length of family specific header
365 * @tb: destination array with maxtype+1 elements
366 * @maxtype: maximum attribute type to be expected
367 * @policy: validation policy
368 *
369 * See nla_parse()
370 */
Patrick McHardy3a6c2b42009-08-25 16:07:40 +0200371static inline int nlmsg_parse(const struct nlmsghdr *nlh, int hdrlen,
Thomas Grafbfa83a92005-11-10 02:25:51 +0100372 struct nlattr *tb[], int maxtype,
Patrick McHardyef7c79e2007-06-05 12:38:30 -0700373 const struct nla_policy *policy)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100374{
375 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
376 return -EINVAL;
377
378 return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
379 nlmsg_attrlen(nlh, hdrlen), policy);
380}
381
382/**
383 * nlmsg_find_attr - find a specific attribute in a netlink message
384 * @nlh: netlink message header
385 * @hdrlen: length of familiy specific header
386 * @attrtype: type of attribute to look for
387 *
388 * Returns the first attribute which matches the specified type.
389 */
Nelson Elhage6b8c92b2010-11-03 16:35:40 +0000390static inline struct nlattr *nlmsg_find_attr(const struct nlmsghdr *nlh,
Thomas Grafbfa83a92005-11-10 02:25:51 +0100391 int hdrlen, int attrtype)
392{
393 return nla_find(nlmsg_attrdata(nlh, hdrlen),
394 nlmsg_attrlen(nlh, hdrlen), attrtype);
395}
396
397/**
398 * nlmsg_validate - validate a netlink message including attributes
399 * @nlh: netlinket message header
400 * @hdrlen: length of familiy specific header
401 * @maxtype: maximum attribute type to be expected
402 * @policy: validation policy
403 */
Jan Engelhardt36546542010-11-16 09:52:32 -0800404static inline int nlmsg_validate(const struct nlmsghdr *nlh,
405 int hdrlen, int maxtype,
Patrick McHardyef7c79e2007-06-05 12:38:30 -0700406 const struct nla_policy *policy)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100407{
408 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
409 return -EINVAL;
410
411 return nla_validate(nlmsg_attrdata(nlh, hdrlen),
412 nlmsg_attrlen(nlh, hdrlen), maxtype, policy);
413}
414
415/**
Thomas Graf97676b62006-08-15 00:31:41 -0700416 * nlmsg_report - need to report back to application?
417 * @nlh: netlink message header
418 *
419 * Returns 1 if a report back to the application is requested.
420 */
Patrick McHardy3a6c2b42009-08-25 16:07:40 +0200421static inline int nlmsg_report(const struct nlmsghdr *nlh)
Thomas Graf97676b62006-08-15 00:31:41 -0700422{
423 return !!(nlh->nlmsg_flags & NLM_F_ECHO);
424}
425
426/**
Thomas Grafbfa83a92005-11-10 02:25:51 +0100427 * nlmsg_for_each_attr - iterate over a stream of attributes
428 * @pos: loop counter, set to current attribute
429 * @nlh: netlink message header
430 * @hdrlen: length of familiy specific header
431 * @rem: initialized to len, holds bytes currently remaining in stream
432 */
433#define nlmsg_for_each_attr(pos, nlh, hdrlen, rem) \
434 nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
435 nlmsg_attrlen(nlh, hdrlen), rem)
436
437#if 0
438/* FIXME: Enable once all users have been converted */
439
440/**
441 * __nlmsg_put - Add a new netlink message to an skb
442 * @skb: socket buffer to store message in
443 * @pid: netlink process id
444 * @seq: sequence number of message
445 * @type: message type
446 * @payload: length of message payload
447 * @flags: message flags
448 *
449 * The caller is responsible to ensure that the skb provides enough
450 * tailroom for both the netlink header and payload.
451 */
452static inline struct nlmsghdr *__nlmsg_put(struct sk_buff *skb, u32 pid,
453 u32 seq, int type, int payload,
454 int flags)
455{
456 struct nlmsghdr *nlh;
457
458 nlh = (struct nlmsghdr *) skb_put(skb, nlmsg_total_size(payload));
459 nlh->nlmsg_type = type;
460 nlh->nlmsg_len = nlmsg_msg_size(payload);
461 nlh->nlmsg_flags = flags;
462 nlh->nlmsg_pid = pid;
463 nlh->nlmsg_seq = seq;
464
465 memset((unsigned char *) nlmsg_data(nlh) + payload, 0,
466 nlmsg_padlen(payload));
467
468 return nlh;
469}
470#endif
471
472/**
473 * nlmsg_put - Add a new netlink message to an skb
474 * @skb: socket buffer to store message in
475 * @pid: netlink process id
476 * @seq: sequence number of message
477 * @type: message type
478 * @payload: length of message payload
479 * @flags: message flags
480 *
481 * Returns NULL if the tailroom of the skb is insufficient to store
482 * the message header and payload.
483 */
484static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq,
485 int type, int payload, int flags)
486{
487 if (unlikely(skb_tailroom(skb) < nlmsg_total_size(payload)))
488 return NULL;
489
490 return __nlmsg_put(skb, pid, seq, type, payload, flags);
491}
492
493/**
494 * nlmsg_put_answer - Add a new callback based netlink message to an skb
495 * @skb: socket buffer to store message in
496 * @cb: netlink callback
497 * @type: message type
498 * @payload: length of message payload
499 * @flags: message flags
500 *
501 * Returns NULL if the tailroom of the skb is insufficient to store
502 * the message header and payload.
503 */
504static inline struct nlmsghdr *nlmsg_put_answer(struct sk_buff *skb,
505 struct netlink_callback *cb,
506 int type, int payload,
507 int flags)
508{
509 return nlmsg_put(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
510 type, payload, flags);
511}
512
513/**
514 * nlmsg_new - Allocate a new netlink message
Thomas Graf339bf982006-11-10 14:10:15 -0800515 * @payload: size of the message payload
Thomas Graffe4944e2006-08-04 23:03:05 -0700516 * @flags: the type of memory to allocate.
Thomas Grafbfa83a92005-11-10 02:25:51 +0100517 *
Thomas Graf339bf982006-11-10 14:10:15 -0800518 * Use NLMSG_DEFAULT_SIZE if the size of the payload isn't known
519 * and a good default is needed.
Thomas Grafbfa83a92005-11-10 02:25:51 +0100520 */
Thomas Graf339bf982006-11-10 14:10:15 -0800521static inline struct sk_buff *nlmsg_new(size_t payload, gfp_t flags)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100522{
Thomas Graf339bf982006-11-10 14:10:15 -0800523 return alloc_skb(nlmsg_total_size(payload), flags);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100524}
525
526/**
527 * nlmsg_end - Finalize a netlink message
528 * @skb: socket buffer the message is stored in
529 * @nlh: netlink message header
530 *
531 * Corrects the netlink message header to include the appeneded
532 * attributes. Only necessary if attributes have been added to
533 * the message.
534 *
535 * Returns the total data length of the skb.
536 */
537static inline int nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
538{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700539 nlh->nlmsg_len = skb_tail_pointer(skb) - (unsigned char *)nlh;
Thomas Grafbfa83a92005-11-10 02:25:51 +0100540
541 return skb->len;
542}
543
544/**
Thomas Graffe4944e2006-08-04 23:03:05 -0700545 * nlmsg_get_pos - return current position in netlink message
546 * @skb: socket buffer the message is stored in
547 *
548 * Returns a pointer to the current tail of the message.
549 */
550static inline void *nlmsg_get_pos(struct sk_buff *skb)
551{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700552 return skb_tail_pointer(skb);
Thomas Graffe4944e2006-08-04 23:03:05 -0700553}
554
555/**
556 * nlmsg_trim - Trim message to a mark
557 * @skb: socket buffer the message is stored in
558 * @mark: mark to trim to
559 *
Thomas Grafbc3ed282008-06-03 16:36:54 -0700560 * Trims the message to the provided mark.
Thomas Graffe4944e2006-08-04 23:03:05 -0700561 */
Thomas Grafbc3ed282008-06-03 16:36:54 -0700562static inline void nlmsg_trim(struct sk_buff *skb, const void *mark)
Thomas Graffe4944e2006-08-04 23:03:05 -0700563{
564 if (mark)
565 skb_trim(skb, (unsigned char *) mark - skb->data);
Thomas Graffe4944e2006-08-04 23:03:05 -0700566}
567
568/**
Thomas Grafbfa83a92005-11-10 02:25:51 +0100569 * nlmsg_cancel - Cancel construction of a netlink message
570 * @skb: socket buffer the message is stored in
571 * @nlh: netlink message header
572 *
573 * Removes the complete netlink message including all
Thomas Grafbc3ed282008-06-03 16:36:54 -0700574 * attributes from the socket buffer again.
Thomas Grafbfa83a92005-11-10 02:25:51 +0100575 */
Thomas Grafbc3ed282008-06-03 16:36:54 -0700576static inline void nlmsg_cancel(struct sk_buff *skb, struct nlmsghdr *nlh)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100577{
Thomas Grafbc3ed282008-06-03 16:36:54 -0700578 nlmsg_trim(skb, nlh);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100579}
580
581/**
582 * nlmsg_free - free a netlink message
583 * @skb: socket buffer of netlink message
584 */
585static inline void nlmsg_free(struct sk_buff *skb)
586{
587 kfree_skb(skb);
588}
589
590/**
591 * nlmsg_multicast - multicast a netlink message
592 * @sk: netlink socket to spread messages to
593 * @skb: netlink message as socket buffer
594 * @pid: own netlink pid to avoid sending to yourself
595 * @group: multicast group id
Thomas Grafd387f6a2006-08-15 00:31:06 -0700596 * @flags: allocation flags
Thomas Grafbfa83a92005-11-10 02:25:51 +0100597 */
598static inline int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,
Thomas Grafd387f6a2006-08-15 00:31:06 -0700599 u32 pid, unsigned int group, gfp_t flags)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100600{
601 int err;
602
603 NETLINK_CB(skb).dst_group = group;
604
Thomas Grafd387f6a2006-08-15 00:31:06 -0700605 err = netlink_broadcast(sk, skb, pid, group, flags);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100606 if (err > 0)
607 err = 0;
608
609 return err;
610}
611
612/**
613 * nlmsg_unicast - unicast a netlink message
614 * @sk: netlink socket to spread message to
615 * @skb: netlink message as socket buffer
616 * @pid: netlink pid of the destination socket
617 */
618static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 pid)
619{
620 int err;
621
622 err = netlink_unicast(sk, skb, pid, MSG_DONTWAIT);
623 if (err > 0)
624 err = 0;
625
626 return err;
627}
628
629/**
630 * nlmsg_for_each_msg - iterate over a stream of messages
631 * @pos: loop counter, set to current message
632 * @head: head of message stream
633 * @len: length of message stream
634 * @rem: initialized to len, holds bytes currently remaining in stream
635 */
636#define nlmsg_for_each_msg(pos, head, len, rem) \
637 for (pos = head, rem = len; \
638 nlmsg_ok(pos, rem); \
639 pos = nlmsg_next(pos, &(rem)))
640
641/**************************************************************************
642 * Netlink Attributes
643 **************************************************************************/
644
645/**
646 * nla_attr_size - length of attribute not including padding
647 * @payload: length of payload
648 */
649static inline int nla_attr_size(int payload)
650{
651 return NLA_HDRLEN + payload;
652}
653
654/**
655 * nla_total_size - total length of attribute including padding
656 * @payload: length of payload
657 */
658static inline int nla_total_size(int payload)
659{
660 return NLA_ALIGN(nla_attr_size(payload));
661}
662
663/**
664 * nla_padlen - length of padding at the tail of attribute
665 * @payload: length of payload
666 */
667static inline int nla_padlen(int payload)
668{
669 return nla_total_size(payload) - nla_attr_size(payload);
670}
671
672/**
Thomas Graf8f4c1f92007-09-12 14:44:36 +0200673 * nla_type - attribute type
674 * @nla: netlink attribute
675 */
676static inline int nla_type(const struct nlattr *nla)
677{
678 return nla->nla_type & NLA_TYPE_MASK;
679}
680
681/**
Thomas Grafbfa83a92005-11-10 02:25:51 +0100682 * nla_data - head of payload
683 * @nla: netlink attribute
684 */
685static inline void *nla_data(const struct nlattr *nla)
686{
687 return (char *) nla + NLA_HDRLEN;
688}
689
690/**
691 * nla_len - length of payload
692 * @nla: netlink attribute
693 */
694static inline int nla_len(const struct nlattr *nla)
695{
696 return nla->nla_len - NLA_HDRLEN;
697}
698
699/**
700 * nla_ok - check if the netlink attribute fits into the remaining bytes
701 * @nla: netlink attribute
702 * @remaining: number of bytes remaining in attribute stream
703 */
704static inline int nla_ok(const struct nlattr *nla, int remaining)
705{
Vegard Nossum1045b032008-09-11 19:05:29 -0700706 return remaining >= (int) sizeof(*nla) &&
Thomas Grafbfa83a92005-11-10 02:25:51 +0100707 nla->nla_len >= sizeof(*nla) &&
708 nla->nla_len <= remaining;
709}
710
711/**
Pierre Ynardd1ec3b72007-10-10 21:09:48 -0700712 * nla_next - next netlink attribute in attribute stream
Thomas Grafbfa83a92005-11-10 02:25:51 +0100713 * @nla: netlink attribute
714 * @remaining: number of bytes remaining in attribute stream
715 *
716 * Returns the next netlink attribute in the attribute stream and
717 * decrements remaining by the size of the current attribute.
718 */
719static inline struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
720{
721 int totlen = NLA_ALIGN(nla->nla_len);
722
723 *remaining -= totlen;
724 return (struct nlattr *) ((char *) nla + totlen);
725}
726
727/**
Thomas Graffe4944e2006-08-04 23:03:05 -0700728 * nla_find_nested - find attribute in a set of nested attributes
729 * @nla: attribute containing the nested attributes
730 * @attrtype: type of attribute to look for
731 *
732 * Returns the first attribute which matches the specified type.
733 */
Jan Engelhardt36546542010-11-16 09:52:32 -0800734static inline struct nlattr *
735nla_find_nested(const struct nlattr *nla, int attrtype)
Thomas Graffe4944e2006-08-04 23:03:05 -0700736{
737 return nla_find(nla_data(nla), nla_len(nla), attrtype);
738}
739
740/**
Thomas Grafbfa83a92005-11-10 02:25:51 +0100741 * nla_parse_nested - parse nested attributes
742 * @tb: destination array with maxtype+1 elements
743 * @maxtype: maximum attribute type to be expected
744 * @nla: attribute containing the nested attributes
745 * @policy: validation policy
746 *
747 * See nla_parse()
748 */
749static inline int nla_parse_nested(struct nlattr *tb[], int maxtype,
Patrick McHardyb057efd2008-10-28 11:59:11 -0700750 const struct nlattr *nla,
Patrick McHardyef7c79e2007-06-05 12:38:30 -0700751 const struct nla_policy *policy)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100752{
753 return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
754}
Patrick McHardy1092cb22007-06-25 13:49:35 -0700755
756/**
Pierre Ynardd1ec3b72007-10-10 21:09:48 -0700757 * nla_put_u8 - Add a u8 netlink attribute to a socket buffer
Thomas Grafbfa83a92005-11-10 02:25:51 +0100758 * @skb: socket buffer to add attribute to
759 * @attrtype: attribute type
760 * @value: numeric value
761 */
762static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
763{
764 return nla_put(skb, attrtype, sizeof(u8), &value);
765}
766
767/**
768 * nla_put_u16 - Add a u16 netlink attribute to a socket buffer
769 * @skb: socket buffer to add attribute to
770 * @attrtype: attribute type
771 * @value: numeric value
772 */
773static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
774{
775 return nla_put(skb, attrtype, sizeof(u16), &value);
776}
777
778/**
779 * nla_put_u32 - Add a u32 netlink attribute to a socket buffer
780 * @skb: socket buffer to add attribute to
781 * @attrtype: attribute type
782 * @value: numeric value
783 */
784static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
785{
786 return nla_put(skb, attrtype, sizeof(u32), &value);
787}
788
789/**
790 * nla_put_64 - Add a u64 netlink attribute to a socket buffer
791 * @skb: socket buffer to add attribute to
792 * @attrtype: attribute type
793 * @value: numeric value
794 */
795static inline int nla_put_u64(struct sk_buff *skb, int attrtype, u64 value)
796{
797 return nla_put(skb, attrtype, sizeof(u64), &value);
798}
799
800/**
801 * nla_put_string - Add a string netlink attribute to a socket buffer
802 * @skb: socket buffer to add attribute to
803 * @attrtype: attribute type
804 * @str: NUL terminated string
805 */
806static inline int nla_put_string(struct sk_buff *skb, int attrtype,
807 const char *str)
808{
809 return nla_put(skb, attrtype, strlen(str) + 1, str);
810}
811
812/**
813 * nla_put_flag - Add a flag netlink attribute to a socket buffer
814 * @skb: socket buffer to add attribute to
815 * @attrtype: attribute type
816 */
817static inline int nla_put_flag(struct sk_buff *skb, int attrtype)
818{
819 return nla_put(skb, attrtype, 0, NULL);
820}
821
822/**
823 * nla_put_msecs - Add a msecs netlink attribute to a socket buffer
824 * @skb: socket buffer to add attribute to
825 * @attrtype: attribute type
826 * @jiffies: number of msecs in jiffies
827 */
828static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
829 unsigned long jiffies)
830{
831 u64 tmp = jiffies_to_msecs(jiffies);
832 return nla_put(skb, attrtype, sizeof(u64), &tmp);
833}
834
835#define NLA_PUT(skb, attrtype, attrlen, data) \
836 do { \
Patrick McHardyf4d900a2007-12-05 03:31:53 -0800837 if (unlikely(nla_put(skb, attrtype, attrlen, data) < 0)) \
Thomas Grafbfa83a92005-11-10 02:25:51 +0100838 goto nla_put_failure; \
839 } while(0)
840
841#define NLA_PUT_TYPE(skb, type, attrtype, value) \
842 do { \
843 type __tmp = value; \
844 NLA_PUT(skb, attrtype, sizeof(type), &__tmp); \
845 } while(0)
846
847#define NLA_PUT_U8(skb, attrtype, value) \
848 NLA_PUT_TYPE(skb, u8, attrtype, value)
849
850#define NLA_PUT_U16(skb, attrtype, value) \
851 NLA_PUT_TYPE(skb, u16, attrtype, value)
852
Thomas Graf4a89c252006-11-24 17:14:51 -0800853#define NLA_PUT_LE16(skb, attrtype, value) \
854 NLA_PUT_TYPE(skb, __le16, attrtype, value)
855
Patrick McHardy838965b2007-12-17 22:29:26 -0800856#define NLA_PUT_BE16(skb, attrtype, value) \
857 NLA_PUT_TYPE(skb, __be16, attrtype, value)
858
Thomas Grafbfa83a92005-11-10 02:25:51 +0100859#define NLA_PUT_U32(skb, attrtype, value) \
860 NLA_PUT_TYPE(skb, u32, attrtype, value)
861
Al Viro00012e52006-09-26 22:14:41 -0700862#define NLA_PUT_BE32(skb, attrtype, value) \
863 NLA_PUT_TYPE(skb, __be32, attrtype, value)
864
Thomas Grafbfa83a92005-11-10 02:25:51 +0100865#define NLA_PUT_U64(skb, attrtype, value) \
866 NLA_PUT_TYPE(skb, u64, attrtype, value)
867
Krzysztof Piotr Oledzki07a7c102008-07-21 10:01:14 -0700868#define NLA_PUT_BE64(skb, attrtype, value) \
869 NLA_PUT_TYPE(skb, __be64, attrtype, value)
870
Thomas Grafbfa83a92005-11-10 02:25:51 +0100871#define NLA_PUT_STRING(skb, attrtype, value) \
872 NLA_PUT(skb, attrtype, strlen(value) + 1, value)
873
Johannes Bergff5dfe72006-08-26 19:17:53 -0700874#define NLA_PUT_FLAG(skb, attrtype) \
Thomas Grafbfa83a92005-11-10 02:25:51 +0100875 NLA_PUT(skb, attrtype, 0, NULL)
876
877#define NLA_PUT_MSECS(skb, attrtype, jiffies) \
878 NLA_PUT_U64(skb, attrtype, jiffies_to_msecs(jiffies))
879
880/**
881 * nla_get_u32 - return payload of u32 attribute
882 * @nla: u32 netlink attribute
883 */
Patrick McHardyb057efd2008-10-28 11:59:11 -0700884static inline u32 nla_get_u32(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100885{
886 return *(u32 *) nla_data(nla);
887}
888
889/**
Al Viro00012e52006-09-26 22:14:41 -0700890 * nla_get_be32 - return payload of __be32 attribute
891 * @nla: __be32 netlink attribute
892 */
Patrick McHardyb057efd2008-10-28 11:59:11 -0700893static inline __be32 nla_get_be32(const struct nlattr *nla)
Al Viro00012e52006-09-26 22:14:41 -0700894{
895 return *(__be32 *) nla_data(nla);
896}
897
898/**
Thomas Grafbfa83a92005-11-10 02:25:51 +0100899 * nla_get_u16 - return payload of u16 attribute
900 * @nla: u16 netlink attribute
901 */
Patrick McHardyb057efd2008-10-28 11:59:11 -0700902static inline u16 nla_get_u16(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100903{
904 return *(u16 *) nla_data(nla);
905}
906
907/**
Patrick McHardy838965b2007-12-17 22:29:26 -0800908 * nla_get_be16 - return payload of __be16 attribute
909 * @nla: __be16 netlink attribute
910 */
Patrick McHardyb057efd2008-10-28 11:59:11 -0700911static inline __be16 nla_get_be16(const struct nlattr *nla)
Patrick McHardy838965b2007-12-17 22:29:26 -0800912{
913 return *(__be16 *) nla_data(nla);
914}
915
916/**
Thomas Graf4a89c252006-11-24 17:14:51 -0800917 * nla_get_le16 - return payload of __le16 attribute
918 * @nla: __le16 netlink attribute
919 */
Patrick McHardyb057efd2008-10-28 11:59:11 -0700920static inline __le16 nla_get_le16(const struct nlattr *nla)
Thomas Graf4a89c252006-11-24 17:14:51 -0800921{
922 return *(__le16 *) nla_data(nla);
923}
924
925/**
Thomas Grafbfa83a92005-11-10 02:25:51 +0100926 * nla_get_u8 - return payload of u8 attribute
927 * @nla: u8 netlink attribute
928 */
Patrick McHardyb057efd2008-10-28 11:59:11 -0700929static inline u8 nla_get_u8(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100930{
931 return *(u8 *) nla_data(nla);
932}
933
934/**
935 * nla_get_u64 - return payload of u64 attribute
936 * @nla: u64 netlink attribute
937 */
Patrick McHardyb057efd2008-10-28 11:59:11 -0700938static inline u64 nla_get_u64(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100939{
940 u64 tmp;
941
942 nla_memcpy(&tmp, nla, sizeof(tmp));
943
944 return tmp;
945}
946
947/**
Pablo Neira Ayusoa17c8592009-05-27 17:50:35 +0200948 * nla_get_be64 - return payload of __be64 attribute
949 * @nla: __be64 netlink attribute
950 */
951static inline __be64 nla_get_be64(const struct nlattr *nla)
952{
Pablo Neira Ayusof5d410f2010-03-16 13:30:44 +0000953 __be64 tmp;
954
955 nla_memcpy(&tmp, nla, sizeof(tmp));
956
957 return tmp;
Pablo Neira Ayusoa17c8592009-05-27 17:50:35 +0200958}
959
960/**
Thomas Grafbfa83a92005-11-10 02:25:51 +0100961 * nla_get_flag - return payload of flag attribute
962 * @nla: flag netlink attribute
963 */
Patrick McHardyb057efd2008-10-28 11:59:11 -0700964static inline int nla_get_flag(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100965{
966 return !!nla;
967}
968
969/**
970 * nla_get_msecs - return payload of msecs attribute
971 * @nla: msecs netlink attribute
972 *
973 * Returns the number of milliseconds in jiffies.
974 */
Patrick McHardyb057efd2008-10-28 11:59:11 -0700975static inline unsigned long nla_get_msecs(const struct nlattr *nla)
Thomas Grafbfa83a92005-11-10 02:25:51 +0100976{
977 u64 msecs = nla_get_u64(nla);
978
979 return msecs_to_jiffies((unsigned long) msecs);
980}
981
982/**
983 * nla_nest_start - Start a new level of nested attributes
984 * @skb: socket buffer to add attributes to
985 * @attrtype: attribute type of container
986 *
987 * Returns the container attribute
988 */
989static inline struct nlattr *nla_nest_start(struct sk_buff *skb, int attrtype)
990{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700991 struct nlattr *start = (struct nlattr *)skb_tail_pointer(skb);
Thomas Grafbfa83a92005-11-10 02:25:51 +0100992
993 if (nla_put(skb, attrtype, 0, NULL) < 0)
994 return NULL;
995
996 return start;
997}
998
999/**
1000 * nla_nest_end - Finalize nesting of attributes
Pierre Ynardd1ec3b72007-10-10 21:09:48 -07001001 * @skb: socket buffer the attributes are stored in
Thomas Grafbfa83a92005-11-10 02:25:51 +01001002 * @start: container attribute
1003 *
1004 * Corrects the container attribute header to include the all
1005 * appeneded attributes.
1006 *
1007 * Returns the total data length of the skb.
1008 */
1009static inline int nla_nest_end(struct sk_buff *skb, struct nlattr *start)
1010{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001011 start->nla_len = skb_tail_pointer(skb) - (unsigned char *)start;
Thomas Grafbfa83a92005-11-10 02:25:51 +01001012 return skb->len;
1013}
1014
1015/**
1016 * nla_nest_cancel - Cancel nesting of attributes
1017 * @skb: socket buffer the message is stored in
1018 * @start: container attribute
1019 *
1020 * Removes the container attribute and including all nested
Thomas Grafbc3ed282008-06-03 16:36:54 -07001021 * attributes. Returns -EMSGSIZE
Thomas Grafbfa83a92005-11-10 02:25:51 +01001022 */
Thomas Grafbc3ed282008-06-03 16:36:54 -07001023static inline void nla_nest_cancel(struct sk_buff *skb, struct nlattr *start)
Thomas Grafbfa83a92005-11-10 02:25:51 +01001024{
Thomas Grafbc3ed282008-06-03 16:36:54 -07001025 nlmsg_trim(skb, start);
Thomas Grafbfa83a92005-11-10 02:25:51 +01001026}
1027
1028/**
Paul Moore4fe5d5c2006-09-25 15:54:03 -07001029 * nla_validate_nested - Validate a stream of nested attributes
1030 * @start: container attribute
1031 * @maxtype: maximum attribute type to be expected
1032 * @policy: validation policy
1033 *
1034 * Validates all attributes in the nested attribute stream against the
1035 * specified policy. Attributes with a type exceeding maxtype will be
1036 * ignored. See documenation of struct nla_policy for more details.
1037 *
1038 * Returns 0 on success or a negative error code.
1039 */
Jan Engelhardt36546542010-11-16 09:52:32 -08001040static inline int nla_validate_nested(const struct nlattr *start, int maxtype,
Patrick McHardyef7c79e2007-06-05 12:38:30 -07001041 const struct nla_policy *policy)
Paul Moore4fe5d5c2006-09-25 15:54:03 -07001042{
1043 return nla_validate(nla_data(start), nla_len(start), maxtype, policy);
1044}
1045
1046/**
Thomas Grafbfa83a92005-11-10 02:25:51 +01001047 * nla_for_each_attr - iterate over a stream of attributes
1048 * @pos: loop counter, set to current attribute
1049 * @head: head of attribute stream
1050 * @len: length of attribute stream
1051 * @rem: initialized to len, holds bytes currently remaining in stream
1052 */
1053#define nla_for_each_attr(pos, head, len, rem) \
1054 for (pos = head, rem = len; \
1055 nla_ok(pos, rem); \
1056 pos = nla_next(pos, &(rem)))
1057
Thomas Graffe4944e2006-08-04 23:03:05 -07001058/**
1059 * nla_for_each_nested - iterate over nested attributes
1060 * @pos: loop counter, set to current attribute
1061 * @nla: attribute containing the nested attributes
1062 * @rem: initialized to len, holds bytes currently remaining in stream
1063 */
1064#define nla_for_each_nested(pos, nla, rem) \
1065 nla_for_each_attr(pos, nla_data(nla), nla_len(nla), rem)
1066
Thomas Grafbfa83a92005-11-10 02:25:51 +01001067#endif