1#ifndef __LINUX_RTNETLINK_H
2#define __LINUX_RTNETLINK_H
3
4#include <linux/types.h>
5#include <linux/netlink.h>
6#include <linux/if_link.h>
7#include <linux/if_addr.h>
8#include <linux/neighbour.h>
9
10
11
12
13#define RTNL_FAMILY_IPMR 128
14#define RTNL_FAMILY_IP6MR 129
15#define RTNL_FAMILY_MAX 129
16
17
18
19
20
21
22
23enum {
24 RTM_BASE = 16,
25#define RTM_BASE RTM_BASE
26
27 RTM_NEWLINK = 16,
28#define RTM_NEWLINK RTM_NEWLINK
29 RTM_DELLINK,
30#define RTM_DELLINK RTM_DELLINK
31 RTM_GETLINK,
32#define RTM_GETLINK RTM_GETLINK
33 RTM_SETLINK,
34#define RTM_SETLINK RTM_SETLINK
35
36 RTM_NEWADDR = 20,
37#define RTM_NEWADDR RTM_NEWADDR
38 RTM_DELADDR,
39#define RTM_DELADDR RTM_DELADDR
40 RTM_GETADDR,
41#define RTM_GETADDR RTM_GETADDR
42
43 RTM_NEWROUTE = 24,
44#define RTM_NEWROUTE RTM_NEWROUTE
45 RTM_DELROUTE,
46#define RTM_DELROUTE RTM_DELROUTE
47 RTM_GETROUTE,
48#define RTM_GETROUTE RTM_GETROUTE
49
50 RTM_NEWNEIGH = 28,
51#define RTM_NEWNEIGH RTM_NEWNEIGH
52 RTM_DELNEIGH,
53#define RTM_DELNEIGH RTM_DELNEIGH
54 RTM_GETNEIGH,
55#define RTM_GETNEIGH RTM_GETNEIGH
56
57 RTM_NEWRULE = 32,
58#define RTM_NEWRULE RTM_NEWRULE
59 RTM_DELRULE,
60#define RTM_DELRULE RTM_DELRULE
61 RTM_GETRULE,
62#define RTM_GETRULE RTM_GETRULE
63
64 RTM_NEWQDISC = 36,
65#define RTM_NEWQDISC RTM_NEWQDISC
66 RTM_DELQDISC,
67#define RTM_DELQDISC RTM_DELQDISC
68 RTM_GETQDISC,
69#define RTM_GETQDISC RTM_GETQDISC
70
71 RTM_NEWTCLASS = 40,
72#define RTM_NEWTCLASS RTM_NEWTCLASS
73 RTM_DELTCLASS,
74#define RTM_DELTCLASS RTM_DELTCLASS
75 RTM_GETTCLASS,
76#define RTM_GETTCLASS RTM_GETTCLASS
77
78 RTM_NEWTFILTER = 44,
79#define RTM_NEWTFILTER RTM_NEWTFILTER
80 RTM_DELTFILTER,
81#define RTM_DELTFILTER RTM_DELTFILTER
82 RTM_GETTFILTER,
83#define RTM_GETTFILTER RTM_GETTFILTER
84
85 RTM_NEWACTION = 48,
86#define RTM_NEWACTION RTM_NEWACTION
87 RTM_DELACTION,
88#define RTM_DELACTION RTM_DELACTION
89 RTM_GETACTION,
90#define RTM_GETACTION RTM_GETACTION
91
92 RTM_NEWPREFIX = 52,
93#define RTM_NEWPREFIX RTM_NEWPREFIX
94
95 RTM_GETMULTICAST = 58,
96#define RTM_GETMULTICAST RTM_GETMULTICAST
97
98 RTM_GETANYCAST = 62,
99#define RTM_GETANYCAST RTM_GETANYCAST
100
101 RTM_NEWNEIGHTBL = 64,
102#define RTM_NEWNEIGHTBL RTM_NEWNEIGHTBL
103 RTM_GETNEIGHTBL = 66,
104#define RTM_GETNEIGHTBL RTM_GETNEIGHTBL
105 RTM_SETNEIGHTBL,
106#define RTM_SETNEIGHTBL RTM_SETNEIGHTBL
107
108 RTM_NEWNDUSEROPT = 68,
109#define RTM_NEWNDUSEROPT RTM_NEWNDUSEROPT
110
111 RTM_NEWADDRLABEL = 72,
112#define RTM_NEWADDRLABEL RTM_NEWADDRLABEL
113 RTM_DELADDRLABEL,
114#define RTM_DELADDRLABEL RTM_DELADDRLABEL
115 RTM_GETADDRLABEL,
116#define RTM_GETADDRLABEL RTM_GETADDRLABEL
117
118 RTM_GETDCB = 78,
119#define RTM_GETDCB RTM_GETDCB
120 RTM_SETDCB,
121#define RTM_SETDCB RTM_SETDCB
122
123 __RTM_MAX,
124#define RTM_MAX (((__RTM_MAX + 3) & ~3) - 1)
125};
126
127#define RTM_NR_MSGTYPES (RTM_MAX + 1 - RTM_BASE)
128#define RTM_NR_FAMILIES (RTM_NR_MSGTYPES >> 2)
129#define RTM_FAM(cmd) (((cmd) - RTM_BASE) >> 2)
130
131
132
133
134
135
136
137struct rtattr {
138 unsigned short rta_len;
139 unsigned short rta_type;
140};
141
142
143
144#define RTA_ALIGNTO 4
145#define RTA_ALIGN(len) ( ((len)+RTA_ALIGNTO-1) & ~(RTA_ALIGNTO-1) )
146#define RTA_OK(rta,len) ((len) >= (int)sizeof(struct rtattr) && \
147 (rta)->rta_len >= sizeof(struct rtattr) && \
148 (rta)->rta_len <= (len))
149#define RTA_NEXT(rta,attrlen) ((attrlen) -= RTA_ALIGN((rta)->rta_len), \
150 (struct rtattr*)(((char*)(rta)) + RTA_ALIGN((rta)->rta_len)))
151#define RTA_LENGTH(len) (RTA_ALIGN(sizeof(struct rtattr)) + (len))
152#define RTA_SPACE(len) RTA_ALIGN(RTA_LENGTH(len))
153#define RTA_DATA(rta) ((void*)(((char*)(rta)) + RTA_LENGTH(0)))
154#define RTA_PAYLOAD(rta) ((int)((rta)->rta_len) - RTA_LENGTH(0))
155
156
157
158
159
160
161
162
163struct rtmsg {
164 unsigned char rtm_family;
165 unsigned char rtm_dst_len;
166 unsigned char rtm_src_len;
167 unsigned char rtm_tos;
168
169 unsigned char rtm_table;
170 unsigned char rtm_protocol;
171 unsigned char rtm_scope;
172 unsigned char rtm_type;
173
174 unsigned rtm_flags;
175};
176
177
178
179enum {
180 RTN_UNSPEC,
181 RTN_UNICAST,
182 RTN_LOCAL,
183 RTN_BROADCAST,
184
185 RTN_ANYCAST,
186
187 RTN_MULTICAST,
188 RTN_BLACKHOLE,
189 RTN_UNREACHABLE,
190 RTN_PROHIBIT,
191 RTN_THROW,
192 RTN_NAT,
193 RTN_XRESOLVE,
194 __RTN_MAX
195};
196
197#define RTN_MAX (__RTN_MAX - 1)
198
199
200
201
202#define RTPROT_UNSPEC 0
203#define RTPROT_REDIRECT 1
204
205#define RTPROT_KERNEL 2
206#define RTPROT_BOOT 3
207#define RTPROT_STATIC 4
208
209
210
211
212
213
214
215
216#define RTPROT_GATED 8
217#define RTPROT_RA 9
218#define RTPROT_MRT 10
219#define RTPROT_ZEBRA 11
220#define RTPROT_BIRD 12
221#define RTPROT_DNROUTED 13
222#define RTPROT_XORP 14
223#define RTPROT_NTK 15
224#define RTPROT_DHCP 16
225
226
227
228
229
230
231
232
233
234
235
236
237enum rt_scope_t {
238 RT_SCOPE_UNIVERSE=0,
239
240 RT_SCOPE_SITE=200,
241 RT_SCOPE_LINK=253,
242 RT_SCOPE_HOST=254,
243 RT_SCOPE_NOWHERE=255
244};
245
246
247
248#define RTM_F_NOTIFY 0x100
249#define RTM_F_CLONED 0x200
250#define RTM_F_EQUALIZE 0x400
251#define RTM_F_PREFIX 0x800
252
253
254
255enum rt_class_t {
256 RT_TABLE_UNSPEC=0,
257
258 RT_TABLE_COMPAT=252,
259 RT_TABLE_DEFAULT=253,
260 RT_TABLE_MAIN=254,
261 RT_TABLE_LOCAL=255,
262 RT_TABLE_MAX=0xFFFFFFFF
263};
264
265
266
267
268enum rtattr_type_t {
269 RTA_UNSPEC,
270 RTA_DST,
271 RTA_SRC,
272 RTA_IIF,
273 RTA_OIF,
274 RTA_GATEWAY,
275 RTA_PRIORITY,
276 RTA_PREFSRC,
277 RTA_METRICS,
278 RTA_MULTIPATH,
279 RTA_PROTOINFO,
280 RTA_FLOW,
281 RTA_CACHEINFO,
282 RTA_SESSION,
283 RTA_MP_ALGO,
284 RTA_TABLE,
285 RTA_MARK,
286 __RTA_MAX
287};
288
289#define RTA_MAX (__RTA_MAX - 1)
290
291#define RTM_RTA(r) ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct rtmsg))))
292#define RTM_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct rtmsg))
293
294
295
296
297
298
299
300
301
302
303struct rtnexthop {
304 unsigned short rtnh_len;
305 unsigned char rtnh_flags;
306 unsigned char rtnh_hops;
307 int rtnh_ifindex;
308};
309
310
311
312#define RTNH_F_DEAD 1
313#define RTNH_F_PERVASIVE 2
314#define RTNH_F_ONLINK 4
315
316
317
318#define RTNH_ALIGNTO 4
319#define RTNH_ALIGN(len) ( ((len)+RTNH_ALIGNTO-1) & ~(RTNH_ALIGNTO-1) )
320#define RTNH_OK(rtnh,len) ((rtnh)->rtnh_len >= sizeof(struct rtnexthop) && \
321 ((int)(rtnh)->rtnh_len) <= (len))
322#define RTNH_NEXT(rtnh) ((struct rtnexthop*)(((char*)(rtnh)) + RTNH_ALIGN((rtnh)->rtnh_len)))
323#define RTNH_LENGTH(len) (RTNH_ALIGN(sizeof(struct rtnexthop)) + (len))
324#define RTNH_SPACE(len) RTNH_ALIGN(RTNH_LENGTH(len))
325#define RTNH_DATA(rtnh) ((struct rtattr*)(((char*)(rtnh)) + RTNH_LENGTH(0)))
326
327
328
329struct rta_cacheinfo {
330 __u32 rta_clntref;
331 __u32 rta_lastuse;
332 __s32 rta_expires;
333 __u32 rta_error;
334 __u32 rta_used;
335
336#define RTNETLINK_HAVE_PEERINFO 1
337 __u32 rta_id;
338 __u32 rta_ts;
339 __u32 rta_tsage;
340};
341
342
343
344enum {
345 RTAX_UNSPEC,
346#define RTAX_UNSPEC RTAX_UNSPEC
347 RTAX_LOCK,
348#define RTAX_LOCK RTAX_LOCK
349 RTAX_MTU,
350#define RTAX_MTU RTAX_MTU
351 RTAX_WINDOW,
352#define RTAX_WINDOW RTAX_WINDOW
353 RTAX_RTT,
354#define RTAX_RTT RTAX_RTT
355 RTAX_RTTVAR,
356#define RTAX_RTTVAR RTAX_RTTVAR
357 RTAX_SSTHRESH,
358#define RTAX_SSTHRESH RTAX_SSTHRESH
359 RTAX_CWND,
360#define RTAX_CWND RTAX_CWND
361 RTAX_ADVMSS,
362#define RTAX_ADVMSS RTAX_ADVMSS
363 RTAX_REORDERING,
364#define RTAX_REORDERING RTAX_REORDERING
365 RTAX_HOPLIMIT,
366#define RTAX_HOPLIMIT RTAX_HOPLIMIT
367 RTAX_INITCWND,
368#define RTAX_INITCWND RTAX_INITCWND
369 RTAX_FEATURES,
370#define RTAX_FEATURES RTAX_FEATURES
371 RTAX_RTO_MIN,
372#define RTAX_RTO_MIN RTAX_RTO_MIN
373 RTAX_INITRWND,
374#define RTAX_INITRWND RTAX_INITRWND
375 __RTAX_MAX
376};
377
378#define RTAX_MAX (__RTAX_MAX - 1)
379
380#define RTAX_FEATURE_ECN 0x00000001
381#define RTAX_FEATURE_SACK 0x00000002
382#define RTAX_FEATURE_TIMESTAMP 0x00000004
383#define RTAX_FEATURE_ALLFRAG 0x00000008
384
385struct rta_session {
386 __u8 proto;
387 __u8 pad1;
388 __u16 pad2;
389
390 union {
391 struct {
392 __u16 sport;
393 __u16 dport;
394 } ports;
395
396 struct {
397 __u8 type;
398 __u8 code;
399 __u16 ident;
400 } icmpt;
401
402 __u32 spi;
403 } u;
404};
405
406
407
408
409
410struct rtgenmsg {
411 unsigned char rtgen_family;
412};
413
414
415
416
417
418
419
420
421
422
423struct ifinfomsg {
424 unsigned char ifi_family;
425 unsigned char __ifi_pad;
426 unsigned short ifi_type;
427 int ifi_index;
428 unsigned ifi_flags;
429 unsigned ifi_change;
430};
431
432
433
434
435
436struct prefixmsg {
437 unsigned char prefix_family;
438 unsigned char prefix_pad1;
439 unsigned short prefix_pad2;
440 int prefix_ifindex;
441 unsigned char prefix_type;
442 unsigned char prefix_len;
443 unsigned char prefix_flags;
444 unsigned char prefix_pad3;
445};
446
447enum
448{
449 PREFIX_UNSPEC,
450 PREFIX_ADDRESS,
451 PREFIX_CACHEINFO,
452 __PREFIX_MAX
453};
454
455#define PREFIX_MAX (__PREFIX_MAX - 1)
456
457struct prefix_cacheinfo {
458 __u32 preferred_time;
459 __u32 valid_time;
460};
461
462
463
464
465
466
467struct tcmsg {
468 unsigned char tcm_family;
469 unsigned char tcm__pad1;
470 unsigned short tcm__pad2;
471 int tcm_ifindex;
472 __u32 tcm_handle;
473 __u32 tcm_parent;
474 __u32 tcm_info;
475};
476
477enum {
478 TCA_UNSPEC,
479 TCA_KIND,
480 TCA_OPTIONS,
481 TCA_STATS,
482 TCA_XSTATS,
483 TCA_RATE,
484 TCA_FCNT,
485 TCA_STATS2,
486 TCA_STAB,
487 __TCA_MAX
488};
489
490#define TCA_MAX (__TCA_MAX - 1)
491
492#define TCA_RTA(r) ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcmsg))))
493#define TCA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcmsg))
494
495
496
497
498
499struct nduseroptmsg {
500 unsigned char nduseropt_family;
501 unsigned char nduseropt_pad1;
502 unsigned short nduseropt_opts_len;
503 int nduseropt_ifindex;
504 __u8 nduseropt_icmp_type;
505 __u8 nduseropt_icmp_code;
506 unsigned short nduseropt_pad2;
507 unsigned int nduseropt_pad3;
508
509};
510
511enum {
512 NDUSEROPT_UNSPEC,
513 NDUSEROPT_SRCADDR,
514 __NDUSEROPT_MAX
515};
516
517#define NDUSEROPT_MAX (__NDUSEROPT_MAX - 1)
518
519#ifndef __KERNEL__
520
521#define RTMGRP_LINK 1
522#define RTMGRP_NOTIFY 2
523#define RTMGRP_NEIGH 4
524#define RTMGRP_TC 8
525
526#define RTMGRP_IPV4_IFADDR 0x10
527#define RTMGRP_IPV4_MROUTE 0x20
528#define RTMGRP_IPV4_ROUTE 0x40
529#define RTMGRP_IPV4_RULE 0x80
530
531#define RTMGRP_IPV6_IFADDR 0x100
532#define RTMGRP_IPV6_MROUTE 0x200
533#define RTMGRP_IPV6_ROUTE 0x400
534#define RTMGRP_IPV6_IFINFO 0x800
535
536#define RTMGRP_DECnet_IFADDR 0x1000
537#define RTMGRP_DECnet_ROUTE 0x4000
538
539#define RTMGRP_IPV6_PREFIX 0x20000
540#endif
541
542
543enum rtnetlink_groups {
544 RTNLGRP_NONE,
545#define RTNLGRP_NONE RTNLGRP_NONE
546 RTNLGRP_LINK,
547#define RTNLGRP_LINK RTNLGRP_LINK
548 RTNLGRP_NOTIFY,
549#define RTNLGRP_NOTIFY RTNLGRP_NOTIFY
550 RTNLGRP_NEIGH,
551#define RTNLGRP_NEIGH RTNLGRP_NEIGH
552 RTNLGRP_TC,
553#define RTNLGRP_TC RTNLGRP_TC
554 RTNLGRP_IPV4_IFADDR,
555#define RTNLGRP_IPV4_IFADDR RTNLGRP_IPV4_IFADDR
556 RTNLGRP_IPV4_MROUTE,
557#define RTNLGRP_IPV4_MROUTE RTNLGRP_IPV4_MROUTE
558 RTNLGRP_IPV4_ROUTE,
559#define RTNLGRP_IPV4_ROUTE RTNLGRP_IPV4_ROUTE
560 RTNLGRP_IPV4_RULE,
561#define RTNLGRP_IPV4_RULE RTNLGRP_IPV4_RULE
562 RTNLGRP_IPV6_IFADDR,
563#define RTNLGRP_IPV6_IFADDR RTNLGRP_IPV6_IFADDR
564 RTNLGRP_IPV6_MROUTE,
565#define RTNLGRP_IPV6_MROUTE RTNLGRP_IPV6_MROUTE
566 RTNLGRP_IPV6_ROUTE,
567#define RTNLGRP_IPV6_ROUTE RTNLGRP_IPV6_ROUTE
568 RTNLGRP_IPV6_IFINFO,
569#define RTNLGRP_IPV6_IFINFO RTNLGRP_IPV6_IFINFO
570 RTNLGRP_DECnet_IFADDR,
571#define RTNLGRP_DECnet_IFADDR RTNLGRP_DECnet_IFADDR
572 RTNLGRP_NOP2,
573 RTNLGRP_DECnet_ROUTE,
574#define RTNLGRP_DECnet_ROUTE RTNLGRP_DECnet_ROUTE
575 RTNLGRP_DECnet_RULE,
576#define RTNLGRP_DECnet_RULE RTNLGRP_DECnet_RULE
577 RTNLGRP_NOP4,
578 RTNLGRP_IPV6_PREFIX,
579#define RTNLGRP_IPV6_PREFIX RTNLGRP_IPV6_PREFIX
580 RTNLGRP_IPV6_RULE,
581#define RTNLGRP_IPV6_RULE RTNLGRP_IPV6_RULE
582 RTNLGRP_ND_USEROPT,
583#define RTNLGRP_ND_USEROPT RTNLGRP_ND_USEROPT
584 RTNLGRP_PHONET_IFADDR,
585#define RTNLGRP_PHONET_IFADDR RTNLGRP_PHONET_IFADDR
586 RTNLGRP_PHONET_ROUTE,
587#define RTNLGRP_PHONET_ROUTE RTNLGRP_PHONET_ROUTE
588 RTNLGRP_DCB,
589#define RTNLGRP_DCB RTNLGRP_DCB
590 __RTNLGRP_MAX
591};
592#define RTNLGRP_MAX (__RTNLGRP_MAX - 1)
593
594
595struct tcamsg {
596 unsigned char tca_family;
597 unsigned char tca__pad1;
598 unsigned short tca__pad2;
599};
600#define TA_RTA(r) ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcamsg))))
601#define TA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcamsg))
602#define TCA_ACT_TAB 1
603#define TCAA_MAX 1
604
605
606#define RTEXT_FILTER_VF (1 << 0)
607
608
609
610#ifdef __KERNEL__
611
612#include <linux/mutex.h>
613#include <linux/netdevice.h>
614
615static __inline__ int rtattr_strcmp(const struct rtattr *rta, const char *str)
616{
617 int len = strlen(str) + 1;
618 return len > rta->rta_len || memcmp(RTA_DATA(rta), str, len);
619}
620
621extern int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, u32 group, int echo);
622extern int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid);
623extern void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid,
624 u32 group, struct nlmsghdr *nlh, gfp_t flags);
625extern void rtnl_set_sk_err(struct net *net, u32 group, int error);
626extern int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics);
627extern int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst,
628 u32 id, u32 ts, u32 tsage, long expires,
629 u32 error);
630
631extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
632
633#define RTA_PUT(skb, attrtype, attrlen, data) \
634({ if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
635 goto rtattr_failure; \
636 __rta_fill(skb, attrtype, attrlen, data); })
637
638#define RTA_APPEND(skb, attrlen, data) \
639({ if (unlikely(skb_tailroom(skb) < (int)(attrlen))) \
640 goto rtattr_failure; \
641 memcpy(skb_put(skb, attrlen), data, attrlen); })
642
643#define RTA_PUT_NOHDR(skb, attrlen, data) \
644({ RTA_APPEND(skb, RTA_ALIGN(attrlen), data); \
645 memset(skb_tail_pointer(skb) - (RTA_ALIGN(attrlen) - attrlen), 0, \
646 RTA_ALIGN(attrlen) - attrlen); })
647
648#define RTA_PUT_U8(skb, attrtype, value) \
649({ u8 _tmp = (value); \
650 RTA_PUT(skb, attrtype, sizeof(u8), &_tmp); })
651
652#define RTA_PUT_U16(skb, attrtype, value) \
653({ u16 _tmp = (value); \
654 RTA_PUT(skb, attrtype, sizeof(u16), &_tmp); })
655
656#define RTA_PUT_U32(skb, attrtype, value) \
657({ u32 _tmp = (value); \
658 RTA_PUT(skb, attrtype, sizeof(u32), &_tmp); })
659
660#define RTA_PUT_U64(skb, attrtype, value) \
661({ u64 _tmp = (value); \
662 RTA_PUT(skb, attrtype, sizeof(u64), &_tmp); })
663
664#define RTA_PUT_SECS(skb, attrtype, value) \
665 RTA_PUT_U64(skb, attrtype, (value) / HZ)
666
667#define RTA_PUT_MSECS(skb, attrtype, value) \
668 RTA_PUT_U64(skb, attrtype, jiffies_to_msecs(value))
669
670#define RTA_PUT_STRING(skb, attrtype, value) \
671 RTA_PUT(skb, attrtype, strlen(value) + 1, value)
672
673#define RTA_PUT_FLAG(skb, attrtype) \
674 RTA_PUT(skb, attrtype, 0, NULL);
675
676#define RTA_NEST(skb, type) \
677({ struct rtattr *__start = (struct rtattr *)skb_tail_pointer(skb); \
678 RTA_PUT(skb, type, 0, NULL); \
679 __start; })
680
681#define RTA_NEST_END(skb, start) \
682({ (start)->rta_len = skb_tail_pointer(skb) - (unsigned char *)(start); \
683 (skb)->len; })
684
685#define RTA_NEST_COMPAT(skb, type, attrlen, data) \
686({ struct rtattr *__start = (struct rtattr *)skb_tail_pointer(skb); \
687 RTA_PUT(skb, type, attrlen, data); \
688 RTA_NEST(skb, type); \
689 __start; })
690
691#define RTA_NEST_COMPAT_END(skb, start) \
692({ struct rtattr *__nest = (void *)(start) + NLMSG_ALIGN((start)->rta_len); \
693 (start)->rta_len = skb_tail_pointer(skb) - (unsigned char *)(start); \
694 RTA_NEST_END(skb, __nest); \
695 (skb)->len; })
696
697#define RTA_NEST_CANCEL(skb, start) \
698({ if (start) \
699 skb_trim(skb, (unsigned char *) (start) - (skb)->data); \
700 -1; })
701
702#define RTA_GET_U8(rta) \
703({ if (!rta || RTA_PAYLOAD(rta) < sizeof(u8)) \
704 goto rtattr_failure; \
705 *(u8 *) RTA_DATA(rta); })
706
707#define RTA_GET_U16(rta) \
708({ if (!rta || RTA_PAYLOAD(rta) < sizeof(u16)) \
709 goto rtattr_failure; \
710 *(u16 *) RTA_DATA(rta); })
711
712#define RTA_GET_U32(rta) \
713({ if (!rta || RTA_PAYLOAD(rta) < sizeof(u32)) \
714 goto rtattr_failure; \
715 *(u32 *) RTA_DATA(rta); })
716
717#define RTA_GET_U64(rta) \
718({ u64 _tmp; \
719 if (!rta || RTA_PAYLOAD(rta) < sizeof(u64)) \
720 goto rtattr_failure; \
721 memcpy(&_tmp, RTA_DATA(rta), sizeof(_tmp)); \
722 _tmp; })
723
724#define RTA_GET_FLAG(rta) (!!(rta))
725
726#define RTA_GET_SECS(rta) ((unsigned long) RTA_GET_U64(rta) * HZ)
727#define RTA_GET_MSECS(rta) (msecs_to_jiffies((unsigned long) RTA_GET_U64(rta)))
728
729static inline struct rtattr *
730__rta_reserve(struct sk_buff *skb, int attrtype, int attrlen)
731{
732 struct rtattr *rta;
733 int size = RTA_LENGTH(attrlen);
734
735 rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
736 rta->rta_type = attrtype;
737 rta->rta_len = size;
738 memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
739 return rta;
740}
741
742#define __RTA_PUT(skb, attrtype, attrlen) \
743({ if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
744 goto rtattr_failure; \
745 __rta_reserve(skb, attrtype, attrlen); })
746
747extern void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change);
748
749
750extern void rtnl_lock(void);
751extern void rtnl_unlock(void);
752extern int rtnl_trylock(void);
753extern int rtnl_is_locked(void);
754#ifdef CONFIG_PROVE_LOCKING
755extern int lockdep_rtnl_is_held(void);
756#endif
757
758
759
760
761
762
763
764
765#define rcu_dereference_rtnl(p) \
766 rcu_dereference_check(p, lockdep_rtnl_is_held())
767
768
769
770
771
772
773
774
775
776#define rtnl_dereference(p) \
777 rcu_dereference_protected(p, lockdep_rtnl_is_held())
778
779static inline struct netdev_queue *dev_ingress_queue(struct net_device *dev)
780{
781 return rtnl_dereference(dev->ingress_queue);
782}
783
784extern struct netdev_queue *dev_ingress_queue_create(struct net_device *dev);
785
786extern void rtnetlink_init(void);
787extern void __rtnl_unlock(void);
788
789#define ASSERT_RTNL() do { \
790 if (unlikely(!rtnl_is_locked())) { \
791 printk(KERN_ERR "RTNL: assertion failed at %s (%d)\n", \
792 __FILE__, __LINE__); \
793 dump_stack(); \
794 } \
795} while(0)
796
797static inline u32 rtm_get_table(struct rtattr **rta, u8 table)
798{
799 return RTA_GET_U32(rta[RTA_TABLE-1]);
800rtattr_failure:
801 return table;
802}
803
804#endif
805
806
807#endif
808