ppp: Use a real SKB control block in fragmentation engine.
[deliverable/linux.git] / net / ipv6 / ip6_tunnel.c
CommitLineData
1da177e4 1/*
c4d3efaf 2 * IPv6 tunneling device
1da177e4
LT
3 * Linux INET6 implementation
4 *
5 * Authors:
1ab1457c 6 * Ville Nuorvala <vnuorval@tcs.hut.fi>
c4d3efaf 7 * Yasuyuki Kozakai <kozakai@linux-ipv6.org>
1da177e4 8 *
1da177e4 9 * Based on:
c4d3efaf 10 * linux/net/ipv6/sit.c and linux/net/ipv4/ipip.c
1da177e4
LT
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
1da177e4 21#include <linux/module.h>
4fc268d2 22#include <linux/capability.h>
1da177e4
LT
23#include <linux/errno.h>
24#include <linux/types.h>
25#include <linux/sockios.h>
c4d3efaf 26#include <linux/icmp.h>
1da177e4
LT
27#include <linux/if.h>
28#include <linux/in.h>
29#include <linux/ip.h>
30#include <linux/if_tunnel.h>
31#include <linux/net.h>
32#include <linux/in6.h>
33#include <linux/netdevice.h>
34#include <linux/if_arp.h>
35#include <linux/icmpv6.h>
36#include <linux/init.h>
37#include <linux/route.h>
38#include <linux/rtnetlink.h>
39#include <linux/netfilter_ipv6.h>
5a0e3ad6 40#include <linux/slab.h>
1da177e4
LT
41
42#include <asm/uaccess.h>
43#include <asm/atomic.h>
44
c4d3efaf 45#include <net/icmp.h>
1da177e4
LT
46#include <net/ip.h>
47#include <net/ipv6.h>
1da177e4
LT
48#include <net/ip6_route.h>
49#include <net/addrconf.h>
50#include <net/ip6_tunnel.h>
51#include <net/xfrm.h>
52#include <net/dsfield.h>
53#include <net/inet_ecn.h>
13eeb8e9
PE
54#include <net/net_namespace.h>
55#include <net/netns/generic.h>
1da177e4
LT
56
57MODULE_AUTHOR("Ville Nuorvala");
c4d3efaf 58MODULE_DESCRIPTION("IPv6 tunneling device");
1da177e4
LT
59MODULE_LICENSE("GPL");
60
61#define IPV6_TLV_TEL_DST_SIZE 8
62
63#ifdef IP6_TNL_DEBUG
0dc47877 64#define IP6_TNL_TRACE(x...) printk(KERN_DEBUG "%s:" x "\n", __func__)
1da177e4
LT
65#else
66#define IP6_TNL_TRACE(x...) do {;} while(0)
67#endif
68
69#define IPV6_TCLASS_MASK (IPV6_FLOWINFO_MASK & ~IPV6_FLOWLABEL_MASK)
c4d3efaf 70#define IPV6_TCLASS_SHIFT 20
1da177e4
LT
71
72#define HASH_SIZE 32
73
e69a4adc 74#define HASH(addr) ((__force u32)((addr)->s6_addr32[0] ^ (addr)->s6_addr32[1] ^ \
1ab1457c
YH
75 (addr)->s6_addr32[2] ^ (addr)->s6_addr32[3]) & \
76 (HASH_SIZE - 1))
1da177e4 77
8560f226 78static int ip6_tnl_dev_init(struct net_device *dev);
3144581c 79static void ip6_tnl_dev_setup(struct net_device *dev);
1da177e4 80
f99189b1 81static int ip6_tnl_net_id __read_mostly;
13eeb8e9 82struct ip6_tnl_net {
15820e12
PE
83 /* the IPv6 tunnel fallback device */
84 struct net_device *fb_tnl_dev;
3e6c9fb5 85 /* lists for storing tunnels in use */
94767632
ED
86 struct ip6_tnl __rcu *tnls_r_l[HASH_SIZE];
87 struct ip6_tnl __rcu *tnls_wc[1];
88 struct ip6_tnl __rcu **tnls[2];
13eeb8e9
PE
89};
90
8560f226
ED
91/* often modified stats are per cpu, other are shared (netdev->stats) */
92struct pcpu_tstats {
93 unsigned long rx_packets;
94 unsigned long rx_bytes;
95 unsigned long tx_packets;
96 unsigned long tx_bytes;
97};
98
99static struct net_device_stats *ip6_get_stats(struct net_device *dev)
100{
101 struct pcpu_tstats sum = { 0 };
102 int i;
103
104 for_each_possible_cpu(i) {
105 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
106
107 sum.rx_packets += tstats->rx_packets;
108 sum.rx_bytes += tstats->rx_bytes;
109 sum.tx_packets += tstats->tx_packets;
110 sum.tx_bytes += tstats->tx_bytes;
111 }
112 dev->stats.rx_packets = sum.rx_packets;
113 dev->stats.rx_bytes = sum.rx_bytes;
114 dev->stats.tx_packets = sum.tx_packets;
115 dev->stats.tx_bytes = sum.tx_bytes;
116 return &dev->stats;
117}
118
2922bc8a 119/*
94767632 120 * Locking : hash tables are protected by RCU and RTNL
2922bc8a 121 */
1da177e4
LT
122
123static inline struct dst_entry *ip6_tnl_dst_check(struct ip6_tnl *t)
124{
125 struct dst_entry *dst = t->dst_cache;
126
1ab1457c 127 if (dst && dst->obsolete &&
1da177e4
LT
128 dst->ops->check(dst, t->dst_cookie) == NULL) {
129 t->dst_cache = NULL;
130 dst_release(dst);
131 return NULL;
132 }
133
134 return dst;
135}
136
137static inline void ip6_tnl_dst_reset(struct ip6_tnl *t)
138{
139 dst_release(t->dst_cache);
140 t->dst_cache = NULL;
141}
142
143static inline void ip6_tnl_dst_store(struct ip6_tnl *t, struct dst_entry *dst)
144{
145 struct rt6_info *rt = (struct rt6_info *) dst;
146 t->dst_cookie = rt->rt6i_node ? rt->rt6i_node->fn_sernum : 0;
147 dst_release(t->dst_cache);
148 t->dst_cache = dst;
149}
150
151/**
3144581c 152 * ip6_tnl_lookup - fetch tunnel matching the end-point addresses
1ab1457c
YH
153 * @remote: the address of the tunnel exit-point
154 * @local: the address of the tunnel entry-point
1da177e4 155 *
1ab1457c 156 * Return:
1da177e4 157 * tunnel matching given end-points if found,
1ab1457c 158 * else fallback tunnel if its device is up,
1da177e4
LT
159 * else %NULL
160 **/
161
2922bc8a
ED
162#define for_each_ip6_tunnel_rcu(start) \
163 for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))
164
1da177e4 165static struct ip6_tnl *
2dd02c89 166ip6_tnl_lookup(struct net *net, struct in6_addr *remote, struct in6_addr *local)
1da177e4 167{
94767632
ED
168 unsigned int h0 = HASH(remote);
169 unsigned int h1 = HASH(local);
1da177e4 170 struct ip6_tnl *t;
3e6c9fb5 171 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1da177e4 172
2922bc8a 173 for_each_ip6_tunnel_rcu(ip6n->tnls_r_l[h0 ^ h1]) {
1da177e4
LT
174 if (ipv6_addr_equal(local, &t->parms.laddr) &&
175 ipv6_addr_equal(remote, &t->parms.raddr) &&
176 (t->dev->flags & IFF_UP))
177 return t;
178 }
2922bc8a
ED
179 t = rcu_dereference(ip6n->tnls_wc[0]);
180 if (t && (t->dev->flags & IFF_UP))
1da177e4
LT
181 return t;
182
183 return NULL;
184}
185
186/**
3144581c 187 * ip6_tnl_bucket - get head of list matching given tunnel parameters
1ab1457c 188 * @p: parameters containing tunnel end-points
1da177e4
LT
189 *
190 * Description:
3144581c 191 * ip6_tnl_bucket() returns the head of the list matching the
1da177e4
LT
192 * &struct in6_addr entries laddr and raddr in @p.
193 *
1ab1457c 194 * Return: head of IPv6 tunnel list
1da177e4
LT
195 **/
196
94767632 197static struct ip6_tnl __rcu **
2dd02c89 198ip6_tnl_bucket(struct ip6_tnl_net *ip6n, struct ip6_tnl_parm *p)
1da177e4
LT
199{
200 struct in6_addr *remote = &p->raddr;
201 struct in6_addr *local = &p->laddr;
202 unsigned h = 0;
203 int prio = 0;
204
205 if (!ipv6_addr_any(remote) || !ipv6_addr_any(local)) {
206 prio = 1;
207 h = HASH(remote) ^ HASH(local);
208 }
3e6c9fb5 209 return &ip6n->tnls[prio][h];
1da177e4
LT
210}
211
212/**
3144581c 213 * ip6_tnl_link - add tunnel to hash table
1da177e4
LT
214 * @t: tunnel to be added
215 **/
216
217static void
2dd02c89 218ip6_tnl_link(struct ip6_tnl_net *ip6n, struct ip6_tnl *t)
1da177e4 219{
94767632 220 struct ip6_tnl __rcu **tp = ip6_tnl_bucket(ip6n, &t->parms);
1da177e4 221
94767632 222 rcu_assign_pointer(t->next , rtnl_dereference(*tp));
2922bc8a 223 rcu_assign_pointer(*tp, t);
1da177e4
LT
224}
225
226/**
3144581c 227 * ip6_tnl_unlink - remove tunnel from hash table
1da177e4
LT
228 * @t: tunnel to be removed
229 **/
230
231static void
2dd02c89 232ip6_tnl_unlink(struct ip6_tnl_net *ip6n, struct ip6_tnl *t)
1da177e4 233{
94767632
ED
234 struct ip6_tnl __rcu **tp;
235 struct ip6_tnl *iter;
236
237 for (tp = ip6_tnl_bucket(ip6n, &t->parms);
238 (iter = rtnl_dereference(*tp)) != NULL;
239 tp = &iter->next) {
240 if (t == iter) {
241 rcu_assign_pointer(*tp, t->next);
1da177e4
LT
242 break;
243 }
244 }
245}
246
8560f226
ED
247static void ip6_dev_free(struct net_device *dev)
248{
249 free_percpu(dev->tstats);
250 free_netdev(dev);
251}
252
1da177e4
LT
253/**
254 * ip6_tnl_create() - create a new tunnel
255 * @p: tunnel parameters
256 * @pt: pointer to new tunnel
257 *
258 * Description:
259 * Create tunnel matching given parameters.
1ab1457c
YH
260 *
261 * Return:
567131a7 262 * created tunnel or NULL
1da177e4
LT
263 **/
264
2dd02c89 265static struct ip6_tnl *ip6_tnl_create(struct net *net, struct ip6_tnl_parm *p)
1da177e4
LT
266{
267 struct net_device *dev;
268 struct ip6_tnl *t;
269 char name[IFNAMSIZ];
270 int err;
2dd02c89 271 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1da177e4 272
34cc7ba6 273 if (p->name[0])
1da177e4 274 strlcpy(name, p->name, IFNAMSIZ);
34cc7ba6
PE
275 else
276 sprintf(name, "ip6tnl%%d");
277
3144581c 278 dev = alloc_netdev(sizeof (*t), name, ip6_tnl_dev_setup);
1da177e4 279 if (dev == NULL)
567131a7 280 goto failed;
1da177e4 281
554eb277
PE
282 dev_net_set(dev, net);
283
b37d428b
PE
284 if (strchr(name, '%')) {
285 if (dev_alloc_name(dev, name) < 0)
286 goto failed_free;
287 }
288
2941a486 289 t = netdev_priv(dev);
1da177e4 290 t->parms = *p;
8560f226
ED
291 err = ip6_tnl_dev_init(dev);
292 if (err < 0)
293 goto failed_free;
1da177e4 294
b37d428b
PE
295 if ((err = register_netdevice(dev)) < 0)
296 goto failed_free;
297
1da177e4 298 dev_hold(dev);
2dd02c89 299 ip6_tnl_link(ip6n, t);
567131a7 300 return t;
b37d428b
PE
301
302failed_free:
8560f226 303 ip6_dev_free(dev);
567131a7
VN
304failed:
305 return NULL;
1da177e4
LT
306}
307
308/**
3144581c 309 * ip6_tnl_locate - find or create tunnel matching given parameters
1ab1457c 310 * @p: tunnel parameters
1da177e4
LT
311 * @create: != 0 if allowed to create new tunnel if no match found
312 *
313 * Description:
3144581c 314 * ip6_tnl_locate() first tries to locate an existing tunnel
1da177e4
LT
315 * based on @parms. If this is unsuccessful, but @create is set a new
316 * tunnel device is created and registered for use.
317 *
318 * Return:
567131a7 319 * matching tunnel or NULL
1da177e4
LT
320 **/
321
2dd02c89
PE
322static struct ip6_tnl *ip6_tnl_locate(struct net *net,
323 struct ip6_tnl_parm *p, int create)
1da177e4
LT
324{
325 struct in6_addr *remote = &p->raddr;
326 struct in6_addr *local = &p->laddr;
94767632 327 struct ip6_tnl __rcu **tp;
1da177e4 328 struct ip6_tnl *t;
2dd02c89 329 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1da177e4 330
94767632
ED
331 for (tp = ip6_tnl_bucket(ip6n, p);
332 (t = rtnl_dereference(*tp)) != NULL;
333 tp = &t->next) {
1da177e4 334 if (ipv6_addr_equal(local, &t->parms.laddr) &&
567131a7
VN
335 ipv6_addr_equal(remote, &t->parms.raddr))
336 return t;
1da177e4
LT
337 }
338 if (!create)
567131a7 339 return NULL;
2dd02c89 340 return ip6_tnl_create(net, p);
1da177e4
LT
341}
342
343/**
3144581c 344 * ip6_tnl_dev_uninit - tunnel device uninitializer
1da177e4 345 * @dev: the device to be destroyed
1ab1457c 346 *
1da177e4 347 * Description:
3144581c 348 * ip6_tnl_dev_uninit() removes tunnel from its list
1da177e4
LT
349 **/
350
351static void
3144581c 352ip6_tnl_dev_uninit(struct net_device *dev)
1da177e4 353{
2941a486 354 struct ip6_tnl *t = netdev_priv(dev);
2dd02c89
PE
355 struct net *net = dev_net(dev);
356 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1da177e4 357
94767632
ED
358 if (dev == ip6n->fb_tnl_dev)
359 rcu_assign_pointer(ip6n->tnls_wc[0], NULL);
360 else
2dd02c89 361 ip6_tnl_unlink(ip6n, t);
1da177e4
LT
362 ip6_tnl_dst_reset(t);
363 dev_put(dev);
364}
365
366/**
367 * parse_tvl_tnl_enc_lim - handle encapsulation limit option
368 * @skb: received socket buffer
369 *
1ab1457c
YH
370 * Return:
371 * 0 if none was found,
1da177e4
LT
372 * else index to encapsulation limit
373 **/
374
375static __u16
376parse_tlv_tnl_enc_lim(struct sk_buff *skb, __u8 * raw)
377{
378 struct ipv6hdr *ipv6h = (struct ipv6hdr *) raw;
379 __u8 nexthdr = ipv6h->nexthdr;
380 __u16 off = sizeof (*ipv6h);
381
382 while (ipv6_ext_hdr(nexthdr) && nexthdr != NEXTHDR_NONE) {
383 __u16 optlen = 0;
384 struct ipv6_opt_hdr *hdr;
385 if (raw + off + sizeof (*hdr) > skb->data &&
386 !pskb_may_pull(skb, raw - skb->data + off + sizeof (*hdr)))
387 break;
388
389 hdr = (struct ipv6_opt_hdr *) (raw + off);
390 if (nexthdr == NEXTHDR_FRAGMENT) {
391 struct frag_hdr *frag_hdr = (struct frag_hdr *) hdr;
392 if (frag_hdr->frag_off)
393 break;
394 optlen = 8;
395 } else if (nexthdr == NEXTHDR_AUTH) {
396 optlen = (hdr->hdrlen + 2) << 2;
397 } else {
398 optlen = ipv6_optlen(hdr);
399 }
400 if (nexthdr == NEXTHDR_DEST) {
401 __u16 i = off + 2;
402 while (1) {
403 struct ipv6_tlv_tnl_enc_lim *tel;
404
405 /* No more room for encapsulation limit */
406 if (i + sizeof (*tel) > off + optlen)
407 break;
408
409 tel = (struct ipv6_tlv_tnl_enc_lim *) &raw[i];
410 /* return index of option if found and valid */
411 if (tel->type == IPV6_TLV_TNL_ENCAP_LIMIT &&
412 tel->length == 1)
413 return i;
414 /* else jump to next option */
415 if (tel->type)
416 i += tel->length + 2;
417 else
418 i++;
419 }
420 }
421 nexthdr = hdr->nexthdr;
422 off += optlen;
423 }
424 return 0;
425}
426
427/**
e490d1d8 428 * ip6_tnl_err - tunnel error handler
1da177e4
LT
429 *
430 * Description:
e490d1d8 431 * ip6_tnl_err() should handle errors in the tunnel according
1da177e4
LT
432 * to the specifications in RFC 2473.
433 **/
434
d2acc347 435static int
502b0935 436ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt,
d5fdd6ba 437 u8 *type, u8 *code, int *msg, __u32 *info, int offset)
1da177e4
LT
438{
439 struct ipv6hdr *ipv6h = (struct ipv6hdr *) skb->data;
440 struct ip6_tnl *t;
441 int rel_msg = 0;
d5fdd6ba
BH
442 u8 rel_type = ICMPV6_DEST_UNREACH;
443 u8 rel_code = ICMPV6_ADDR_UNREACH;
1da177e4
LT
444 __u32 rel_info = 0;
445 __u16 len;
d2acc347 446 int err = -ENOENT;
1da177e4 447
1ab1457c
YH
448 /* If the packet doesn't contain the original IPv6 header we are
449 in trouble since we might need the source address for further
1da177e4
LT
450 processing of the error. */
451
2922bc8a 452 rcu_read_lock();
8704ca7e 453 if ((t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->daddr,
2dd02c89 454 &ipv6h->saddr)) == NULL)
1da177e4
LT
455 goto out;
456
502b0935
YK
457 if (t->parms.proto != ipproto && t->parms.proto != 0)
458 goto out;
459
d2acc347
HX
460 err = 0;
461
e490d1d8 462 switch (*type) {
1da177e4
LT
463 __u32 teli;
464 struct ipv6_tlv_tnl_enc_lim *tel;
465 __u32 mtu;
466 case ICMPV6_DEST_UNREACH:
467 if (net_ratelimit())
468 printk(KERN_WARNING
469 "%s: Path to destination invalid "
470 "or inactive!\n", t->parms.name);
471 rel_msg = 1;
472 break;
473 case ICMPV6_TIME_EXCEED:
e490d1d8 474 if ((*code) == ICMPV6_EXC_HOPLIMIT) {
1da177e4
LT
475 if (net_ratelimit())
476 printk(KERN_WARNING
477 "%s: Too small hop limit or "
1ab1457c 478 "routing loop in tunnel!\n",
1da177e4
LT
479 t->parms.name);
480 rel_msg = 1;
481 }
482 break;
483 case ICMPV6_PARAMPROB:
107a5fe6 484 teli = 0;
e490d1d8 485 if ((*code) == ICMPV6_HDR_FIELD)
107a5fe6 486 teli = parse_tlv_tnl_enc_lim(skb, skb->data);
1da177e4 487
704eae1f 488 if (teli && teli == *info - 2) {
1da177e4
LT
489 tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->data[teli];
490 if (tel->encap_limit == 0) {
491 if (net_ratelimit())
492 printk(KERN_WARNING
493 "%s: Too small encapsulation "
494 "limit or routing loop in "
495 "tunnel!\n", t->parms.name);
496 rel_msg = 1;
497 }
107a5fe6
VN
498 } else if (net_ratelimit()) {
499 printk(KERN_WARNING
500 "%s: Recipient unable to parse tunneled "
501 "packet!\n ", t->parms.name);
1da177e4
LT
502 }
503 break;
504 case ICMPV6_PKT_TOOBIG:
704eae1f 505 mtu = *info - offset;
1da177e4
LT
506 if (mtu < IPV6_MIN_MTU)
507 mtu = IPV6_MIN_MTU;
508 t->dev->mtu = mtu;
509
cc6cdac0 510 if ((len = sizeof (*ipv6h) + ntohs(ipv6h->payload_len)) > mtu) {
1da177e4
LT
511 rel_type = ICMPV6_PKT_TOOBIG;
512 rel_code = 0;
513 rel_info = mtu;
514 rel_msg = 1;
515 }
516 break;
517 }
e490d1d8
YK
518
519 *type = rel_type;
520 *code = rel_code;
521 *info = rel_info;
522 *msg = rel_msg;
523
524out:
2922bc8a 525 rcu_read_unlock();
e490d1d8
YK
526 return err;
527}
528
c4d3efaf
YK
529static int
530ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
d5fdd6ba 531 u8 type, u8 code, int offset, __be32 info)
c4d3efaf
YK
532{
533 int rel_msg = 0;
d5fdd6ba
BH
534 u8 rel_type = type;
535 u8 rel_code = code;
704eae1f 536 __u32 rel_info = ntohl(info);
c4d3efaf
YK
537 int err;
538 struct sk_buff *skb2;
539 struct iphdr *eiph;
540 struct flowi fl;
541 struct rtable *rt;
542
502b0935
YK
543 err = ip6_tnl_err(skb, IPPROTO_IPIP, opt, &rel_type, &rel_code,
544 &rel_msg, &rel_info, offset);
c4d3efaf
YK
545 if (err < 0)
546 return err;
547
548 if (rel_msg == 0)
549 return 0;
550
551 switch (rel_type) {
552 case ICMPV6_DEST_UNREACH:
553 if (rel_code != ICMPV6_ADDR_UNREACH)
554 return 0;
555 rel_type = ICMP_DEST_UNREACH;
556 rel_code = ICMP_HOST_UNREACH;
557 break;
558 case ICMPV6_PKT_TOOBIG:
559 if (rel_code != 0)
560 return 0;
561 rel_type = ICMP_DEST_UNREACH;
562 rel_code = ICMP_FRAG_NEEDED;
563 break;
564 default:
565 return 0;
566 }
567
568 if (!pskb_may_pull(skb, offset + sizeof(struct iphdr)))
569 return 0;
570
571 skb2 = skb_clone(skb, GFP_ATOMIC);
572 if (!skb2)
573 return 0;
574
adf30907
ED
575 skb_dst_drop(skb2);
576
c4d3efaf 577 skb_pull(skb2, offset);
c1d2bbe1 578 skb_reset_network_header(skb2);
eddc9ec5 579 eiph = ip_hdr(skb2);
c4d3efaf
YK
580
581 /* Try to guess incoming interface */
582 memset(&fl, 0, sizeof(fl));
583 fl.fl4_dst = eiph->saddr;
584 fl.fl4_tos = RT_TOS(eiph->tos);
585 fl.proto = IPPROTO_IPIP;
2f7f54b7 586 if (ip_route_output_key(dev_net(skb->dev), &rt, &fl))
c4d3efaf
YK
587 goto out;
588
d8d1f30b 589 skb2->dev = rt->dst.dev;
c4d3efaf
YK
590
591 /* route "incoming" packet */
592 if (rt->rt_flags & RTCF_LOCAL) {
593 ip_rt_put(rt);
594 rt = NULL;
595 fl.fl4_dst = eiph->daddr;
596 fl.fl4_src = eiph->saddr;
597 fl.fl4_tos = eiph->tos;
2f7f54b7 598 if (ip_route_output_key(dev_net(skb->dev), &rt, &fl) ||
d8d1f30b 599 rt->dst.dev->type != ARPHRD_TUNNEL) {
c4d3efaf
YK
600 ip_rt_put(rt);
601 goto out;
602 }
adf30907 603 skb_dst_set(skb2, (struct dst_entry *)rt);
c4d3efaf
YK
604 } else {
605 ip_rt_put(rt);
606 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos,
607 skb2->dev) ||
adf30907 608 skb_dst(skb2)->dev->type != ARPHRD_TUNNEL)
c4d3efaf
YK
609 goto out;
610 }
611
612 /* change mtu on this route */
613 if (rel_type == ICMP_DEST_UNREACH && rel_code == ICMP_FRAG_NEEDED) {
adf30907 614 if (rel_info > dst_mtu(skb_dst(skb2)))
c4d3efaf
YK
615 goto out;
616
adf30907 617 skb_dst(skb2)->ops->update_pmtu(skb_dst(skb2), rel_info);
c4d3efaf
YK
618 }
619
704eae1f 620 icmp_send(skb2, rel_type, rel_code, htonl(rel_info));
c4d3efaf
YK
621
622out:
623 kfree_skb(skb2);
624 return 0;
625}
626
e490d1d8
YK
627static int
628ip6ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
d5fdd6ba 629 u8 type, u8 code, int offset, __be32 info)
e490d1d8
YK
630{
631 int rel_msg = 0;
d5fdd6ba
BH
632 u8 rel_type = type;
633 u8 rel_code = code;
704eae1f 634 __u32 rel_info = ntohl(info);
e490d1d8
YK
635 int err;
636
502b0935
YK
637 err = ip6_tnl_err(skb, IPPROTO_IPV6, opt, &rel_type, &rel_code,
638 &rel_msg, &rel_info, offset);
e490d1d8
YK
639 if (err < 0)
640 return err;
641
642 if (rel_msg && pskb_may_pull(skb, offset + sizeof(struct ipv6hdr))) {
1da177e4
LT
643 struct rt6_info *rt;
644 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
305d4b3c 645
1da177e4 646 if (!skb2)
e490d1d8 647 return 0;
1da177e4 648
adf30907 649 skb_dst_drop(skb2);
1da177e4 650 skb_pull(skb2, offset);
c1d2bbe1 651 skb_reset_network_header(skb2);
1da177e4
LT
652
653 /* Try to guess incoming interface */
2f7f54b7
PE
654 rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr,
655 NULL, 0, 0);
1da177e4
LT
656
657 if (rt && rt->rt6i_dev)
658 skb2->dev = rt->rt6i_dev;
659
3ffe533c 660 icmpv6_send(skb2, rel_type, rel_code, rel_info);
1da177e4
LT
661
662 if (rt)
d8d1f30b 663 dst_release(&rt->dst);
1da177e4
LT
664
665 kfree_skb(skb2);
666 }
e490d1d8
YK
667
668 return 0;
1da177e4
LT
669}
670
c4d3efaf
YK
671static void ip4ip6_dscp_ecn_decapsulate(struct ip6_tnl *t,
672 struct ipv6hdr *ipv6h,
673 struct sk_buff *skb)
674{
675 __u8 dsfield = ipv6_get_dsfield(ipv6h) & ~INET_ECN_MASK;
676
677 if (t->parms.flags & IP6_TNL_F_RCV_DSCP_COPY)
eddc9ec5 678 ipv4_change_dsfield(ip_hdr(skb), INET_ECN_MASK, dsfield);
c4d3efaf
YK
679
680 if (INET_ECN_is_ce(dsfield))
eddc9ec5 681 IP_ECN_set_ce(ip_hdr(skb));
c4d3efaf
YK
682}
683
8359925b
YK
684static void ip6ip6_dscp_ecn_decapsulate(struct ip6_tnl *t,
685 struct ipv6hdr *ipv6h,
686 struct sk_buff *skb)
1da177e4 687{
8359925b 688 if (t->parms.flags & IP6_TNL_F_RCV_DSCP_COPY)
29bb43b4 689 ipv6_copy_dscp(ipv6_get_dsfield(ipv6h), ipv6_hdr(skb));
1da177e4 690
8359925b 691 if (INET_ECN_is_ce(ipv6_get_dsfield(ipv6h)))
0660e03f 692 IP6_ECN_set_ce(ipv6_hdr(skb));
1da177e4 693}
8359925b 694
f1a28eab 695/* called with rcu_read_lock() */
09c6bbf0
VN
696static inline int ip6_tnl_rcv_ctl(struct ip6_tnl *t)
697{
698 struct ip6_tnl_parm *p = &t->parms;
699 int ret = 0;
2f7f54b7 700 struct net *net = dev_net(t->dev);
09c6bbf0
VN
701
702 if (p->flags & IP6_TNL_F_CAP_RCV) {
1ab1457c 703 struct net_device *ldev = NULL;
09c6bbf0
VN
704
705 if (p->link)
f1a28eab 706 ldev = dev_get_by_index_rcu(net, p->link);
09c6bbf0
VN
707
708 if ((ipv6_addr_is_multicast(&p->laddr) ||
2f7f54b7
PE
709 likely(ipv6_chk_addr(net, &p->laddr, ldev, 0))) &&
710 likely(!ipv6_chk_addr(net, &p->raddr, NULL, 0)))
09c6bbf0
VN
711 ret = 1;
712
09c6bbf0
VN
713 }
714 return ret;
715}
1da177e4
LT
716
717/**
3144581c 718 * ip6_tnl_rcv - decapsulate IPv6 packet and retransmit it locally
1da177e4 719 * @skb: received socket buffer
8359925b
YK
720 * @protocol: ethernet protocol ID
721 * @dscp_ecn_decapsulate: the function to decapsulate DSCP code and ECN
1da177e4
LT
722 *
723 * Return: 0
724 **/
725
8359925b 726static int ip6_tnl_rcv(struct sk_buff *skb, __u16 protocol,
502b0935 727 __u8 ipproto,
8359925b
YK
728 void (*dscp_ecn_decapsulate)(struct ip6_tnl *t,
729 struct ipv6hdr *ipv6h,
730 struct sk_buff *skb))
1da177e4 731{
1da177e4 732 struct ip6_tnl *t;
0660e03f 733 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
1da177e4 734
2922bc8a 735 rcu_read_lock();
1da177e4 736
8704ca7e 737 if ((t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->saddr,
2dd02c89 738 &ipv6h->daddr)) != NULL) {
8560f226
ED
739 struct pcpu_tstats *tstats;
740
502b0935 741 if (t->parms.proto != ipproto && t->parms.proto != 0) {
2922bc8a 742 rcu_read_unlock();
502b0935
YK
743 goto discard;
744 }
745
1da177e4 746 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
2922bc8a 747 rcu_read_unlock();
50fba2aa 748 goto discard;
1da177e4
LT
749 }
750
09c6bbf0 751 if (!ip6_tnl_rcv_ctl(t)) {
3dca02af 752 t->dev->stats.rx_dropped++;
2922bc8a 753 rcu_read_unlock();
1da177e4
LT
754 goto discard;
755 }
756 secpath_reset(skb);
b0e380b1 757 skb->mac_header = skb->network_header;
c1d2bbe1 758 skb_reset_network_header(skb);
8359925b 759 skb->protocol = htons(protocol);
1da177e4
LT
760 skb->pkt_type = PACKET_HOST;
761 memset(skb->cb, 0, sizeof(struct inet6_skb_parm));
8359925b 762
8560f226
ED
763 tstats = this_cpu_ptr(t->dev->tstats);
764 tstats->rx_packets++;
765 tstats->rx_bytes += skb->len;
766
767 __skb_tunnel_rx(skb, t->dev);
8359925b 768
d19d56dd 769 dscp_ecn_decapsulate(t, ipv6h, skb);
8990f468
ED
770
771 if (netif_rx(skb) == NET_RX_DROP)
772 t->dev->stats.rx_dropped++;
773
2922bc8a 774 rcu_read_unlock();
1da177e4
LT
775 return 0;
776 }
2922bc8a 777 rcu_read_unlock();
1da177e4 778 return 1;
50fba2aa
HX
779
780discard:
781 kfree_skb(skb);
782 return 0;
1da177e4
LT
783}
784
c4d3efaf
YK
785static int ip4ip6_rcv(struct sk_buff *skb)
786{
502b0935
YK
787 return ip6_tnl_rcv(skb, ETH_P_IP, IPPROTO_IPIP,
788 ip4ip6_dscp_ecn_decapsulate);
c4d3efaf
YK
789}
790
8359925b
YK
791static int ip6ip6_rcv(struct sk_buff *skb)
792{
502b0935
YK
793 return ip6_tnl_rcv(skb, ETH_P_IPV6, IPPROTO_IPV6,
794 ip6ip6_dscp_ecn_decapsulate);
8359925b
YK
795}
796
6fb32dde
VN
797struct ipv6_tel_txoption {
798 struct ipv6_txoptions ops;
799 __u8 dst_opt[8];
800};
1da177e4 801
6fb32dde
VN
802static void init_tel_txopt(struct ipv6_tel_txoption *opt, __u8 encap_limit)
803{
804 memset(opt, 0, sizeof(struct ipv6_tel_txoption));
1da177e4 805
6fb32dde
VN
806 opt->dst_opt[2] = IPV6_TLV_TNL_ENCAP_LIMIT;
807 opt->dst_opt[3] = 1;
808 opt->dst_opt[4] = encap_limit;
809 opt->dst_opt[5] = IPV6_TLV_PADN;
810 opt->dst_opt[6] = 1;
1da177e4 811
6fb32dde
VN
812 opt->ops.dst0opt = (struct ipv6_opt_hdr *) opt->dst_opt;
813 opt->ops.opt_nflen = 8;
1da177e4
LT
814}
815
816/**
3144581c 817 * ip6_tnl_addr_conflict - compare packet addresses to tunnel's own
1da177e4 818 * @t: the outgoing tunnel device
1ab1457c 819 * @hdr: IPv6 header from the incoming packet
1da177e4
LT
820 *
821 * Description:
1ab1457c 822 * Avoid trivial tunneling loop by checking that tunnel exit-point
1da177e4
LT
823 * doesn't match source of incoming packet.
824 *
1ab1457c 825 * Return:
1da177e4
LT
826 * 1 if conflict,
827 * 0 else
828 **/
829
830static inline int
3144581c 831ip6_tnl_addr_conflict(struct ip6_tnl *t, struct ipv6hdr *hdr)
1da177e4
LT
832{
833 return ipv6_addr_equal(&t->parms.raddr, &hdr->saddr);
834}
835
09c6bbf0
VN
836static inline int ip6_tnl_xmit_ctl(struct ip6_tnl *t)
837{
838 struct ip6_tnl_parm *p = &t->parms;
839 int ret = 0;
2f7f54b7 840 struct net *net = dev_net(t->dev);
09c6bbf0 841
1ab1457c 842 if (p->flags & IP6_TNL_F_CAP_XMIT) {
09c6bbf0
VN
843 struct net_device *ldev = NULL;
844
f1a28eab 845 rcu_read_lock();
09c6bbf0 846 if (p->link)
f1a28eab 847 ldev = dev_get_by_index_rcu(net, p->link);
09c6bbf0 848
2f7f54b7 849 if (unlikely(!ipv6_chk_addr(net, &p->laddr, ldev, 0)))
09c6bbf0
VN
850 printk(KERN_WARNING
851 "%s xmit: Local address not yet configured!\n",
852 p->name);
853 else if (!ipv6_addr_is_multicast(&p->raddr) &&
2f7f54b7 854 unlikely(ipv6_chk_addr(net, &p->raddr, NULL, 0)))
09c6bbf0
VN
855 printk(KERN_WARNING
856 "%s xmit: Routing loop! "
857 "Remote address found on this node!\n",
858 p->name);
859 else
860 ret = 1;
f1a28eab 861 rcu_read_unlock();
09c6bbf0
VN
862 }
863 return ret;
864}
1da177e4 865/**
61ec2aec 866 * ip6_tnl_xmit2 - encapsulate packet and send
1da177e4 867 * @skb: the outgoing socket buffer
1ab1457c 868 * @dev: the outgoing tunnel device
61ec2aec
YK
869 * @dsfield: dscp code for outer header
870 * @fl: flow of tunneled packet
871 * @encap_limit: encapsulation limit
872 * @pmtu: Path MTU is stored if packet is too big
1da177e4
LT
873 *
874 * Description:
875 * Build new header and do some sanity checks on the packet before sending
876 * it.
877 *
1ab1457c 878 * Return:
c4d3efaf 879 * 0 on success
61ec2aec
YK
880 * -1 fail
881 * %-EMSGSIZE message too big. return mtu in this case.
1da177e4
LT
882 **/
883
61ec2aec
YK
884static int ip6_tnl_xmit2(struct sk_buff *skb,
885 struct net_device *dev,
886 __u8 dsfield,
887 struct flowi *fl,
888 int encap_limit,
889 __u32 *pmtu)
1da177e4 890{
52479b62 891 struct net *net = dev_net(dev);
2941a486 892 struct ip6_tnl *t = netdev_priv(dev);
3dca02af 893 struct net_device_stats *stats = &t->dev->stats;
0660e03f 894 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
6fb32dde 895 struct ipv6_tel_txoption opt;
1da177e4
LT
896 struct dst_entry *dst;
897 struct net_device *tdev;
898 int mtu;
c2636b4d 899 unsigned int max_headroom = sizeof(struct ipv6hdr);
1da177e4 900 u8 proto;
61ec2aec 901 int err = -1;
1da177e4 902 int pkt_len;
1da177e4 903
1da177e4
LT
904 if ((dst = ip6_tnl_dst_check(t)) != NULL)
905 dst_hold(dst);
a57ebc90 906 else {
52479b62 907 dst = ip6_route_output(net, NULL, fl);
1da177e4 908
52479b62 909 if (dst->error || xfrm_lookup(net, &dst, fl, NULL, 0) < 0)
a57ebc90
PM
910 goto tx_err_link_failure;
911 }
1da177e4
LT
912
913 tdev = dst->dev;
914
915 if (tdev == dev) {
916 stats->collisions++;
917 if (net_ratelimit())
1ab1457c 918 printk(KERN_WARNING
1da177e4
LT
919 "%s: Local routing loop detected!\n",
920 t->parms.name);
921 goto tx_err_dst_release;
922 }
923 mtu = dst_mtu(dst) - sizeof (*ipv6h);
6fb32dde 924 if (encap_limit >= 0) {
1da177e4
LT
925 max_headroom += 8;
926 mtu -= 8;
927 }
928 if (mtu < IPV6_MIN_MTU)
929 mtu = IPV6_MIN_MTU;
adf30907
ED
930 if (skb_dst(skb))
931 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
1da177e4 932 if (skb->len > mtu) {
61ec2aec
YK
933 *pmtu = mtu;
934 err = -EMSGSIZE;
1da177e4
LT
935 goto tx_err_dst_release;
936 }
937
938 /*
939 * Okay, now see if we can stuff it in the buffer as-is.
940 */
941 max_headroom += LL_RESERVED_SPACE(tdev);
1ab1457c 942
cfbba49d
PM
943 if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
944 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
1da177e4 945 struct sk_buff *new_skb;
1ab1457c 946
1da177e4
LT
947 if (!(new_skb = skb_realloc_headroom(skb, max_headroom)))
948 goto tx_err_dst_release;
949
950 if (skb->sk)
951 skb_set_owner_w(new_skb, skb->sk);
952 kfree_skb(skb);
953 skb = new_skb;
954 }
adf30907
ED
955 skb_dst_drop(skb);
956 skb_dst_set(skb, dst_clone(dst));
1da177e4 957
b0e380b1 958 skb->transport_header = skb->network_header;
1da177e4 959
61ec2aec 960 proto = fl->proto;
6fb32dde
VN
961 if (encap_limit >= 0) {
962 init_tel_txopt(&opt, encap_limit);
963 ipv6_push_nfrag_opts(skb, &opt.ops, &proto, NULL);
964 }
e2d1bca7
ACM
965 skb_push(skb, sizeof(struct ipv6hdr));
966 skb_reset_network_header(skb);
0660e03f 967 ipv6h = ipv6_hdr(skb);
61ec2aec 968 *(__be32*)ipv6h = fl->fl6_flowlabel | htonl(0x60000000);
1da177e4
LT
969 dsfield = INET_ECN_encapsulate(0, dsfield);
970 ipv6_change_dsfield(ipv6h, ~INET_ECN_MASK, dsfield);
1da177e4
LT
971 ipv6h->hop_limit = t->parms.hop_limit;
972 ipv6h->nexthdr = proto;
61ec2aec
YK
973 ipv6_addr_copy(&ipv6h->saddr, &fl->fl6_src);
974 ipv6_addr_copy(&ipv6h->daddr, &fl->fl6_dst);
1da177e4
LT
975 nf_reset(skb);
976 pkt_len = skb->len;
ef76bc23 977 err = ip6_local_out(skb);
1da177e4 978
b9df3cb8 979 if (net_xmit_eval(err) == 0) {
8560f226
ED
980 struct pcpu_tstats *tstats = this_cpu_ptr(t->dev->tstats);
981
982 tstats->tx_bytes += pkt_len;
983 tstats->tx_packets++;
1da177e4
LT
984 } else {
985 stats->tx_errors++;
986 stats->tx_aborted_errors++;
987 }
988 ip6_tnl_dst_store(t, dst);
1da177e4
LT
989 return 0;
990tx_err_link_failure:
991 stats->tx_carrier_errors++;
992 dst_link_failure(skb);
993tx_err_dst_release:
994 dst_release(dst);
61ec2aec
YK
995 return err;
996}
997
c4d3efaf
YK
998static inline int
999ip4ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
1000{
1001 struct ip6_tnl *t = netdev_priv(dev);
eddc9ec5 1002 struct iphdr *iph = ip_hdr(skb);
c4d3efaf
YK
1003 int encap_limit = -1;
1004 struct flowi fl;
1005 __u8 dsfield;
1006 __u32 mtu;
1007 int err;
1008
502b0935
YK
1009 if ((t->parms.proto != IPPROTO_IPIP && t->parms.proto != 0) ||
1010 !ip6_tnl_xmit_ctl(t))
c4d3efaf
YK
1011 return -1;
1012
1013 if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1014 encap_limit = t->parms.encap_limit;
1015
1016 memcpy(&fl, &t->fl, sizeof (fl));
1017 fl.proto = IPPROTO_IPIP;
1018
1019 dsfield = ipv4_get_dsfield(iph);
1020
1021 if ((t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS))
b77f2fa6
AV
1022 fl.fl6_flowlabel |= htonl((__u32)iph->tos << IPV6_TCLASS_SHIFT)
1023 & IPV6_TCLASS_MASK;
c4d3efaf
YK
1024
1025 err = ip6_tnl_xmit2(skb, dev, dsfield, &fl, encap_limit, &mtu);
1026 if (err != 0) {
1027 /* XXX: send ICMP error even if DF is not set. */
1028 if (err == -EMSGSIZE)
1029 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
1030 htonl(mtu));
1031 return -1;
1032 }
1033
1034 return 0;
1035}
1036
61ec2aec
YK
1037static inline int
1038ip6ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
1039{
1040 struct ip6_tnl *t = netdev_priv(dev);
0660e03f 1041 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
61ec2aec
YK
1042 int encap_limit = -1;
1043 __u16 offset;
1044 struct flowi fl;
1045 __u8 dsfield;
1046 __u32 mtu;
1047 int err;
1048
502b0935
YK
1049 if ((t->parms.proto != IPPROTO_IPV6 && t->parms.proto != 0) ||
1050 !ip6_tnl_xmit_ctl(t) || ip6_tnl_addr_conflict(t, ipv6h))
61ec2aec
YK
1051 return -1;
1052
d56f90a7
ACM
1053 offset = parse_tlv_tnl_enc_lim(skb, skb_network_header(skb));
1054 if (offset > 0) {
61ec2aec 1055 struct ipv6_tlv_tnl_enc_lim *tel;
d56f90a7 1056 tel = (struct ipv6_tlv_tnl_enc_lim *)&skb_network_header(skb)[offset];
61ec2aec
YK
1057 if (tel->encap_limit == 0) {
1058 icmpv6_send(skb, ICMPV6_PARAMPROB,
3ffe533c 1059 ICMPV6_HDR_FIELD, offset + 2);
61ec2aec
YK
1060 return -1;
1061 }
1062 encap_limit = tel->encap_limit - 1;
1063 } else if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1064 encap_limit = t->parms.encap_limit;
1065
1066 memcpy(&fl, &t->fl, sizeof (fl));
1067 fl.proto = IPPROTO_IPV6;
1068
1069 dsfield = ipv6_get_dsfield(ipv6h);
1070 if ((t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS))
1071 fl.fl6_flowlabel |= (*(__be32 *) ipv6h & IPV6_TCLASS_MASK);
1072 if ((t->parms.flags & IP6_TNL_F_USE_ORIG_FLOWLABEL))
1073 fl.fl6_flowlabel |= (*(__be32 *) ipv6h & IPV6_FLOWLABEL_MASK);
1074
1075 err = ip6_tnl_xmit2(skb, dev, dsfield, &fl, encap_limit, &mtu);
1076 if (err != 0) {
1077 if (err == -EMSGSIZE)
3ffe533c 1078 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
61ec2aec
YK
1079 return -1;
1080 }
1081
1082 return 0;
1083}
1084
6fef4c0c 1085static netdev_tx_t
61ec2aec
YK
1086ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
1087{
1088 struct ip6_tnl *t = netdev_priv(dev);
3dca02af 1089 struct net_device_stats *stats = &t->dev->stats;
61ec2aec
YK
1090 int ret;
1091
61ec2aec 1092 switch (skb->protocol) {
60678040 1093 case htons(ETH_P_IP):
c4d3efaf
YK
1094 ret = ip4ip6_tnl_xmit(skb, dev);
1095 break;
60678040 1096 case htons(ETH_P_IPV6):
61ec2aec
YK
1097 ret = ip6ip6_tnl_xmit(skb, dev);
1098 break;
1099 default:
1100 goto tx_err;
1101 }
1102
1103 if (ret < 0)
1104 goto tx_err;
1105
6ed10654 1106 return NETDEV_TX_OK;
61ec2aec 1107
1da177e4
LT
1108tx_err:
1109 stats->tx_errors++;
1110 stats->tx_dropped++;
1111 kfree_skb(skb);
6ed10654 1112 return NETDEV_TX_OK;
1da177e4
LT
1113}
1114
1115static void ip6_tnl_set_cap(struct ip6_tnl *t)
1116{
1117 struct ip6_tnl_parm *p = &t->parms;
09c6bbf0
VN
1118 int ltype = ipv6_addr_type(&p->laddr);
1119 int rtype = ipv6_addr_type(&p->raddr);
1da177e4
LT
1120
1121 p->flags &= ~(IP6_TNL_F_CAP_XMIT|IP6_TNL_F_CAP_RCV);
1122
09c6bbf0
VN
1123 if (ltype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
1124 rtype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
1125 !((ltype|rtype) & IPV6_ADDR_LOOPBACK) &&
305d4b3c 1126 (!((ltype|rtype) & IPV6_ADDR_LINKLOCAL) || p->link)) {
09c6bbf0
VN
1127 if (ltype&IPV6_ADDR_UNICAST)
1128 p->flags |= IP6_TNL_F_CAP_XMIT;
1129 if (rtype&IPV6_ADDR_UNICAST)
1130 p->flags |= IP6_TNL_F_CAP_RCV;
1da177e4
LT
1131 }
1132}
1133
3144581c 1134static void ip6_tnl_link_config(struct ip6_tnl *t)
1da177e4
LT
1135{
1136 struct net_device *dev = t->dev;
1137 struct ip6_tnl_parm *p = &t->parms;
1138 struct flowi *fl = &t->fl;
1139
3a6d54c5
JP
1140 memcpy(dev->dev_addr, &p->laddr, sizeof(struct in6_addr));
1141 memcpy(dev->broadcast, &p->raddr, sizeof(struct in6_addr));
1da177e4
LT
1142
1143 /* Set up flowi template */
1144 ipv6_addr_copy(&fl->fl6_src, &p->laddr);
1145 ipv6_addr_copy(&fl->fl6_dst, &p->raddr);
1146 fl->oif = p->link;
1147 fl->fl6_flowlabel = 0;
1148
1149 if (!(p->flags&IP6_TNL_F_USE_ORIG_TCLASS))
1150 fl->fl6_flowlabel |= IPV6_TCLASS_MASK & p->flowinfo;
1151 if (!(p->flags&IP6_TNL_F_USE_ORIG_FLOWLABEL))
1152 fl->fl6_flowlabel |= IPV6_FLOWLABEL_MASK & p->flowinfo;
1153
1154 ip6_tnl_set_cap(t);
1155
1156 if (p->flags&IP6_TNL_F_CAP_XMIT && p->flags&IP6_TNL_F_CAP_RCV)
1157 dev->flags |= IFF_POINTOPOINT;
1158 else
1159 dev->flags &= ~IFF_POINTOPOINT;
1160
1161 dev->iflink = p->link;
1162
1163 if (p->flags & IP6_TNL_F_CAP_XMIT) {
305d4b3c
VN
1164 int strict = (ipv6_addr_type(&p->raddr) &
1165 (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));
1166
2f7f54b7
PE
1167 struct rt6_info *rt = rt6_lookup(dev_net(dev),
1168 &p->raddr, &p->laddr,
305d4b3c 1169 p->link, strict);
1da177e4
LT
1170
1171 if (rt == NULL)
1172 return;
1173
1174 if (rt->rt6i_dev) {
1175 dev->hard_header_len = rt->rt6i_dev->hard_header_len +
1176 sizeof (struct ipv6hdr);
1177
1178 dev->mtu = rt->rt6i_dev->mtu - sizeof (struct ipv6hdr);
1179
1180 if (dev->mtu < IPV6_MIN_MTU)
1181 dev->mtu = IPV6_MIN_MTU;
1182 }
d8d1f30b 1183 dst_release(&rt->dst);
1da177e4
LT
1184 }
1185}
1186
1187/**
3144581c 1188 * ip6_tnl_change - update the tunnel parameters
1da177e4
LT
1189 * @t: tunnel to be changed
1190 * @p: tunnel configuration parameters
1da177e4
LT
1191 *
1192 * Description:
3144581c 1193 * ip6_tnl_change() updates the tunnel parameters
1da177e4
LT
1194 **/
1195
1196static int
3144581c 1197ip6_tnl_change(struct ip6_tnl *t, struct ip6_tnl_parm *p)
1da177e4
LT
1198{
1199 ipv6_addr_copy(&t->parms.laddr, &p->laddr);
1200 ipv6_addr_copy(&t->parms.raddr, &p->raddr);
1201 t->parms.flags = p->flags;
1202 t->parms.hop_limit = p->hop_limit;
1203 t->parms.encap_limit = p->encap_limit;
1204 t->parms.flowinfo = p->flowinfo;
8181b8c1 1205 t->parms.link = p->link;
502b0935 1206 t->parms.proto = p->proto;
0c088890 1207 ip6_tnl_dst_reset(t);
3144581c 1208 ip6_tnl_link_config(t);
1da177e4
LT
1209 return 0;
1210}
1211
1212/**
3144581c 1213 * ip6_tnl_ioctl - configure ipv6 tunnels from userspace
1da177e4
LT
1214 * @dev: virtual device associated with tunnel
1215 * @ifr: parameters passed from userspace
1216 * @cmd: command to be performed
1217 *
1218 * Description:
3144581c 1219 * ip6_tnl_ioctl() is used for managing IPv6 tunnels
1ab1457c 1220 * from userspace.
1da177e4
LT
1221 *
1222 * The possible commands are the following:
1223 * %SIOCGETTUNNEL: get tunnel parameters for device
1224 * %SIOCADDTUNNEL: add tunnel matching given tunnel parameters
1225 * %SIOCCHGTUNNEL: change tunnel parameters to those given
1226 * %SIOCDELTUNNEL: delete tunnel
1227 *
1ab1457c 1228 * The fallback device "ip6tnl0", created during module
1da177e4
LT
1229 * initialization, can be used for creating other tunnel devices.
1230 *
1231 * Return:
1232 * 0 on success,
1233 * %-EFAULT if unable to copy data to or from userspace,
1234 * %-EPERM if current process hasn't %CAP_NET_ADMIN set
1235 * %-EINVAL if passed tunnel parameters are invalid,
1236 * %-EEXIST if changing a tunnel's parameters would cause a conflict
1237 * %-ENODEV if attempting to change or delete a nonexisting device
1238 **/
1239
1240static int
3144581c 1241ip6_tnl_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1da177e4
LT
1242{
1243 int err = 0;
1da177e4
LT
1244 struct ip6_tnl_parm p;
1245 struct ip6_tnl *t = NULL;
2dd02c89
PE
1246 struct net *net = dev_net(dev);
1247 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1da177e4
LT
1248
1249 switch (cmd) {
1250 case SIOCGETTUNNEL:
15820e12 1251 if (dev == ip6n->fb_tnl_dev) {
567131a7 1252 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof (p))) {
1da177e4
LT
1253 err = -EFAULT;
1254 break;
1255 }
2dd02c89 1256 t = ip6_tnl_locate(net, &p, 0);
567131a7
VN
1257 }
1258 if (t == NULL)
2941a486 1259 t = netdev_priv(dev);
1da177e4
LT
1260 memcpy(&p, &t->parms, sizeof (p));
1261 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof (p))) {
1262 err = -EFAULT;
1263 }
1264 break;
1265 case SIOCADDTUNNEL:
1266 case SIOCCHGTUNNEL:
1267 err = -EPERM;
1da177e4
LT
1268 if (!capable(CAP_NET_ADMIN))
1269 break;
567131a7
VN
1270 err = -EFAULT;
1271 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof (p)))
1da177e4 1272 break;
567131a7 1273 err = -EINVAL;
502b0935
YK
1274 if (p.proto != IPPROTO_IPV6 && p.proto != IPPROTO_IPIP &&
1275 p.proto != 0)
1da177e4 1276 break;
2dd02c89 1277 t = ip6_tnl_locate(net, &p, cmd == SIOCADDTUNNEL);
15820e12 1278 if (dev != ip6n->fb_tnl_dev && cmd == SIOCCHGTUNNEL) {
567131a7
VN
1279 if (t != NULL) {
1280 if (t->dev != dev) {
1281 err = -EEXIST;
1282 break;
1283 }
1284 } else
1285 t = netdev_priv(dev);
1286
2dd02c89 1287 ip6_tnl_unlink(ip6n, t);
3144581c 1288 err = ip6_tnl_change(t, &p);
2dd02c89 1289 ip6_tnl_link(ip6n, t);
1da177e4
LT
1290 netdev_state_change(dev);
1291 }
567131a7 1292 if (t) {
1da177e4 1293 err = 0;
567131a7
VN
1294 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof (p)))
1295 err = -EFAULT;
1296
1297 } else
1298 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1da177e4
LT
1299 break;
1300 case SIOCDELTUNNEL:
1301 err = -EPERM;
1302 if (!capable(CAP_NET_ADMIN))
1303 break;
1304
15820e12 1305 if (dev == ip6n->fb_tnl_dev) {
567131a7
VN
1306 err = -EFAULT;
1307 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof (p)))
1da177e4 1308 break;
567131a7 1309 err = -ENOENT;
2dd02c89 1310 if ((t = ip6_tnl_locate(net, &p, 0)) == NULL)
1da177e4 1311 break;
567131a7 1312 err = -EPERM;
15820e12 1313 if (t->dev == ip6n->fb_tnl_dev)
1da177e4 1314 break;
567131a7 1315 dev = t->dev;
1da177e4 1316 }
22f8cde5
SH
1317 err = 0;
1318 unregister_netdevice(dev);
1da177e4
LT
1319 break;
1320 default:
1321 err = -EINVAL;
1322 }
1323 return err;
1324}
1325
1da177e4 1326/**
3144581c 1327 * ip6_tnl_change_mtu - change mtu manually for tunnel device
1da177e4
LT
1328 * @dev: virtual device associated with tunnel
1329 * @new_mtu: the new mtu
1330 *
1331 * Return:
1332 * 0 on success,
1333 * %-EINVAL if mtu too small
1334 **/
1335
1336static int
3144581c 1337ip6_tnl_change_mtu(struct net_device *dev, int new_mtu)
1da177e4
LT
1338{
1339 if (new_mtu < IPV6_MIN_MTU) {
1340 return -EINVAL;
1341 }
1342 dev->mtu = new_mtu;
1343 return 0;
1344}
1345
1326c3d5
SH
1346
1347static const struct net_device_ops ip6_tnl_netdev_ops = {
8560f226 1348 .ndo_uninit = ip6_tnl_dev_uninit,
1326c3d5 1349 .ndo_start_xmit = ip6_tnl_xmit,
8560f226 1350 .ndo_do_ioctl = ip6_tnl_ioctl,
1326c3d5 1351 .ndo_change_mtu = ip6_tnl_change_mtu,
8560f226 1352 .ndo_get_stats = ip6_get_stats,
1326c3d5
SH
1353};
1354
8560f226 1355
1da177e4 1356/**
3144581c 1357 * ip6_tnl_dev_setup - setup virtual tunnel device
1da177e4
LT
1358 * @dev: virtual device associated with tunnel
1359 *
1360 * Description:
1361 * Initialize function pointers and device parameters
1362 **/
1363
3144581c 1364static void ip6_tnl_dev_setup(struct net_device *dev)
1da177e4 1365{
1326c3d5 1366 dev->netdev_ops = &ip6_tnl_netdev_ops;
8560f226 1367 dev->destructor = ip6_dev_free;
1da177e4
LT
1368
1369 dev->type = ARPHRD_TUNNEL6;
1370 dev->hard_header_len = LL_MAX_HEADER + sizeof (struct ipv6hdr);
1371 dev->mtu = ETH_DATA_LEN - sizeof (struct ipv6hdr);
1372 dev->flags |= IFF_NOARP;
1373 dev->addr_len = sizeof(struct in6_addr);
554eb277 1374 dev->features |= NETIF_F_NETNS_LOCAL;
1da177e4
LT
1375}
1376
1377
1378/**
3144581c 1379 * ip6_tnl_dev_init_gen - general initializer for all tunnel devices
1da177e4
LT
1380 * @dev: virtual device associated with tunnel
1381 **/
1382
8560f226 1383static inline int
3144581c 1384ip6_tnl_dev_init_gen(struct net_device *dev)
1da177e4 1385{
2941a486 1386 struct ip6_tnl *t = netdev_priv(dev);
8560f226 1387
1da177e4
LT
1388 t->dev = dev;
1389 strcpy(t->parms.name, dev->name);
8560f226
ED
1390 dev->tstats = alloc_percpu(struct pcpu_tstats);
1391 if (!dev->tstats)
1392 return -ENOMEM;
1393 return 0;
1da177e4
LT
1394}
1395
1396/**
3144581c 1397 * ip6_tnl_dev_init - initializer for all non fallback tunnel devices
1da177e4
LT
1398 * @dev: virtual device associated with tunnel
1399 **/
1400
8560f226 1401static int ip6_tnl_dev_init(struct net_device *dev)
1da177e4 1402{
2941a486 1403 struct ip6_tnl *t = netdev_priv(dev);
8560f226
ED
1404 int err = ip6_tnl_dev_init_gen(dev);
1405
1406 if (err)
1407 return err;
3144581c 1408 ip6_tnl_link_config(t);
8560f226 1409 return 0;
1da177e4
LT
1410}
1411
1412/**
3144581c 1413 * ip6_fb_tnl_dev_init - initializer for fallback tunnel device
1da177e4
LT
1414 * @dev: fallback device
1415 *
1416 * Return: 0
1417 **/
1418
8560f226 1419static int __net_init ip6_fb_tnl_dev_init(struct net_device *dev)
1da177e4 1420{
2941a486 1421 struct ip6_tnl *t = netdev_priv(dev);
3e6c9fb5
PE
1422 struct net *net = dev_net(dev);
1423 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
8560f226
ED
1424 int err = ip6_tnl_dev_init_gen(dev);
1425
1426 if (err)
1427 return err;
3e6c9fb5 1428
502b0935 1429 t->parms.proto = IPPROTO_IPV6;
1da177e4 1430 dev_hold(dev);
94767632 1431 rcu_assign_pointer(ip6n->tnls_wc[0], t);
8560f226 1432 return 0;
1da177e4
LT
1433}
1434
3ff2cfa5 1435static struct xfrm6_tunnel ip4ip6_handler __read_mostly = {
c4d3efaf
YK
1436 .handler = ip4ip6_rcv,
1437 .err_handler = ip4ip6_err,
1438 .priority = 1,
1439};
1440
3ff2cfa5 1441static struct xfrm6_tunnel ip6ip6_handler __read_mostly = {
0303770d
PM
1442 .handler = ip6ip6_rcv,
1443 .err_handler = ip6ip6_err,
d2acc347 1444 .priority = 1,
1da177e4
LT
1445};
1446
2c8c1e72 1447static void __net_exit ip6_tnl_destroy_tunnels(struct ip6_tnl_net *ip6n)
3e6c9fb5
PE
1448{
1449 int h;
1450 struct ip6_tnl *t;
cf4432f5 1451 LIST_HEAD(list);
3e6c9fb5
PE
1452
1453 for (h = 0; h < HASH_SIZE; h++) {
94767632 1454 t = rtnl_dereference(ip6n->tnls_r_l[h]);
cf4432f5
ED
1455 while (t != NULL) {
1456 unregister_netdevice_queue(t->dev, &list);
94767632 1457 t = rtnl_dereference(t->next);
cf4432f5 1458 }
3e6c9fb5
PE
1459 }
1460
94767632 1461 t = rtnl_dereference(ip6n->tnls_wc[0]);
cf4432f5
ED
1462 unregister_netdevice_queue(t->dev, &list);
1463 unregister_netdevice_many(&list);
3e6c9fb5
PE
1464}
1465
2c8c1e72 1466static int __net_init ip6_tnl_init_net(struct net *net)
13eeb8e9 1467{
ac31cd3c 1468 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
13eeb8e9 1469 int err;
13eeb8e9 1470
3e6c9fb5
PE
1471 ip6n->tnls[0] = ip6n->tnls_wc;
1472 ip6n->tnls[1] = ip6n->tnls_r_l;
1473
15820e12
PE
1474 err = -ENOMEM;
1475 ip6n->fb_tnl_dev = alloc_netdev(sizeof(struct ip6_tnl), "ip6tnl0",
1476 ip6_tnl_dev_setup);
1477
1478 if (!ip6n->fb_tnl_dev)
1479 goto err_alloc_dev;
be77e593 1480 dev_net_set(ip6n->fb_tnl_dev, net);
15820e12 1481
8560f226
ED
1482 err = ip6_fb_tnl_dev_init(ip6n->fb_tnl_dev);
1483 if (err < 0)
1484 goto err_register;
15820e12
PE
1485
1486 err = register_netdev(ip6n->fb_tnl_dev);
1487 if (err < 0)
1488 goto err_register;
13eeb8e9
PE
1489 return 0;
1490
15820e12 1491err_register:
8560f226 1492 ip6_dev_free(ip6n->fb_tnl_dev);
15820e12 1493err_alloc_dev:
13eeb8e9
PE
1494 return err;
1495}
1496
2c8c1e72 1497static void __net_exit ip6_tnl_exit_net(struct net *net)
13eeb8e9 1498{
ac31cd3c 1499 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
13eeb8e9 1500
3e6c9fb5
PE
1501 rtnl_lock();
1502 ip6_tnl_destroy_tunnels(ip6n);
1503 rtnl_unlock();
13eeb8e9
PE
1504}
1505
1506static struct pernet_operations ip6_tnl_net_ops = {
1507 .init = ip6_tnl_init_net,
1508 .exit = ip6_tnl_exit_net,
ac31cd3c
EB
1509 .id = &ip6_tnl_net_id,
1510 .size = sizeof(struct ip6_tnl_net),
13eeb8e9
PE
1511};
1512
1da177e4
LT
1513/**
1514 * ip6_tunnel_init - register protocol and reserve needed resources
1515 *
1516 * Return: 0 on success
1517 **/
1518
1519static int __init ip6_tunnel_init(void)
1520{
1521 int err;
1522
d5aa407f
AD
1523 err = register_pernet_device(&ip6_tnl_net_ops);
1524 if (err < 0)
1525 goto out_pernet;
1526
1527 err = xfrm6_tunnel_register(&ip4ip6_handler, AF_INET);
1528 if (err < 0) {
3144581c 1529 printk(KERN_ERR "ip6_tunnel init: can't register ip4ip6\n");
d5aa407f 1530 goto out_ip4ip6;
c4d3efaf
YK
1531 }
1532
d5aa407f
AD
1533 err = xfrm6_tunnel_register(&ip6ip6_handler, AF_INET6);
1534 if (err < 0) {
3144581c 1535 printk(KERN_ERR "ip6_tunnel init: can't register ip6ip6\n");
d5aa407f 1536 goto out_ip6ip6;
1da177e4 1537 }
13eeb8e9 1538
1da177e4 1539 return 0;
d5aa407f
AD
1540
1541out_ip6ip6:
c4d3efaf 1542 xfrm6_tunnel_deregister(&ip4ip6_handler, AF_INET);
d5aa407f
AD
1543out_ip4ip6:
1544 unregister_pernet_device(&ip6_tnl_net_ops);
1545out_pernet:
1da177e4
LT
1546 return err;
1547}
1548
1549/**
1550 * ip6_tunnel_cleanup - free resources and unregister protocol
1551 **/
1552
1553static void __exit ip6_tunnel_cleanup(void)
1554{
c4d3efaf 1555 if (xfrm6_tunnel_deregister(&ip4ip6_handler, AF_INET))
3144581c 1556 printk(KERN_INFO "ip6_tunnel close: can't deregister ip4ip6\n");
c4d3efaf 1557
73d605d1 1558 if (xfrm6_tunnel_deregister(&ip6ip6_handler, AF_INET6))
3144581c 1559 printk(KERN_INFO "ip6_tunnel close: can't deregister ip6ip6\n");
1da177e4 1560
ac31cd3c 1561 unregister_pernet_device(&ip6_tnl_net_ops);
1da177e4
LT
1562}
1563
1564module_init(ip6_tunnel_init);
1565module_exit(ip6_tunnel_cleanup);
This page took 0.627373 seconds and 5 git commands to generate.