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