LCOV - code coverage report
Current view: top level - include/linux - rtnetlink.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 1 100.0 %
Date: 2017-01-25 Functions: 0 0 -

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

Generated by: LCOV version 1.10