include/linux/rtnetlink.h

   1 #ifndef __LINUX_RTNETLINK_H
   2 #define __LINUX_RTNETLINK_H
   3
   4 #include <linux/config.h>
   5 #include <linux/netlink.h>
   6
   7 #define RTNL_DEBUG 1
   8
   9
  10 /****
  11  *              Routing/neighbour discovery messages.
  12  ****/
  13
  14 /* Types of messages */
  15
  16 #define RTM_BASE        0x10
  17
  18 #define RTM_NEWLINK     (RTM_BASE+0)
  19 #define RTM_DELLINK     (RTM_BASE+1)
  20 #define RTM_GETLINK     (RTM_BASE+2)
  21
  22 #define RTM_NEWADDR     (RTM_BASE+4)
  23 #define RTM_DELADDR     (RTM_BASE+5)
  24 #define RTM_GETADDR     (RTM_BASE+6)
  25
  26 #define RTM_NEWROUTE    (RTM_BASE+8)
  27 #define RTM_DELROUTE    (RTM_BASE+9)
  28 #define RTM_GETROUTE    (RTM_BASE+10)
  29
  30 #define RTM_NEWNEIGH    (RTM_BASE+12)
  31 #define RTM_DELNEIGH    (RTM_BASE+13)
  32 #define RTM_GETNEIGH    (RTM_BASE+14)
  33
  34 #define RTM_NEWRULE     (RTM_BASE+16)
  35 #define RTM_DELRULE     (RTM_BASE+17)
  36 #define RTM_GETRULE     (RTM_BASE+18)
  37
  38 #define RTM_NEWQDISC    (RTM_BASE+20)
  39 #define RTM_DELQDISC    (RTM_BASE+21)
  40 #define RTM_GETQDISC    (RTM_BASE+22)
  41
  42 #define RTM_NEWTCLASS   (RTM_BASE+24)
  43 #define RTM_DELTCLASS   (RTM_BASE+25)
  44 #define RTM_GETTCLASS   (RTM_BASE+26)
  45
  46 #define RTM_NEWTFILTER  (RTM_BASE+28)
  47 #define RTM_DELTFILTER  (RTM_BASE+29)
  48 #define RTM_GETTFILTER  (RTM_BASE+30)
  49
  50 #define RTM_MAX         (RTM_BASE+31)
  51
  52 /*
  53    Generic structure for encapsulation optional route information.
  54    It is reminiscent of sockaddr, but with sa_family replaced
  55    with attribute type.
  56  */
  57
  58 struct rtattr
  59 {
  60         unsigned short  rta_len;
  61         unsigned short  rta_type;
  62 };
  63
  64 /* Macros to handle rtattributes */
  65
  66 #define RTA_ALIGNTO     4
  67 #define RTA_ALIGN(len) ( ((len)+RTA_ALIGNTO-1) & ~(RTA_ALIGNTO-1) )
  68 #define RTA_OK(rta,len) ((len) > 0 && (rta)->rta_len >= sizeof(struct rtattr) && \
  69                          (rta)->rta_len <= (len))
  70 #define RTA_NEXT(rta,attrlen)   ((attrlen) -= RTA_ALIGN((rta)->rta_len), \
  71                                  (struct rtattr*)(((char*)(rta)) + RTA_ALIGN((rta)->rta_len)))
  72 #define RTA_LENGTH(len) (RTA_ALIGN(sizeof(struct rtattr)) + (len))
  73 #define RTA_SPACE(len)  RTA_ALIGN(RTA_LENGTH(len))
  74 #define RTA_DATA(rta)   ((void*)(((char*)(rta)) + RTA_LENGTH(0)))
  75 #define RTA_PAYLOAD(rta) ((int)((rta)->rta_len) - RTA_LENGTH(0))
  76
  77
  78
  79
  80 /******************************************************************************
  81  *              Definitions used in routing table administation.
  82  ****/
  83
  84 struct rtmsg
  85 {
  86         unsigned char           rtm_family;
  87         unsigned char           rtm_dst_len;
  88         unsigned char           rtm_src_len;
  89         unsigned char           rtm_tos;
  90
  91         unsigned char           rtm_table;      /* Routing table id */
  92         unsigned char           rtm_protocol;   /* Routing protocol; see below  */
  93         unsigned char           rtm_scope;      /* See below */
  94         unsigned char           rtm_type;       /* See below    */
  95
  96         unsigned                rtm_flags;
  97 };
  98
  99 /* rtm_type */
 100
 101 enum
 102 {
 103         RTN_UNSPEC,
 104         RTN_UNICAST,            /* Gateway or direct route      */
 105         RTN_LOCAL,              /* Accept locally               */
 106         RTN_BROADCAST,          /* Accept locally as broadcast,
 107                                    send as broadcast */
 108         RTN_ANYCAST,            /* Accept locally as broadcast,
 109                                    but send as unicast */
 110         RTN_MULTICAST,          /* Multicast route              */
 111         RTN_BLACKHOLE,          /* Drop                         */
 112         RTN_UNREACHABLE,        /* Destination is unreachable   */
 113         RTN_PROHIBIT,           /* Administratively prohibited  */
 114         RTN_THROW,              /* Not in this table            */
 115         RTN_NAT,                /* Translate this address       */
 116         RTN_XRESOLVE,           /* Use external resolver        */
 117 };
 118
 119 #define RTN_MAX RTN_XRESOLVE
 120
 121
 122 /* rtm_protocol */
 123
 124 #define RTPROT_UNSPEC   0
 125 #define RTPROT_REDIRECT 1       /* Route installed by ICMP redirects;
 126                                    not used by current IPv4 */
 127 #define RTPROT_KERNEL   2       /* Route installed by kernel            */
 128 #define RTPROT_BOOT     3       /* Route installed during boot          */
 129 #define RTPROT_STATIC   4       /* Route installed by administrator     */
 130
 131 /* Values of protocol >= RTPROT_STATIC are not interpreted by kernel;
 132    they just passed from user and back as is.
 133    It will be used by hypothetical multiple routing daemons.
 134    Note that protocol values should be standardized in order to
 135    avoid conflicts.
 136  */
 137
 138 #define RTPROT_GATED    8       /* Apparently, GateD */
 139 #define RTPROT_RA       9       /* RDISC/ND router advertisments */
 140 #define RTPROT_MRT      10      /* Merit MRT */
 141 #define RTPROT_ZEBRA    11      /* Zebra */
 142 #define RTPROT_BIRD     12      /* BIRD */
 143
 144 /* rtm_scope
 145
 146    Really it is not scope, but sort of distance to the destination.
 147    NOWHERE are reserved for not existing destinations, HOST is our
 148    local addresses, LINK are destinations, located on directly attached
 149    link and UNIVERSE is everywhere in the Universe.
 150
 151    Intermediate values are also possible f.e. interior routes
 152    could be assigned a value between UNIVERSE and LINK.
 153 */
 154
 155 enum rt_scope_t
 156 {
 157         RT_SCOPE_UNIVERSE=0,
 158 /* User defined values  */
 159         RT_SCOPE_SITE=200,
 160         RT_SCOPE_LINK=253,
 161         RT_SCOPE_HOST=254,
 162         RT_SCOPE_NOWHERE=255
 163 };
 164
 165 /* rtm_flags */
 166
 167 #define RTM_F_NOTIFY            0x100   /* Notify user of route change  */
 168 #define RTM_F_CLONED            0x200   /* This route is cloned         */
 169 #define RTM_F_EQUALIZE          0x400   /* Multipath equalizer: NI      */
 170
 171 /* Reserved table identifiers */
 172
 173 enum rt_class_t
 174 {
 175         RT_TABLE_UNSPEC=0,
 176 /* User defined values */
 177         RT_TABLE_DEFAULT=253,
 178         RT_TABLE_MAIN=254,
 179         RT_TABLE_LOCAL=255
 180 };
 181 #define RT_TABLE_MAX RT_TABLE_LOCAL
 182
 183
 184
 185 /* Routing message attributes */
 186
 187 enum rtattr_type_t
 188 {
 189         RTA_UNSPEC,
 190         RTA_DST,
 191         RTA_SRC,
 192         RTA_IIF,
 193         RTA_OIF,
 194         RTA_GATEWAY,
 195         RTA_PRIORITY,
 196         RTA_PREFSRC,
 197         RTA_METRICS,
 198         RTA_MULTIPATH,
 199         RTA_PROTOINFO,
 200         RTA_FLOW,
 201         RTA_CACHEINFO
 202 };
 203
 204 #define RTA_MAX RTA_CACHEINFO
 205
 206 #define RTM_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct rtmsg))))
 207 #define RTM_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct rtmsg))
 208
 209 /* RTM_MULTIPATH --- array of struct rtnexthop.
 210  *
 211  * "struct rtnexthop" describres all necessary nexthop information,
 212  * i.e. parameters of path to a destination via this nextop.
 213  *
 214  * At the moment it is impossible to set different prefsrc, mtu, window
 215  * and rtt for different paths from multipath.
 216  */
 217
 218 struct rtnexthop
 219 {
 220         unsigned short          rtnh_len;
 221         unsigned char           rtnh_flags;
 222         unsigned char           rtnh_hops;
 223         int                     rtnh_ifindex;
 224 };
 225
 226 /* rtnh_flags */
 227
 228 #define RTNH_F_DEAD             1       /* Nexthop is dead (used by multipath)  */
 229 #define RTNH_F_PERVASIVE        2       /* Do recursive gateway lookup  */
 230 #define RTNH_F_ONLINK           4       /* Gateway is forced on link    */
 231
 232 /* Macros to handle hexthops */
 233
 234 #define RTNH_ALIGNTO    4
 235 #define RTNH_ALIGN(len) ( ((len)+RTNH_ALIGNTO-1) & ~(RTNH_ALIGNTO-1) )
 236 #define RTNH_OK(rtnh,len) ((rtnh)->rtnh_len >= sizeof(struct rtnexthop) && \
 237                            ((int)(rtnh)->rtnh_len) <= (len))
 238 #define RTNH_NEXT(rtnh) ((struct rtnexthop*)(((char*)(rtnh)) + RTNH_ALIGN((rtnh)->rtnh_len)))
 239 #define RTNH_LENGTH(len) (RTNH_ALIGN(sizeof(struct rtnexthop)) + (len))
 240 #define RTNH_SPACE(len) RTNH_ALIGN(RTNH_LENGTH(len))
 241 #define RTNH_DATA(rtnh)   ((struct rtattr*)(((char*)(rtnh)) + RTNH_LENGTH(0)))
 242
 243 /* RTM_CACHEINFO */
 244
 245 struct rta_cacheinfo
 246 {
 247         __u32   rta_clntref;
 248         __u32   rta_lastuse;
 249         __s32   rta_expires;
 250         __u32   rta_error;
 251         __u32   rta_used;
 252 };
 253
 254 /* RTM_METRICS --- array of struct rtattr with types of RTAX_* */
 255
 256 enum
 257 {
 258         RTAX_UNSPEC,
 259         RTAX_LOCK,
 260         RTAX_MTU,
 261         RTAX_WINDOW,
 262         RTAX_RTT,
 263         RTAX_HOPS,
 264         RTAX_SSTHRESH,
 265         RTAX_CWND,
 266 };
 267
 268 #define RTAX_MAX RTAX_CWND
 269
 270
 271
 272 /*********************************************************
 273  *              Interface address.
 274  ****/
 275
 276 struct ifaddrmsg
 277 {
 278         unsigned char   ifa_family;
 279         unsigned char   ifa_prefixlen;  /* The prefix length            */
 280         unsigned char   ifa_flags;      /* Flags                        */
 281         unsigned char   ifa_scope;      /* See above                    */
 282         int             ifa_index;      /* Link index                   */
 283 };
 284
 285 enum
 286 {
 287         IFA_UNSPEC,
 288         IFA_ADDRESS,
 289         IFA_LOCAL,
 290         IFA_LABEL,
 291         IFA_BROADCAST,
 292         IFA_ANYCAST,
 293         IFA_CACHEINFO
 294 };
 295
 296 #define IFA_MAX IFA_CACHEINFO
 297
 298 /* ifa_flags */
 299
 300 #define IFA_F_SECONDARY         0x01
 301
 302 #define IFA_F_DEPRECATED        0x20
 303 #define IFA_F_TENTATIVE         0x40
 304 #define IFA_F_PERMANENT         0x80
 305
 306 struct ifa_cacheinfo
 307 {
 308         __s32   ifa_prefered;
 309         __s32   ifa_valid;
 310 };
 311
 312
 313 #define IFA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ifaddrmsg))))
 314 #define IFA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ifaddrmsg))
 315
 316 /*
 317    Important comment:
 318    IFA_ADDRESS is prefix address, rather than local interface address.
 319    It makes no difference for normally configured broadcast interfaces,
 320    but for point-to-point IFA_ADDRESS is DESTINATION address,
 321    local address is supplied in IFA_LOCAL attribute.
 322  */
 323
 324 /**************************************************************
 325  *              Neighbour discovery.
 326  ****/
 327
 328 struct ndmsg
 329 {
 330         unsigned char   ndm_family;
 331         unsigned char   ndm_pad1;
 332         unsigned short  ndm_pad2;
 333         int             ndm_ifindex;    /* Link index                   */
 334         __u16           ndm_state;
 335         __u8            ndm_flags;
 336         __u8            ndm_type;
 337 };
 338
 339 enum
 340 {
 341         NDA_UNSPEC,
 342         NDA_DST,
 343         NDA_LLADDR,
 344         NDA_CACHEINFO
 345 };
 346
 347 #define NDA_MAX NDA_CACHEINFO
 348
 349 #define NDA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
 350 #define NDA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ndmsg))
 351
 352 /*
 353  *      Neighbor Cache Entry Flags
 354  */
 355
 356 #define NTF_PROXY       0x08    /* == ATF_PUBL */
 357 #define NTF_ROUTER      0x80
 358
 359 /*
 360  *      Neighbor Cache Entry States.
 361  */
 362
 363 #define NUD_INCOMPLETE  0x01
 364 #define NUD_REACHABLE   0x02
 365 #define NUD_STALE       0x04
 366 #define NUD_DELAY       0x08
 367 #define NUD_PROBE       0x10
 368 #define NUD_FAILED      0x20
 369
 370 /* Dummy states */
 371 #define NUD_NOARP       0x40
 372 #define NUD_PERMANENT   0x80
 373 #define NUD_NONE        0x00
 374
 375
 376 struct nda_cacheinfo
 377 {
 378         __u32           ndm_confirmed;
 379         __u32           ndm_used;
 380         __u32           ndm_updated;
 381         __u32           ndm_refcnt;
 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 enum
 413 {
 414         IFLA_UNSPEC,
 415         IFLA_ADDRESS,
 416         IFLA_BROADCAST,
 417         IFLA_IFNAME,
 418         IFLA_MTU,
 419         IFLA_LINK,
 420         IFLA_QDISC,
 421         IFLA_STATS,
 422         IFLA_COST,
 423         IFLA_PRIORITY
 424 };
 425
 426
 427 #define IFLA_MAX IFLA_STATS
 428
 429 #define IFLA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ifinfomsg))))
 430 #define IFLA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ifinfomsg))
 431
 432 /* ifi_flags.
 433
 434    IFF_* flags.
 435
 436    The only change is:
 437    IFF_LOOPBACK, IFF_BROADCAST and IFF_POINTOPOINT are
 438    more not changeable by user. They describe link media
 439    characteristics and set by device driver.
 440
 441    Comments:
 442    - Combination IFF_BROADCAST|IFF_POINTOPOINT is invalid
 443    - If neiher of these three flags are set;
 444      the interface is NBMA.
 445
 446    - IFF_MULTICAST does not mean anything special:
 447    multicasts can be used on all not-NBMA links.
 448    IFF_MULTICAST means that this media uses special encapsulation
 449    for multicast frames. Apparently, all IFF_POINTOPOINT and
 450    IFF_BROADCAST devices are able to use multicasts too.
 451  */
 452
 453 /* ifi_link.
 454    For usual devices it is equal ifi_index.
 455    If it is a "virtual interface" (f.e. tunnel), ifi_link
 456    can point to real physical interface (f.e. for bandwidth calculations),
 457    or maybe 0, what means, that real media is unknown (usual
 458    for IPIP tunnels, when route to endpoint is allowed to change)
 459  */
 460
 461 /*****************************************************************
 462  *              Traffic control messages.
 463  ****/
 464
 465 struct tcmsg
 466 {
 467         unsigned char   tcm_family;
 468         unsigned char   tcm__pad1;
 469         unsigned short  tcm__pad2;
 470         int             tcm_ifindex;
 471         __u32           tcm_handle;
 472         __u32           tcm_parent;
 473         __u32           tcm_info;
 474 };
 475
 476 enum
 477 {
 478         TCA_UNSPEC,
 479         TCA_KIND,
 480         TCA_OPTIONS,
 481         TCA_STATS,
 482         TCA_XSTATS,
 483         TCA_RATE,
 484 };
 485
 486 #define TCA_MAX TCA_RATE
 487
 488 #define TCA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcmsg))))
 489 #define TCA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcmsg))
 490
 491
 492 /* SUMMARY: maximal rtattr understood by kernel */
 493
 494 #define RTATTR_MAX              RTA_MAX
 495
 496 /* RTnetlink multicast groups */
 497
 498 #define RTMGRP_LINK             1
 499 #define RTMGRP_NOTIFY           2
 500 #define RTMGRP_NEIGH            4
 501 #define RTMGRP_TC               8
 502
 503 #define RTMGRP_IPV4_IFADDR      0x10
 504 #define RTMGRP_IPV4_MROUTE      0x20
 505 #define RTMGRP_IPV4_ROUTE       0x40
 506
 507 #define RTMGRP_IPV6_IFADDR      0x100
 508 #define RTMGRP_IPV6_MROUTE      0x200
 509 #define RTMGRP_IPV6_ROUTE       0x400
 510
 511 #define RTMGRP_DECnet_IFADDR    0x1000
 512 #define RTMGRP_DECnet_ROUTE     0x4000
 513
 514 /* End of information exported to user level */
 515
 516 #ifdef __KERNEL__
 517
 518 extern __inline__ int rtattr_strcmp(struct rtattr *rta, char *str)
 519 {
 520         int len = strlen(str) + 1;
 521         return len > rta->rta_len || memcmp(RTA_DATA(rta), str, len);
 522 }
 523
 524 extern int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len);
 525
 526 #ifdef CONFIG_RTNETLINK
 527 extern struct sock *rtnl;
 528
 529 struct rtnetlink_link
 530 {
 531         int (*doit)(struct sk_buff *, struct nlmsghdr*, void *attr);
 532         int (*dumpit)(struct sk_buff *, struct netlink_callback *cb);
 533 };
 534
 535 extern struct rtnetlink_link * rtnetlink_links[NPROTO];
 536 extern int rtnetlink_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb);
 537 extern int rtnetlink_send(struct sk_buff *skb, u32 pid, u32 group, int echo);
 538
 539 extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
 540
 541 #define RTA_PUT(skb, attrtype, attrlen, data) \
 542 ({ if (skb_tailroom(skb) < (int)RTA_SPACE(attrlen)) goto rtattr_failure; \
 543    __rta_fill(skb, attrtype, attrlen, data); })
 544 #endif
 545
 546 extern struct semaphore rtnl_sem;
 547
 548 #define rtnl_exlock()           do { } while(0)
 549 #define rtnl_exunlock()         do { } while(0)
 550 #define rtnl_exlock_nowait()    (0)
 551
 552 #define rtnl_shlock()           down(&rtnl_sem)
 553 #define rtnl_shlock_nowait()    down_trylock(&rtnl_sem)
 554
 555 #ifndef CONFIG_RTNETLINK
 556 #define rtnl_shunlock() up(&rtnl_sem)
 557 #else
 558 #define rtnl_shunlock() do { up(&rtnl_sem); \
 559                              if (rtnl && rtnl->receive_queue.qlen) \
 560                                      rtnl->data_ready(rtnl, 0); \
 561                         } while(0)
 562 #endif
 563
 564 extern void rtnl_lock(void);
 565 extern void rtnl_unlock(void);
 566 extern void rtnetlink_init(void);
 567
 568
 569
 570 #endif /* __KERNEL__ */
 571
 572
 573 #endif  /* __LINUX_RTNETLINK_H */