source: src/linux/universal/linux-3.18/net/ipv6/ip6_tunnel.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 5 weeks ago

update

File size: 44.8 KB
Line 
1/*
2 *      IPv6 tunneling device
3 *      Linux INET6 implementation
4 *
5 *      Authors:
6 *      Ville Nuorvala          <vnuorval@tcs.hut.fi>
7 *      Yasuyuki Kozakai        <kozakai@linux-ipv6.org>
8 *
9 *      Based on:
10 *      linux/net/ipv6/sit.c and linux/net/ipv4/ipip.c
11 *
12 *      RFC 2473
13 *
14 *      This program is free software; you can redistribute it and/or
15 *      modify it under the terms of the GNU General Public License
16 *      as published by the Free Software Foundation; either version
17 *      2 of the License, or (at your option) any later version.
18 *
19 */
20
21#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
23#include <linux/module.h>
24#include <linux/capability.h>
25#include <linux/errno.h>
26#include <linux/types.h>
27#include <linux/sockios.h>
28#include <linux/icmp.h>
29#include <linux/if.h>
30#include <linux/in.h>
31#include <linux/ip.h>
32#include <linux/net.h>
33#include <linux/in6.h>
34#include <linux/netdevice.h>
35#include <linux/if_arp.h>
36#include <linux/icmpv6.h>
37#include <linux/init.h>
38#include <linux/route.h>
39#include <linux/rtnetlink.h>
40#include <linux/netfilter_ipv6.h>
41#include <linux/slab.h>
42#include <linux/hash.h>
43#include <linux/etherdevice.h>
44
45#include <asm/uaccess.h>
46#include <linux/atomic.h>
47
48#include <net/icmp.h>
49#include <net/ip.h>
50#include <net/ip_tunnels.h>
51#include <net/ipv6.h>
52#include <net/ip6_route.h>
53#include <net/addrconf.h>
54#include <net/ip6_tunnel.h>
55#include <net/xfrm.h>
56#include <net/dsfield.h>
57#include <net/inet_ecn.h>
58#include <net/net_namespace.h>
59#include <net/netns/generic.h>
60
61MODULE_AUTHOR("Ville Nuorvala");
62MODULE_DESCRIPTION("IPv6 tunneling device");
63MODULE_LICENSE("GPL");
64MODULE_ALIAS_RTNL_LINK("ip6tnl");
65MODULE_ALIAS_NETDEV("ip6tnl0");
66
67#ifdef IP6_TNL_DEBUG
68#define IP6_TNL_TRACE(x...) pr_debug("%s:" x "\n", __func__)
69#else
70#define IP6_TNL_TRACE(x...) do {;} while(0)
71#endif
72
73#define HASH_SIZE_SHIFT  5
74#define HASH_SIZE (1 << HASH_SIZE_SHIFT)
75
76static bool log_ecn_error = true;
77module_param(log_ecn_error, bool, 0644);
78MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
79
80static u32 HASH(const struct in6_addr *addr1, const struct in6_addr *addr2)
81{
82        u32 hash = ipv6_addr_hash(addr1) ^ ipv6_addr_hash(addr2);
83
84        return hash_32(hash, HASH_SIZE_SHIFT);
85}
86
87static int ip6_tnl_dev_init(struct net_device *dev);
88static void ip6_tnl_dev_setup(struct net_device *dev);
89static struct rtnl_link_ops ip6_link_ops __read_mostly;
90
91static int ip6_tnl_net_id __read_mostly;
92struct ip6_tnl_net {
93        /* the IPv6 tunnel fallback device */
94        struct net_device *fb_tnl_dev;
95        /* lists for storing tunnels in use */
96        struct ip6_tnl __rcu *tnls_r_l[HASH_SIZE];
97        struct ip6_tnl __rcu *tnls_wc[1];
98        struct ip6_tnl __rcu **tnls[2];
99};
100
101static struct net_device_stats *ip6_get_stats(struct net_device *dev)
102{
103        struct pcpu_sw_netstats tmp, sum = { 0 };
104        int i;
105
106        for_each_possible_cpu(i) {
107                unsigned int start;
108                const struct pcpu_sw_netstats *tstats =
109                                                   per_cpu_ptr(dev->tstats, i);
110
111                do {
112                        start = u64_stats_fetch_begin_irq(&tstats->syncp);
113                        tmp.rx_packets = tstats->rx_packets;
114                        tmp.rx_bytes = tstats->rx_bytes;
115                        tmp.tx_packets = tstats->tx_packets;
116                        tmp.tx_bytes =  tstats->tx_bytes;
117                } while (u64_stats_fetch_retry_irq(&tstats->syncp, start));
118
119                sum.rx_packets += tmp.rx_packets;
120                sum.rx_bytes   += tmp.rx_bytes;
121                sum.tx_packets += tmp.tx_packets;
122                sum.tx_bytes   += tmp.tx_bytes;
123        }
124        dev->stats.rx_packets = sum.rx_packets;
125        dev->stats.rx_bytes   = sum.rx_bytes;
126        dev->stats.tx_packets = sum.tx_packets;
127        dev->stats.tx_bytes   = sum.tx_bytes;
128        return &dev->stats;
129}
130
131/*
132 * Locking : hash tables are protected by RCU and RTNL
133 */
134
135struct dst_entry *ip6_tnl_dst_check(struct ip6_tnl *t)
136{
137        struct dst_entry *dst = t->dst_cache;
138
139        if (dst && dst->obsolete &&
140            dst->ops->check(dst, t->dst_cookie) == NULL) {
141                t->dst_cache = NULL;
142                dst_release(dst);
143                return NULL;
144        }
145
146        return dst;
147}
148EXPORT_SYMBOL_GPL(ip6_tnl_dst_check);
149
150void ip6_tnl_dst_reset(struct ip6_tnl *t)
151{
152        dst_release(t->dst_cache);
153        t->dst_cache = NULL;
154}
155EXPORT_SYMBOL_GPL(ip6_tnl_dst_reset);
156
157void ip6_tnl_dst_store(struct ip6_tnl *t, struct dst_entry *dst)
158{
159        struct rt6_info *rt = (struct rt6_info *) dst;
160        t->dst_cookie = rt->rt6i_node ? rt->rt6i_node->fn_sernum : 0;
161        dst_release(t->dst_cache);
162        t->dst_cache = dst;
163}
164EXPORT_SYMBOL_GPL(ip6_tnl_dst_store);
165
166/**
167 * ip6_tnl_lookup - fetch tunnel matching the end-point addresses
168 *   @remote: the address of the tunnel exit-point
169 *   @local: the address of the tunnel entry-point
170 *
171 * Return:
172 *   tunnel matching given end-points if found,
173 *   else fallback tunnel if its device is up,
174 *   else %NULL
175 **/
176
177#define for_each_ip6_tunnel_rcu(start) \
178        for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))
179
180static struct ip6_tnl *
181ip6_tnl_lookup(struct net *net, const struct in6_addr *remote, const struct in6_addr *local)
182{
183        unsigned int hash = HASH(remote, local);
184        struct ip6_tnl *t;
185        struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
186
187        for_each_ip6_tunnel_rcu(ip6n->tnls_r_l[hash]) {
188                if (ipv6_addr_equal(local, &t->parms.laddr) &&
189                    ipv6_addr_equal(remote, &t->parms.raddr) &&
190                    (t->dev->flags & IFF_UP))
191                        return t;
192        }
193        t = rcu_dereference(ip6n->tnls_wc[0]);
194        if (t && (t->dev->flags & IFF_UP))
195                return t;
196
197        return NULL;
198}
199
200/**
201 * ip6_tnl_bucket - get head of list matching given tunnel parameters
202 *   @p: parameters containing tunnel end-points
203 *
204 * Description:
205 *   ip6_tnl_bucket() returns the head of the list matching the
206 *   &struct in6_addr entries laddr and raddr in @p.
207 *
208 * Return: head of IPv6 tunnel list
209 **/
210
211static struct ip6_tnl __rcu **
212ip6_tnl_bucket(struct ip6_tnl_net *ip6n, const struct __ip6_tnl_parm *p)
213{
214        const struct in6_addr *remote = &p->raddr;
215        const struct in6_addr *local = &p->laddr;
216        unsigned int h = 0;
217        int prio = 0;
218
219        if (!ipv6_addr_any(remote) || !ipv6_addr_any(local)) {
220                prio = 1;
221                h = HASH(remote, local);
222        }
223        return &ip6n->tnls[prio][h];
224}
225
226/**
227 * ip6_tnl_link - add tunnel to hash table
228 *   @t: tunnel to be added
229 **/
230
231static void
232ip6_tnl_link(struct ip6_tnl_net *ip6n, struct ip6_tnl *t)
233{
234        struct ip6_tnl __rcu **tp = ip6_tnl_bucket(ip6n, &t->parms);
235
236        rcu_assign_pointer(t->next , rtnl_dereference(*tp));
237        rcu_assign_pointer(*tp, t);
238}
239
240/**
241 * ip6_tnl_unlink - remove tunnel from hash table
242 *   @t: tunnel to be removed
243 **/
244
245static void
246ip6_tnl_unlink(struct ip6_tnl_net *ip6n, struct ip6_tnl *t)
247{
248        struct ip6_tnl __rcu **tp;
249        struct ip6_tnl *iter;
250
251        for (tp = ip6_tnl_bucket(ip6n, &t->parms);
252             (iter = rtnl_dereference(*tp)) != NULL;
253             tp = &iter->next) {
254                if (t == iter) {
255                        rcu_assign_pointer(*tp, t->next);
256                        break;
257                }
258        }
259}
260
261static void ip6_dev_free(struct net_device *dev)
262{
263        free_percpu(dev->tstats);
264        free_netdev(dev);
265}
266
267static int ip6_tnl_create2(struct net_device *dev)
268{
269        struct ip6_tnl *t = netdev_priv(dev);
270        struct net *net = dev_net(dev);
271        struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
272        int err;
273
274        t = netdev_priv(dev);
275
276        dev->rtnl_link_ops = &ip6_link_ops;
277        err = register_netdevice(dev);
278        if (err < 0)
279                goto out;
280
281        strcpy(t->parms.name, dev->name);
282
283        dev_hold(dev);
284        ip6_tnl_link(ip6n, t);
285        return 0;
286
287out:
288        return err;
289}
290
291/**
292 * ip6_tnl_create - create a new tunnel
293 *   @p: tunnel parameters
294 *   @pt: pointer to new tunnel
295 *
296 * Description:
297 *   Create tunnel matching given parameters.
298 *
299 * Return:
300 *   created tunnel or NULL
301 **/
302
303static struct ip6_tnl *ip6_tnl_create(struct net *net, struct __ip6_tnl_parm *p)
304{
305        struct net_device *dev;
306        struct ip6_tnl *t;
307        char name[IFNAMSIZ];
308        int err;
309
310        if (p->name[0])
311                strlcpy(name, p->name, IFNAMSIZ);
312        else
313                sprintf(name, "ip6tnl%%d");
314
315        dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN,
316                           ip6_tnl_dev_setup);
317        if (dev == NULL)
318                goto failed;
319
320        dev_net_set(dev, net);
321
322        t = netdev_priv(dev);
323        t->parms = *p;
324        t->net = dev_net(dev);
325        err = ip6_tnl_create2(dev);
326        if (err < 0)
327                goto failed_free;
328
329        return t;
330
331failed_free:
332        ip6_dev_free(dev);
333failed:
334        return NULL;
335}
336
337/**
338 * ip6_tnl_locate - find or create tunnel matching given parameters
339 *   @p: tunnel parameters
340 *   @create: != 0 if allowed to create new tunnel if no match found
341 *
342 * Description:
343 *   ip6_tnl_locate() first tries to locate an existing tunnel
344 *   based on @parms. If this is unsuccessful, but @create is set a new
345 *   tunnel device is created and registered for use.
346 *
347 * Return:
348 *   matching tunnel or NULL
349 **/
350
351static struct ip6_tnl *ip6_tnl_locate(struct net *net,
352                struct __ip6_tnl_parm *p, int create)
353{
354        const struct in6_addr *remote = &p->raddr;
355        const struct in6_addr *local = &p->laddr;
356        struct ip6_tnl __rcu **tp;
357        struct ip6_tnl *t;
358        struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
359
360        for (tp = ip6_tnl_bucket(ip6n, p);
361             (t = rtnl_dereference(*tp)) != NULL;
362             tp = &t->next) {
363                if (ipv6_addr_equal(local, &t->parms.laddr) &&
364                    ipv6_addr_equal(remote, &t->parms.raddr)) {
365                        if (create)
366                                return NULL;
367
368                        return t;
369                }
370        }
371        if (!create)
372                return NULL;
373        return ip6_tnl_create(net, p);
374}
375
376/**
377 * ip6_tnl_dev_uninit - tunnel device uninitializer
378 *   @dev: the device to be destroyed
379 *
380 * Description:
381 *   ip6_tnl_dev_uninit() removes tunnel from its list
382 **/
383
384static void
385ip6_tnl_dev_uninit(struct net_device *dev)
386{
387        struct ip6_tnl *t = netdev_priv(dev);
388        struct net *net = t->net;
389        struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
390
391        if (dev == ip6n->fb_tnl_dev)
392                RCU_INIT_POINTER(ip6n->tnls_wc[0], NULL);
393        else
394                ip6_tnl_unlink(ip6n, t);
395        ip6_tnl_dst_reset(t);
396        dev_put(dev);
397}
398
399/**
400 * parse_tvl_tnl_enc_lim - handle encapsulation limit option
401 *   @skb: received socket buffer
402 *
403 * Return:
404 *   0 if none was found,
405 *   else index to encapsulation limit
406 **/
407
408__u16 ip6_tnl_parse_tlv_enc_lim(struct sk_buff *skb, __u8 *raw)
409{
410        const struct ipv6hdr *ipv6h = (const struct ipv6hdr *)raw;
411        unsigned int nhoff = raw - skb->data;
412        unsigned int off = nhoff + sizeof(*ipv6h);
413        u8 next, nexthdr = ipv6h->nexthdr;
414
415        while (ipv6_ext_hdr(nexthdr) && nexthdr != NEXTHDR_NONE) {
416                struct ipv6_opt_hdr *hdr;
417                u16 optlen;
418
419                if (!pskb_may_pull(skb, off + sizeof(*hdr)))
420                        break;
421
422                hdr = (struct ipv6_opt_hdr *)(skb->data + off);
423                if (nexthdr == NEXTHDR_FRAGMENT) {
424                        struct frag_hdr *frag_hdr = (struct frag_hdr *) hdr;
425                        if (frag_hdr->frag_off)
426                                break;
427                        optlen = 8;
428                } else if (nexthdr == NEXTHDR_AUTH) {
429                        optlen = (hdr->hdrlen + 2) << 2;
430                } else {
431                        optlen = ipv6_optlen(hdr);
432                }
433                /* cache hdr->nexthdr, since pskb_may_pull() might
434                 * invalidate hdr
435                 */
436                next = hdr->nexthdr;
437                if (nexthdr == NEXTHDR_DEST) {
438                        u16 i = 2;
439
440                        /* Remember : hdr is no longer valid at this point. */
441                        if (!pskb_may_pull(skb, off + optlen))
442                                break;
443
444                        while (1) {
445                                struct ipv6_tlv_tnl_enc_lim *tel;
446
447                                /* No more room for encapsulation limit */
448                                if (i + sizeof(*tel) > optlen)
449                                        break;
450
451                                tel = (struct ipv6_tlv_tnl_enc_lim *)(skb->data + off + i);
452                                /* return index of option if found and valid */
453                                if (tel->type == IPV6_TLV_TNL_ENCAP_LIMIT &&
454                                    tel->length == 1)
455                                        return i + off - nhoff;
456                                /* else jump to next option */
457                                if (tel->type)
458                                        i += tel->length + 2;
459                                else
460                                        i++;
461                        }
462                }
463                nexthdr = next;
464                off += optlen;
465        }
466        return 0;
467}
468EXPORT_SYMBOL(ip6_tnl_parse_tlv_enc_lim);
469
470/**
471 * ip6_tnl_err - tunnel error handler
472 *
473 * Description:
474 *   ip6_tnl_err() should handle errors in the tunnel according
475 *   to the specifications in RFC 2473.
476 **/
477
478static int
479ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt,
480            u8 *type, u8 *code, int *msg, __u32 *info, int offset)
481{
482        const struct ipv6hdr *ipv6h = (const struct ipv6hdr *) skb->data;
483        struct ip6_tnl *t;
484        int rel_msg = 0;
485        u8 rel_type = ICMPV6_DEST_UNREACH;
486        u8 rel_code = ICMPV6_ADDR_UNREACH;
487        __u32 rel_info = 0;
488        __u16 len;
489        int err = -ENOENT;
490
491        /* If the packet doesn't contain the original IPv6 header we are
492           in trouble since we might need the source address for further
493           processing of the error. */
494
495        rcu_read_lock();
496        if ((t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->daddr,
497                                        &ipv6h->saddr)) == NULL)
498                goto out;
499
500        if (t->parms.proto != ipproto && t->parms.proto != 0)
501                goto out;
502
503        err = 0;
504
505        switch (*type) {
506                __u32 teli;
507                struct ipv6_tlv_tnl_enc_lim *tel;
508                __u32 mtu;
509        case ICMPV6_DEST_UNREACH:
510                net_warn_ratelimited("%s: Path to destination invalid or inactive!\n",
511                                     t->parms.name);
512                rel_msg = 1;
513                break;
514        case ICMPV6_TIME_EXCEED:
515                if ((*code) == ICMPV6_EXC_HOPLIMIT) {
516                        net_warn_ratelimited("%s: Too small hop limit or routing loop in tunnel!\n",
517                                             t->parms.name);
518                        rel_msg = 1;
519                }
520                break;
521        case ICMPV6_PARAMPROB:
522                teli = 0;
523                if ((*code) == ICMPV6_HDR_FIELD)
524                        teli = ip6_tnl_parse_tlv_enc_lim(skb, skb->data);
525
526                if (teli && teli == *info - 2) {
527                        tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->data[teli];
528                        if (tel->encap_limit == 0) {
529                                net_warn_ratelimited("%s: Too small encapsulation limit or routing loop in tunnel!\n",
530                                                     t->parms.name);
531                                rel_msg = 1;
532                        }
533                } else {
534                        net_warn_ratelimited("%s: Recipient unable to parse tunneled packet!\n",
535                                             t->parms.name);
536                }
537                break;
538        case ICMPV6_PKT_TOOBIG:
539                mtu = *info - offset;
540                if (mtu < IPV6_MIN_MTU)
541                        mtu = IPV6_MIN_MTU;
542                t->dev->mtu = mtu;
543
544                if ((len = sizeof(*ipv6h) + ntohs(ipv6h->payload_len)) > mtu) {
545                        rel_type = ICMPV6_PKT_TOOBIG;
546                        rel_code = 0;
547                        rel_info = mtu;
548                        rel_msg = 1;
549                }
550                break;
551        }
552
553        *type = rel_type;
554        *code = rel_code;
555        *info = rel_info;
556        *msg = rel_msg;
557
558out:
559        rcu_read_unlock();
560        return err;
561}
562
563static int
564ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
565           u8 type, u8 code, int offset, __be32 info)
566{
567        int rel_msg = 0;
568        u8 rel_type = type;
569        u8 rel_code = code;
570        __u32 rel_info = ntohl(info);
571        int err;
572        struct sk_buff *skb2;
573        const struct iphdr *eiph;
574        struct rtable *rt;
575        struct flowi4 fl4;
576
577        err = ip6_tnl_err(skb, IPPROTO_IPIP, opt, &rel_type, &rel_code,
578                          &rel_msg, &rel_info, offset);
579        if (err < 0)
580                return err;
581
582        if (rel_msg == 0)
583                return 0;
584
585        switch (rel_type) {
586        case ICMPV6_DEST_UNREACH:
587                if (rel_code != ICMPV6_ADDR_UNREACH)
588                        return 0;
589                rel_type = ICMP_DEST_UNREACH;
590                rel_code = ICMP_HOST_UNREACH;
591                break;
592        case ICMPV6_PKT_TOOBIG:
593                if (rel_code != 0)
594                        return 0;
595                rel_type = ICMP_DEST_UNREACH;
596                rel_code = ICMP_FRAG_NEEDED;
597                break;
598        case NDISC_REDIRECT:
599                rel_type = ICMP_REDIRECT;
600                rel_code = ICMP_REDIR_HOST;
601        default:
602                return 0;
603        }
604
605        if (!pskb_may_pull(skb, offset + sizeof(struct iphdr)))
606                return 0;
607
608        skb2 = skb_clone(skb, GFP_ATOMIC);
609        if (!skb2)
610                return 0;
611
612        skb_dst_drop(skb2);
613
614        skb_pull(skb2, offset);
615        skb_reset_network_header(skb2);
616        eiph = ip_hdr(skb2);
617
618        /* Try to guess incoming interface */
619        rt = ip_route_output_ports(dev_net(skb->dev), &fl4, NULL,
620                                   eiph->saddr, 0,
621                                   0, 0,
622                                   IPPROTO_IPIP, RT_TOS(eiph->tos), 0);
623        if (IS_ERR(rt))
624                goto out;
625
626        skb2->dev = rt->dst.dev;
627
628        /* route "incoming" packet */
629        if (rt->rt_flags & RTCF_LOCAL) {
630                ip_rt_put(rt);
631                rt = NULL;
632                rt = ip_route_output_ports(dev_net(skb->dev), &fl4, NULL,
633                                           eiph->daddr, eiph->saddr,
634                                           0, 0,
635                                           IPPROTO_IPIP,
636                                           RT_TOS(eiph->tos), 0);
637                if (IS_ERR(rt) ||
638                    rt->dst.dev->type != ARPHRD_TUNNEL) {
639                        if (!IS_ERR(rt))
640                                ip_rt_put(rt);
641                        goto out;
642                }
643                skb_dst_set(skb2, &rt->dst);
644        } else {
645                ip_rt_put(rt);
646                if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos,
647                                   skb2->dev) ||
648                    skb_dst(skb2)->dev->type != ARPHRD_TUNNEL)
649                        goto out;
650        }
651
652        /* change mtu on this route */
653        if (rel_type == ICMP_DEST_UNREACH && rel_code == ICMP_FRAG_NEEDED) {
654                if (rel_info > dst_mtu(skb_dst(skb2)))
655                        goto out;
656
657                skb_dst(skb2)->ops->update_pmtu(skb_dst(skb2), NULL, skb2, rel_info);
658        }
659        if (rel_type == ICMP_REDIRECT)
660                skb_dst(skb2)->ops->redirect(skb_dst(skb2), NULL, skb2);
661
662        icmp_send(skb2, rel_type, rel_code, htonl(rel_info));
663
664out:
665        kfree_skb(skb2);
666        return 0;
667}
668
669static int
670ip6ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
671           u8 type, u8 code, int offset, __be32 info)
672{
673        int rel_msg = 0;
674        u8 rel_type = type;
675        u8 rel_code = code;
676        __u32 rel_info = ntohl(info);
677        int err;
678
679        err = ip6_tnl_err(skb, IPPROTO_IPV6, opt, &rel_type, &rel_code,
680                          &rel_msg, &rel_info, offset);
681        if (err < 0)
682                return err;
683
684        if (rel_msg && pskb_may_pull(skb, offset + sizeof(struct ipv6hdr))) {
685                struct rt6_info *rt;
686                struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
687
688                if (!skb2)
689                        return 0;
690
691                skb_dst_drop(skb2);
692                skb_pull(skb2, offset);
693                skb_reset_network_header(skb2);
694
695                /* Try to guess incoming interface */
696                rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr,
697                                NULL, 0, 0);
698
699                if (rt && rt->dst.dev)
700                        skb2->dev = rt->dst.dev;
701
702                icmpv6_send(skb2, rel_type, rel_code, rel_info);
703
704                ip6_rt_put(rt);
705
706                kfree_skb(skb2);
707        }
708
709        return 0;
710}
711
712static int ip4ip6_dscp_ecn_decapsulate(const struct ip6_tnl *t,
713                                       const struct ipv6hdr *ipv6h,
714                                       struct sk_buff *skb)
715{
716        __u8 dsfield = ipv6_get_dsfield(ipv6h) & ~INET_ECN_MASK;
717
718        if (t->parms.flags & IP6_TNL_F_RCV_DSCP_COPY)
719                ipv4_change_dsfield(ip_hdr(skb), INET_ECN_MASK, dsfield);
720
721        return IP6_ECN_decapsulate(ipv6h, skb);
722}
723
724static int ip6ip6_dscp_ecn_decapsulate(const struct ip6_tnl *t,
725                                       const struct ipv6hdr *ipv6h,
726                                       struct sk_buff *skb)
727{
728        if (t->parms.flags & IP6_TNL_F_RCV_DSCP_COPY)
729                ipv6_copy_dscp(ipv6_get_dsfield(ipv6h), ipv6_hdr(skb));
730
731        return IP6_ECN_decapsulate(ipv6h, skb);
732}
733
734__u32 ip6_tnl_get_cap(struct ip6_tnl *t,
735                             const struct in6_addr *laddr,
736                             const struct in6_addr *raddr)
737{
738        struct __ip6_tnl_parm *p = &t->parms;
739        int ltype = ipv6_addr_type(laddr);
740        int rtype = ipv6_addr_type(raddr);
741        __u32 flags = 0;
742
743        if (ltype == IPV6_ADDR_ANY || rtype == IPV6_ADDR_ANY) {
744                flags = IP6_TNL_F_CAP_PER_PACKET;
745        } else if (ltype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
746                   rtype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
747                   !((ltype|rtype) & IPV6_ADDR_LOOPBACK) &&
748                   (!((ltype|rtype) & IPV6_ADDR_LINKLOCAL) || p->link)) {
749                if (ltype&IPV6_ADDR_UNICAST)
750                        flags |= IP6_TNL_F_CAP_XMIT;
751                if (rtype&IPV6_ADDR_UNICAST)
752                        flags |= IP6_TNL_F_CAP_RCV;
753        }
754        return flags;
755}
756EXPORT_SYMBOL(ip6_tnl_get_cap);
757
758/* called with rcu_read_lock() */
759int ip6_tnl_rcv_ctl(struct ip6_tnl *t,
760                                  const struct in6_addr *laddr,
761                                  const struct in6_addr *raddr)
762{
763        struct __ip6_tnl_parm *p = &t->parms;
764        int ret = 0;
765        struct net *net = t->net;
766
767        if ((p->flags & IP6_TNL_F_CAP_RCV) ||
768            ((p->flags & IP6_TNL_F_CAP_PER_PACKET) &&
769             (ip6_tnl_get_cap(t, laddr, raddr) & IP6_TNL_F_CAP_RCV))) {
770                struct net_device *ldev = NULL;
771
772                if (p->link)
773                        ldev = dev_get_by_index_rcu(net, p->link);
774
775                if ((ipv6_addr_is_multicast(laddr) ||
776                     likely(ipv6_chk_addr(net, laddr, ldev, 0))) &&
777                    likely(!ipv6_chk_addr(net, raddr, NULL, 0)))
778                        ret = 1;
779        }
780        return ret;
781}
782EXPORT_SYMBOL_GPL(ip6_tnl_rcv_ctl);
783
784/**
785 * ip6_tnl_rcv - decapsulate IPv6 packet and retransmit it locally
786 *   @skb: received socket buffer
787 *   @protocol: ethernet protocol ID
788 *   @dscp_ecn_decapsulate: the function to decapsulate DSCP code and ECN
789 *
790 * Return: 0
791 **/
792
793static int ip6_tnl_rcv(struct sk_buff *skb, __u16 protocol,
794                       __u8 ipproto,
795                       int (*dscp_ecn_decapsulate)(const struct ip6_tnl *t,
796                                                   const struct ipv6hdr *ipv6h,
797                                                   struct sk_buff *skb))
798{
799        struct ip6_tnl *t;
800        const struct ipv6hdr *ipv6h = ipv6_hdr(skb);
801        int err;
802
803        rcu_read_lock();
804
805        if ((t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->saddr,
806                                        &ipv6h->daddr)) != NULL) {
807                struct pcpu_sw_netstats *tstats;
808
809                if (t->parms.proto != ipproto && t->parms.proto != 0) {
810                        rcu_read_unlock();
811                        goto discard;
812                }
813
814                if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
815                        rcu_read_unlock();
816                        goto discard;
817                }
818
819                if (!ip6_tnl_rcv_ctl(t, &ipv6h->daddr, &ipv6h->saddr)) {
820                        t->dev->stats.rx_dropped++;
821                        rcu_read_unlock();
822                        goto discard;
823                }
824                skb->mac_header = skb->network_header;
825                skb_reset_network_header(skb);
826                skb->protocol = htons(protocol);
827                memset(skb->cb, 0, sizeof(struct inet6_skb_parm));
828
829                __skb_tunnel_rx(skb, t->dev, t->net);
830
831                err = dscp_ecn_decapsulate(t, ipv6h, skb);
832                if (unlikely(err)) {
833                        if (log_ecn_error)
834                                net_info_ratelimited("non-ECT from %pI6 with dsfield=%#x\n",
835                                                     &ipv6h->saddr,
836                                                     ipv6_get_dsfield(ipv6h));
837                        if (err > 1) {
838                                ++t->dev->stats.rx_frame_errors;
839                                ++t->dev->stats.rx_errors;
840                                rcu_read_unlock();
841                                goto discard;
842                        }
843                }
844
845                tstats = this_cpu_ptr(t->dev->tstats);
846                u64_stats_update_begin(&tstats->syncp);
847                tstats->rx_packets++;
848                tstats->rx_bytes += skb->len;
849                u64_stats_update_end(&tstats->syncp);
850
851                netif_rx(skb);
852
853                rcu_read_unlock();
854                return 0;
855        }
856        rcu_read_unlock();
857        return 1;
858
859discard:
860        kfree_skb(skb);
861        return 0;
862}
863
864static int ip4ip6_rcv(struct sk_buff *skb)
865{
866        return ip6_tnl_rcv(skb, ETH_P_IP, IPPROTO_IPIP,
867                           ip4ip6_dscp_ecn_decapsulate);
868}
869
870static int ip6ip6_rcv(struct sk_buff *skb)
871{
872        return ip6_tnl_rcv(skb, ETH_P_IPV6, IPPROTO_IPV6,
873                           ip6ip6_dscp_ecn_decapsulate);
874}
875
876struct ipv6_tel_txoption {
877        struct ipv6_txoptions ops;
878        __u8 dst_opt[8];
879};
880
881static void init_tel_txopt(struct ipv6_tel_txoption *opt, __u8 encap_limit)
882{
883        memset(opt, 0, sizeof(struct ipv6_tel_txoption));
884
885        opt->dst_opt[2] = IPV6_TLV_TNL_ENCAP_LIMIT;
886        opt->dst_opt[3] = 1;
887        opt->dst_opt[4] = encap_limit;
888        opt->dst_opt[5] = IPV6_TLV_PADN;
889        opt->dst_opt[6] = 1;
890
891        opt->ops.dst0opt = (struct ipv6_opt_hdr *) opt->dst_opt;
892        opt->ops.opt_nflen = 8;
893}
894
895/**
896 * ip6_tnl_addr_conflict - compare packet addresses to tunnel's own
897 *   @t: the outgoing tunnel device
898 *   @hdr: IPv6 header from the incoming packet
899 *
900 * Description:
901 *   Avoid trivial tunneling loop by checking that tunnel exit-point
902 *   doesn't match source of incoming packet.
903 *
904 * Return:
905 *   1 if conflict,
906 *   0 else
907 **/
908
909static inline bool
910ip6_tnl_addr_conflict(const struct ip6_tnl *t, const struct ipv6hdr *hdr)
911{
912        return ipv6_addr_equal(&t->parms.raddr, &hdr->saddr);
913}
914
915int ip6_tnl_xmit_ctl(struct ip6_tnl *t)
916{
917        struct __ip6_tnl_parm *p = &t->parms;
918        int ret = 0;
919        struct net *net = t->net;
920
921        if (p->flags & IP6_TNL_F_CAP_XMIT) {
922                struct net_device *ldev = NULL;
923
924                rcu_read_lock();
925                if (p->link)
926                        ldev = dev_get_by_index_rcu(net, p->link);
927
928                if (unlikely(!ipv6_chk_addr(net, &p->laddr, ldev, 0)))
929                        pr_warn("%s xmit: Local address not yet configured!\n",
930                                p->name);
931                else if (!ipv6_addr_is_multicast(&p->raddr) &&
932                         unlikely(ipv6_chk_addr(net, &p->raddr, NULL, 0)))
933                        pr_warn("%s xmit: Routing loop! Remote address found on this node!\n",
934                                p->name);
935                else
936                        ret = 1;
937                rcu_read_unlock();
938        }
939        return ret;
940}
941EXPORT_SYMBOL_GPL(ip6_tnl_xmit_ctl);
942
943/**
944 * ip6_tnl_xmit2 - encapsulate packet and send
945 *   @skb: the outgoing socket buffer
946 *   @dev: the outgoing tunnel device
947 *   @dsfield: dscp code for outer header
948 *   @fl: flow of tunneled packet
949 *   @encap_limit: encapsulation limit
950 *   @pmtu: Path MTU is stored if packet is too big
951 *
952 * Description:
953 *   Build new header and do some sanity checks on the packet before sending
954 *   it.
955 *
956 * Return:
957 *   0 on success
958 *   -1 fail
959 *   %-EMSGSIZE message too big. return mtu in this case.
960 **/
961
962static int ip6_tnl_xmit2(struct sk_buff *skb,
963                         struct net_device *dev,
964                         __u8 dsfield,
965                         struct flowi6 *fl6,
966                         int encap_limit,
967                         __u32 *pmtu)
968{
969        struct ip6_tnl *t = netdev_priv(dev);
970        struct net *net = t->net;
971        struct net_device_stats *stats = &t->dev->stats;
972        struct ipv6hdr *ipv6h = ipv6_hdr(skb);
973        struct ipv6_tel_txoption opt;
974        struct dst_entry *dst = NULL, *ndst = NULL;
975        struct net_device *tdev;
976        int mtu;
977        unsigned int max_headroom = sizeof(struct ipv6hdr);
978        u8 proto;
979        int err = -1;
980
981        if (!fl6->flowi6_mark)
982                dst = ip6_tnl_dst_check(t);
983        if (!dst) {
984                ndst = ip6_route_output(net, NULL, fl6);
985
986                if (ndst->error)
987                        goto tx_err_link_failure;
988                ndst = xfrm_lookup(net, ndst, flowi6_to_flowi(fl6), NULL, 0);
989                if (IS_ERR(ndst)) {
990                        err = PTR_ERR(ndst);
991                        ndst = NULL;
992                        goto tx_err_link_failure;
993                }
994                dst = ndst;
995        }
996
997        tdev = dst->dev;
998
999        if (tdev == dev) {
1000                stats->collisions++;
1001                net_warn_ratelimited("%s: Local routing loop detected!\n",
1002                                     t->parms.name);
1003                goto tx_err_dst_release;
1004        }
1005        mtu = dst_mtu(dst) - sizeof(*ipv6h);
1006        if (encap_limit >= 0) {
1007                max_headroom += 8;
1008                mtu -= 8;
1009        }
1010        if (mtu < IPV6_MIN_MTU)
1011                mtu = IPV6_MIN_MTU;
1012        if (skb_dst(skb))
1013                skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
1014        if (skb->len > mtu) {
1015                *pmtu = mtu;
1016                err = -EMSGSIZE;
1017                goto tx_err_dst_release;
1018        }
1019
1020        skb_scrub_packet(skb, !net_eq(t->net, dev_net(dev)));
1021
1022        /*
1023         * Okay, now see if we can stuff it in the buffer as-is.
1024         */
1025        max_headroom += LL_RESERVED_SPACE(tdev);
1026
1027        if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
1028            (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
1029                struct sk_buff *new_skb;
1030
1031                if (!(new_skb = skb_realloc_headroom(skb, max_headroom)))
1032                        goto tx_err_dst_release;
1033
1034                if (skb->sk)
1035                        skb_set_owner_w(new_skb, skb->sk);
1036                consume_skb(skb);
1037                skb = new_skb;
1038        }
1039        if (fl6->flowi6_mark) {
1040                skb_dst_set(skb, dst);
1041                ndst = NULL;
1042        } else {
1043                skb_dst_set_noref(skb, dst);
1044        }
1045        skb->transport_header = skb->network_header;
1046
1047        proto = fl6->flowi6_proto;
1048        if (encap_limit >= 0) {
1049                init_tel_txopt(&opt, encap_limit);
1050                ipv6_push_nfrag_opts(skb, &opt.ops, &proto, NULL);
1051        }
1052
1053        if (likely(!skb->encapsulation)) {
1054                skb_reset_inner_headers(skb);
1055                skb->encapsulation = 1;
1056        }
1057
1058        skb_push(skb, sizeof(struct ipv6hdr));
1059        skb_reset_network_header(skb);
1060        ipv6h = ipv6_hdr(skb);
1061        ip6_flow_hdr(ipv6h, INET_ECN_encapsulate(0, dsfield),
1062                     ip6_make_flowlabel(net, skb, fl6->flowlabel, false));
1063        ipv6h->hop_limit = t->parms.hop_limit;
1064        ipv6h->nexthdr = proto;
1065        ipv6h->saddr = fl6->saddr;
1066        ipv6h->daddr = fl6->daddr;
1067        ip6tunnel_xmit(skb, dev);
1068        if (ndst)
1069                ip6_tnl_dst_store(t, ndst);
1070        return 0;
1071tx_err_link_failure:
1072        stats->tx_carrier_errors++;
1073        dst_link_failure(skb);
1074tx_err_dst_release:
1075        dst_release(ndst);
1076        return err;
1077}
1078
1079static inline int
1080ip4ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
1081{
1082        struct ip6_tnl *t = netdev_priv(dev);
1083        const struct iphdr  *iph = ip_hdr(skb);
1084        int encap_limit = -1;
1085        struct flowi6 fl6;
1086        __u8 dsfield;
1087        __u32 mtu;
1088        int err;
1089
1090        if ((t->parms.proto != IPPROTO_IPIP && t->parms.proto != 0) ||
1091            !ip6_tnl_xmit_ctl(t))
1092                return -1;
1093
1094        if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1095                encap_limit = t->parms.encap_limit;
1096
1097        memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));
1098        fl6.flowi6_proto = IPPROTO_IPIP;
1099
1100        dsfield = ipv4_get_dsfield(iph);
1101
1102        if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
1103                fl6.flowlabel |= htonl((__u32)iph->tos << IPV6_TCLASS_SHIFT)
1104                                          & IPV6_TCLASS_MASK;
1105        if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)
1106                fl6.flowi6_mark = skb->mark;
1107
1108        err = ip6_tnl_xmit2(skb, dev, dsfield, &fl6, encap_limit, &mtu);
1109        if (err != 0) {
1110                /* XXX: send ICMP error even if DF is not set. */
1111                if (err == -EMSGSIZE)
1112                        icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
1113                                  htonl(mtu));
1114                return -1;
1115        }
1116
1117        return 0;
1118}
1119
1120static inline int
1121ip6ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
1122{
1123        struct ip6_tnl *t = netdev_priv(dev);
1124        struct ipv6hdr *ipv6h = ipv6_hdr(skb);
1125        int encap_limit = -1;
1126        __u16 offset;
1127        struct flowi6 fl6;
1128        __u8 dsfield;
1129        __u32 mtu;
1130        int err;
1131
1132        if ((t->parms.proto != IPPROTO_IPV6 && t->parms.proto != 0) ||
1133            !ip6_tnl_xmit_ctl(t) || ip6_tnl_addr_conflict(t, ipv6h))
1134                return -1;
1135
1136        offset = ip6_tnl_parse_tlv_enc_lim(skb, skb_network_header(skb));
1137        if (offset > 0) {
1138                struct ipv6_tlv_tnl_enc_lim *tel;
1139                tel = (struct ipv6_tlv_tnl_enc_lim *)&skb_network_header(skb)[offset];
1140                if (tel->encap_limit == 0) {
1141                        icmpv6_send(skb, ICMPV6_PARAMPROB,
1142                                    ICMPV6_HDR_FIELD, offset + 2);
1143                        return -1;
1144                }
1145                encap_limit = tel->encap_limit - 1;
1146        } else if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1147                encap_limit = t->parms.encap_limit;
1148
1149        memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));
1150        fl6.flowi6_proto = IPPROTO_IPV6;
1151
1152        dsfield = ipv6_get_dsfield(ipv6h);
1153        if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
1154                fl6.flowlabel |= net_hdr_word(ipv6h) & IPV6_TCLASS_MASK;
1155        if (t->parms.flags & IP6_TNL_F_USE_ORIG_FLOWLABEL)
1156                fl6.flowlabel |= ip6_flowlabel(ipv6h);
1157        if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)
1158                fl6.flowi6_mark = skb->mark;
1159
1160        err = ip6_tnl_xmit2(skb, dev, dsfield, &fl6, encap_limit, &mtu);
1161        if (err != 0) {
1162                if (err == -EMSGSIZE)
1163                        icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
1164                return -1;
1165        }
1166
1167        return 0;
1168}
1169
1170static netdev_tx_t
1171ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
1172{
1173        struct ip6_tnl *t = netdev_priv(dev);
1174        struct net_device_stats *stats = &t->dev->stats;
1175        int ret;
1176
1177        switch (skb->protocol) {
1178        case htons(ETH_P_IP):
1179                ret = ip4ip6_tnl_xmit(skb, dev);
1180                break;
1181        case htons(ETH_P_IPV6):
1182                ret = ip6ip6_tnl_xmit(skb, dev);
1183                break;
1184        default:
1185                goto tx_err;
1186        }
1187
1188        if (ret < 0)
1189                goto tx_err;
1190
1191        return NETDEV_TX_OK;
1192
1193tx_err:
1194        stats->tx_errors++;
1195        stats->tx_dropped++;
1196        kfree_skb(skb);
1197        return NETDEV_TX_OK;
1198}
1199
1200static void ip6_tnl_link_config(struct ip6_tnl *t)
1201{
1202        struct net_device *dev = t->dev;
1203        struct __ip6_tnl_parm *p = &t->parms;
1204        struct flowi6 *fl6 = &t->fl.u.ip6;
1205
1206        memcpy(dev->dev_addr, &p->laddr, sizeof(struct in6_addr));
1207        memcpy(dev->broadcast, &p->raddr, sizeof(struct in6_addr));
1208
1209        /* Set up flowi template */
1210        fl6->saddr = p->laddr;
1211        fl6->daddr = p->raddr;
1212        fl6->flowi6_oif = p->link;
1213        fl6->flowlabel = 0;
1214
1215        if (!(p->flags&IP6_TNL_F_USE_ORIG_TCLASS))
1216                fl6->flowlabel |= IPV6_TCLASS_MASK & p->flowinfo;
1217        if (!(p->flags&IP6_TNL_F_USE_ORIG_FLOWLABEL))
1218                fl6->flowlabel |= IPV6_FLOWLABEL_MASK & p->flowinfo;
1219
1220        p->flags &= ~(IP6_TNL_F_CAP_XMIT|IP6_TNL_F_CAP_RCV|IP6_TNL_F_CAP_PER_PACKET);
1221        p->flags |= ip6_tnl_get_cap(t, &p->laddr, &p->raddr);
1222
1223        if (p->flags&IP6_TNL_F_CAP_XMIT && p->flags&IP6_TNL_F_CAP_RCV)
1224                dev->flags |= IFF_POINTOPOINT;
1225        else
1226                dev->flags &= ~IFF_POINTOPOINT;
1227
1228        dev->iflink = p->link;
1229
1230        if (p->flags & IP6_TNL_F_CAP_XMIT) {
1231                int strict = (ipv6_addr_type(&p->raddr) &
1232                              (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));
1233
1234                struct rt6_info *rt = rt6_lookup(t->net,
1235                                                 &p->raddr, &p->laddr,
1236                                                 p->link, strict);
1237
1238                if (rt == NULL)
1239                        return;
1240
1241                if (rt->dst.dev) {
1242                        dev->hard_header_len = rt->dst.dev->hard_header_len +
1243                                sizeof(struct ipv6hdr);
1244
1245                        dev->mtu = rt->dst.dev->mtu - sizeof(struct ipv6hdr);
1246                        if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1247                                dev->mtu -= 8;
1248
1249                        if (dev->mtu < IPV6_MIN_MTU)
1250                                dev->mtu = IPV6_MIN_MTU;
1251                }
1252                ip6_rt_put(rt);
1253        }
1254}
1255
1256/**
1257 * ip6_tnl_change - update the tunnel parameters
1258 *   @t: tunnel to be changed
1259 *   @p: tunnel configuration parameters
1260 *
1261 * Description:
1262 *   ip6_tnl_change() updates the tunnel parameters
1263 **/
1264
1265static int
1266ip6_tnl_change(struct ip6_tnl *t, const struct __ip6_tnl_parm *p)
1267{
1268        t->parms.laddr = p->laddr;
1269        t->parms.raddr = p->raddr;
1270        t->parms.flags = p->flags;
1271        t->parms.hop_limit = p->hop_limit;
1272        t->parms.encap_limit = p->encap_limit;
1273        t->parms.flowinfo = p->flowinfo;
1274        t->parms.link = p->link;
1275        t->parms.proto = p->proto;
1276        ip6_tnl_dst_reset(t);
1277        ip6_tnl_link_config(t);
1278        return 0;
1279}
1280
1281static int ip6_tnl_update(struct ip6_tnl *t, struct __ip6_tnl_parm *p)
1282{
1283        struct net *net = t->net;
1284        struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1285        int err;
1286
1287        ip6_tnl_unlink(ip6n, t);
1288        synchronize_net();
1289        err = ip6_tnl_change(t, p);
1290        ip6_tnl_link(ip6n, t);
1291        netdev_state_change(t->dev);
1292        return err;
1293}
1294
1295static void
1296ip6_tnl_parm_from_user(struct __ip6_tnl_parm *p, const struct ip6_tnl_parm *u)
1297{
1298        p->laddr = u->laddr;
1299        p->raddr = u->raddr;
1300        p->flags = u->flags;
1301        p->hop_limit = u->hop_limit;
1302        p->encap_limit = u->encap_limit;
1303        p->flowinfo = u->flowinfo;
1304        p->link = u->link;
1305        p->proto = u->proto;
1306        memcpy(p->name, u->name, sizeof(u->name));
1307}
1308
1309static void
1310ip6_tnl_parm_to_user(struct ip6_tnl_parm *u, const struct __ip6_tnl_parm *p)
1311{
1312        u->laddr = p->laddr;
1313        u->raddr = p->raddr;
1314        u->flags = p->flags;
1315        u->hop_limit = p->hop_limit;
1316        u->encap_limit = p->encap_limit;
1317        u->flowinfo = p->flowinfo;
1318        u->link = p->link;
1319        u->proto = p->proto;
1320        memcpy(u->name, p->name, sizeof(u->name));
1321}
1322
1323/**
1324 * ip6_tnl_ioctl - configure ipv6 tunnels from userspace
1325 *   @dev: virtual device associated with tunnel
1326 *   @ifr: parameters passed from userspace
1327 *   @cmd: command to be performed
1328 *
1329 * Description:
1330 *   ip6_tnl_ioctl() is used for managing IPv6 tunnels
1331 *   from userspace.
1332 *
1333 *   The possible commands are the following:
1334 *     %SIOCGETTUNNEL: get tunnel parameters for device
1335 *     %SIOCADDTUNNEL: add tunnel matching given tunnel parameters
1336 *     %SIOCCHGTUNNEL: change tunnel parameters to those given
1337 *     %SIOCDELTUNNEL: delete tunnel
1338 *
1339 *   The fallback device "ip6tnl0", created during module
1340 *   initialization, can be used for creating other tunnel devices.
1341 *
1342 * Return:
1343 *   0 on success,
1344 *   %-EFAULT if unable to copy data to or from userspace,
1345 *   %-EPERM if current process hasn't %CAP_NET_ADMIN set
1346 *   %-EINVAL if passed tunnel parameters are invalid,
1347 *   %-EEXIST if changing a tunnel's parameters would cause a conflict
1348 *   %-ENODEV if attempting to change or delete a nonexisting device
1349 **/
1350
1351static int
1352ip6_tnl_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1353{
1354        int err = 0;
1355        struct ip6_tnl_parm p;
1356        struct __ip6_tnl_parm p1;
1357        struct ip6_tnl *t = netdev_priv(dev);
1358        struct net *net = t->net;
1359        struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1360
1361        switch (cmd) {
1362        case SIOCGETTUNNEL:
1363                if (dev == ip6n->fb_tnl_dev) {
1364                        if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1365                                err = -EFAULT;
1366                                break;
1367                        }
1368                        ip6_tnl_parm_from_user(&p1, &p);
1369                        t = ip6_tnl_locate(net, &p1, 0);
1370                        if (t == NULL)
1371                                t = netdev_priv(dev);
1372                } else {
1373                        memset(&p, 0, sizeof(p));
1374                }
1375                ip6_tnl_parm_to_user(&p, &t->parms);
1376                if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p))) {
1377                        err = -EFAULT;
1378                }
1379                break;
1380        case SIOCADDTUNNEL:
1381        case SIOCCHGTUNNEL:
1382                err = -EPERM;
1383                if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1384                        break;
1385                err = -EFAULT;
1386                if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1387                        break;
1388                err = -EINVAL;
1389                if (p.proto != IPPROTO_IPV6 && p.proto != IPPROTO_IPIP &&
1390                    p.proto != 0)
1391                        break;
1392                ip6_tnl_parm_from_user(&p1, &p);
1393                t = ip6_tnl_locate(net, &p1, cmd == SIOCADDTUNNEL);
1394                if (dev != ip6n->fb_tnl_dev && cmd == SIOCCHGTUNNEL) {
1395                        if (t != NULL) {
1396                                if (t->dev != dev) {
1397                                        err = -EEXIST;
1398                                        break;
1399                                }
1400                        } else
1401                                t = netdev_priv(dev);
1402
1403                        err = ip6_tnl_update(t, &p1);
1404                }
1405                if (t) {
1406                        err = 0;
1407                        ip6_tnl_parm_to_user(&p, &t->parms);
1408                        if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
1409                                err = -EFAULT;
1410
1411                } else
1412                        err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1413                break;
1414        case SIOCDELTUNNEL:
1415                err = -EPERM;
1416                if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1417                        break;
1418
1419                if (dev == ip6n->fb_tnl_dev) {
1420                        err = -EFAULT;
1421                        if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1422                                break;
1423                        err = -ENOENT;
1424                        ip6_tnl_parm_from_user(&p1, &p);
1425                        t = ip6_tnl_locate(net, &p1, 0);
1426                        if (t == NULL)
1427                                break;
1428                        err = -EPERM;
1429                        if (t->dev == ip6n->fb_tnl_dev)
1430                                break;
1431                        dev = t->dev;
1432                }
1433                err = 0;
1434                unregister_netdevice(dev);
1435                break;
1436        default:
1437                err = -EINVAL;
1438        }
1439        return err;
1440}
1441
1442/**
1443 * ip6_tnl_change_mtu - change mtu manually for tunnel device
1444 *   @dev: virtual device associated with tunnel
1445 *   @new_mtu: the new mtu
1446 *
1447 * Return:
1448 *   0 on success,
1449 *   %-EINVAL if mtu too small
1450 **/
1451
1452static int
1453ip6_tnl_change_mtu(struct net_device *dev, int new_mtu)
1454{
1455        struct ip6_tnl *tnl = netdev_priv(dev);
1456
1457        if (tnl->parms.proto == IPPROTO_IPIP) {
1458                if (new_mtu < 68)
1459                        return -EINVAL;
1460        } else {
1461                if (new_mtu < IPV6_MIN_MTU)
1462                        return -EINVAL;
1463        }
1464        if (new_mtu > 0xFFF8 - dev->hard_header_len)
1465                return -EINVAL;
1466        dev->mtu = new_mtu;
1467        return 0;
1468}
1469
1470
1471static const struct net_device_ops ip6_tnl_netdev_ops = {
1472        .ndo_init       = ip6_tnl_dev_init,
1473        .ndo_uninit     = ip6_tnl_dev_uninit,
1474        .ndo_start_xmit = ip6_tnl_xmit,
1475        .ndo_do_ioctl   = ip6_tnl_ioctl,
1476        .ndo_change_mtu = ip6_tnl_change_mtu,
1477        .ndo_get_stats  = ip6_get_stats,
1478};
1479
1480
1481/**
1482 * ip6_tnl_dev_setup - setup virtual tunnel device
1483 *   @dev: virtual device associated with tunnel
1484 *
1485 * Description:
1486 *   Initialize function pointers and device parameters
1487 **/
1488
1489static void ip6_tnl_dev_setup(struct net_device *dev)
1490{
1491        struct ip6_tnl *t;
1492
1493        dev->netdev_ops = &ip6_tnl_netdev_ops;
1494        dev->destructor = ip6_dev_free;
1495
1496        dev->type = ARPHRD_TUNNEL6;
1497        dev->hard_header_len = LL_MAX_HEADER + sizeof(struct ipv6hdr);
1498        dev->mtu = ETH_DATA_LEN - sizeof(struct ipv6hdr);
1499        t = netdev_priv(dev);
1500        if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1501                dev->mtu -= 8;
1502        dev->flags |= IFF_NOARP;
1503        dev->addr_len = sizeof(struct in6_addr);
1504        netif_keep_dst(dev);
1505        /* This perm addr will be used as interface identifier by IPv6 */
1506        dev->addr_assign_type = NET_ADDR_RANDOM;
1507        eth_random_addr(dev->perm_addr);
1508}
1509
1510
1511/**
1512 * ip6_tnl_dev_init_gen - general initializer for all tunnel devices
1513 *   @dev: virtual device associated with tunnel
1514 **/
1515
1516static inline int
1517ip6_tnl_dev_init_gen(struct net_device *dev)
1518{
1519        struct ip6_tnl *t = netdev_priv(dev);
1520
1521        t->dev = dev;
1522        t->net = dev_net(dev);
1523        dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1524        if (!dev->tstats)
1525                return -ENOMEM;
1526        return 0;
1527}
1528
1529/**
1530 * ip6_tnl_dev_init - initializer for all non fallback tunnel devices
1531 *   @dev: virtual device associated with tunnel
1532 **/
1533
1534static int ip6_tnl_dev_init(struct net_device *dev)
1535{
1536        struct ip6_tnl *t = netdev_priv(dev);
1537        int err = ip6_tnl_dev_init_gen(dev);
1538
1539        if (err)
1540                return err;
1541        ip6_tnl_link_config(t);
1542        return 0;
1543}
1544
1545/**
1546 * ip6_fb_tnl_dev_init - initializer for fallback tunnel device
1547 *   @dev: fallback device
1548 *
1549 * Return: 0
1550 **/
1551
1552static int __net_init ip6_fb_tnl_dev_init(struct net_device *dev)
1553{
1554        struct ip6_tnl *t = netdev_priv(dev);
1555        struct net *net = dev_net(dev);
1556        struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1557
1558        t->parms.proto = IPPROTO_IPV6;
1559        dev_hold(dev);
1560
1561        rcu_assign_pointer(ip6n->tnls_wc[0], t);
1562        return 0;
1563}
1564
1565static int ip6_tnl_validate(struct nlattr *tb[], struct nlattr *data[])
1566{
1567        u8 proto;
1568
1569        if (!data || !data[IFLA_IPTUN_PROTO])
1570                return 0;
1571
1572        proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1573        if (proto != IPPROTO_IPV6 &&
1574            proto != IPPROTO_IPIP &&
1575            proto != 0)
1576                return -EINVAL;
1577
1578        return 0;
1579}
1580
1581static void ip6_tnl_netlink_parms(struct nlattr *data[],
1582                                  struct __ip6_tnl_parm *parms)
1583{
1584        memset(parms, 0, sizeof(*parms));
1585
1586        if (!data)
1587                return;
1588
1589        if (data[IFLA_IPTUN_LINK])
1590                parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
1591
1592        if (data[IFLA_IPTUN_LOCAL])
1593                nla_memcpy(&parms->laddr, data[IFLA_IPTUN_LOCAL],
1594                           sizeof(struct in6_addr));
1595
1596        if (data[IFLA_IPTUN_REMOTE])
1597                nla_memcpy(&parms->raddr, data[IFLA_IPTUN_REMOTE],
1598                           sizeof(struct in6_addr));
1599
1600        if (data[IFLA_IPTUN_TTL])
1601                parms->hop_limit = nla_get_u8(data[IFLA_IPTUN_TTL]);
1602
1603        if (data[IFLA_IPTUN_ENCAP_LIMIT])
1604                parms->encap_limit = nla_get_u8(data[IFLA_IPTUN_ENCAP_LIMIT]);
1605
1606        if (data[IFLA_IPTUN_FLOWINFO])
1607                parms->flowinfo = nla_get_be32(data[IFLA_IPTUN_FLOWINFO]);
1608
1609        if (data[IFLA_IPTUN_FLAGS])
1610                parms->flags = nla_get_u32(data[IFLA_IPTUN_FLAGS]);
1611
1612        if (data[IFLA_IPTUN_PROTO])
1613                parms->proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1614}
1615
1616static int ip6_tnl_newlink(struct net *src_net, struct net_device *dev,
1617                           struct nlattr *tb[], struct nlattr *data[])
1618{
1619        struct net *net = dev_net(dev);
1620        struct ip6_tnl *nt;
1621
1622        nt = netdev_priv(dev);
1623        ip6_tnl_netlink_parms(data, &nt->parms);
1624
1625        if (ip6_tnl_locate(net, &nt->parms, 0))
1626                return -EEXIST;
1627
1628        return ip6_tnl_create2(dev);
1629}
1630
1631static int ip6_tnl_changelink(struct net_device *dev, struct nlattr *tb[],
1632                              struct nlattr *data[])
1633{
1634        struct ip6_tnl *t = netdev_priv(dev);
1635        struct __ip6_tnl_parm p;
1636        struct net *net = t->net;
1637        struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1638
1639        if (dev == ip6n->fb_tnl_dev)
1640                return -EINVAL;
1641
1642        ip6_tnl_netlink_parms(data, &p);
1643
1644        t = ip6_tnl_locate(net, &p, 0);
1645
1646        if (t) {
1647                if (t->dev != dev)
1648                        return -EEXIST;
1649        } else
1650                t = netdev_priv(dev);
1651
1652        return ip6_tnl_update(t, &p);
1653}
1654
1655static void ip6_tnl_dellink(struct net_device *dev, struct list_head *head)
1656{
1657        struct net *net = dev_net(dev);
1658        struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1659
1660        if (dev != ip6n->fb_tnl_dev)
1661                unregister_netdevice_queue(dev, head);
1662}
1663
1664static size_t ip6_tnl_get_size(const struct net_device *dev)
1665{
1666        return
1667                /* IFLA_IPTUN_LINK */
1668                nla_total_size(4) +
1669                /* IFLA_IPTUN_LOCAL */
1670                nla_total_size(sizeof(struct in6_addr)) +
1671                /* IFLA_IPTUN_REMOTE */
1672                nla_total_size(sizeof(struct in6_addr)) +
1673                /* IFLA_IPTUN_TTL */
1674                nla_total_size(1) +
1675                /* IFLA_IPTUN_ENCAP_LIMIT */
1676                nla_total_size(1) +
1677                /* IFLA_IPTUN_FLOWINFO */
1678                nla_total_size(4) +
1679                /* IFLA_IPTUN_FLAGS */
1680                nla_total_size(4) +
1681                /* IFLA_IPTUN_PROTO */
1682                nla_total_size(1) +
1683                0;
1684}
1685
1686static int ip6_tnl_fill_info(struct sk_buff *skb, const struct net_device *dev)
1687{
1688        struct ip6_tnl *tunnel = netdev_priv(dev);
1689        struct __ip6_tnl_parm *parm = &tunnel->parms;
1690
1691        if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
1692            nla_put(skb, IFLA_IPTUN_LOCAL, sizeof(struct in6_addr),
1693                    &parm->laddr) ||
1694            nla_put(skb, IFLA_IPTUN_REMOTE, sizeof(struct in6_addr),
1695                    &parm->raddr) ||
1696            nla_put_u8(skb, IFLA_IPTUN_TTL, parm->hop_limit) ||
1697            nla_put_u8(skb, IFLA_IPTUN_ENCAP_LIMIT, parm->encap_limit) ||
1698            nla_put_be32(skb, IFLA_IPTUN_FLOWINFO, parm->flowinfo) ||
1699            nla_put_u32(skb, IFLA_IPTUN_FLAGS, parm->flags) ||
1700            nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->proto))
1701                goto nla_put_failure;
1702        return 0;
1703
1704nla_put_failure:
1705        return -EMSGSIZE;
1706}
1707
1708static const struct nla_policy ip6_tnl_policy[IFLA_IPTUN_MAX + 1] = {
1709        [IFLA_IPTUN_LINK]               = { .type = NLA_U32 },
1710        [IFLA_IPTUN_LOCAL]              = { .len = sizeof(struct in6_addr) },
1711        [IFLA_IPTUN_REMOTE]             = { .len = sizeof(struct in6_addr) },
1712        [IFLA_IPTUN_TTL]                = { .type = NLA_U8 },
1713        [IFLA_IPTUN_ENCAP_LIMIT]        = { .type = NLA_U8 },
1714        [IFLA_IPTUN_FLOWINFO]           = { .type = NLA_U32 },
1715        [IFLA_IPTUN_FLAGS]              = { .type = NLA_U32 },
1716        [IFLA_IPTUN_PROTO]              = { .type = NLA_U8 },
1717};
1718
1719static struct rtnl_link_ops ip6_link_ops __read_mostly = {
1720        .kind           = "ip6tnl",
1721        .maxtype        = IFLA_IPTUN_MAX,
1722        .policy         = ip6_tnl_policy,
1723        .priv_size      = sizeof(struct ip6_tnl),
1724        .setup          = ip6_tnl_dev_setup,
1725        .validate       = ip6_tnl_validate,
1726        .newlink        = ip6_tnl_newlink,
1727        .changelink     = ip6_tnl_changelink,
1728        .dellink        = ip6_tnl_dellink,
1729        .get_size       = ip6_tnl_get_size,
1730        .fill_info      = ip6_tnl_fill_info,
1731};
1732
1733static struct xfrm6_tunnel ip4ip6_handler __read_mostly = {
1734        .handler        = ip4ip6_rcv,
1735        .err_handler    = ip4ip6_err,
1736        .priority       =       1,
1737};
1738
1739static struct xfrm6_tunnel ip6ip6_handler __read_mostly = {
1740        .handler        = ip6ip6_rcv,
1741        .err_handler    = ip6ip6_err,
1742        .priority       =       1,
1743};
1744
1745static void __net_exit ip6_tnl_destroy_tunnels(struct net *net)
1746{
1747        struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1748        struct net_device *dev, *aux;
1749        int h;
1750        struct ip6_tnl *t;
1751        LIST_HEAD(list);
1752
1753        for_each_netdev_safe(net, dev, aux)
1754                if (dev->rtnl_link_ops == &ip6_link_ops)
1755                        unregister_netdevice_queue(dev, &list);
1756
1757        for (h = 0; h < HASH_SIZE; h++) {
1758                t = rtnl_dereference(ip6n->tnls_r_l[h]);
1759                while (t != NULL) {
1760                        /* If dev is in the same netns, it has already
1761                         * been added to the list by the previous loop.
1762                         */
1763                        if (!net_eq(dev_net(t->dev), net))
1764                                unregister_netdevice_queue(t->dev, &list);
1765                        t = rtnl_dereference(t->next);
1766                }
1767        }
1768
1769        unregister_netdevice_many(&list);
1770}
1771
1772static int __net_init ip6_tnl_init_net(struct net *net)
1773{
1774        struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1775        struct ip6_tnl *t = NULL;
1776        int err;
1777
1778        ip6n->tnls[0] = ip6n->tnls_wc;
1779        ip6n->tnls[1] = ip6n->tnls_r_l;
1780
1781        err = -ENOMEM;
1782        ip6n->fb_tnl_dev = alloc_netdev(sizeof(struct ip6_tnl), "ip6tnl0",
1783                                        NET_NAME_UNKNOWN, ip6_tnl_dev_setup);
1784
1785        if (!ip6n->fb_tnl_dev)
1786                goto err_alloc_dev;
1787        dev_net_set(ip6n->fb_tnl_dev, net);
1788        ip6n->fb_tnl_dev->rtnl_link_ops = &ip6_link_ops;
1789        /* FB netdevice is special: we have one, and only one per netns.
1790         * Allowing to move it to another netns is clearly unsafe.
1791         */
1792        ip6n->fb_tnl_dev->features |= NETIF_F_NETNS_LOCAL;
1793
1794        err = ip6_fb_tnl_dev_init(ip6n->fb_tnl_dev);
1795        if (err < 0)
1796                goto err_register;
1797
1798        err = register_netdev(ip6n->fb_tnl_dev);
1799        if (err < 0)
1800                goto err_register;
1801
1802        t = netdev_priv(ip6n->fb_tnl_dev);
1803
1804        strcpy(t->parms.name, ip6n->fb_tnl_dev->name);
1805        return 0;
1806
1807err_register:
1808        ip6_dev_free(ip6n->fb_tnl_dev);
1809err_alloc_dev:
1810        return err;
1811}
1812
1813static void __net_exit ip6_tnl_exit_net(struct net *net)
1814{
1815        rtnl_lock();
1816        ip6_tnl_destroy_tunnels(net);
1817        rtnl_unlock();
1818}
1819
1820static struct pernet_operations ip6_tnl_net_ops = {
1821        .init = ip6_tnl_init_net,
1822        .exit = ip6_tnl_exit_net,
1823        .id   = &ip6_tnl_net_id,
1824        .size = sizeof(struct ip6_tnl_net),
1825};
1826
1827/**
1828 * ip6_tunnel_init - register protocol and reserve needed resources
1829 *
1830 * Return: 0 on success
1831 **/
1832
1833static int __init ip6_tunnel_init(void)
1834{
1835        int  err;
1836
1837        err = register_pernet_device(&ip6_tnl_net_ops);
1838        if (err < 0)
1839                goto out_pernet;
1840
1841        err = xfrm6_tunnel_register(&ip4ip6_handler, AF_INET);
1842        if (err < 0) {
1843                pr_err("%s: can't register ip4ip6\n", __func__);
1844                goto out_ip4ip6;
1845        }
1846
1847        err = xfrm6_tunnel_register(&ip6ip6_handler, AF_INET6);
1848        if (err < 0) {
1849                pr_err("%s: can't register ip6ip6\n", __func__);
1850                goto out_ip6ip6;
1851        }
1852        err = rtnl_link_register(&ip6_link_ops);
1853        if (err < 0)
1854                goto rtnl_link_failed;
1855
1856        return 0;
1857
1858rtnl_link_failed:
1859        xfrm6_tunnel_deregister(&ip6ip6_handler, AF_INET6);
1860out_ip6ip6:
1861        xfrm6_tunnel_deregister(&ip4ip6_handler, AF_INET);
1862out_ip4ip6:
1863        unregister_pernet_device(&ip6_tnl_net_ops);
1864out_pernet:
1865        return err;
1866}
1867
1868/**
1869 * ip6_tunnel_cleanup - free resources and unregister protocol
1870 **/
1871
1872static void __exit ip6_tunnel_cleanup(void)
1873{
1874        rtnl_link_unregister(&ip6_link_ops);
1875        if (xfrm6_tunnel_deregister(&ip4ip6_handler, AF_INET))
1876                pr_info("%s: can't deregister ip4ip6\n", __func__);
1877
1878        if (xfrm6_tunnel_deregister(&ip6ip6_handler, AF_INET6))
1879                pr_info("%s: can't deregister ip6ip6\n", __func__);
1880
1881        unregister_pernet_device(&ip6_tnl_net_ops);
1882}
1883
1884module_init(ip6_tunnel_init);
1885module_exit(ip6_tunnel_cleanup);
Note: See TracBrowser for help on using the repository browser.