Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
netlink.h
Go to the documentation of this file.
1 #ifndef __NET_NETLINK_H
2 #define __NET_NETLINK_H
3 
4 #include <linux/types.h>
5 #include <linux/netlink.h>
6 #include <linux/jiffies.h>
7 
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()
38  * nlmsg_end() finalize netlink message
39  * nlmsg_get_pos() return current position in message
40  * nlmsg_trim() trim part of message
41  * 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
47  * nlmsg_notify() send notification message
48  *
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  *
69  * Misc:
70  * nlmsg_report() report back to application?
71  *
72  * ------------------------------------------------------------------------
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:
87  * struct nlattr netlink attribute header
88  *
89  * Attribute Construction:
90  * nla_reserve(skb, type, len) reserve room for an attribute
91  * nla_reserve_nohdr(skb, len) reserve room for an attribute w/o hdr
92  * nla_put(skb, type, len, data) add attribute to skb
93  * nla_put_nohdr(skb, len, data) add attribute w/o hdr
94  * nla_append(skb, len, data) append data to skb
95  *
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_s8(skb, type, value) add s8 attribute to skb
102  * nla_put_s16(skb, type, value) add s16 attribute to skb
103  * nla_put_s32(skb, type, value) add s32 attribute to skb
104  * nla_put_s64(skb, type, value) add s64 attribute to skb
105  * nla_put_string(skb, type, str) add string attribute to skb
106  * nla_put_flag(skb, type) add flag attribute to skb
107  * nla_put_msecs(skb, type, jiffies) add msecs attribute to skb
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_s8(nla) get payload for a s8 attribute
129  * nla_get_s16(nla) get payload for a s16 attribute
130  * nla_get_s32(nla) get payload for a s32 attribute
131  * nla_get_s64(nla) get payload for a s64 attribute
132  * nla_get_flag(nla) return 1 if flag is true
133  * nla_get_msecs(nla) get payload for a msecs attribute
134  *
135  * Attribute Misc:
136  * nla_memcpy(dest, nla, count) copy attribute into memory
137  * nla_memcmp(nla, data, size) compare attribute with memory area
138  * nla_strlcpy(dst, nla, size) copy attribute to a sized string
139  * nla_strcmp(nla, str) compare attribute with string
140  *
141  * Attribute Parsing:
142  * nla_ok(nla, remaining) does nla fit into remaining bytes?
143  * nla_next(nla, remaining) get next netlink attribute
144  * nla_validate() validate a stream of attributes
145  * nla_validate_nested() validate a stream of nested attributes
146  * nla_find() find attribute in stream of attributes
147  * nla_find_nested() find attribute in nested attributes
148  * nla_parse() parse and validate stream of attrs
149  * nla_parse_nested() parse nested attribuets
150  * nla_for_each_attr() loop over all attributes
151  * nla_for_each_nested() loop over the nested attributes
152  *=========================================================================
153  */
154 
158 enum {
176 };
177 
178 #define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
179 
212 struct nla_policy {
215 };
216 
222 struct nl_info {
223  struct nlmsghdr *nlh;
224  struct net *nl_net;
226 };
227 
228 extern int netlink_rcv_skb(struct sk_buff *skb,
229  int (*cb)(struct sk_buff *,
230  struct nlmsghdr *));
231 extern int nlmsg_notify(struct sock *sk, struct sk_buff *skb,
232  u32 portid, unsigned int group, int report,
233  gfp_t flags);
234 
235 extern int nla_validate(const struct nlattr *head,
236  int len, int maxtype,
237  const struct nla_policy *policy);
238 extern int nla_parse(struct nlattr **tb, int maxtype,
239  const struct nlattr *head, int len,
240  const struct nla_policy *policy);
241 extern int nla_policy_len(const struct nla_policy *, int);
242 extern struct nlattr * nla_find(const struct nlattr *head,
243  int len, int attrtype);
244 extern size_t nla_strlcpy(char *dst, const struct nlattr *nla,
245  size_t dstsize);
246 extern int nla_memcpy(void *dest, const struct nlattr *src, int count);
247 extern int nla_memcmp(const struct nlattr *nla, const void *data,
248  size_t size);
249 extern int nla_strcmp(const struct nlattr *nla, const char *str);
250 extern struct nlattr * __nla_reserve(struct sk_buff *skb, int attrtype,
251  int attrlen);
252 extern void * __nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
253 extern struct nlattr * nla_reserve(struct sk_buff *skb, int attrtype,
254  int attrlen);
255 extern void * nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
256 extern void __nla_put(struct sk_buff *skb, int attrtype,
257  int attrlen, const void *data);
258 extern void __nla_put_nohdr(struct sk_buff *skb, int attrlen,
259  const void *data);
260 extern int nla_put(struct sk_buff *skb, int attrtype,
261  int attrlen, const void *data);
262 extern int nla_put_nohdr(struct sk_buff *skb, int attrlen,
263  const void *data);
264 extern int nla_append(struct sk_buff *skb, int attrlen,
265  const void *data);
266 
267 /**************************************************************************
268  * Netlink Messages
269  **************************************************************************/
270 
275 static inline int nlmsg_msg_size(int payload)
276 {
277  return NLMSG_HDRLEN + payload;
278 }
279 
284 static inline int nlmsg_total_size(int payload)
285 {
286  return NLMSG_ALIGN(nlmsg_msg_size(payload));
287 }
288 
293 static inline int nlmsg_padlen(int payload)
294 {
295  return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
296 }
297 
302 static inline void *nlmsg_data(const struct nlmsghdr *nlh)
303 {
304  return (unsigned char *) nlh + NLMSG_HDRLEN;
305 }
306 
311 static inline int nlmsg_len(const struct nlmsghdr *nlh)
312 {
313  return nlh->nlmsg_len - NLMSG_HDRLEN;
314 }
315 
321 static inline struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh,
322  int hdrlen)
323 {
324  unsigned char *data = nlmsg_data(nlh);
325  return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
326 }
327 
333 static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
334 {
335  return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
336 }
337 
343 static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
344 {
345  return (remaining >= (int) sizeof(struct nlmsghdr) &&
346  nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
347  nlh->nlmsg_len <= remaining);
348 }
349 
358 static inline struct nlmsghdr *
359 nlmsg_next(const struct nlmsghdr *nlh, int *remaining)
360 {
361  int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
362 
363  *remaining -= totlen;
364 
365  return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
366 }
367 
378 static inline int nlmsg_parse(const struct nlmsghdr *nlh, int hdrlen,
379  struct nlattr *tb[], int maxtype,
380  const struct nla_policy *policy)
381 {
382  if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
383  return -EINVAL;
384 
385  return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
386  nlmsg_attrlen(nlh, hdrlen), policy);
387 }
388 
397 static inline struct nlattr *nlmsg_find_attr(const struct nlmsghdr *nlh,
398  int hdrlen, int attrtype)
399 {
400  return nla_find(nlmsg_attrdata(nlh, hdrlen),
401  nlmsg_attrlen(nlh, hdrlen), attrtype);
402 }
403 
411 static inline int nlmsg_validate(const struct nlmsghdr *nlh,
412  int hdrlen, int maxtype,
413  const struct nla_policy *policy)
414 {
415  if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
416  return -EINVAL;
417 
418  return nla_validate(nlmsg_attrdata(nlh, hdrlen),
419  nlmsg_attrlen(nlh, hdrlen), maxtype, policy);
420 }
421 
428 static inline int nlmsg_report(const struct nlmsghdr *nlh)
429 {
430  return !!(nlh->nlmsg_flags & NLM_F_ECHO);
431 }
432 
440 #define nlmsg_for_each_attr(pos, nlh, hdrlen, rem) \
441  nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
442  nlmsg_attrlen(nlh, hdrlen), rem)
443 
456 static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
457  int type, int payload, int flags)
458 {
459  if (unlikely(skb_tailroom(skb) < nlmsg_total_size(payload)))
460  return NULL;
461 
462  return __nlmsg_put(skb, portid, seq, type, payload, flags);
463 }
464 
476 static inline struct nlmsghdr *nlmsg_put_answer(struct sk_buff *skb,
477  struct netlink_callback *cb,
478  int type, int payload,
479  int flags)
480 {
481  return nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
482  type, payload, flags);
483 }
484 
493 static inline struct sk_buff *nlmsg_new(size_t payload, gfp_t flags)
494 {
495  return alloc_skb(nlmsg_total_size(payload), flags);
496 }
497 
509 static inline int nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
510 {
511  nlh->nlmsg_len = skb_tail_pointer(skb) - (unsigned char *)nlh;
512 
513  return skb->len;
514 }
515 
522 static inline void *nlmsg_get_pos(struct sk_buff *skb)
523 {
524  return skb_tail_pointer(skb);
525 }
526 
534 static inline void nlmsg_trim(struct sk_buff *skb, const void *mark)
535 {
536  if (mark)
537  skb_trim(skb, (unsigned char *) mark - skb->data);
538 }
539 
548 static inline void nlmsg_cancel(struct sk_buff *skb, struct nlmsghdr *nlh)
549 {
550  nlmsg_trim(skb, nlh);
551 }
552 
557 static inline void nlmsg_free(struct sk_buff *skb)
558 {
559  kfree_skb(skb);
560 }
561 
570 static inline int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,
571  u32 portid, unsigned int group, gfp_t flags)
572 {
573  int err;
574 
575  NETLINK_CB(skb).dst_group = group;
576 
577  err = netlink_broadcast(sk, skb, portid, group, flags);
578  if (err > 0)
579  err = 0;
580 
581  return err;
582 }
583 
590 static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 portid)
591 {
592  int err;
593 
594  err = netlink_unicast(sk, skb, portid, MSG_DONTWAIT);
595  if (err > 0)
596  err = 0;
597 
598  return err;
599 }
600 
608 #define nlmsg_for_each_msg(pos, head, len, rem) \
609  for (pos = head, rem = len; \
610  nlmsg_ok(pos, rem); \
611  pos = nlmsg_next(pos, &(rem)))
612 
628 static inline void
629 nl_dump_check_consistent(struct netlink_callback *cb,
630  struct nlmsghdr *nlh)
631 {
632  if (cb->prev_seq && cb->seq != cb->prev_seq)
634  cb->prev_seq = cb->seq;
635 }
636 
637 /**************************************************************************
638  * Netlink Attributes
639  **************************************************************************/
640 
645 static inline int nla_attr_size(int payload)
646 {
647  return NLA_HDRLEN + payload;
648 }
649 
654 static inline int nla_total_size(int payload)
655 {
656  return NLA_ALIGN(nla_attr_size(payload));
657 }
658 
663 static inline int nla_padlen(int payload)
664 {
665  return nla_total_size(payload) - nla_attr_size(payload);
666 }
667 
672 static inline int nla_type(const struct nlattr *nla)
673 {
674  return nla->nla_type & NLA_TYPE_MASK;
675 }
676 
681 static inline void *nla_data(const struct nlattr *nla)
682 {
683  return (char *) nla + NLA_HDRLEN;
684 }
685 
690 static inline int nla_len(const struct nlattr *nla)
691 {
692  return nla->nla_len - NLA_HDRLEN;
693 }
694 
700 static inline int nla_ok(const struct nlattr *nla, int remaining)
701 {
702  return remaining >= (int) sizeof(*nla) &&
703  nla->nla_len >= sizeof(*nla) &&
704  nla->nla_len <= remaining;
705 }
706 
715 static inline struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
716 {
717  int totlen = NLA_ALIGN(nla->nla_len);
718 
719  *remaining -= totlen;
720  return (struct nlattr *) ((char *) nla + totlen);
721 }
722 
730 static inline struct nlattr *
731 nla_find_nested(const struct nlattr *nla, int attrtype)
732 {
733  return nla_find(nla_data(nla), nla_len(nla), attrtype);
734 }
735 
745 static inline int nla_parse_nested(struct nlattr *tb[], int maxtype,
746  const struct nlattr *nla,
747  const struct nla_policy *policy)
748 {
749  return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
750 }
751 
758 static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
759 {
760  return nla_put(skb, attrtype, sizeof(u8), &value);
761 }
762 
769 static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
770 {
771  return nla_put(skb, attrtype, sizeof(u16), &value);
772 }
773 
780 static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value)
781 {
782  return nla_put(skb, attrtype, sizeof(__be16), &value);
783 }
784 
791 static inline int nla_put_net16(struct sk_buff *skb, int attrtype, __be16 value)
792 {
793  return nla_put_be16(skb, attrtype | NLA_F_NET_BYTEORDER, value);
794 }
795 
802 static inline int nla_put_le16(struct sk_buff *skb, int attrtype, __le16 value)
803 {
804  return nla_put(skb, attrtype, sizeof(__le16), &value);
805 }
806 
813 static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
814 {
815  return nla_put(skb, attrtype, sizeof(u32), &value);
816 }
817 
824 static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value)
825 {
826  return nla_put(skb, attrtype, sizeof(__be32), &value);
827 }
828 
835 static inline int nla_put_net32(struct sk_buff *skb, int attrtype, __be32 value)
836 {
837  return nla_put_be32(skb, attrtype | NLA_F_NET_BYTEORDER, value);
838 }
839 
846 static inline int nla_put_le32(struct sk_buff *skb, int attrtype, __le32 value)
847 {
848  return nla_put(skb, attrtype, sizeof(__le32), &value);
849 }
850 
857 static inline int nla_put_u64(struct sk_buff *skb, int attrtype, u64 value)
858 {
859  return nla_put(skb, attrtype, sizeof(u64), &value);
860 }
861 
868 static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value)
869 {
870  return nla_put(skb, attrtype, sizeof(__be64), &value);
871 }
872 
879 static inline int nla_put_net64(struct sk_buff *skb, int attrtype, __be64 value)
880 {
881  return nla_put_be64(skb, attrtype | NLA_F_NET_BYTEORDER, value);
882 }
883 
890 static inline int nla_put_le64(struct sk_buff *skb, int attrtype, __le64 value)
891 {
892  return nla_put(skb, attrtype, sizeof(__le64), &value);
893 }
894 
901 static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value)
902 {
903  return nla_put(skb, attrtype, sizeof(s8), &value);
904 }
905 
912 static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value)
913 {
914  return nla_put(skb, attrtype, sizeof(s16), &value);
915 }
916 
923 static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value)
924 {
925  return nla_put(skb, attrtype, sizeof(s32), &value);
926 }
927 
934 static inline int nla_put_s64(struct sk_buff *skb, int attrtype, s64 value)
935 {
936  return nla_put(skb, attrtype, sizeof(s64), &value);
937 }
938 
945 static inline int nla_put_string(struct sk_buff *skb, int attrtype,
946  const char *str)
947 {
948  return nla_put(skb, attrtype, strlen(str) + 1, str);
949 }
950 
956 static inline int nla_put_flag(struct sk_buff *skb, int attrtype)
957 {
958  return nla_put(skb, attrtype, 0, NULL);
959 }
960 
967 static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
968  unsigned long jiffies)
969 {
970  u64 tmp = jiffies_to_msecs(jiffies);
971  return nla_put(skb, attrtype, sizeof(u64), &tmp);
972 }
973 
978 static inline u32 nla_get_u32(const struct nlattr *nla)
979 {
980  return *(u32 *) nla_data(nla);
981 }
982 
987 static inline __be32 nla_get_be32(const struct nlattr *nla)
988 {
989  return *(__be32 *) nla_data(nla);
990 }
991 
996 static inline u16 nla_get_u16(const struct nlattr *nla)
997 {
998  return *(u16 *) nla_data(nla);
999 }
1000 
1005 static inline __be16 nla_get_be16(const struct nlattr *nla)
1006 {
1007  return *(__be16 *) nla_data(nla);
1008 }
1009 
1014 static inline __le16 nla_get_le16(const struct nlattr *nla)
1015 {
1016  return *(__le16 *) nla_data(nla);
1017 }
1018 
1023 static inline u8 nla_get_u8(const struct nlattr *nla)
1024 {
1025  return *(u8 *) nla_data(nla);
1026 }
1027 
1032 static inline u64 nla_get_u64(const struct nlattr *nla)
1033 {
1034  u64 tmp;
1035 
1036  nla_memcpy(&tmp, nla, sizeof(tmp));
1037 
1038  return tmp;
1039 }
1040 
1045 static inline __be64 nla_get_be64(const struct nlattr *nla)
1046 {
1047  __be64 tmp;
1048 
1049  nla_memcpy(&tmp, nla, sizeof(tmp));
1050 
1051  return tmp;
1052 }
1053 
1058 static inline s32 nla_get_s32(const struct nlattr *nla)
1059 {
1060  return *(s32 *) nla_data(nla);
1061 }
1062 
1067 static inline s16 nla_get_s16(const struct nlattr *nla)
1068 {
1069  return *(s16 *) nla_data(nla);
1070 }
1071 
1076 static inline s8 nla_get_s8(const struct nlattr *nla)
1077 {
1078  return *(s8 *) nla_data(nla);
1079 }
1080 
1085 static inline s64 nla_get_s64(const struct nlattr *nla)
1086 {
1087  s64 tmp;
1088 
1089  nla_memcpy(&tmp, nla, sizeof(tmp));
1090 
1091  return tmp;
1092 }
1093 
1098 static inline int nla_get_flag(const struct nlattr *nla)
1099 {
1100  return !!nla;
1101 }
1102 
1109 static inline unsigned long nla_get_msecs(const struct nlattr *nla)
1110 {
1111  u64 msecs = nla_get_u64(nla);
1112 
1113  return msecs_to_jiffies((unsigned long) msecs);
1114 }
1115 
1123 static inline struct nlattr *nla_nest_start(struct sk_buff *skb, int attrtype)
1124 {
1125  struct nlattr *start = (struct nlattr *)skb_tail_pointer(skb);
1126 
1127  if (nla_put(skb, attrtype, 0, NULL) < 0)
1128  return NULL;
1129 
1130  return start;
1131 }
1132 
1143 static inline int nla_nest_end(struct sk_buff *skb, struct nlattr *start)
1144 {
1145  start->nla_len = skb_tail_pointer(skb) - (unsigned char *)start;
1146  return skb->len;
1147 }
1148 
1157 static inline void nla_nest_cancel(struct sk_buff *skb, struct nlattr *start)
1158 {
1159  nlmsg_trim(skb, start);
1160 }
1161 
1174 static inline int nla_validate_nested(const struct nlattr *start, int maxtype,
1175  const struct nla_policy *policy)
1176 {
1177  return nla_validate(nla_data(start), nla_len(start), maxtype, policy);
1178 }
1179 
1187 #define nla_for_each_attr(pos, head, len, rem) \
1188  for (pos = head, rem = len; \
1189  nla_ok(pos, rem); \
1190  pos = nla_next(pos, &(rem)))
1191 
1198 #define nla_for_each_nested(pos, nla, rem) \
1199  nla_for_each_attr(pos, nla_data(nla), nla_len(nla), rem)
1200 
1201 #endif