[RTNETLINK] Fix RTM_MAX to represent the maximum valid message type
[linux-2.6.git] / include / linux / rtnetlink.h
1 #ifndef __LINUX_RTNETLINK_H
2 #define __LINUX_RTNETLINK_H
3
4 #include <linux/netlink.h>
5
6 /****
7  *              Routing/neighbour discovery messages.
8  ****/
9
10 /* Types of messages */
11
12 enum {
13         RTM_BASE        = 16,
14 #define RTM_BASE        RTM_BASE
15
16         RTM_NEWLINK     = 16,
17 #define RTM_NEWLINK     RTM_NEWLINK
18         RTM_DELLINK,
19 #define RTM_DELLINK     RTM_DELLINK
20         RTM_GETLINK,
21 #define RTM_GETLINK     RTM_GETLINK
22         RTM_SETLINK,
23 #define RTM_SETLINK     RTM_SETLINK
24
25         RTM_NEWADDR     = 20,
26 #define RTM_NEWADDR     RTM_NEWADDR
27         RTM_DELADDR,
28 #define RTM_DELADDR     RTM_DELADDR
29         RTM_GETADDR,
30 #define RTM_GETADDR     RTM_GETADDR
31
32         RTM_NEWROUTE    = 24,
33 #define RTM_NEWROUTE    RTM_NEWROUTE
34         RTM_DELROUTE,
35 #define RTM_DELROUTE    RTM_DELROUTE
36         RTM_GETROUTE,
37 #define RTM_GETROUTE    RTM_GETROUTE
38
39         RTM_NEWNEIGH    = 28,
40 #define RTM_NEWNEIGH    RTM_NEWNEIGH
41         RTM_DELNEIGH,
42 #define RTM_DELNEIGH    RTM_DELNEIGH
43         RTM_GETNEIGH,
44 #define RTM_GETNEIGH    RTM_GETNEIGH
45
46         RTM_NEWRULE     = 32,
47 #define RTM_NEWRULE     RTM_NEWRULE
48         RTM_DELRULE,
49 #define RTM_DELRULE     RTM_DELRULE
50         RTM_GETRULE,
51 #define RTM_GETRULE     RTM_GETRULE
52
53         RTM_NEWQDISC    = 36,
54 #define RTM_NEWQDISC    RTM_NEWQDISC
55         RTM_DELQDISC,
56 #define RTM_DELQDISC    RTM_DELQDISC
57         RTM_GETQDISC,
58 #define RTM_GETQDISC    RTM_GETQDISC
59
60         RTM_NEWTCLASS   = 40,
61 #define RTM_NEWTCLASS   RTM_NEWTCLASS
62         RTM_DELTCLASS,
63 #define RTM_DELTCLASS   RTM_DELTCLASS
64         RTM_GETTCLASS,
65 #define RTM_GETTCLASS   RTM_GETTCLASS
66
67         RTM_NEWTFILTER  = 44,
68 #define RTM_NEWTFILTER  RTM_NEWTFILTER
69         RTM_DELTFILTER,
70 #define RTM_DELTFILTER  RTM_DELTFILTER
71         RTM_GETTFILTER,
72 #define RTM_GETTFILTER  RTM_GETTFILTER
73
74         RTM_NEWACTION   = 48,
75 #define RTM_NEWACTION   RTM_NEWACTION
76         RTM_DELACTION,
77 #define RTM_DELACTION   RTM_DELACTION
78         RTM_GETACTION,
79 #define RTM_GETACTION   RTM_GETACTION
80
81         RTM_NEWPREFIX   = 52,
82 #define RTM_NEWPREFIX   RTM_NEWPREFIX
83         RTM_GETPREFIX   = 54,
84 #define RTM_GETPREFIX   RTM_GETPREFIX
85
86         RTM_GETMULTICAST = 58,
87 #define RTM_GETMULTICAST RTM_GETMULTICAST
88
89         RTM_GETANYCAST  = 62,
90 #define RTM_GETANYCAST  RTM_GETANYCAST
91
92         __RTM_MAX,
93 #define RTM_MAX         (((__RTM_MAX + 3) & ~3) - 1)
94 };
95
96 /* 
97    Generic structure for encapsulation of optional route information.
98    It is reminiscent of sockaddr, but with sa_family replaced
99    with attribute type.
100  */
101
102 struct rtattr
103 {
104         unsigned short  rta_len;
105         unsigned short  rta_type;
106 };
107
108 /* Macros to handle rtattributes */
109
110 #define RTA_ALIGNTO     4
111 #define RTA_ALIGN(len) ( ((len)+RTA_ALIGNTO-1) & ~(RTA_ALIGNTO-1) )
112 #define RTA_OK(rta,len) ((len) >= (int)sizeof(struct rtattr) && \
113                          (rta)->rta_len >= sizeof(struct rtattr) && \
114                          (rta)->rta_len <= (len))
115 #define RTA_NEXT(rta,attrlen)   ((attrlen) -= RTA_ALIGN((rta)->rta_len), \
116                                  (struct rtattr*)(((char*)(rta)) + RTA_ALIGN((rta)->rta_len)))
117 #define RTA_LENGTH(len) (RTA_ALIGN(sizeof(struct rtattr)) + (len))
118 #define RTA_SPACE(len)  RTA_ALIGN(RTA_LENGTH(len))
119 #define RTA_DATA(rta)   ((void*)(((char*)(rta)) + RTA_LENGTH(0)))
120 #define RTA_PAYLOAD(rta) ((int)((rta)->rta_len) - RTA_LENGTH(0))
121
122
123
124
125 /******************************************************************************
126  *              Definitions used in routing table administration.
127  ****/
128
129 struct rtmsg
130 {
131         unsigned char           rtm_family;
132         unsigned char           rtm_dst_len;
133         unsigned char           rtm_src_len;
134         unsigned char           rtm_tos;
135
136         unsigned char           rtm_table;      /* Routing table id */
137         unsigned char           rtm_protocol;   /* Routing protocol; see below  */
138         unsigned char           rtm_scope;      /* See below */ 
139         unsigned char           rtm_type;       /* See below    */
140
141         unsigned                rtm_flags;
142 };
143
144 /* rtm_type */
145
146 enum
147 {
148         RTN_UNSPEC,
149         RTN_UNICAST,            /* Gateway or direct route      */
150         RTN_LOCAL,              /* Accept locally               */
151         RTN_BROADCAST,          /* Accept locally as broadcast,
152                                    send as broadcast */
153         RTN_ANYCAST,            /* Accept locally as broadcast,
154                                    but send as unicast */
155         RTN_MULTICAST,          /* Multicast route              */
156         RTN_BLACKHOLE,          /* Drop                         */
157         RTN_UNREACHABLE,        /* Destination is unreachable   */
158         RTN_PROHIBIT,           /* Administratively prohibited  */
159         RTN_THROW,              /* Not in this table            */
160         RTN_NAT,                /* Translate this address       */
161         RTN_XRESOLVE,           /* Use external resolver        */
162         __RTN_MAX
163 };
164
165 #define RTN_MAX (__RTN_MAX - 1)
166
167
168 /* rtm_protocol */
169
170 #define RTPROT_UNSPEC   0
171 #define RTPROT_REDIRECT 1       /* Route installed by ICMP redirects;
172                                    not used by current IPv4 */
173 #define RTPROT_KERNEL   2       /* Route installed by kernel            */
174 #define RTPROT_BOOT     3       /* Route installed during boot          */
175 #define RTPROT_STATIC   4       /* Route installed by administrator     */
176
177 /* Values of protocol >= RTPROT_STATIC are not interpreted by kernel;
178    they are just passed from user and back as is.
179    It will be used by hypothetical multiple routing daemons.
180    Note that protocol values should be standardized in order to
181    avoid conflicts.
182  */
183
184 #define RTPROT_GATED    8       /* Apparently, GateD */
185 #define RTPROT_RA       9       /* RDISC/ND router advertisements */
186 #define RTPROT_MRT      10      /* Merit MRT */
187 #define RTPROT_ZEBRA    11      /* Zebra */
188 #define RTPROT_BIRD     12      /* BIRD */
189 #define RTPROT_DNROUTED 13      /* DECnet routing daemon */
190 #define RTPROT_XORP     14      /* XORP */
191
192 /* rtm_scope
193
194    Really it is not scope, but sort of distance to the destination.
195    NOWHERE are reserved for not existing destinations, HOST is our
196    local addresses, LINK are destinations, located on directly attached
197    link and UNIVERSE is everywhere in the Universe.
198
199    Intermediate values are also possible f.e. interior routes
200    could be assigned a value between UNIVERSE and LINK.
201 */
202
203 enum rt_scope_t
204 {
205         RT_SCOPE_UNIVERSE=0,
206 /* User defined values  */
207         RT_SCOPE_SITE=200,
208         RT_SCOPE_LINK=253,
209         RT_SCOPE_HOST=254,
210         RT_SCOPE_NOWHERE=255
211 };
212
213 /* rtm_flags */
214
215 #define RTM_F_NOTIFY            0x100   /* Notify user of route change  */
216 #define RTM_F_CLONED            0x200   /* This route is cloned         */
217 #define RTM_F_EQUALIZE          0x400   /* Multipath equalizer: NI      */
218 #define RTM_F_PREFIX            0x800   /* Prefix addresses             */
219
220 /* Reserved table identifiers */
221
222 enum rt_class_t
223 {
224         RT_TABLE_UNSPEC=0,
225 /* User defined values */
226         RT_TABLE_DEFAULT=253,
227         RT_TABLE_MAIN=254,
228         RT_TABLE_LOCAL=255,
229         __RT_TABLE_MAX
230 };
231 #define RT_TABLE_MAX (__RT_TABLE_MAX - 1)
232
233
234
235 /* Routing message attributes */
236
237 enum rtattr_type_t
238 {
239         RTA_UNSPEC,
240         RTA_DST,
241         RTA_SRC,
242         RTA_IIF,
243         RTA_OIF,
244         RTA_GATEWAY,
245         RTA_PRIORITY,
246         RTA_PREFSRC,
247         RTA_METRICS,
248         RTA_MULTIPATH,
249         RTA_PROTOINFO,
250         RTA_FLOW,
251         RTA_CACHEINFO,
252         RTA_SESSION,
253         RTA_MP_ALGO,
254         __RTA_MAX
255 };
256
257 #define RTA_MAX (__RTA_MAX - 1)
258
259 #define RTM_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct rtmsg))))
260 #define RTM_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct rtmsg))
261
262 /* RTM_MULTIPATH --- array of struct rtnexthop.
263  *
264  * "struct rtnexthop" describes all necessary nexthop information,
265  * i.e. parameters of path to a destination via this nexthop.
266  *
267  * At the moment it is impossible to set different prefsrc, mtu, window
268  * and rtt for different paths from multipath.
269  */
270
271 struct rtnexthop
272 {
273         unsigned short          rtnh_len;
274         unsigned char           rtnh_flags;
275         unsigned char           rtnh_hops;
276         int                     rtnh_ifindex;
277 };
278
279 /* rtnh_flags */
280
281 #define RTNH_F_DEAD             1       /* Nexthop is dead (used by multipath)  */
282 #define RTNH_F_PERVASIVE        2       /* Do recursive gateway lookup  */
283 #define RTNH_F_ONLINK           4       /* Gateway is forced on link    */
284
285 /* Macros to handle hexthops */
286
287 #define RTNH_ALIGNTO    4
288 #define RTNH_ALIGN(len) ( ((len)+RTNH_ALIGNTO-1) & ~(RTNH_ALIGNTO-1) )
289 #define RTNH_OK(rtnh,len) ((rtnh)->rtnh_len >= sizeof(struct rtnexthop) && \
290                            ((int)(rtnh)->rtnh_len) <= (len))
291 #define RTNH_NEXT(rtnh) ((struct rtnexthop*)(((char*)(rtnh)) + RTNH_ALIGN((rtnh)->rtnh_len)))
292 #define RTNH_LENGTH(len) (RTNH_ALIGN(sizeof(struct rtnexthop)) + (len))
293 #define RTNH_SPACE(len) RTNH_ALIGN(RTNH_LENGTH(len))
294 #define RTNH_DATA(rtnh)   ((struct rtattr*)(((char*)(rtnh)) + RTNH_LENGTH(0)))
295
296 /* RTM_CACHEINFO */
297
298 struct rta_cacheinfo
299 {
300         __u32   rta_clntref;
301         __u32   rta_lastuse;
302         __s32   rta_expires;
303         __u32   rta_error;
304         __u32   rta_used;
305
306 #define RTNETLINK_HAVE_PEERINFO 1
307         __u32   rta_id;
308         __u32   rta_ts;
309         __u32   rta_tsage;
310 };
311
312 /* RTM_METRICS --- array of struct rtattr with types of RTAX_* */
313
314 enum
315 {
316         RTAX_UNSPEC,
317 #define RTAX_UNSPEC RTAX_UNSPEC
318         RTAX_LOCK,
319 #define RTAX_LOCK RTAX_LOCK
320         RTAX_MTU,
321 #define RTAX_MTU RTAX_MTU
322         RTAX_WINDOW,
323 #define RTAX_WINDOW RTAX_WINDOW
324         RTAX_RTT,
325 #define RTAX_RTT RTAX_RTT
326         RTAX_RTTVAR,
327 #define RTAX_RTTVAR RTAX_RTTVAR
328         RTAX_SSTHRESH,
329 #define RTAX_SSTHRESH RTAX_SSTHRESH
330         RTAX_CWND,
331 #define RTAX_CWND RTAX_CWND
332         RTAX_ADVMSS,
333 #define RTAX_ADVMSS RTAX_ADVMSS
334         RTAX_REORDERING,
335 #define RTAX_REORDERING RTAX_REORDERING
336         RTAX_HOPLIMIT,
337 #define RTAX_HOPLIMIT RTAX_HOPLIMIT
338         RTAX_INITCWND,
339 #define RTAX_INITCWND RTAX_INITCWND
340         RTAX_FEATURES,
341 #define RTAX_FEATURES RTAX_FEATURES
342         __RTAX_MAX
343 };
344
345 #define RTAX_MAX (__RTAX_MAX - 1)
346
347 #define RTAX_FEATURE_ECN        0x00000001
348 #define RTAX_FEATURE_SACK       0x00000002
349 #define RTAX_FEATURE_TIMESTAMP  0x00000004
350 #define RTAX_FEATURE_ALLFRAG    0x00000008
351
352 struct rta_session
353 {
354         __u8    proto;
355
356         union {
357                 struct {
358                         __u16   sport;
359                         __u16   dport;
360                 } ports;
361
362                 struct {
363                         __u8    type;
364                         __u8    code;
365                         __u16   ident;
366                 } icmpt;
367
368                 __u32           spi;
369         } u;
370 };
371
372
373 /*********************************************************
374  *              Interface address.
375  ****/
376
377 struct ifaddrmsg
378 {
379         unsigned char   ifa_family;
380         unsigned char   ifa_prefixlen;  /* The prefix length            */
381         unsigned char   ifa_flags;      /* Flags                        */
382         unsigned char   ifa_scope;      /* See above                    */
383         int             ifa_index;      /* Link index                   */
384 };
385
386 enum
387 {
388         IFA_UNSPEC,
389         IFA_ADDRESS,
390         IFA_LOCAL,
391         IFA_LABEL,
392         IFA_BROADCAST,
393         IFA_ANYCAST,
394         IFA_CACHEINFO,
395         IFA_MULTICAST,
396         __IFA_MAX
397 };
398
399 #define IFA_MAX (__IFA_MAX - 1)
400
401 /* ifa_flags */
402
403 #define IFA_F_SECONDARY         0x01
404 #define IFA_F_TEMPORARY         IFA_F_SECONDARY
405
406 #define IFA_F_DEPRECATED        0x20
407 #define IFA_F_TENTATIVE         0x40
408 #define IFA_F_PERMANENT         0x80
409
410 struct ifa_cacheinfo
411 {
412         __u32   ifa_prefered;
413         __u32   ifa_valid;
414         __u32   cstamp; /* created timestamp, hundredths of seconds */
415         __u32   tstamp; /* updated timestamp, hundredths of seconds */
416 };
417
418
419 #define IFA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ifaddrmsg))))
420 #define IFA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ifaddrmsg))
421
422 /*
423    Important comment:
424    IFA_ADDRESS is prefix address, rather than local interface address.
425    It makes no difference for normally configured broadcast interfaces,
426    but for point-to-point IFA_ADDRESS is DESTINATION address,
427    local address is supplied in IFA_LOCAL attribute.
428  */
429
430 /**************************************************************
431  *              Neighbour discovery.
432  ****/
433
434 struct ndmsg
435 {
436         unsigned char   ndm_family;
437         unsigned char   ndm_pad1;
438         unsigned short  ndm_pad2;
439         int             ndm_ifindex;    /* Link index                   */
440         __u16           ndm_state;
441         __u8            ndm_flags;
442         __u8            ndm_type;
443 };
444
445 enum
446 {
447         NDA_UNSPEC,
448         NDA_DST,
449         NDA_LLADDR,
450         NDA_CACHEINFO,
451         NDA_PROBES,
452         __NDA_MAX
453 };
454
455 #define NDA_MAX (__NDA_MAX - 1)
456
457 #define NDA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
458 #define NDA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ndmsg))
459
460 /*
461  *      Neighbor Cache Entry Flags
462  */
463
464 #define NTF_PROXY       0x08    /* == ATF_PUBL */
465 #define NTF_ROUTER      0x80
466
467 /*
468  *      Neighbor Cache Entry States.
469  */
470
471 #define NUD_INCOMPLETE  0x01
472 #define NUD_REACHABLE   0x02
473 #define NUD_STALE       0x04
474 #define NUD_DELAY       0x08
475 #define NUD_PROBE       0x10
476 #define NUD_FAILED      0x20
477
478 /* Dummy states */
479 #define NUD_NOARP       0x40
480 #define NUD_PERMANENT   0x80
481 #define NUD_NONE        0x00
482
483
484 struct nda_cacheinfo
485 {
486         __u32           ndm_confirmed;
487         __u32           ndm_used;
488         __u32           ndm_updated;
489         __u32           ndm_refcnt;
490 };
491
492 /****
493  *              General form of address family dependent message.
494  ****/
495
496 struct rtgenmsg
497 {
498         unsigned char           rtgen_family;
499 };
500
501 /*****************************************************************
502  *              Link layer specific messages.
503  ****/
504
505 /* struct ifinfomsg
506  * passes link level specific information, not dependent
507  * on network protocol.
508  */
509
510 struct ifinfomsg
511 {
512         unsigned char   ifi_family;
513         unsigned char   __ifi_pad;
514         unsigned short  ifi_type;               /* ARPHRD_* */
515         int             ifi_index;              /* Link index   */
516         unsigned        ifi_flags;              /* IFF_* flags  */
517         unsigned        ifi_change;             /* IFF_* change mask */
518 };
519
520 /********************************************************************
521  *              prefix information 
522  ****/
523
524 struct prefixmsg
525 {
526         unsigned char   prefix_family;
527         int             prefix_ifindex;
528         unsigned char   prefix_type;
529         unsigned char   prefix_len;
530         unsigned char   prefix_flags;
531 };
532
533 enum 
534 {
535         PREFIX_UNSPEC,
536         PREFIX_ADDRESS,
537         PREFIX_CACHEINFO,
538         __PREFIX_MAX
539 };
540
541 #define PREFIX_MAX      (__PREFIX_MAX - 1)
542
543 struct prefix_cacheinfo
544 {
545         __u32   preferred_time;
546         __u32   valid_time;
547 };
548
549 /* The struct should be in sync with struct net_device_stats */
550 struct rtnl_link_stats
551 {
552         __u32   rx_packets;             /* total packets received       */
553         __u32   tx_packets;             /* total packets transmitted    */
554         __u32   rx_bytes;               /* total bytes received         */
555         __u32   tx_bytes;               /* total bytes transmitted      */
556         __u32   rx_errors;              /* bad packets received         */
557         __u32   tx_errors;              /* packet transmit problems     */
558         __u32   rx_dropped;             /* no space in linux buffers    */
559         __u32   tx_dropped;             /* no space available in linux  */
560         __u32   multicast;              /* multicast packets received   */
561         __u32   collisions;
562
563         /* detailed rx_errors: */
564         __u32   rx_length_errors;
565         __u32   rx_over_errors;         /* receiver ring buff overflow  */
566         __u32   rx_crc_errors;          /* recved pkt with crc error    */
567         __u32   rx_frame_errors;        /* recv'd frame alignment error */
568         __u32   rx_fifo_errors;         /* recv'r fifo overrun          */
569         __u32   rx_missed_errors;       /* receiver missed packet       */
570
571         /* detailed tx_errors */
572         __u32   tx_aborted_errors;
573         __u32   tx_carrier_errors;
574         __u32   tx_fifo_errors;
575         __u32   tx_heartbeat_errors;
576         __u32   tx_window_errors;
577         
578         /* for cslip etc */
579         __u32   rx_compressed;
580         __u32   tx_compressed;
581 };
582
583 /* The struct should be in sync with struct ifmap */
584 struct rtnl_link_ifmap
585 {
586         __u64   mem_start;
587         __u64   mem_end;
588         __u64   base_addr;
589         __u16   irq;
590         __u8    dma;
591         __u8    port;
592 };
593
594 enum
595 {
596         IFLA_UNSPEC,
597         IFLA_ADDRESS,
598         IFLA_BROADCAST,
599         IFLA_IFNAME,
600         IFLA_MTU,
601         IFLA_LINK,
602         IFLA_QDISC,
603         IFLA_STATS,
604         IFLA_COST,
605 #define IFLA_COST IFLA_COST
606         IFLA_PRIORITY,
607 #define IFLA_PRIORITY IFLA_PRIORITY
608         IFLA_MASTER,
609 #define IFLA_MASTER IFLA_MASTER
610         IFLA_WIRELESS,          /* Wireless Extension event - see wireless.h */
611 #define IFLA_WIRELESS IFLA_WIRELESS
612         IFLA_PROTINFO,          /* Protocol specific information for a link */
613 #define IFLA_PROTINFO IFLA_PROTINFO
614         IFLA_TXQLEN,
615 #define IFLA_TXQLEN IFLA_TXQLEN
616         IFLA_MAP,
617 #define IFLA_MAP IFLA_MAP
618         IFLA_WEIGHT,
619 #define IFLA_WEIGHT IFLA_WEIGHT
620         __IFLA_MAX
621 };
622
623
624 #define IFLA_MAX (__IFLA_MAX - 1)
625
626 #define IFLA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ifinfomsg))))
627 #define IFLA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ifinfomsg))
628
629 /* ifi_flags.
630
631    IFF_* flags.
632
633    The only change is:
634    IFF_LOOPBACK, IFF_BROADCAST and IFF_POINTOPOINT are
635    more not changeable by user. They describe link media
636    characteristics and set by device driver.
637
638    Comments:
639    - Combination IFF_BROADCAST|IFF_POINTOPOINT is invalid
640    - If neither of these three flags are set;
641      the interface is NBMA.
642
643    - IFF_MULTICAST does not mean anything special:
644    multicasts can be used on all not-NBMA links.
645    IFF_MULTICAST means that this media uses special encapsulation
646    for multicast frames. Apparently, all IFF_POINTOPOINT and
647    IFF_BROADCAST devices are able to use multicasts too.
648  */
649
650 /* IFLA_LINK.
651    For usual devices it is equal ifi_index.
652    If it is a "virtual interface" (f.e. tunnel), ifi_link
653    can point to real physical interface (f.e. for bandwidth calculations),
654    or maybe 0, what means, that real media is unknown (usual
655    for IPIP tunnels, when route to endpoint is allowed to change)
656  */
657
658 /* Subtype attributes for IFLA_PROTINFO */
659 enum
660 {
661         IFLA_INET6_UNSPEC,
662         IFLA_INET6_FLAGS,       /* link flags                   */
663         IFLA_INET6_CONF,        /* sysctl parameters            */
664         IFLA_INET6_STATS,       /* statistics                   */
665         IFLA_INET6_MCAST,       /* MC things. What of them?     */
666         IFLA_INET6_CACHEINFO,   /* time values and max reasm size */
667         __IFLA_INET6_MAX
668 };
669
670 #define IFLA_INET6_MAX  (__IFLA_INET6_MAX - 1)
671
672 struct ifla_cacheinfo
673 {
674         __u32   max_reasm_len;
675         __u32   tstamp;         /* ipv6InterfaceTable updated timestamp */
676         __u32   reachable_time;
677         __u32   retrans_time;
678 };
679
680 /*****************************************************************
681  *              Traffic control messages.
682  ****/
683
684 struct tcmsg
685 {
686         unsigned char   tcm_family;
687         unsigned char   tcm__pad1;
688         unsigned short  tcm__pad2;
689         int             tcm_ifindex;
690         __u32           tcm_handle;
691         __u32           tcm_parent;
692         __u32           tcm_info;
693 };
694
695 enum
696 {
697         TCA_UNSPEC,
698         TCA_KIND,
699         TCA_OPTIONS,
700         TCA_STATS,
701         TCA_XSTATS,
702         TCA_RATE,
703         TCA_FCNT,
704         TCA_STATS2,
705         __TCA_MAX
706 };
707
708 #define TCA_MAX (__TCA_MAX - 1)
709
710 #define TCA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcmsg))))
711 #define TCA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcmsg))
712
713
714 /* RTnetlink multicast groups */
715
716 #define RTMGRP_LINK             1
717 #define RTMGRP_NOTIFY           2
718 #define RTMGRP_NEIGH            4
719 #define RTMGRP_TC               8
720
721 #define RTMGRP_IPV4_IFADDR      0x10
722 #define RTMGRP_IPV4_MROUTE      0x20
723 #define RTMGRP_IPV4_ROUTE       0x40
724
725 #define RTMGRP_IPV6_IFADDR      0x100
726 #define RTMGRP_IPV6_MROUTE      0x200
727 #define RTMGRP_IPV6_ROUTE       0x400
728 #define RTMGRP_IPV6_IFINFO      0x800
729
730 #define RTMGRP_DECnet_IFADDR    0x1000
731 #define RTMGRP_DECnet_ROUTE     0x4000
732
733 #define RTMGRP_IPV6_PREFIX      0x20000
734
735 /* TC action piece */
736 struct tcamsg
737 {
738         unsigned char   tca_family;
739         unsigned char   tca__pad1;
740         unsigned short  tca__pad2;
741 };
742 #define TA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcamsg))))
743 #define TA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcamsg))
744 #define TCA_ACT_TAB 1 /* attr type must be >=1 */       
745 #define TCAA_MAX 1
746
747 /* End of information exported to user level */
748
749 #ifdef __KERNEL__
750
751 #include <linux/config.h>
752
753 extern size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size);
754 static __inline__ int rtattr_strcmp(const struct rtattr *rta, const char *str)
755 {
756         int len = strlen(str) + 1;
757         return len > rta->rta_len || memcmp(RTA_DATA(rta), str, len);
758 }
759
760 extern int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len);
761
762 #define rtattr_parse_nested(tb, max, rta) \
763         rtattr_parse((tb), (max), RTA_DATA((rta)), RTA_PAYLOAD((rta)))
764
765 extern struct sock *rtnl;
766
767 struct rtnetlink_link
768 {
769         int (*doit)(struct sk_buff *, struct nlmsghdr*, void *attr);
770         int (*dumpit)(struct sk_buff *, struct netlink_callback *cb);
771 };
772
773 extern struct rtnetlink_link * rtnetlink_links[NPROTO];
774 extern int rtnetlink_send(struct sk_buff *skb, u32 pid, u32 group, int echo);
775 extern int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics);
776
777 extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
778
779 #define RTA_PUT(skb, attrtype, attrlen, data) \
780 ({      if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
781                  goto rtattr_failure; \
782         __rta_fill(skb, attrtype, attrlen, data); }) 
783
784 #define RTA_PUT_NOHDR(skb, attrlen, data) \
785 ({      if (unlikely(skb_tailroom(skb) < (int)(attrlen))) \
786                 goto rtattr_failure; \
787         memcpy(skb_put(skb, RTA_ALIGN(attrlen)), data, attrlen); })
788                 
789 static inline struct rtattr *
790 __rta_reserve(struct sk_buff *skb, int attrtype, int attrlen)
791 {
792         struct rtattr *rta;
793         int size = RTA_LENGTH(attrlen);
794
795         rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
796         rta->rta_type = attrtype;
797         rta->rta_len = size;
798         return rta;
799 }
800
801 #define __RTA_PUT(skb, attrtype, attrlen) \
802 ({      if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
803                 goto rtattr_failure; \
804         __rta_reserve(skb, attrtype, attrlen); })
805
806 extern void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change);
807
808 extern struct semaphore rtnl_sem;
809
810 #define rtnl_shlock()           down(&rtnl_sem)
811 #define rtnl_shlock_nowait()    down_trylock(&rtnl_sem)
812
813 #define rtnl_shunlock() do { up(&rtnl_sem); \
814                              if (rtnl && rtnl->sk_receive_queue.qlen) \
815                                      rtnl->sk_data_ready(rtnl, 0); \
816                         } while(0)
817
818 extern void rtnl_lock(void);
819 extern int rtnl_lock_interruptible(void);
820 extern void rtnl_unlock(void);
821 extern void rtnetlink_init(void);
822
823 #define ASSERT_RTNL() do { \
824         if (unlikely(down_trylock(&rtnl_sem) == 0)) { \
825                 up(&rtnl_sem); \
826                 printk(KERN_ERR "RTNL: assertion failed at %s (%d)\n", \
827                        __FILE__,  __LINE__); \
828                 dump_stack(); \
829         } \
830 } while(0)
831
832 #define BUG_TRAP(x) do { \
833         if (unlikely(!(x))) { \
834                 printk(KERN_ERR "KERNEL: assertion (%s) failed at %s (%d)\n", \
835                         #x,  __FILE__ , __LINE__); \
836         } \
837 } while(0)
838
839 #endif /* __KERNEL__ */
840
841
842 #endif  /* __LINUX_RTNETLINK_H */