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
  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 */