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 extern int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst,
 589                               u32 id, u32 ts, u32 tsage, long expires,
 590                               u32 error);
 591
 592 extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
 593
 594 #define RTA_PUT(skb, attrtype, attrlen, data) \
 595 ({      if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
 596                  goto rtattr_failure; \
 597         __rta_fill(skb, attrtype, attrlen, data); })
 598
 599 #define RTA_APPEND(skb, attrlen, data) \
 600 ({      if (unlikely(skb_tailroom(skb) < (int)(attrlen))) \
 601                 goto rtattr_failure; \
 602         memcpy(skb_put(skb, attrlen), data, attrlen); })
 603
 604 #define RTA_PUT_NOHDR(skb, attrlen, data) \
 605 ({      RTA_APPEND(skb, RTA_ALIGN(attrlen), data); \
 606         memset(skb->tail - (RTA_ALIGN(attrlen) - attrlen), 0, \
 607                RTA_ALIGN(attrlen) - attrlen); })
 608
 609 #define RTA_PUT_U8(skb, attrtype, value) \
 610 ({      u8 _tmp = (value); \
 611         RTA_PUT(skb, attrtype, sizeof(u8), &_tmp); })
 612
 613 #define RTA_PUT_U16(skb, attrtype, value) \
 614 ({      u16 _tmp = (value); \
 615         RTA_PUT(skb, attrtype, sizeof(u16), &_tmp); })
 616
 617 #define RTA_PUT_U32(skb, attrtype, value) \
 618 ({      u32 _tmp = (value); \
 619         RTA_PUT(skb, attrtype, sizeof(u32), &_tmp); })
 620
 621 #define RTA_PUT_U64(skb, attrtype, value) \
 622 ({      u64 _tmp = (value); \
 623         RTA_PUT(skb, attrtype, sizeof(u64), &_tmp); })
 624
 625 #define RTA_PUT_SECS(skb, attrtype, value) \
 626         RTA_PUT_U64(skb, attrtype, (value) / HZ)
 627
 628 #define RTA_PUT_MSECS(skb, attrtype, value) \
 629         RTA_PUT_U64(skb, attrtype, jiffies_to_msecs(value))
 630
 631 #define RTA_PUT_STRING(skb, attrtype, value) \
 632         RTA_PUT(skb, attrtype, strlen(value) + 1, value)
 633
 634 #define RTA_PUT_FLAG(skb, attrtype) \
 635         RTA_PUT(skb, attrtype, 0, NULL);
 636
 637 #define RTA_NEST(skb, type) \
 638 ({      struct rtattr *__start = (struct rtattr *) (skb)->tail; \
 639         RTA_PUT(skb, type, 0, NULL); \
 640         __start;  })
 641
 642 #define RTA_NEST_END(skb, start) \
 643 ({      (start)->rta_len = ((skb)->tail - (unsigned char *) (start)); \
 644         (skb)->len; })
 645
 646 #define RTA_NEST_CANCEL(skb, start) \
 647 ({      if (start) \
 648                 skb_trim(skb, (unsigned char *) (start) - (skb)->data); \
 649         -1; })
 650
 651 #define RTA_GET_U8(rta) \
 652 ({      if (!rta || RTA_PAYLOAD(rta) < sizeof(u8)) \
 653                 goto rtattr_failure; \
 654         *(u8 *) RTA_DATA(rta); })
 655
 656 #define RTA_GET_U16(rta) \
 657 ({      if (!rta || RTA_PAYLOAD(rta) < sizeof(u16)) \
 658                 goto rtattr_failure; \
 659         *(u16 *) RTA_DATA(rta); })
 660
 661 #define RTA_GET_U32(rta) \
 662 ({      if (!rta || RTA_PAYLOAD(rta) < sizeof(u32)) \
 663                 goto rtattr_failure; \
 664         *(u32 *) RTA_DATA(rta); })
 665
 666 #define RTA_GET_U64(rta) \
 667 ({      u64 _tmp; \
 668         if (!rta || RTA_PAYLOAD(rta) < sizeof(u64)) \
 669                 goto rtattr_failure; \
 670         memcpy(&_tmp, RTA_DATA(rta), sizeof(_tmp)); \
 671         _tmp; })
 672
 673 #define RTA_GET_FLAG(rta) (!!(rta))
 674
 675 #define RTA_GET_SECS(rta) ((unsigned long) RTA_GET_U64(rta) * HZ)
 676 #define RTA_GET_MSECS(rta) (msecs_to_jiffies((unsigned long) RTA_GET_U64(rta)))
 677
 678 static inline struct rtattr *
 679 __rta_reserve(struct sk_buff *skb, int attrtype, int attrlen)
 680 {
 681         struct rtattr *rta;
 682         int size = RTA_LENGTH(attrlen);
 683
 684         rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
 685         rta->rta_type = attrtype;
 686         rta->rta_len = size;
 687         memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
 688         return rta;
 689 }
 690
 691 #define __RTA_PUT(skb, attrtype, attrlen) \
 692 ({      if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
 693                 goto rtattr_failure; \
 694         __rta_reserve(skb, attrtype, attrlen); })
 695
 696 extern void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change);
 697
 698 /* RTNL is used as a global lock for all changes to network configuration  */
 699 extern void rtnl_lock(void);
 700 extern void rtnl_unlock(void);
 701 extern int rtnl_trylock(void);
 702
 703 extern void rtnetlink_init(void);
 704 extern void __rtnl_unlock(void);
 705
 706 #define ASSERT_RTNL() do { \
 707         if (unlikely(rtnl_trylock())) { \
 708                 rtnl_unlock(); \
 709                 printk(KERN_ERR "RTNL: assertion failed at %s (%d)\n", \
 710                        __FILE__,  __LINE__); \
 711                 dump_stack(); \
 712         } \
 713 } while(0)
 714
 715 #define BUG_TRAP(x) do { \
 716         if (unlikely(!(x))) { \
 717                 printk(KERN_ERR "KERNEL: assertion (%s) failed at %s (%d)\n", \
 718                         #x,  __FILE__ , __LINE__); \
 719         } \
 720 } while(0)
 721
 722 static inline u32 rtm_get_table(struct rtattr **rta, u8 table)
 723 {
 724         return RTA_GET_U32(rta[RTA_TABLE-1]);
 725 rtattr_failure:
 726         return table;
 727 }
 728
 729 #endif /* __KERNEL__ */
 730
 731
 732 #endif  /* __LINUX_RTNETLINK_H */