[IPv6] prefix: Convert RTM_NEWPREFIX notifications to use the new netlink api
[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 #include <linux/if_link.h>
6
7 /****
8  *              Routing/neighbour discovery messages.
9  ****/
10
11 /* Types of messages */
12
13 enum {
14         RTM_BASE        = 16,
15 #define RTM_BASE        RTM_BASE
16
17         RTM_NEWLINK     = 16,
18 #define RTM_NEWLINK     RTM_NEWLINK
19         RTM_DELLINK,
20 #define RTM_DELLINK     RTM_DELLINK
21         RTM_GETLINK,
22 #define RTM_GETLINK     RTM_GETLINK
23         RTM_SETLINK,
24 #define RTM_SETLINK     RTM_SETLINK
25
26         RTM_NEWADDR     = 20,
27 #define RTM_NEWADDR     RTM_NEWADDR
28         RTM_DELADDR,
29 #define RTM_DELADDR     RTM_DELADDR
30         RTM_GETADDR,
31 #define RTM_GETADDR     RTM_GETADDR
32
33         RTM_NEWROUTE    = 24,
34 #define RTM_NEWROUTE    RTM_NEWROUTE
35         RTM_DELROUTE,
36 #define RTM_DELROUTE    RTM_DELROUTE
37         RTM_GETROUTE,
38 #define RTM_GETROUTE    RTM_GETROUTE
39
40         RTM_NEWNEIGH    = 28,
41 #define RTM_NEWNEIGH    RTM_NEWNEIGH
42         RTM_DELNEIGH,
43 #define RTM_DELNEIGH    RTM_DELNEIGH
44         RTM_GETNEIGH,
45 #define RTM_GETNEIGH    RTM_GETNEIGH
46
47         RTM_NEWRULE     = 32,
48 #define RTM_NEWRULE     RTM_NEWRULE
49         RTM_DELRULE,
50 #define RTM_DELRULE     RTM_DELRULE
51         RTM_GETRULE,
52 #define RTM_GETRULE     RTM_GETRULE
53
54         RTM_NEWQDISC    = 36,
55 #define RTM_NEWQDISC    RTM_NEWQDISC
56         RTM_DELQDISC,
57 #define RTM_DELQDISC    RTM_DELQDISC
58         RTM_GETQDISC,
59 #define RTM_GETQDISC    RTM_GETQDISC
60
61         RTM_NEWTCLASS   = 40,
62 #define RTM_NEWTCLASS   RTM_NEWTCLASS
63         RTM_DELTCLASS,
64 #define RTM_DELTCLASS   RTM_DELTCLASS
65         RTM_GETTCLASS,
66 #define RTM_GETTCLASS   RTM_GETTCLASS
67
68         RTM_NEWTFILTER  = 44,
69 #define RTM_NEWTFILTER  RTM_NEWTFILTER
70         RTM_DELTFILTER,
71 #define RTM_DELTFILTER  RTM_DELTFILTER
72         RTM_GETTFILTER,
73 #define RTM_GETTFILTER  RTM_GETTFILTER
74
75         RTM_NEWACTION   = 48,
76 #define RTM_NEWACTION   RTM_NEWACTION
77         RTM_DELACTION,
78 #define RTM_DELACTION   RTM_DELACTION
79         RTM_GETACTION,
80 #define RTM_GETACTION   RTM_GETACTION
81
82         RTM_NEWPREFIX   = 52,
83 #define RTM_NEWPREFIX   RTM_NEWPREFIX
84
85         RTM_GETMULTICAST = 58,
86 #define RTM_GETMULTICAST RTM_GETMULTICAST
87
88         RTM_GETANYCAST  = 62,
89 #define RTM_GETANYCAST  RTM_GETANYCAST
90
91         RTM_NEWNEIGHTBL = 64,
92 #define RTM_NEWNEIGHTBL RTM_NEWNEIGHTBL
93         RTM_GETNEIGHTBL = 66,
94 #define RTM_GETNEIGHTBL RTM_GETNEIGHTBL
95         RTM_SETNEIGHTBL,
96 #define RTM_SETNEIGHTBL RTM_SETNEIGHTBL
97
98         __RTM_MAX,
99 #define RTM_MAX         (((__RTM_MAX + 3) & ~3) - 1)
100 };
101
102 #define RTM_NR_MSGTYPES (RTM_MAX + 1 - RTM_BASE)
103 #define RTM_NR_FAMILIES (RTM_NR_MSGTYPES >> 2)
104 #define RTM_FAM(cmd)    (((cmd) - RTM_BASE) >> 2)
105
106 /* 
107    Generic structure for encapsulation of optional route information.
108    It is reminiscent of sockaddr, but with sa_family replaced
109    with attribute type.
110  */
111
112 struct rtattr
113 {
114         unsigned short  rta_len;
115         unsigned short  rta_type;
116 };
117
118 /* Macros to handle rtattributes */
119
120 #define RTA_ALIGNTO     4
121 #define RTA_ALIGN(len) ( ((len)+RTA_ALIGNTO-1) & ~(RTA_ALIGNTO-1) )
122 #define RTA_OK(rta,len) ((len) >= (int)sizeof(struct rtattr) && \
123                          (rta)->rta_len >= sizeof(struct rtattr) && \
124                          (rta)->rta_len <= (len))
125 #define RTA_NEXT(rta,attrlen)   ((attrlen) -= RTA_ALIGN((rta)->rta_len), \
126                                  (struct rtattr*)(((char*)(rta)) + RTA_ALIGN((rta)->rta_len)))
127 #define RTA_LENGTH(len) (RTA_ALIGN(sizeof(struct rtattr)) + (len))
128 #define RTA_SPACE(len)  RTA_ALIGN(RTA_LENGTH(len))
129 #define RTA_DATA(rta)   ((void*)(((char*)(rta)) + RTA_LENGTH(0)))
130 #define RTA_PAYLOAD(rta) ((int)((rta)->rta_len) - RTA_LENGTH(0))
131
132
133
134
135 /******************************************************************************
136  *              Definitions used in routing table administration.
137  ****/
138
139 struct rtmsg
140 {
141         unsigned char           rtm_family;
142         unsigned char           rtm_dst_len;
143         unsigned char           rtm_src_len;
144         unsigned char           rtm_tos;
145
146         unsigned char           rtm_table;      /* Routing table id */
147         unsigned char           rtm_protocol;   /* Routing protocol; see below  */
148         unsigned char           rtm_scope;      /* See below */ 
149         unsigned char           rtm_type;       /* See below    */
150
151         unsigned                rtm_flags;
152 };
153
154 /* rtm_type */
155
156 enum
157 {
158         RTN_UNSPEC,
159         RTN_UNICAST,            /* Gateway or direct route      */
160         RTN_LOCAL,              /* Accept locally               */
161         RTN_BROADCAST,          /* Accept locally as broadcast,
162                                    send as broadcast */
163         RTN_ANYCAST,            /* Accept locally as broadcast,
164                                    but send as unicast */
165         RTN_MULTICAST,          /* Multicast route              */
166         RTN_BLACKHOLE,          /* Drop                         */
167         RTN_UNREACHABLE,        /* Destination is unreachable   */
168         RTN_PROHIBIT,           /* Administratively prohibited  */
169         RTN_THROW,              /* Not in this table            */
170         RTN_NAT,                /* Translate this address       */
171         RTN_XRESOLVE,           /* Use external resolver        */
172         __RTN_MAX
173 };
174
175 #define RTN_MAX (__RTN_MAX - 1)
176
177
178 /* rtm_protocol */
179
180 #define RTPROT_UNSPEC   0
181 #define RTPROT_REDIRECT 1       /* Route installed by ICMP redirects;
182                                    not used by current IPv4 */
183 #define RTPROT_KERNEL   2       /* Route installed by kernel            */
184 #define RTPROT_BOOT     3       /* Route installed during boot          */
185 #define RTPROT_STATIC   4       /* Route installed by administrator     */
186
187 /* Values of protocol >= RTPROT_STATIC are not interpreted by kernel;
188    they are just passed from user and back as is.
189    It will be used by hypothetical multiple routing daemons.
190    Note that protocol values should be standardized in order to
191    avoid conflicts.
192  */
193
194 #define RTPROT_GATED    8       /* Apparently, GateD */
195 #define RTPROT_RA       9       /* RDISC/ND router advertisements */
196 #define RTPROT_MRT      10      /* Merit MRT */
197 #define RTPROT_ZEBRA    11      /* Zebra */
198 #define RTPROT_BIRD     12      /* BIRD */
199 #define RTPROT_DNROUTED 13      /* DECnet routing daemon */
200 #define RTPROT_XORP     14      /* XORP */
201 #define RTPROT_NTK      15      /* Netsukuku */
202
203 /* rtm_scope
204
205    Really it is not scope, but sort of distance to the destination.
206    NOWHERE are reserved for not existing destinations, HOST is our
207    local addresses, LINK are destinations, located on directly attached
208    link and UNIVERSE is everywhere in the Universe.
209
210    Intermediate values are also possible f.e. interior routes
211    could be assigned a value between UNIVERSE and LINK.
212 */
213
214 enum rt_scope_t
215 {
216         RT_SCOPE_UNIVERSE=0,
217 /* User defined values  */
218         RT_SCOPE_SITE=200,
219         RT_SCOPE_LINK=253,
220         RT_SCOPE_HOST=254,
221         RT_SCOPE_NOWHERE=255
222 };
223
224 /* rtm_flags */
225
226 #define RTM_F_NOTIFY            0x100   /* Notify user of route change  */
227 #define RTM_F_CLONED            0x200   /* This route is cloned         */
228 #define RTM_F_EQUALIZE          0x400   /* Multipath equalizer: NI      */
229 #define RTM_F_PREFIX            0x800   /* Prefix addresses             */
230
231 /* Reserved table identifiers */
232
233 enum rt_class_t
234 {
235         RT_TABLE_UNSPEC=0,
236 /* User defined values */
237         RT_TABLE_DEFAULT=253,
238         RT_TABLE_MAIN=254,
239         RT_TABLE_LOCAL=255,
240         RT_TABLE_MAX=0xFFFFFFFF
241 };
242
243
244 /* Routing message attributes */
245
246 enum rtattr_type_t
247 {
248         RTA_UNSPEC,
249         RTA_DST,
250         RTA_SRC,
251         RTA_IIF,
252         RTA_OIF,
253         RTA_GATEWAY,
254         RTA_PRIORITY,
255         RTA_PREFSRC,
256         RTA_METRICS,
257         RTA_MULTIPATH,
258         RTA_PROTOINFO,
259         RTA_FLOW,
260         RTA_CACHEINFO,
261         RTA_SESSION,
262         RTA_MP_ALGO,
263         RTA_TABLE,
264         __RTA_MAX
265 };
266
267 #define RTA_MAX (__RTA_MAX - 1)
268
269 #define RTM_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct rtmsg))))
270 #define RTM_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct rtmsg))
271
272 /* RTM_MULTIPATH --- array of struct rtnexthop.
273  *
274  * "struct rtnexthop" describes all necessary nexthop information,
275  * i.e. parameters of path to a destination via this nexthop.
276  *
277  * At the moment it is impossible to set different prefsrc, mtu, window
278  * and rtt for different paths from multipath.
279  */
280
281 struct rtnexthop
282 {
283         unsigned short          rtnh_len;
284         unsigned char           rtnh_flags;
285         unsigned char           rtnh_hops;
286         int                     rtnh_ifindex;
287 };
288
289 /* rtnh_flags */
290
291 #define RTNH_F_DEAD             1       /* Nexthop is dead (used by multipath)  */
292 #define RTNH_F_PERVASIVE        2       /* Do recursive gateway lookup  */
293 #define RTNH_F_ONLINK           4       /* Gateway is forced on link    */
294
295 /* Macros to handle hexthops */
296
297 #define RTNH_ALIGNTO    4
298 #define RTNH_ALIGN(len) ( ((len)+RTNH_ALIGNTO-1) & ~(RTNH_ALIGNTO-1) )
299 #define RTNH_OK(rtnh,len) ((rtnh)->rtnh_len >= sizeof(struct rtnexthop) && \
300                            ((int)(rtnh)->rtnh_len) <= (len))
301 #define RTNH_NEXT(rtnh) ((struct rtnexthop*)(((char*)(rtnh)) + RTNH_ALIGN((rtnh)->rtnh_len)))
302 #define RTNH_LENGTH(len) (RTNH_ALIGN(sizeof(struct rtnexthop)) + (len))
303 #define RTNH_SPACE(len) RTNH_ALIGN(RTNH_LENGTH(len))
304 #define RTNH_DATA(rtnh)   ((struct rtattr*)(((char*)(rtnh)) + RTNH_LENGTH(0)))
305
306 /* RTM_CACHEINFO */
307
308 struct rta_cacheinfo
309 {
310         __u32   rta_clntref;
311         __u32   rta_lastuse;
312         __s32   rta_expires;
313         __u32   rta_error;
314         __u32   rta_used;
315
316 #define RTNETLINK_HAVE_PEERINFO 1
317         __u32   rta_id;
318         __u32   rta_ts;
319         __u32   rta_tsage;
320 };
321
322 /* RTM_METRICS --- array of struct rtattr with types of RTAX_* */
323
324 enum
325 {
326         RTAX_UNSPEC,
327 #define RTAX_UNSPEC RTAX_UNSPEC
328         RTAX_LOCK,
329 #define RTAX_LOCK RTAX_LOCK
330         RTAX_MTU,
331 #define RTAX_MTU RTAX_MTU
332         RTAX_WINDOW,
333 #define RTAX_WINDOW RTAX_WINDOW
334         RTAX_RTT,
335 #define RTAX_RTT RTAX_RTT
336         RTAX_RTTVAR,
337 #define RTAX_RTTVAR RTAX_RTTVAR
338         RTAX_SSTHRESH,
339 #define RTAX_SSTHRESH RTAX_SSTHRESH
340         RTAX_CWND,
341 #define RTAX_CWND RTAX_CWND
342         RTAX_ADVMSS,
343 #define RTAX_ADVMSS RTAX_ADVMSS
344         RTAX_REORDERING,
345 #define RTAX_REORDERING RTAX_REORDERING
346         RTAX_HOPLIMIT,
347 #define RTAX_HOPLIMIT RTAX_HOPLIMIT
348         RTAX_INITCWND,
349 #define RTAX_INITCWND RTAX_INITCWND
350         RTAX_FEATURES,
351 #define RTAX_FEATURES RTAX_FEATURES
352         __RTAX_MAX
353 };
354
355 #define RTAX_MAX (__RTAX_MAX - 1)
356
357 #define RTAX_FEATURE_ECN        0x00000001
358 #define RTAX_FEATURE_SACK       0x00000002
359 #define RTAX_FEATURE_TIMESTAMP  0x00000004
360 #define RTAX_FEATURE_ALLFRAG    0x00000008
361
362 struct rta_session
363 {
364         __u8    proto;
365         __u8    pad1;
366         __u16   pad2;
367
368         union {
369                 struct {
370                         __u16   sport;
371                         __u16   dport;
372                 } ports;
373
374                 struct {
375                         __u8    type;
376                         __u8    code;
377                         __u16   ident;
378                 } icmpt;
379
380                 __u32           spi;
381         } u;
382 };
383
384 /****
385  *              General form of address family dependent message.
386  ****/
387
388 struct rtgenmsg
389 {
390         unsigned char           rtgen_family;
391 };
392
393 /*****************************************************************
394  *              Link layer specific messages.
395  ****/
396
397 /* struct ifinfomsg
398  * passes link level specific information, not dependent
399  * on network protocol.
400  */
401
402 struct ifinfomsg
403 {
404         unsigned char   ifi_family;
405         unsigned char   __ifi_pad;
406         unsigned short  ifi_type;               /* ARPHRD_* */
407         int             ifi_index;              /* Link index   */
408         unsigned        ifi_flags;              /* IFF_* flags  */
409         unsigned        ifi_change;             /* IFF_* change mask */
410 };
411
412 /********************************************************************
413  *              prefix information 
414  ****/
415
416 struct prefixmsg
417 {
418         unsigned char   prefix_family;
419         unsigned char   prefix_pad1;
420         unsigned short  prefix_pad2;
421         int             prefix_ifindex;
422         unsigned char   prefix_type;
423         unsigned char   prefix_len;
424         unsigned char   prefix_flags;
425         unsigned char   prefix_pad3;
426 };
427
428 enum 
429 {
430         PREFIX_UNSPEC,
431         PREFIX_ADDRESS,
432         PREFIX_CACHEINFO,
433         __PREFIX_MAX
434 };
435
436 #define PREFIX_MAX      (__PREFIX_MAX - 1)
437
438 struct prefix_cacheinfo
439 {
440         __u32   preferred_time;
441         __u32   valid_time;
442 };
443
444
445 /*****************************************************************
446  *              Traffic control messages.
447  ****/
448
449 struct tcmsg
450 {
451         unsigned char   tcm_family;
452         unsigned char   tcm__pad1;
453         unsigned short  tcm__pad2;
454         int             tcm_ifindex;
455         __u32           tcm_handle;
456         __u32           tcm_parent;
457         __u32           tcm_info;
458 };
459
460 enum
461 {
462         TCA_UNSPEC,
463         TCA_KIND,
464         TCA_OPTIONS,
465         TCA_STATS,
466         TCA_XSTATS,
467         TCA_RATE,
468         TCA_FCNT,
469         TCA_STATS2,
470         __TCA_MAX
471 };
472
473 #define TCA_MAX (__TCA_MAX - 1)
474
475 #define TCA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcmsg))))
476 #define TCA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcmsg))
477
478 #ifndef __KERNEL__
479 /* RTnetlink multicast groups - backwards compatibility for userspace */
480 #define RTMGRP_LINK             1
481 #define RTMGRP_NOTIFY           2
482 #define RTMGRP_NEIGH            4
483 #define RTMGRP_TC               8
484
485 #define RTMGRP_IPV4_IFADDR      0x10
486 #define RTMGRP_IPV4_MROUTE      0x20
487 #define RTMGRP_IPV4_ROUTE       0x40
488 #define RTMGRP_IPV4_RULE        0x80
489
490 #define RTMGRP_IPV6_IFADDR      0x100
491 #define RTMGRP_IPV6_MROUTE      0x200
492 #define RTMGRP_IPV6_ROUTE       0x400
493 #define RTMGRP_IPV6_IFINFO      0x800
494
495 #define RTMGRP_DECnet_IFADDR    0x1000
496 #define RTMGRP_DECnet_ROUTE     0x4000
497
498 #define RTMGRP_IPV6_PREFIX      0x20000
499 #endif
500
501 /* RTnetlink multicast groups */
502 enum rtnetlink_groups {
503         RTNLGRP_NONE,
504 #define RTNLGRP_NONE            RTNLGRP_NONE
505         RTNLGRP_LINK,
506 #define RTNLGRP_LINK            RTNLGRP_LINK
507         RTNLGRP_NOTIFY,
508 #define RTNLGRP_NOTIFY          RTNLGRP_NOTIFY
509         RTNLGRP_NEIGH,
510 #define RTNLGRP_NEIGH           RTNLGRP_NEIGH
511         RTNLGRP_TC,
512 #define RTNLGRP_TC              RTNLGRP_TC
513         RTNLGRP_IPV4_IFADDR,
514 #define RTNLGRP_IPV4_IFADDR     RTNLGRP_IPV4_IFADDR
515         RTNLGRP_IPV4_MROUTE,
516 #define RTNLGRP_IPV4_MROUTE     RTNLGRP_IPV4_MROUTE
517         RTNLGRP_IPV4_ROUTE,
518 #define RTNLGRP_IPV4_ROUTE      RTNLGRP_IPV4_ROUTE
519         RTNLGRP_IPV4_RULE,
520 #define RTNLGRP_IPV4_RULE       RTNLGRP_IPV4_RULE
521         RTNLGRP_IPV6_IFADDR,
522 #define RTNLGRP_IPV6_IFADDR     RTNLGRP_IPV6_IFADDR
523         RTNLGRP_IPV6_MROUTE,
524 #define RTNLGRP_IPV6_MROUTE     RTNLGRP_IPV6_MROUTE
525         RTNLGRP_IPV6_ROUTE,
526 #define RTNLGRP_IPV6_ROUTE      RTNLGRP_IPV6_ROUTE
527         RTNLGRP_IPV6_IFINFO,
528 #define RTNLGRP_IPV6_IFINFO     RTNLGRP_IPV6_IFINFO
529         RTNLGRP_DECnet_IFADDR,
530 #define RTNLGRP_DECnet_IFADDR   RTNLGRP_DECnet_IFADDR
531         RTNLGRP_NOP2,
532         RTNLGRP_DECnet_ROUTE,
533 #define RTNLGRP_DECnet_ROUTE    RTNLGRP_DECnet_ROUTE
534         RTNLGRP_DECnet_RULE,
535 #define RTNLGRP_DECnet_RULE     RTNLGRP_DECnet_RULE
536         RTNLGRP_NOP4,
537         RTNLGRP_IPV6_PREFIX,
538 #define RTNLGRP_IPV6_PREFIX     RTNLGRP_IPV6_PREFIX
539         RTNLGRP_IPV6_RULE,
540 #define RTNLGRP_IPV6_RULE       RTNLGRP_IPV6_RULE
541         __RTNLGRP_MAX
542 };
543 #define RTNLGRP_MAX     (__RTNLGRP_MAX - 1)
544
545 /* TC action piece */
546 struct tcamsg
547 {
548         unsigned char   tca_family;
549         unsigned char   tca__pad1;
550         unsigned short  tca__pad2;
551 };
552 #define TA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcamsg))))
553 #define TA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcamsg))
554 #define TCA_ACT_TAB 1 /* attr type must be >=1 */       
555 #define TCAA_MAX 1
556
557 /* End of information exported to user level */
558
559 #ifdef __KERNEL__
560
561 #include <linux/mutex.h>
562
563 extern size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size);
564 static __inline__ int rtattr_strcmp(const struct rtattr *rta, const char *str)
565 {
566         int len = strlen(str) + 1;
567         return len > rta->rta_len || memcmp(RTA_DATA(rta), str, len);
568 }
569
570 extern int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len);
571
572 #define rtattr_parse_nested(tb, max, rta) \
573         rtattr_parse((tb), (max), RTA_DATA((rta)), RTA_PAYLOAD((rta)))
574
575 struct rtnetlink_link
576 {
577         int (*doit)(struct sk_buff *, struct nlmsghdr*, void *attr);
578         int (*dumpit)(struct sk_buff *, struct netlink_callback *cb);
579 };
580
581 extern struct rtnetlink_link * rtnetlink_links[NPROTO];
582 extern int rtnetlink_send(struct sk_buff *skb, u32 pid, u32 group, int echo);
583 extern int rtnl_unicast(struct sk_buff *skb, u32 pid);
584 extern int rtnl_notify(struct sk_buff *skb, u32 pid, u32 group,
585                        struct nlmsghdr *nlh, gfp_t flags);
586 extern void rtnl_set_sk_err(u32 group, int error);
587 extern int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics);
588
589 extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
590
591 #define RTA_PUT(skb, attrtype, attrlen, data) \
592 ({      if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
593                  goto rtattr_failure; \
594         __rta_fill(skb, attrtype, attrlen, data); }) 
595
596 #define RTA_APPEND(skb, attrlen, data) \
597 ({      if (unlikely(skb_tailroom(skb) < (int)(attrlen))) \
598                 goto rtattr_failure; \
599         memcpy(skb_put(skb, attrlen), data, attrlen); })
600
601 #define RTA_PUT_NOHDR(skb, attrlen, data) \
602 ({      RTA_APPEND(skb, RTA_ALIGN(attrlen), data); \
603         memset(skb->tail - (RTA_ALIGN(attrlen) - attrlen), 0, \
604                RTA_ALIGN(attrlen) - attrlen); })
605
606 #define RTA_PUT_U8(skb, attrtype, value) \
607 ({      u8 _tmp = (value); \
608         RTA_PUT(skb, attrtype, sizeof(u8), &_tmp); })
609
610 #define RTA_PUT_U16(skb, attrtype, value) \
611 ({      u16 _tmp = (value); \
612         RTA_PUT(skb, attrtype, sizeof(u16), &_tmp); })
613
614 #define RTA_PUT_U32(skb, attrtype, value) \
615 ({      u32 _tmp = (value); \
616         RTA_PUT(skb, attrtype, sizeof(u32), &_tmp); })
617
618 #define RTA_PUT_U64(skb, attrtype, value) \
619 ({      u64 _tmp = (value); \
620         RTA_PUT(skb, attrtype, sizeof(u64), &_tmp); })
621
622 #define RTA_PUT_SECS(skb, attrtype, value) \
623         RTA_PUT_U64(skb, attrtype, (value) / HZ)
624
625 #define RTA_PUT_MSECS(skb, attrtype, value) \
626         RTA_PUT_U64(skb, attrtype, jiffies_to_msecs(value))
627
628 #define RTA_PUT_STRING(skb, attrtype, value) \
629         RTA_PUT(skb, attrtype, strlen(value) + 1, value)
630
631 #define RTA_PUT_FLAG(skb, attrtype) \
632         RTA_PUT(skb, attrtype, 0, NULL);
633
634 #define RTA_NEST(skb, type) \
635 ({      struct rtattr *__start = (struct rtattr *) (skb)->tail; \
636         RTA_PUT(skb, type, 0, NULL); \
637         __start;  })
638
639 #define RTA_NEST_END(skb, start) \
640 ({      (start)->rta_len = ((skb)->tail - (unsigned char *) (start)); \
641         (skb)->len; })
642
643 #define RTA_NEST_CANCEL(skb, start) \
644 ({      if (start) \
645                 skb_trim(skb, (unsigned char *) (start) - (skb)->data); \
646         -1; })
647
648 #define RTA_GET_U8(rta) \
649 ({      if (!rta || RTA_PAYLOAD(rta) < sizeof(u8)) \
650                 goto rtattr_failure; \
651         *(u8 *) RTA_DATA(rta); })
652
653 #define RTA_GET_U16(rta) \
654 ({      if (!rta || RTA_PAYLOAD(rta) < sizeof(u16)) \
655                 goto rtattr_failure; \
656         *(u16 *) RTA_DATA(rta); })
657
658 #define RTA_GET_U32(rta) \
659 ({      if (!rta || RTA_PAYLOAD(rta) < sizeof(u32)) \
660                 goto rtattr_failure; \
661         *(u32 *) RTA_DATA(rta); })
662
663 #define RTA_GET_U64(rta) \
664 ({      u64 _tmp; \
665         if (!rta || RTA_PAYLOAD(rta) < sizeof(u64)) \
666                 goto rtattr_failure; \
667         memcpy(&_tmp, RTA_DATA(rta), sizeof(_tmp)); \
668         _tmp; })
669
670 #define RTA_GET_FLAG(rta) (!!(rta))
671
672 #define RTA_GET_SECS(rta) ((unsigned long) RTA_GET_U64(rta) * HZ)
673 #define RTA_GET_MSECS(rta) (msecs_to_jiffies((unsigned long) RTA_GET_U64(rta)))
674                 
675 static inline struct rtattr *
676 __rta_reserve(struct sk_buff *skb, int attrtype, int attrlen)
677 {
678         struct rtattr *rta;
679         int size = RTA_LENGTH(attrlen);
680
681         rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
682         rta->rta_type = attrtype;
683         rta->rta_len = size;
684         memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
685         return rta;
686 }
687
688 #define __RTA_PUT(skb, attrtype, attrlen) \
689 ({      if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
690                 goto rtattr_failure; \
691         __rta_reserve(skb, attrtype, attrlen); })
692
693 extern void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change);
694
695 /* RTNL is used as a global lock for all changes to network configuration  */
696 extern void rtnl_lock(void);
697 extern void rtnl_unlock(void);
698 extern int rtnl_trylock(void);
699
700 extern void rtnetlink_init(void);
701 extern void __rtnl_unlock(void);
702
703 #define ASSERT_RTNL() do { \
704         if (unlikely(rtnl_trylock())) { \
705                 rtnl_unlock(); \
706                 printk(KERN_ERR "RTNL: assertion failed at %s (%d)\n", \
707                        __FILE__,  __LINE__); \
708                 dump_stack(); \
709         } \
710 } while(0)
711
712 #define BUG_TRAP(x) do { \
713         if (unlikely(!(x))) { \
714                 printk(KERN_ERR "KERNEL: assertion (%s) failed at %s (%d)\n", \
715                         #x,  __FILE__ , __LINE__); \
716         } \
717 } while(0)
718
719 static inline u32 rtm_get_table(struct rtattr **rta, u8 table)
720 {
721         return RTA_GET_U32(rta[RTA_TABLE-1]);
722 rtattr_failure:
723         return table;
724 }
725
726 #endif /* __KERNEL__ */
727
728
729 #endif  /* __LINUX_RTNETLINK_H */