home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / linux / ipv6.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  9.5 KB  |  442 lines
  1. #ifndef _IPV6_H
  2. #define _IPV6_H
  3.  
  4. #include <linux/in6.h>
  5. #include <asm/byteorder.h>
  6.  
  7. /* The latest drafts declared increase in minimal mtu up to 1280. */
  8.  
  9. #define IPV6_MIN_MTU    1280
  10.  
  11. /*
  12.  *    Advanced API
  13.  *    source interface/address selection, source routing, etc...
  14.  *    *under construction*
  15.  */
  16.  
  17.  
  18. struct in6_pktinfo {
  19.     struct in6_addr    ipi6_addr;
  20.     int        ipi6_ifindex;
  21. };
  22.  
  23.  
  24. struct in6_ifreq {
  25.     struct in6_addr    ifr6_addr;
  26.     __u32        ifr6_prefixlen;
  27.     int        ifr6_ifindex; 
  28. };
  29.  
  30. #define IPV6_SRCRT_STRICT    0x01    /* this hop must be a neighbor    */
  31. #define IPV6_SRCRT_TYPE_0    0    /* IPv6 type 0 Routing Header    */
  32.  
  33. /*
  34.  *    routing header
  35.  */
  36. struct ipv6_rt_hdr {
  37.     __u8        nexthdr;
  38.     __u8        hdrlen;
  39.     __u8        type;
  40.     __u8        segments_left;
  41.  
  42.     /*
  43.      *    type specific data
  44.      *    variable length field
  45.      */
  46. };
  47.  
  48.  
  49. struct ipv6_opt_hdr {
  50.     __u8         nexthdr;
  51.     __u8         hdrlen;
  52.     /* 
  53.      * TLV encoded option data follows.
  54.      */
  55. };
  56.  
  57. #define ipv6_destopt_hdr ipv6_opt_hdr
  58. #define ipv6_hopopt_hdr  ipv6_opt_hdr
  59.  
  60. #ifdef __KERNEL__
  61. #define ipv6_optlen(p)  (((p)->hdrlen+1) << 3)
  62. #endif
  63.  
  64. /*
  65.  *    routing header type 0 (used in cmsghdr struct)
  66.  */
  67.  
  68. struct rt0_hdr {
  69.     struct ipv6_rt_hdr    rt_hdr;
  70.     __u32            reserved;
  71.     struct in6_addr        addr[0];
  72.  
  73. #define rt0_type        rt_hdr.type
  74. };
  75.  
  76. struct ipv6_auth_hdr {
  77.     __u8  nexthdr;
  78.     __u8  hdrlen;           /* This one is measured in 32 bit units! */
  79.     __u16 reserved;
  80.     __u32 spi;
  81.     __u32 seq_no;           /* Sequence number */
  82.     __u8  auth_data[0];     /* Length variable but >=4. Mind the 64 bit alignment! */
  83. };
  84.  
  85. struct ipv6_esp_hdr {
  86.     __u32 spi;
  87.     __u32 seq_no;           /* Sequence number */
  88.     __u8  enc_data[0];      /* Length variable but >=8. Mind the 64 bit alignment! */
  89. };
  90.  
  91. struct ipv6_comp_hdr {
  92.     __u8 nexthdr;
  93.     __u8 flags;
  94.     __u16 cpi;
  95. };
  96.  
  97. /*
  98.  *    IPv6 fixed header
  99.  *
  100.  *    BEWARE, it is incorrect. The first 4 bits of flow_lbl
  101.  *    are glued to priority now, forming "class".
  102.  */
  103.  
  104. struct ipv6hdr {
  105. #if defined(__LITTLE_ENDIAN_BITFIELD)
  106.     __u8            priority:4,
  107.                 version:4;
  108. #elif defined(__BIG_ENDIAN_BITFIELD)
  109.     __u8            version:4,
  110.                 priority:4;
  111. #else
  112. #error    "Please fix <asm/byteorder.h>"
  113. #endif
  114.     __u8            flow_lbl[3];
  115.  
  116.     __u16            payload_len;
  117.     __u8            nexthdr;
  118.     __u8            hop_limit;
  119.  
  120.     struct    in6_addr    saddr;
  121.     struct    in6_addr    daddr;
  122. };
  123.  
  124. /*
  125.  * This structure contains configuration options per IPv6 link.
  126.  */
  127. struct ipv6_devconf {
  128.     __s32        forwarding;
  129.     __s32        hop_limit;
  130.     __s32        mtu6;
  131.     __s32        accept_ra;
  132.     __s32        accept_redirects;
  133.     __s32        autoconf;
  134.     __s32        dad_transmits;
  135.     __s32        rtr_solicits;
  136.     __s32        rtr_solicit_interval;
  137.     __s32        rtr_solicit_delay;
  138.     __s32        force_mld_version;
  139. #ifdef CONFIG_IPV6_PRIVACY
  140.     __s32        use_tempaddr;
  141.     __s32        temp_valid_lft;
  142.     __s32        temp_prefered_lft;
  143.     __s32        regen_max_retry;
  144.     __s32        max_desync_factor;
  145. #endif
  146.     __s32        max_addresses;
  147.     __s32        accept_ra_defrtr;
  148.     __s32        accept_ra_pinfo;
  149. #ifdef CONFIG_IPV6_ROUTER_PREF
  150.     __s32        accept_ra_rtr_pref;
  151.     __s32        rtr_probe_interval;
  152. #ifdef CONFIG_IPV6_ROUTE_INFO
  153.     __s32        accept_ra_rt_info_max_plen;
  154. #endif
  155. #endif
  156.     void        *sysctl;
  157. };
  158.  
  159. /* index values for the variables in ipv6_devconf */
  160. enum {
  161.     DEVCONF_FORWARDING = 0,
  162.     DEVCONF_HOPLIMIT,
  163.     DEVCONF_MTU6,
  164.     DEVCONF_ACCEPT_RA,
  165.     DEVCONF_ACCEPT_REDIRECTS,
  166.     DEVCONF_AUTOCONF,
  167.     DEVCONF_DAD_TRANSMITS,
  168.     DEVCONF_RTR_SOLICITS,
  169.     DEVCONF_RTR_SOLICIT_INTERVAL,
  170.     DEVCONF_RTR_SOLICIT_DELAY,
  171.     DEVCONF_USE_TEMPADDR,
  172.     DEVCONF_TEMP_VALID_LFT,
  173.     DEVCONF_TEMP_PREFERED_LFT,
  174.     DEVCONF_REGEN_MAX_RETRY,
  175.     DEVCONF_MAX_DESYNC_FACTOR,
  176.     DEVCONF_MAX_ADDRESSES,
  177.     DEVCONF_FORCE_MLD_VERSION,
  178.     DEVCONF_ACCEPT_RA_DEFRTR,
  179.     DEVCONF_ACCEPT_RA_PINFO,
  180.     DEVCONF_ACCEPT_RA_RTR_PREF,
  181.     DEVCONF_RTR_PROBE_INTERVAL,
  182.     DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN,
  183.     DEVCONF_MAX
  184. };
  185.  
  186. #ifdef __KERNEL__
  187. #include <linux/icmpv6.h>
  188. #include <linux/tcp.h>
  189. #include <linux/udp.h>
  190.  
  191. #include <net/if_inet6.h>       /* struct ipv6_mc_socklist */
  192. #include <net/inet_sock.h>
  193.  
  194. /* 
  195.    This structure contains results of exthdrs parsing
  196.    as offsets from skb->nh.
  197.  */
  198.  
  199. struct inet6_skb_parm {
  200.     int            iif;
  201.     __u16            ra;
  202.     __u16            hop;
  203.     __u16            dst0;
  204.     __u16            srcrt;
  205.     __u16            dst1;
  206.     __u16            lastopt;
  207.     __u32            nhoff;
  208.     __u16            flags;
  209.  
  210. #define IP6SKB_XFRM_TRANSFORMED    1
  211. };
  212.  
  213. #define IP6CB(skb)    ((struct inet6_skb_parm*)((skb)->cb))
  214.  
  215. static inline int inet6_iif(const struct sk_buff *skb)
  216. {
  217.     return IP6CB(skb)->iif;
  218. }
  219.  
  220. struct inet6_request_sock {
  221.     struct in6_addr        loc_addr;
  222.     struct in6_addr        rmt_addr;
  223.     struct sk_buff        *pktopts;
  224.     int            iif;
  225. };
  226.  
  227. struct tcp6_request_sock {
  228.     struct tcp_request_sock      tcp6rsk_tcp;
  229.     struct inet6_request_sock tcp6rsk_inet6;
  230. };
  231.  
  232. /**
  233.  * struct ipv6_pinfo - ipv6 private area
  234.  *
  235.  * In the struct sock hierarchy (tcp6_sock, upd6_sock, etc)
  236.  * this _must_ be the last member, so that inet6_sk_generic
  237.  * is able to calculate its offset from the base struct sock
  238.  * by using the struct proto->slab_obj_size member. -acme
  239.  */
  240. struct ipv6_pinfo {
  241.     struct in6_addr     saddr;
  242.     struct in6_addr     rcv_saddr;
  243.     struct in6_addr        daddr;
  244.     struct in6_addr        *daddr_cache;
  245.  
  246.     __u32            flow_label;
  247.     __u32            frag_size;
  248.     __s16            hop_limit;
  249.     __s16            mcast_hops;
  250.     int            mcast_oif;
  251.  
  252.     /* pktoption flags */
  253.     union {
  254.         struct {
  255.             __u16    srcrt:2,
  256.                 osrcrt:2,
  257.                     rxinfo:1,
  258.                     rxoinfo:1,
  259.                 rxhlim:1,
  260.                 rxohlim:1,
  261.                 hopopts:1,
  262.                 ohopopts:1,
  263.                 dstopts:1,
  264.                 odstopts:1,
  265.                                 rxflow:1,
  266.                 rxtclass:1;
  267.         } bits;
  268.         __u16        all;
  269.     } rxopt;
  270.  
  271.     /* sockopt flags */
  272.     __u8            mc_loop:1,
  273.                             recverr:1,
  274.                             sndflow:1,
  275.                 pmtudisc:2,
  276.                 ipv6only:1;
  277.     __u8            tclass;
  278.  
  279.     __u32            dst_cookie;
  280.  
  281.     struct ipv6_mc_socklist    *ipv6_mc_list;
  282.     struct ipv6_ac_socklist    *ipv6_ac_list;
  283.     struct ipv6_fl_socklist *ipv6_fl_list;
  284.  
  285.     struct ipv6_txoptions    *opt;
  286.     struct sk_buff        *pktoptions;
  287.     struct {
  288.         struct ipv6_txoptions *opt;
  289.         struct rt6_info    *rt;
  290.         int hop_limit;
  291.         int tclass;
  292.     } cork;
  293. };
  294.  
  295. /* WARNING: don't change the layout of the members in {raw,udp,tcp}6_sock! */
  296. struct raw6_sock {
  297.     /* inet_sock has to be the first member of raw6_sock */
  298.     struct inet_sock    inet;
  299.     __u32            checksum;    /* perform checksum */
  300.     __u32            offset;        /* checksum offset  */
  301.     struct icmp6_filter    filter;
  302.     /* ipv6_pinfo has to be the last member of raw6_sock, see inet6_sk_generic */
  303.     struct ipv6_pinfo    inet6;
  304. };
  305.  
  306. struct udp6_sock {
  307.     struct udp_sock      udp;
  308.     /* ipv6_pinfo has to be the last member of udp6_sock, see inet6_sk_generic */
  309.     struct ipv6_pinfo inet6;
  310. };
  311.  
  312. struct tcp6_sock {
  313.     struct tcp_sock      tcp;
  314.     /* ipv6_pinfo has to be the last member of tcp6_sock, see inet6_sk_generic */
  315.     struct ipv6_pinfo inet6;
  316. };
  317.  
  318. extern int inet6_sk_rebuild_header(struct sock *sk);
  319.  
  320. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  321. static inline struct ipv6_pinfo * inet6_sk(const struct sock *__sk)
  322. {
  323.     return inet_sk(__sk)->pinet6;
  324. }
  325.  
  326. static inline struct inet6_request_sock *
  327.             inet6_rsk(const struct request_sock *rsk)
  328. {
  329.     return (struct inet6_request_sock *)(((u8 *)rsk) +
  330.                          inet_rsk(rsk)->inet6_rsk_offset);
  331. }
  332.  
  333. static inline u32 inet6_rsk_offset(struct request_sock *rsk)
  334. {
  335.     return rsk->rsk_ops->obj_size - sizeof(struct inet6_request_sock);
  336. }
  337.  
  338. static inline struct request_sock *inet6_reqsk_alloc(struct request_sock_ops *ops)
  339. {
  340.     struct request_sock *req = reqsk_alloc(ops);
  341.  
  342.     if (req != NULL)
  343.         inet_rsk(req)->inet6_rsk_offset = inet6_rsk_offset(req);
  344.  
  345.     return req;
  346. }
  347.  
  348. static inline struct raw6_sock *raw6_sk(const struct sock *sk)
  349. {
  350.     return (struct raw6_sock *)sk;
  351. }
  352.  
  353. static inline void inet_sk_copy_descendant(struct sock *sk_to,
  354.                        const struct sock *sk_from)
  355. {
  356.     int ancestor_size = sizeof(struct inet_sock);
  357.  
  358.     if (sk_from->sk_family == PF_INET6)
  359.         ancestor_size += sizeof(struct ipv6_pinfo);
  360.  
  361.     __inet_sk_copy_descendant(sk_to, sk_from, ancestor_size);
  362. }
  363.  
  364. #define __ipv6_only_sock(sk)    (inet6_sk(sk)->ipv6only)
  365. #define ipv6_only_sock(sk)    ((sk)->sk_family == PF_INET6 && __ipv6_only_sock(sk))
  366.  
  367. struct inet6_timewait_sock {
  368.     struct in6_addr tw_v6_daddr;
  369.     struct in6_addr    tw_v6_rcv_saddr;
  370. };
  371.  
  372. struct tcp6_timewait_sock {
  373.     struct tcp_timewait_sock   tcp6tw_tcp;
  374.     struct inet6_timewait_sock tcp6tw_inet6;
  375. };
  376.  
  377. static inline u16 inet6_tw_offset(const struct proto *prot)
  378. {
  379.     return prot->twsk_prot->twsk_obj_size -
  380.             sizeof(struct inet6_timewait_sock);
  381. }
  382.  
  383. static inline struct inet6_timewait_sock *inet6_twsk(const struct sock *sk)
  384. {
  385.     return (struct inet6_timewait_sock *)(((u8 *)sk) +
  386.                           inet_twsk(sk)->tw_ipv6_offset);
  387. }
  388.  
  389. static inline struct in6_addr *__inet6_rcv_saddr(const struct sock *sk)
  390. {
  391.     return likely(sk->sk_state != TCP_TIME_WAIT) ?
  392.         &inet6_sk(sk)->rcv_saddr : &inet6_twsk(sk)->tw_v6_rcv_saddr;
  393. }
  394.  
  395. static inline struct in6_addr *inet6_rcv_saddr(const struct sock *sk)
  396. {
  397.     return sk->sk_family == AF_INET6 ? __inet6_rcv_saddr(sk) : NULL;
  398. }
  399.  
  400. static inline int inet_v6_ipv6only(const struct sock *sk)
  401. {
  402.     return likely(sk->sk_state != TCP_TIME_WAIT) ?
  403.         ipv6_only_sock(sk) : inet_twsk(sk)->tw_ipv6only;
  404. }
  405. #else
  406. #define __ipv6_only_sock(sk)    0
  407. #define ipv6_only_sock(sk)    0
  408.  
  409. static inline struct ipv6_pinfo * inet6_sk(const struct sock *__sk)
  410. {
  411.     return NULL;
  412. }
  413.  
  414. static inline struct inet6_request_sock *
  415.             inet6_rsk(const struct request_sock *rsk)
  416. {
  417.     return NULL;
  418. }
  419.  
  420. static inline struct raw6_sock *raw6_sk(const struct sock *sk)
  421. {
  422.     return NULL;
  423. }
  424.  
  425. #define __inet6_rcv_saddr(__sk)    NULL
  426. #define inet6_rcv_saddr(__sk)    NULL
  427. #define tcp_twsk_ipv6only(__sk)        0
  428. #define inet_v6_ipv6only(__sk)        0
  429. #endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
  430.  
  431. #define INET6_MATCH(__sk, __hash, __saddr, __daddr, __ports, __dif)\
  432.     (((__sk)->sk_hash == (__hash))                && \
  433.      ((*((__u32 *)&(inet_sk(__sk)->dport))) == (__ports))      && \
  434.      ((__sk)->sk_family        == AF_INET6)        && \
  435.      ipv6_addr_equal(&inet6_sk(__sk)->daddr, (__saddr))    && \
  436.      ipv6_addr_equal(&inet6_sk(__sk)->rcv_saddr, (__daddr))    && \
  437.      (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
  438.  
  439. #endif /* __KERNEL__ */
  440.  
  441. #endif /* _IPV6_H */
  442.