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