net/ipv6/xfrm6_mode_tunnel.c

   1 /*
   2  * xfrm6_mode_tunnel.c - Tunnel mode encapsulation for IPv6.
   3  *
   4  * Copyright (C) 2002 USAGI/WIDE Project
   5  * Copyright (c) 2004-2006 Herbert Xu <herbert@gondor.apana.org.au>
   6  */
   7
   8 #include <linux/gfp.h>
   9 #include <linux/init.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/skbuff.h>
  13 #include <linux/stringify.h>
  14 #include <net/dsfield.h>
  15 #include <net/dst.h>
  16 #include <net/inet_ecn.h>
  17 #include <net/ip6_route.h>
  18 #include <net/ipv6.h>
  19 #include <net/xfrm.h>
  20
  21 /* Informational hook. The decap is still done here. */
  22 static struct xfrm_tunnel_notifier __rcu *rcv_notify_handlers __read_mostly;
  23 static DEFINE_MUTEX(xfrm6_mode_tunnel_input_mutex);
  24
  25 int xfrm6_mode_tunnel_input_register(struct xfrm_tunnel_notifier *handler)
  26 {
  27         struct xfrm_tunnel_notifier __rcu **pprev;
  28         struct xfrm_tunnel_notifier *t;
  29         int ret = -EEXIST;
  30         int priority = handler->priority;
  31
  32         mutex_lock(&xfrm6_mode_tunnel_input_mutex);
  33
  34         for (pprev = &rcv_notify_handlers;
  35              (t = rcu_dereference_protected(*pprev,
  36              lockdep_is_held(&xfrm6_mode_tunnel_input_mutex))) != NULL;
  37              pprev = &t->next) {
  38                 if (t->priority > priority)
  39                         break;
  40                 if (t->priority == priority)
  41                         goto err;
  42
  43         }
  44
  45         handler->next = *pprev;
  46         rcu_assign_pointer(*pprev, handler);
  47
  48         ret = 0;
  49
  50 err:
  51         mutex_unlock(&xfrm6_mode_tunnel_input_mutex);
  52         return ret;
  53 }
  54 EXPORT_SYMBOL_GPL(xfrm6_mode_tunnel_input_register);
  55
  56 int xfrm6_mode_tunnel_input_deregister(struct xfrm_tunnel_notifier *handler)
  57 {
  58         struct xfrm_tunnel_notifier __rcu **pprev;
  59         struct xfrm_tunnel_notifier *t;
  60         int ret = -ENOENT;
  61
  62         mutex_lock(&xfrm6_mode_tunnel_input_mutex);
  63         for (pprev = &rcv_notify_handlers;
  64              (t = rcu_dereference_protected(*pprev,
  65              lockdep_is_held(&xfrm6_mode_tunnel_input_mutex))) != NULL;
  66              pprev = &t->next) {
  67                 if (t == handler) {
  68                         *pprev = handler->next;
  69                         ret = 0;
  70                         break;
  71                 }
  72         }
  73         mutex_unlock(&xfrm6_mode_tunnel_input_mutex);
  74         synchronize_net();
  75
  76         return ret;
  77 }
  78 EXPORT_SYMBOL_GPL(xfrm6_mode_tunnel_input_deregister);
  79
  80 static inline void ipip6_ecn_decapsulate(struct sk_buff *skb)
  81 {
  82         const struct ipv6hdr *outer_iph = ipv6_hdr(skb);
  83         struct ipv6hdr *inner_iph = ipipv6_hdr(skb);
  84
  85         if (INET_ECN_is_ce(ipv6_get_dsfield(outer_iph)))
  86                 IP6_ECN_set_ce(inner_iph);
  87 }
  88
  89 /* Add encapsulation header.
  90  *
  91  * The top IP header will be constructed per RFC 2401.
  92  */
  93 static int xfrm6_mode_tunnel_output(struct xfrm_state *x, struct sk_buff *skb)
  94 {
  95         struct dst_entry *dst = skb_dst(skb);
  96         struct ipv6hdr *top_iph;
  97         int dsfield;
  98
  99         skb_set_network_header(skb, -x->props.header_len);
 100         skb->mac_header = skb->network_header +
 101                           offsetof(struct ipv6hdr, nexthdr);
 102         skb->transport_header = skb->network_header + sizeof(*top_iph);
 103         top_iph = ipv6_hdr(skb);
 104
 105         top_iph->version = 6;
 106
 107         memcpy(top_iph->flow_lbl, XFRM_MODE_SKB_CB(skb)->flow_lbl,
 108                sizeof(top_iph->flow_lbl));
 109         top_iph->nexthdr = xfrm_af2proto(skb_dst(skb)->ops->family);
 110
 111         if (x->props.extra_flags & XFRM_SA_XFLAG_DONT_ENCAP_DSCP)
 112                 dsfield = 0;
 113         else
 114                 dsfield = XFRM_MODE_SKB_CB(skb)->tos;
 115         dsfield = INET_ECN_encapsulate(dsfield, XFRM_MODE_SKB_CB(skb)->tos);
 116         if (x->props.flags & XFRM_STATE_NOECN)
 117                 dsfield &= ~INET_ECN_MASK;
 118         ipv6_change_dsfield(top_iph, 0, dsfield);
 119         top_iph->hop_limit = ip6_dst_hoplimit(dst->child);
 120         top_iph->saddr = *(struct in6_addr *)&x->props.saddr;
 121         top_iph->daddr = *(struct in6_addr *)&x->id.daddr;
 122         return 0;
 123 }
 124
 125 #define for_each_input_rcu(head, handler)       \
 126         for (handler = rcu_dereference(head);   \
 127              handler != NULL;                   \
 128              handler = rcu_dereference(handler->next))
 129
 130
 131 static int xfrm6_mode_tunnel_input(struct xfrm_state *x, struct sk_buff *skb)
 132 {
 133         struct xfrm_tunnel_notifier *handler;
 134         int err = -EINVAL;
 135
 136         if (XFRM_MODE_SKB_CB(skb)->protocol != IPPROTO_IPV6)
 137                 goto out;
 138         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
 139                 goto out;
 140
 141         for_each_input_rcu(rcv_notify_handlers, handler)
 142                 handler->handler(skb);
 143
 144         err = skb_unclone(skb, GFP_ATOMIC);
 145         if (err)
 146                 goto out;
 147
 148         if (x->props.flags & XFRM_STATE_DECAP_DSCP)
 149                 ipv6_copy_dscp(ipv6_get_dsfield(ipv6_hdr(skb)),
 150                                ipipv6_hdr(skb));
 151         if (!(x->props.flags & XFRM_STATE_NOECN))
 152                 ipip6_ecn_decapsulate(skb);
 153
 154         skb_reset_network_header(skb);
 155         skb_mac_header_rebuild(skb);
 156
 157         err = 0;
 158
 159 out:
 160         return err;
 161 }
 162
 163 static struct xfrm_mode xfrm6_tunnel_mode = {
 164         .input2 = xfrm6_mode_tunnel_input,
 165         .input = xfrm_prepare_input,
 166         .output2 = xfrm6_mode_tunnel_output,
 167         .output = xfrm6_prepare_output,
 168         .owner = THIS_MODULE,
 169         .encap = XFRM_MODE_TUNNEL,
 170         .flags = XFRM_MODE_FLAG_TUNNEL,
 171 };
 172
 173 static int __init xfrm6_mode_tunnel_init(void)
 174 {
 175         return xfrm_register_mode(&xfrm6_tunnel_mode, AF_INET6);
 176 }
 177
 178 static void __exit xfrm6_mode_tunnel_exit(void)
 179 {
 180         int err;
 181
 182         err = xfrm_unregister_mode(&xfrm6_tunnel_mode, AF_INET6);
 183         BUG_ON(err);
 184 }
 185
 186 module_init(xfrm6_mode_tunnel_init);
 187 module_exit(xfrm6_mode_tunnel_exit);
 188 MODULE_LICENSE("GPL");
 189 MODULE_ALIAS_XFRM_MODE(AF_INET6, XFRM_MODE_TUNNEL);