LCOV - code coverage report
Current view: top level - include/linux - ipv6.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 _IPV6_H
       2             : #define _IPV6_H
       3             : 
       4             : #include <linux/types.h>
       5             : #include <linux/in6.h>
       6             : #include <asm/byteorder.h>
       7             : 
       8             : /* The latest drafts declared increase in minimal mtu up to 1280. */
       9             : 
      10             : #define IPV6_MIN_MTU    1280
      11             : 
      12             : /*
      13             :  *      Advanced API
      14             :  *      source interface/address selection, source routing, etc...
      15             :  *      *under construction*
      16             :  */
      17             : 
      18             : 
      19             : struct in6_pktinfo {
      20             :         struct in6_addr ipi6_addr;
      21             :         int             ipi6_ifindex;
      22             : };
      23             : 
      24             : 
      25             : struct in6_ifreq {
      26             :         struct in6_addr ifr6_addr;
      27             :         __u32           ifr6_prefixlen;
      28             :         int             ifr6_ifindex; 
      29             : };
      30             : 
      31             : #define IPV6_SRCRT_STRICT       0x01    /* Deprecated; will be removed */
      32             : #define IPV6_SRCRT_TYPE_0       0       /* Deprecated; will be removed */
      33             : #define IPV6_SRCRT_TYPE_2       2       /* IPv6 type 2 Routing Header   */
      34             : 
      35             : /*
      36             :  *      routing header
      37             :  */
      38             : struct ipv6_rt_hdr {
      39             :         __u8            nexthdr;
      40             :         __u8            hdrlen;
      41             :         __u8            type;
      42             :         __u8            segments_left;
      43             : 
      44             :         /*
      45             :          *      type specific data
      46             :          *      variable length field
      47             :          */
      48             : };
      49             : 
      50             : 
      51             : struct ipv6_opt_hdr {
      52             :         __u8            nexthdr;
      53             :         __u8            hdrlen;
      54             :         /* 
      55             :          * TLV encoded option data follows.
      56             :          */
      57             : } __attribute__ ((packed));     /* required for some archs */
      58             : 
      59             : #define ipv6_destopt_hdr ipv6_opt_hdr
      60             : #define ipv6_hopopt_hdr  ipv6_opt_hdr
      61             : 
      62             : #ifdef __KERNEL__
      63             : #define ipv6_optlen(p)  (((p)->hdrlen+1) << 3)
      64             : #endif
      65             : 
      66             : /*
      67             :  *      routing header type 0 (used in cmsghdr struct)
      68             :  */
      69             : 
      70             : struct rt0_hdr {
      71             :         struct ipv6_rt_hdr      rt_hdr;
      72             :         __u32                   reserved;
      73             :         struct in6_addr         addr[0];
      74             : 
      75             : #define rt0_type                rt_hdr.type
      76             : };
      77             : 
      78             : /*
      79             :  *      routing header type 2
      80             :  */
      81             : 
      82             : struct rt2_hdr {
      83             :         struct ipv6_rt_hdr      rt_hdr;
      84             :         __u32                   reserved;
      85             :         struct in6_addr         addr;
      86             : 
      87             : #define rt2_type                rt_hdr.type
      88             : };
      89             : 
      90             : /*
      91             :  *      home address option in destination options header
      92             :  */
      93             : 
      94             : struct ipv6_destopt_hao {
      95             :         __u8                    type;
      96             :         __u8                    length;
      97             :         struct in6_addr         addr;
      98             : } __attribute__ ((__packed__));
      99             : 
     100             : /*
     101             :  *      IPv6 fixed header
     102             :  *
     103             :  *      BEWARE, it is incorrect. The first 4 bits of flow_lbl
     104             :  *      are glued to priority now, forming "class".
     105             :  */
     106             : 
     107             : struct ipv6hdr {
     108             : #if defined(__LITTLE_ENDIAN_BITFIELD)
     109             :         __u8                    priority:4,
     110             :                                 version:4;
     111             : #elif defined(__BIG_ENDIAN_BITFIELD)
     112             :         __u8                    version:4,
     113             :                                 priority:4;
     114             : #else
     115             : #error  "Please fix <asm/byteorder.h>"
     116             : #endif
     117             :         __u8                    flow_lbl[3];
     118             : 
     119             :         __be16                  payload_len;
     120             :         __u8                    nexthdr;
     121             :         __u8                    hop_limit;
     122             : 
     123             :         struct  in6_addr        saddr;
     124             :         struct  in6_addr        daddr;
     125             : };
     126             : 
     127             : #ifdef __KERNEL__
     128             : /*
     129             :  * This structure contains configuration options per IPv6 link.
     130             :  */
     131             : struct ipv6_devconf {
     132             :         __s32           forwarding;
     133             :         __s32           hop_limit;
     134             :         __s32           mtu6;
     135             :         __s32           accept_ra;
     136             :         __s32           accept_redirects;
     137             :         __s32           autoconf;
     138             :         __s32           dad_transmits;
     139             :         __s32           rtr_solicits;
     140             :         __s32           rtr_solicit_interval;
     141             :         __s32           rtr_solicit_delay;
     142             :         __s32           force_mld_version;
     143             : #ifdef CONFIG_IPV6_PRIVACY
     144             :         __s32           use_tempaddr;
     145             :         __s32           temp_valid_lft;
     146             :         __s32           temp_prefered_lft;
     147             :         __s32           regen_max_retry;
     148             :         __s32           max_desync_factor;
     149             : #endif
     150             :         __s32           max_addresses;
     151             :         __s32           accept_ra_defrtr;
     152             :         __s32           accept_ra_pinfo;
     153             : #ifdef CONFIG_IPV6_ROUTER_PREF
     154             :         __s32           accept_ra_rtr_pref;
     155             :         __s32           rtr_probe_interval;
     156             : #ifdef CONFIG_IPV6_ROUTE_INFO
     157             :         __s32           accept_ra_rt_info_max_plen;
     158             : #endif
     159             : #endif
     160             :         __s32           proxy_ndp;
     161             :         __s32           accept_source_route;
     162             : #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
     163             :         __s32           optimistic_dad;
     164             : #endif
     165             : #ifdef CONFIG_IPV6_MROUTE
     166             :         __s32           mc_forwarding;
     167             : #endif
     168             :         __s32           disable_ipv6;
     169             :         __s32           accept_dad;
     170             :         __s32           force_tllao;
     171             :         void            *sysctl;
     172             : };
     173             : 
     174             : struct ipv6_params {
     175             :         __s32 disable_ipv6;
     176             :         __s32 autoconf;
     177             : };
     178             : extern struct ipv6_params ipv6_defaults;
     179             : #endif
     180             : 
     181             : /* index values for the variables in ipv6_devconf */
     182             : enum {
     183             :         DEVCONF_FORWARDING = 0,
     184             :         DEVCONF_HOPLIMIT,
     185             :         DEVCONF_MTU6,
     186             :         DEVCONF_ACCEPT_RA,
     187             :         DEVCONF_ACCEPT_REDIRECTS,
     188             :         DEVCONF_AUTOCONF,
     189             :         DEVCONF_DAD_TRANSMITS,
     190             :         DEVCONF_RTR_SOLICITS,
     191             :         DEVCONF_RTR_SOLICIT_INTERVAL,
     192             :         DEVCONF_RTR_SOLICIT_DELAY,
     193             :         DEVCONF_USE_TEMPADDR,
     194             :         DEVCONF_TEMP_VALID_LFT,
     195             :         DEVCONF_TEMP_PREFERED_LFT,
     196             :         DEVCONF_REGEN_MAX_RETRY,
     197             :         DEVCONF_MAX_DESYNC_FACTOR,
     198             :         DEVCONF_MAX_ADDRESSES,
     199             :         DEVCONF_FORCE_MLD_VERSION,
     200             :         DEVCONF_ACCEPT_RA_DEFRTR,
     201             :         DEVCONF_ACCEPT_RA_PINFO,
     202             :         DEVCONF_ACCEPT_RA_RTR_PREF,
     203             :         DEVCONF_RTR_PROBE_INTERVAL,
     204             :         DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN,
     205             :         DEVCONF_PROXY_NDP,
     206             :         DEVCONF_OPTIMISTIC_DAD,
     207             :         DEVCONF_ACCEPT_SOURCE_ROUTE,
     208             :         DEVCONF_MC_FORWARDING,
     209             :         DEVCONF_DISABLE_IPV6,
     210             :         DEVCONF_ACCEPT_DAD,
     211             :         DEVCONF_FORCE_TLLAO,
     212             :         DEVCONF_MAX
     213             : };
     214             : 
     215             : #ifdef __KERNEL__
     216             : #include <linux/icmpv6.h>
     217             : #include <linux/tcp.h>
     218             : #include <linux/udp.h>
     219             : 
     220             : #include <net/inet_sock.h>
     221             : 
     222             : static inline struct ipv6hdr *ipv6_hdr(const struct sk_buff *skb)
     223             : {
     224             :         return (struct ipv6hdr *)skb_network_header(skb);
     225             : }
     226             : 
     227             : static inline struct ipv6hdr *ipipv6_hdr(const struct sk_buff *skb)
     228             : {
     229             :         return (struct ipv6hdr *)skb_transport_header(skb);
     230             : }
     231             : 
     232             : /* 
     233             :    This structure contains results of exthdrs parsing
     234             :    as offsets from skb->nh.
     235             :  */
     236             : 
     237             : struct inet6_skb_parm {
     238             :         int                     iif;
     239             :         __u16                   ra;
     240             :         __u16                   hop;
     241             :         __u16                   dst0;
     242             :         __u16                   srcrt;
     243             :         __u16                   dst1;
     244             :         __u16                   lastopt;
     245             :         __u32                   nhoff;
     246             :         __u16                   flags;
     247             : #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
     248             :         __u16                   dsthao;
     249             : #endif
     250             : 
     251             : #define IP6SKB_XFRM_TRANSFORMED 1
     252             : #define IP6SKB_FORWARDED        2
     253             : };
     254             : 
     255             : #define IP6CB(skb)      ((struct inet6_skb_parm*)((skb)->cb))
     256             : 
     257             : static inline int inet6_iif(const struct sk_buff *skb)
     258             : {
     259             :         return IP6CB(skb)->iif;
     260             : }
     261             : 
     262             : struct inet6_request_sock {
     263             :         struct in6_addr         loc_addr;
     264             :         struct in6_addr         rmt_addr;
     265             :         struct sk_buff          *pktopts;
     266             :         int                     iif;
     267             : };
     268             : 
     269             : struct tcp6_request_sock {
     270             :         struct tcp_request_sock   tcp6rsk_tcp;
     271             :         struct inet6_request_sock tcp6rsk_inet6;
     272             : };
     273             : 
     274             : struct ipv6_mc_socklist;
     275             : struct ipv6_ac_socklist;
     276             : struct ipv6_fl_socklist;
     277             : 
     278             : /**
     279             :  * struct ipv6_pinfo - ipv6 private area
     280             :  *
     281             :  * In the struct sock hierarchy (tcp6_sock, upd6_sock, etc)
     282             :  * this _must_ be the last member, so that inet6_sk_generic
     283             :  * is able to calculate its offset from the base struct sock
     284             :  * by using the struct proto->slab_obj_size member. -acme
     285             :  */
     286             : struct ipv6_pinfo {
     287             :         struct in6_addr         saddr;
     288             :         struct in6_addr         rcv_saddr;
     289             :         struct in6_addr         daddr;
     290             :         struct in6_pktinfo      sticky_pktinfo;
     291             :         struct in6_addr         *daddr_cache;
     292             : #ifdef CONFIG_IPV6_SUBTREES
     293             :         struct in6_addr         *saddr_cache;
     294             : #endif
     295             : 
     296             :         __be32                  flow_label;
     297             :         __u32                   frag_size;
     298             : 
     299             :         /*
     300             :          * Packed in 16bits.
     301             :          * Omit one shift by by putting the signed field at MSB.
     302             :          */
     303             : #if defined(__BIG_ENDIAN_BITFIELD)
     304             :         __s16                   hop_limit:9;
     305             :         __u16                   __unused_1:7;
     306             : #else
     307             :         __u16                   __unused_1:7;
     308             :         __s16                   hop_limit:9;
     309             : #endif
     310             : 
     311             : #if defined(__BIG_ENDIAN_BITFIELD)
     312             :         /* Packed in 16bits. */
     313             :         __s16                   mcast_hops:9;
     314             :         __u16                   __unused_2:6,
     315             :                                 mc_loop:1;
     316             : #else
     317             :         __u16                   mc_loop:1,
     318             :                                 __unused_2:6;
     319             :         __s16                   mcast_hops:9;
     320             : #endif
     321             :         int                     mcast_oif;
     322             : 
     323             :         /* pktoption flags */
     324             :         union {
     325             :                 struct {
     326             :                         __u16   srcrt:1,
     327             :                                 osrcrt:1,
     328             :                                 rxinfo:1,
     329             :                                 rxoinfo:1,
     330             :                                 rxhlim:1,
     331             :                                 rxohlim:1,
     332             :                                 hopopts:1,
     333             :                                 ohopopts:1,
     334             :                                 dstopts:1,
     335             :                                 odstopts:1,
     336             :                                 rxflow:1,
     337             :                                 rxtclass:1;
     338             :                 } bits;
     339             :                 __u16           all;
     340             :         } rxopt;
     341             : 
     342             :         /* sockopt flags */
     343             :         __u8                    recverr:1,
     344             :                                 sndflow:1,
     345             :                                 pmtudisc:2,
     346             :                                 ipv6only:1,
     347             :                                 srcprefs:3;     /* 001: prefer temporary address
     348             :                                                  * 010: prefer public address
     349             :                                                  * 100: prefer care-of address
     350             :                                                  */
     351             :         __u8                    tclass;
     352             : 
     353             :         __u32                   dst_cookie;
     354             : 
     355             :         struct ipv6_mc_socklist *ipv6_mc_list;
     356             :         struct ipv6_ac_socklist *ipv6_ac_list;
     357             :         struct ipv6_fl_socklist *ipv6_fl_list;
     358             : 
     359             :         struct ipv6_txoptions   *opt;
     360             :         struct sk_buff          *pktoptions;
     361             :         struct {
     362             :                 struct ipv6_txoptions *opt;
     363             :                 u8 hop_limit;
     364             :                 u8 tclass;
     365             :         } cork;
     366             : };
     367             : 
     368             : /* WARNING: don't change the layout of the members in {raw,udp,tcp}6_sock! */
     369             : struct raw6_sock {
     370             :         /* inet_sock has to be the first member of raw6_sock */
     371             :         struct inet_sock        inet;
     372             :         __u32                   checksum;       /* perform checksum */
     373             :         __u32                   offset;         /* checksum offset  */
     374             :         struct icmp6_filter     filter;
     375             :         /* ipv6_pinfo has to be the last member of raw6_sock, see inet6_sk_generic */
     376             :         struct ipv6_pinfo       inet6;
     377             : };
     378             : 
     379             : struct udp6_sock {
     380             :         struct udp_sock   udp;
     381             :         /* ipv6_pinfo has to be the last member of udp6_sock, see inet6_sk_generic */
     382             :         struct ipv6_pinfo inet6;
     383             : };
     384             : 
     385             : struct tcp6_sock {
     386             :         struct tcp_sock   tcp;
     387             :         /* ipv6_pinfo has to be the last member of tcp6_sock, see inet6_sk_generic */
     388             :         struct ipv6_pinfo inet6;
     389             : };
     390             : 
     391             : extern int inet6_sk_rebuild_header(struct sock *sk);
     392             : 
     393             : #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
     394             : static inline struct ipv6_pinfo * inet6_sk(const struct sock *__sk)
     395             : {
     396             :         return inet_sk(__sk)->pinet6;
     397             : }
     398             : 
     399             : static inline struct inet6_request_sock *
     400             :                         inet6_rsk(const struct request_sock *rsk)
     401             : {
     402             :         return (struct inet6_request_sock *)(((u8 *)rsk) +
     403             :                                              inet_rsk(rsk)->inet6_rsk_offset);
     404             : }
     405             : 
     406             : static inline u32 inet6_rsk_offset(struct request_sock *rsk)
     407             : {
     408             :         return rsk->rsk_ops->obj_size - sizeof(struct inet6_request_sock);
     409             : }
     410             : 
     411             : static inline struct request_sock *inet6_reqsk_alloc(struct request_sock_ops *ops)
     412             : {
     413             :         struct request_sock *req = reqsk_alloc(ops);
     414             : 
     415             :         if (req != NULL) {
     416             :                 inet_rsk(req)->inet6_rsk_offset = inet6_rsk_offset(req);
     417             :                 inet6_rsk(req)->pktopts = NULL;
     418             :         }
     419             : 
     420             :         return req;
     421             : }
     422             : 
     423             : static inline struct raw6_sock *raw6_sk(const struct sock *sk)
     424             : {
     425             :         return (struct raw6_sock *)sk;
     426             : }
     427             : 
     428             : static inline void inet_sk_copy_descendant(struct sock *sk_to,
     429             :                                            const struct sock *sk_from)
     430             : {
     431             :         int ancestor_size = sizeof(struct inet_sock);
     432             : 
     433             :         if (sk_from->sk_family == PF_INET6)
     434             :                 ancestor_size += sizeof(struct ipv6_pinfo);
     435             : 
     436             :         __inet_sk_copy_descendant(sk_to, sk_from, ancestor_size);
     437             : }
     438             : 
     439             : #define __ipv6_only_sock(sk)    (inet6_sk(sk)->ipv6only)
     440             : #define ipv6_only_sock(sk)      ((sk)->sk_family == PF_INET6 && __ipv6_only_sock(sk))
     441             : 
     442             : struct inet6_timewait_sock {
     443             :         struct in6_addr tw_v6_daddr;
     444             :         struct in6_addr tw_v6_rcv_saddr;
     445             : };
     446             : 
     447             : struct tcp6_timewait_sock {
     448             :         struct tcp_timewait_sock   tcp6tw_tcp;
     449             :         struct inet6_timewait_sock tcp6tw_inet6;
     450             : };
     451             : 
     452             : static inline u16 inet6_tw_offset(const struct proto *prot)
     453             : {
     454             :         return prot->twsk_prot->twsk_obj_size -
     455             :                         sizeof(struct inet6_timewait_sock);
     456             : }
     457             : 
     458             : static inline struct inet6_timewait_sock *inet6_twsk(const struct sock *sk)
     459             : {
     460             :         return (struct inet6_timewait_sock *)(((u8 *)sk) +
     461             :                                               inet_twsk(sk)->tw_ipv6_offset);
     462             : }
     463             : 
     464             : static inline struct in6_addr *__inet6_rcv_saddr(const struct sock *sk)
     465             : {
     466             :         return likely(sk->sk_state != TCP_TIME_WAIT) ?
     467             :                 &inet6_sk(sk)->rcv_saddr : &inet6_twsk(sk)->tw_v6_rcv_saddr;
     468             : }
     469             : 
     470             : static inline struct in6_addr *inet6_rcv_saddr(const struct sock *sk)
     471             : {
     472             :         return sk->sk_family == AF_INET6 ? __inet6_rcv_saddr(sk) : NULL;
     473             : }
     474             : 
     475             : static inline int inet_v6_ipv6only(const struct sock *sk)
     476             : {
     477             :         return likely(sk->sk_state != TCP_TIME_WAIT) ?
     478             :                 ipv6_only_sock(sk) : inet_twsk(sk)->tw_ipv6only;
     479             : }
     480             : #else
     481             : #define __ipv6_only_sock(sk)    0
     482             : #define ipv6_only_sock(sk)      0
     483             : 
     484             : static inline struct ipv6_pinfo * inet6_sk(const struct sock *__sk)
     485             : {
     486             :         return NULL;
     487             : }
     488             : 
     489             : static inline struct inet6_request_sock *
     490             :                         inet6_rsk(const struct request_sock *rsk)
     491             : {
     492             :         return NULL;
     493             : }
     494             : 
     495             : static inline struct raw6_sock *raw6_sk(const struct sock *sk)
     496             : {
     497             :         return NULL;
     498             : }
     499           1 : 
     500             : #define __inet6_rcv_saddr(__sk) NULL
     501             : #define inet6_rcv_saddr(__sk)   NULL
     502             : #define tcp_twsk_ipv6only(__sk)         0
     503             : #define inet_v6_ipv6only(__sk)          0
     504             : #endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
     505             : 
     506             : #define INET6_MATCH(__sk, __net, __hash, __saddr, __daddr, __ports, __dif)\
     507             :         (((__sk)->sk_hash == (__hash)) && sock_net((__sk)) == (__net)        && \
     508             :          ((*((__portpair *)&(inet_sk(__sk)->inet_dport))) == (__ports)) && \
     509             :          ((__sk)->sk_family          == AF_INET6)            && \
     510             :          ipv6_addr_equal(&inet6_sk(__sk)->daddr, (__saddr))      && \
     511             :          ipv6_addr_equal(&inet6_sk(__sk)->rcv_saddr, (__daddr))  && \
     512             :          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
     513             : 
     514             : #define INET6_TW_MATCH(__sk, __net, __hash, __saddr, __daddr, __ports, __dif) \
     515             :         (((__sk)->sk_hash == (__hash)) && sock_net((__sk)) == (__net)        && \
     516             :          (*((__portpair *)&(inet_twsk(__sk)->tw_dport)) == (__ports))    && \
     517             :          ((__sk)->sk_family         == PF_INET6)                     && \
     518             :          (ipv6_addr_equal(&inet6_twsk(__sk)->tw_v6_daddr, (__saddr)))    && \
     519             :          (ipv6_addr_equal(&inet6_twsk(__sk)->tw_v6_rcv_saddr, (__daddr))) && \
     520             :          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
     521             : 
     522             : #endif /* __KERNEL__ */
     523             : 
     524             : #endif /* _IPV6_H */

Generated by: LCOV version 1.10