blob: 8d918348f5bb62b4b61d8dbb82bc7670c1c98542 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * IPv6 over IPv6 tunnel device
3 * Linux INET6 implementation
4 *
5 * Authors:
6 * Ville Nuorvala <vnuorval@tcs.hut.fi>
7 *
8 * $Id$
9 *
10 * Based on:
11 * linux/net/ipv6/sit.c
12 *
13 * RFC 2473
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version
18 * 2 of the License, or (at your option) any later version.
19 *
20 */
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/module.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080023#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/errno.h>
25#include <linux/types.h>
26#include <linux/sockios.h>
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>
40
41#include <asm/uaccess.h>
42#include <asm/atomic.h>
43
44#include <net/ip.h>
45#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <net/ip6_route.h>
47#include <net/addrconf.h>
48#include <net/ip6_tunnel.h>
49#include <net/xfrm.h>
50#include <net/dsfield.h>
51#include <net/inet_ecn.h>
52
53MODULE_AUTHOR("Ville Nuorvala");
54MODULE_DESCRIPTION("IPv6-in-IPv6 tunnel");
55MODULE_LICENSE("GPL");
56
57#define IPV6_TLV_TEL_DST_SIZE 8
58
59#ifdef IP6_TNL_DEBUG
60#define IP6_TNL_TRACE(x...) printk(KERN_DEBUG "%s:" x "\n", __FUNCTION__)
61#else
62#define IP6_TNL_TRACE(x...) do {;} while(0)
63#endif
64
65#define IPV6_TCLASS_MASK (IPV6_FLOWINFO_MASK & ~IPV6_FLOWLABEL_MASK)
66
67#define HASH_SIZE 32
68
Al Viroe69a4adc2006-11-14 20:56:00 -080069#define HASH(addr) ((__force u32)((addr)->s6_addr32[0] ^ (addr)->s6_addr32[1] ^ \
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 (addr)->s6_addr32[2] ^ (addr)->s6_addr32[3]) & \
71 (HASH_SIZE - 1))
72
73static int ip6ip6_fb_tnl_dev_init(struct net_device *dev);
74static int ip6ip6_tnl_dev_init(struct net_device *dev);
75static void ip6ip6_tnl_dev_setup(struct net_device *dev);
76
77/* the IPv6 tunnel fallback device */
78static struct net_device *ip6ip6_fb_tnl_dev;
79
80
81/* lists for storing tunnels in use */
82static struct ip6_tnl *tnls_r_l[HASH_SIZE];
83static struct ip6_tnl *tnls_wc[1];
84static struct ip6_tnl **tnls[2] = { tnls_wc, tnls_r_l };
85
86/* lock for the tunnel lists */
87static DEFINE_RWLOCK(ip6ip6_lock);
88
89static inline struct dst_entry *ip6_tnl_dst_check(struct ip6_tnl *t)
90{
91 struct dst_entry *dst = t->dst_cache;
92
93 if (dst && dst->obsolete &&
94 dst->ops->check(dst, t->dst_cookie) == NULL) {
95 t->dst_cache = NULL;
96 dst_release(dst);
97 return NULL;
98 }
99
100 return dst;
101}
102
103static inline void ip6_tnl_dst_reset(struct ip6_tnl *t)
104{
105 dst_release(t->dst_cache);
106 t->dst_cache = NULL;
107}
108
109static inline void ip6_tnl_dst_store(struct ip6_tnl *t, struct dst_entry *dst)
110{
111 struct rt6_info *rt = (struct rt6_info *) dst;
112 t->dst_cookie = rt->rt6i_node ? rt->rt6i_node->fn_sernum : 0;
113 dst_release(t->dst_cache);
114 t->dst_cache = dst;
115}
116
117/**
118 * ip6ip6_tnl_lookup - fetch tunnel matching the end-point addresses
119 * @remote: the address of the tunnel exit-point
120 * @local: the address of the tunnel entry-point
121 *
122 * Return:
123 * tunnel matching given end-points if found,
124 * else fallback tunnel if its device is up,
125 * else %NULL
126 **/
127
128static struct ip6_tnl *
129ip6ip6_tnl_lookup(struct in6_addr *remote, struct in6_addr *local)
130{
131 unsigned h0 = HASH(remote);
132 unsigned h1 = HASH(local);
133 struct ip6_tnl *t;
134
135 for (t = tnls_r_l[h0 ^ h1]; t; t = t->next) {
136 if (ipv6_addr_equal(local, &t->parms.laddr) &&
137 ipv6_addr_equal(remote, &t->parms.raddr) &&
138 (t->dev->flags & IFF_UP))
139 return t;
140 }
141 if ((t = tnls_wc[0]) != NULL && (t->dev->flags & IFF_UP))
142 return t;
143
144 return NULL;
145}
146
147/**
148 * ip6ip6_bucket - get head of list matching given tunnel parameters
149 * @p: parameters containing tunnel end-points
150 *
151 * Description:
152 * ip6ip6_bucket() returns the head of the list matching the
153 * &struct in6_addr entries laddr and raddr in @p.
154 *
155 * Return: head of IPv6 tunnel list
156 **/
157
158static struct ip6_tnl **
159ip6ip6_bucket(struct ip6_tnl_parm *p)
160{
161 struct in6_addr *remote = &p->raddr;
162 struct in6_addr *local = &p->laddr;
163 unsigned h = 0;
164 int prio = 0;
165
166 if (!ipv6_addr_any(remote) || !ipv6_addr_any(local)) {
167 prio = 1;
168 h = HASH(remote) ^ HASH(local);
169 }
170 return &tnls[prio][h];
171}
172
173/**
174 * ip6ip6_tnl_link - add tunnel to hash table
175 * @t: tunnel to be added
176 **/
177
178static void
179ip6ip6_tnl_link(struct ip6_tnl *t)
180{
181 struct ip6_tnl **tp = ip6ip6_bucket(&t->parms);
182
183 t->next = *tp;
184 write_lock_bh(&ip6ip6_lock);
185 *tp = t;
186 write_unlock_bh(&ip6ip6_lock);
187}
188
189/**
190 * ip6ip6_tnl_unlink - remove tunnel from hash table
191 * @t: tunnel to be removed
192 **/
193
194static void
195ip6ip6_tnl_unlink(struct ip6_tnl *t)
196{
197 struct ip6_tnl **tp;
198
199 for (tp = ip6ip6_bucket(&t->parms); *tp; tp = &(*tp)->next) {
200 if (t == *tp) {
201 write_lock_bh(&ip6ip6_lock);
202 *tp = t->next;
203 write_unlock_bh(&ip6ip6_lock);
204 break;
205 }
206 }
207}
208
209/**
210 * ip6_tnl_create() - create a new tunnel
211 * @p: tunnel parameters
212 * @pt: pointer to new tunnel
213 *
214 * Description:
215 * Create tunnel matching given parameters.
216 *
217 * Return:
Ville Nuorvala567131a2006-11-24 17:05:41 -0800218 * created tunnel or NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 **/
220
Ville Nuorvala567131a2006-11-24 17:05:41 -0800221static struct ip6_tnl *ip6_tnl_create(struct ip6_tnl_parm *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222{
223 struct net_device *dev;
224 struct ip6_tnl *t;
225 char name[IFNAMSIZ];
226 int err;
227
228 if (p->name[0]) {
229 strlcpy(name, p->name, IFNAMSIZ);
230 } else {
231 int i;
232 for (i = 1; i < IP6_TNL_MAX; i++) {
233 sprintf(name, "ip6tnl%d", i);
234 if (__dev_get_by_name(name) == NULL)
235 break;
236 }
237 if (i == IP6_TNL_MAX)
Ville Nuorvala567131a2006-11-24 17:05:41 -0800238 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 }
240 dev = alloc_netdev(sizeof (*t), name, ip6ip6_tnl_dev_setup);
241 if (dev == NULL)
Ville Nuorvala567131a2006-11-24 17:05:41 -0800242 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Patrick McHardy2941a482006-01-08 22:05:26 -0800244 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 dev->init = ip6ip6_tnl_dev_init;
246 t->parms = *p;
247
248 if ((err = register_netdevice(dev)) < 0) {
249 free_netdev(dev);
Ville Nuorvala567131a2006-11-24 17:05:41 -0800250 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 }
252 dev_hold(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 ip6ip6_tnl_link(t);
Ville Nuorvala567131a2006-11-24 17:05:41 -0800254 return t;
255failed:
256 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257}
258
259/**
260 * ip6ip6_tnl_locate - find or create tunnel matching given parameters
261 * @p: tunnel parameters
262 * @create: != 0 if allowed to create new tunnel if no match found
263 *
264 * Description:
265 * ip6ip6_tnl_locate() first tries to locate an existing tunnel
266 * based on @parms. If this is unsuccessful, but @create is set a new
267 * tunnel device is created and registered for use.
268 *
269 * Return:
Ville Nuorvala567131a2006-11-24 17:05:41 -0800270 * matching tunnel or NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 **/
272
Ville Nuorvala567131a2006-11-24 17:05:41 -0800273static struct ip6_tnl *ip6ip6_tnl_locate(struct ip6_tnl_parm *p, int create)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274{
275 struct in6_addr *remote = &p->raddr;
276 struct in6_addr *local = &p->laddr;
277 struct ip6_tnl *t;
278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 for (t = *ip6ip6_bucket(p); t; t = t->next) {
280 if (ipv6_addr_equal(local, &t->parms.laddr) &&
Ville Nuorvala567131a2006-11-24 17:05:41 -0800281 ipv6_addr_equal(remote, &t->parms.raddr))
282 return t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 }
284 if (!create)
Ville Nuorvala567131a2006-11-24 17:05:41 -0800285 return NULL;
286 return ip6_tnl_create(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287}
288
289/**
290 * ip6ip6_tnl_dev_uninit - tunnel device uninitializer
291 * @dev: the device to be destroyed
292 *
293 * Description:
294 * ip6ip6_tnl_dev_uninit() removes tunnel from its list
295 **/
296
297static void
298ip6ip6_tnl_dev_uninit(struct net_device *dev)
299{
Patrick McHardy2941a482006-01-08 22:05:26 -0800300 struct ip6_tnl *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 if (dev == ip6ip6_fb_tnl_dev) {
303 write_lock_bh(&ip6ip6_lock);
304 tnls_wc[0] = NULL;
305 write_unlock_bh(&ip6ip6_lock);
306 } else {
307 ip6ip6_tnl_unlink(t);
308 }
309 ip6_tnl_dst_reset(t);
310 dev_put(dev);
311}
312
313/**
314 * parse_tvl_tnl_enc_lim - handle encapsulation limit option
315 * @skb: received socket buffer
316 *
317 * Return:
318 * 0 if none was found,
319 * else index to encapsulation limit
320 **/
321
322static __u16
323parse_tlv_tnl_enc_lim(struct sk_buff *skb, __u8 * raw)
324{
325 struct ipv6hdr *ipv6h = (struct ipv6hdr *) raw;
326 __u8 nexthdr = ipv6h->nexthdr;
327 __u16 off = sizeof (*ipv6h);
328
329 while (ipv6_ext_hdr(nexthdr) && nexthdr != NEXTHDR_NONE) {
330 __u16 optlen = 0;
331 struct ipv6_opt_hdr *hdr;
332 if (raw + off + sizeof (*hdr) > skb->data &&
333 !pskb_may_pull(skb, raw - skb->data + off + sizeof (*hdr)))
334 break;
335
336 hdr = (struct ipv6_opt_hdr *) (raw + off);
337 if (nexthdr == NEXTHDR_FRAGMENT) {
338 struct frag_hdr *frag_hdr = (struct frag_hdr *) hdr;
339 if (frag_hdr->frag_off)
340 break;
341 optlen = 8;
342 } else if (nexthdr == NEXTHDR_AUTH) {
343 optlen = (hdr->hdrlen + 2) << 2;
344 } else {
345 optlen = ipv6_optlen(hdr);
346 }
347 if (nexthdr == NEXTHDR_DEST) {
348 __u16 i = off + 2;
349 while (1) {
350 struct ipv6_tlv_tnl_enc_lim *tel;
351
352 /* No more room for encapsulation limit */
353 if (i + sizeof (*tel) > off + optlen)
354 break;
355
356 tel = (struct ipv6_tlv_tnl_enc_lim *) &raw[i];
357 /* return index of option if found and valid */
358 if (tel->type == IPV6_TLV_TNL_ENCAP_LIMIT &&
359 tel->length == 1)
360 return i;
361 /* else jump to next option */
362 if (tel->type)
363 i += tel->length + 2;
364 else
365 i++;
366 }
367 }
368 nexthdr = hdr->nexthdr;
369 off += optlen;
370 }
371 return 0;
372}
373
374/**
375 * ip6ip6_err - tunnel error handler
376 *
377 * Description:
378 * ip6ip6_err() should handle errors in the tunnel according
379 * to the specifications in RFC 2473.
380 **/
381
Herbert Xud2acc342006-03-28 01:12:13 -0800382static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383ip6ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Al Viro04ce6902006-11-08 00:21:01 -0800384 int type, int code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385{
386 struct ipv6hdr *ipv6h = (struct ipv6hdr *) skb->data;
387 struct ip6_tnl *t;
388 int rel_msg = 0;
389 int rel_type = ICMPV6_DEST_UNREACH;
390 int rel_code = ICMPV6_ADDR_UNREACH;
391 __u32 rel_info = 0;
392 __u16 len;
Herbert Xud2acc342006-03-28 01:12:13 -0800393 int err = -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395 /* If the packet doesn't contain the original IPv6 header we are
396 in trouble since we might need the source address for further
397 processing of the error. */
398
399 read_lock(&ip6ip6_lock);
400 if ((t = ip6ip6_tnl_lookup(&ipv6h->daddr, &ipv6h->saddr)) == NULL)
401 goto out;
402
Herbert Xud2acc342006-03-28 01:12:13 -0800403 err = 0;
404
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 switch (type) {
406 __u32 teli;
407 struct ipv6_tlv_tnl_enc_lim *tel;
408 __u32 mtu;
409 case ICMPV6_DEST_UNREACH:
410 if (net_ratelimit())
411 printk(KERN_WARNING
412 "%s: Path to destination invalid "
413 "or inactive!\n", t->parms.name);
414 rel_msg = 1;
415 break;
416 case ICMPV6_TIME_EXCEED:
417 if (code == ICMPV6_EXC_HOPLIMIT) {
418 if (net_ratelimit())
419 printk(KERN_WARNING
420 "%s: Too small hop limit or "
421 "routing loop in tunnel!\n",
422 t->parms.name);
423 rel_msg = 1;
424 }
425 break;
426 case ICMPV6_PARAMPROB:
Ville Nuorvala107a5fe2006-11-24 17:08:58 -0800427 teli = 0;
428 if (code == ICMPV6_HDR_FIELD)
429 teli = parse_tlv_tnl_enc_lim(skb, skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
431 if (teli && teli == ntohl(info) - 2) {
432 tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->data[teli];
433 if (tel->encap_limit == 0) {
434 if (net_ratelimit())
435 printk(KERN_WARNING
436 "%s: Too small encapsulation "
437 "limit or routing loop in "
438 "tunnel!\n", t->parms.name);
439 rel_msg = 1;
440 }
Ville Nuorvala107a5fe2006-11-24 17:08:58 -0800441 } else if (net_ratelimit()) {
442 printk(KERN_WARNING
443 "%s: Recipient unable to parse tunneled "
444 "packet!\n ", t->parms.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 }
446 break;
447 case ICMPV6_PKT_TOOBIG:
448 mtu = ntohl(info) - offset;
449 if (mtu < IPV6_MIN_MTU)
450 mtu = IPV6_MIN_MTU;
451 t->dev->mtu = mtu;
452
Al Virocc6cdac2006-02-18 16:02:18 -0500453 if ((len = sizeof (*ipv6h) + ntohs(ipv6h->payload_len)) > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 rel_type = ICMPV6_PKT_TOOBIG;
455 rel_code = 0;
456 rel_info = mtu;
457 rel_msg = 1;
458 }
459 break;
460 }
461 if (rel_msg && pskb_may_pull(skb, offset + sizeof (*ipv6h))) {
462 struct rt6_info *rt;
463 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
Ville Nuorvala305d4b32006-11-24 17:06:53 -0800464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 if (!skb2)
466 goto out;
467
468 dst_release(skb2->dst);
469 skb2->dst = NULL;
470 skb_pull(skb2, offset);
471 skb2->nh.raw = skb2->data;
472
473 /* Try to guess incoming interface */
474 rt = rt6_lookup(&skb2->nh.ipv6h->saddr, NULL, 0, 0);
475
476 if (rt && rt->rt6i_dev)
477 skb2->dev = rt->rt6i_dev;
478
479 icmpv6_send(skb2, rel_type, rel_code, rel_info, skb2->dev);
480
481 if (rt)
482 dst_release(&rt->u.dst);
483
484 kfree_skb(skb2);
485 }
486out:
487 read_unlock(&ip6ip6_lock);
Herbert Xud2acc342006-03-28 01:12:13 -0800488 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489}
490
491static inline void ip6ip6_ecn_decapsulate(struct ipv6hdr *outer_iph,
492 struct sk_buff *skb)
493{
494 struct ipv6hdr *inner_iph = skb->nh.ipv6h;
495
496 if (INET_ECN_is_ce(ipv6_get_dsfield(outer_iph)))
497 IP6_ECN_set_ce(inner_iph);
498}
Ville Nuorvala09c6bbf2006-11-24 17:06:27 -0800499static inline int ip6_tnl_rcv_ctl(struct ip6_tnl *t)
500{
501 struct ip6_tnl_parm *p = &t->parms;
502 int ret = 0;
503
504 if (p->flags & IP6_TNL_F_CAP_RCV) {
505 struct net_device *ldev = NULL;
506
507 if (p->link)
508 ldev = dev_get_by_index(p->link);
509
510 if ((ipv6_addr_is_multicast(&p->laddr) ||
511 likely(ipv6_chk_addr(&p->laddr, ldev, 0))) &&
512 likely(!ipv6_chk_addr(&p->raddr, NULL, 0)))
513 ret = 1;
514
515 if (ldev)
516 dev_put(ldev);
517 }
518 return ret;
519}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
521/**
522 * ip6ip6_rcv - decapsulate IPv6 packet and retransmit it locally
523 * @skb: received socket buffer
524 *
525 * Return: 0
526 **/
527
528static int
Herbert Xud2acc342006-03-28 01:12:13 -0800529ip6ip6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 struct ipv6hdr *ipv6h;
532 struct ip6_tnl *t;
533
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 ipv6h = skb->nh.ipv6h;
535
536 read_lock(&ip6ip6_lock);
537
538 if ((t = ip6ip6_tnl_lookup(&ipv6h->saddr, &ipv6h->daddr)) != NULL) {
539 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Ken-ichirou MATSUZAWA9f0ede52005-11-09 13:08:29 -0800540 read_unlock(&ip6ip6_lock);
Herbert Xu50fba2a2006-04-04 13:50:45 -0700541 goto discard;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 }
543
Ville Nuorvala09c6bbf2006-11-24 17:06:27 -0800544 if (!ip6_tnl_rcv_ctl(t)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 t->stat.rx_dropped++;
546 read_unlock(&ip6ip6_lock);
547 goto discard;
548 }
549 secpath_reset(skb);
550 skb->mac.raw = skb->nh.raw;
551 skb->nh.raw = skb->data;
552 skb->protocol = htons(ETH_P_IPV6);
553 skb->pkt_type = PACKET_HOST;
554 memset(skb->cb, 0, sizeof(struct inet6_skb_parm));
555 skb->dev = t->dev;
556 dst_release(skb->dst);
557 skb->dst = NULL;
Yasuyuki Kozakai53ab61c2006-11-06 10:06:23 -0800558 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 if (t->parms.flags & IP6_TNL_F_RCV_DSCP_COPY)
560 ipv6_copy_dscp(ipv6h, skb->nh.ipv6h);
561 ip6ip6_ecn_decapsulate(ipv6h, skb);
562 t->stat.rx_packets++;
563 t->stat.rx_bytes += skb->len;
564 netif_rx(skb);
565 read_unlock(&ip6ip6_lock);
566 return 0;
567 }
568 read_unlock(&ip6ip6_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 return 1;
Herbert Xu50fba2a2006-04-04 13:50:45 -0700570
571discard:
572 kfree_skb(skb);
573 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574}
575
Ville Nuorvala6fb32dd2006-11-24 17:08:32 -0800576struct ipv6_tel_txoption {
577 struct ipv6_txoptions ops;
578 __u8 dst_opt[8];
579};
580
581static void init_tel_txopt(struct ipv6_tel_txoption *opt, __u8 encap_limit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582{
Ville Nuorvala6fb32dd2006-11-24 17:08:32 -0800583 memset(opt, 0, sizeof(struct ipv6_tel_txoption));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
Ville Nuorvala6fb32dd2006-11-24 17:08:32 -0800585 opt->dst_opt[2] = IPV6_TLV_TNL_ENCAP_LIMIT;
586 opt->dst_opt[3] = 1;
587 opt->dst_opt[4] = encap_limit;
588 opt->dst_opt[5] = IPV6_TLV_PADN;
589 opt->dst_opt[6] = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Ville Nuorvala6fb32dd2006-11-24 17:08:32 -0800591 opt->ops.dst0opt = (struct ipv6_opt_hdr *) opt->dst_opt;
592 opt->ops.opt_nflen = 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593}
594
595/**
596 * ip6ip6_tnl_addr_conflict - compare packet addresses to tunnel's own
597 * @t: the outgoing tunnel device
598 * @hdr: IPv6 header from the incoming packet
599 *
600 * Description:
601 * Avoid trivial tunneling loop by checking that tunnel exit-point
602 * doesn't match source of incoming packet.
603 *
604 * Return:
605 * 1 if conflict,
606 * 0 else
607 **/
608
609static inline int
610ip6ip6_tnl_addr_conflict(struct ip6_tnl *t, struct ipv6hdr *hdr)
611{
612 return ipv6_addr_equal(&t->parms.raddr, &hdr->saddr);
613}
614
Ville Nuorvala09c6bbf2006-11-24 17:06:27 -0800615static inline int ip6_tnl_xmit_ctl(struct ip6_tnl *t)
616{
617 struct ip6_tnl_parm *p = &t->parms;
618 int ret = 0;
619
620 if (p->flags & IP6_TNL_F_CAP_XMIT) {
621 struct net_device *ldev = NULL;
622
623 if (p->link)
624 ldev = dev_get_by_index(p->link);
625
626 if (unlikely(!ipv6_chk_addr(&p->laddr, ldev, 0)))
627 printk(KERN_WARNING
628 "%s xmit: Local address not yet configured!\n",
629 p->name);
630 else if (!ipv6_addr_is_multicast(&p->raddr) &&
631 unlikely(ipv6_chk_addr(&p->raddr, NULL, 0)))
632 printk(KERN_WARNING
633 "%s xmit: Routing loop! "
634 "Remote address found on this node!\n",
635 p->name);
636 else
637 ret = 1;
638 if (ldev)
639 dev_put(ldev);
640 }
641 return ret;
642}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643/**
644 * ip6ip6_tnl_xmit - encapsulate packet and send
645 * @skb: the outgoing socket buffer
646 * @dev: the outgoing tunnel device
647 *
648 * Description:
649 * Build new header and do some sanity checks on the packet before sending
650 * it.
651 *
652 * Return:
653 * 0
654 **/
655
656static int
657ip6ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
658{
Patrick McHardy2941a482006-01-08 22:05:26 -0800659 struct ip6_tnl *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 struct net_device_stats *stats = &t->stat;
661 struct ipv6hdr *ipv6h = skb->nh.ipv6h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 int encap_limit = -1;
Ville Nuorvala6fb32dd2006-11-24 17:08:32 -0800663 struct ipv6_tel_txoption opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 __u16 offset;
665 struct flowi fl;
666 struct dst_entry *dst;
667 struct net_device *tdev;
668 int mtu;
669 int max_headroom = sizeof(struct ipv6hdr);
670 u8 proto;
671 int err;
672 int pkt_len;
673 int dsfield;
674
675 if (t->recursion++) {
676 stats->collisions++;
677 goto tx_err;
678 }
679 if (skb->protocol != htons(ETH_P_IPV6) ||
Ville Nuorvala09c6bbf2006-11-24 17:06:27 -0800680 !ip6_tnl_xmit_ctl(t) || ip6ip6_tnl_addr_conflict(t, ipv6h))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 goto tx_err;
Ville Nuorvala09c6bbf2006-11-24 17:06:27 -0800682
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 if ((offset = parse_tlv_tnl_enc_lim(skb, skb->nh.raw)) > 0) {
684 struct ipv6_tlv_tnl_enc_lim *tel;
685 tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->nh.raw[offset];
686 if (tel->encap_limit == 0) {
687 icmpv6_send(skb, ICMPV6_PARAMPROB,
688 ICMPV6_HDR_FIELD, offset + 2, skb->dev);
689 goto tx_err;
690 }
691 encap_limit = tel->encap_limit - 1;
Ville Nuorvala6fb32dd2006-11-24 17:08:32 -0800692 } else if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 encap_limit = t->parms.encap_limit;
Ville Nuorvala6fb32dd2006-11-24 17:08:32 -0800694
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 memcpy(&fl, &t->fl, sizeof (fl));
696 proto = fl.proto;
697
698 dsfield = ipv6_get_dsfield(ipv6h);
699 if ((t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS))
Al Viro90bcaf72006-11-08 00:25:17 -0800700 fl.fl6_flowlabel |= (*(__be32 *) ipv6h & IPV6_TCLASS_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 if ((t->parms.flags & IP6_TNL_F_USE_ORIG_FLOWLABEL))
Al Viro90bcaf72006-11-08 00:25:17 -0800702 fl.fl6_flowlabel |= (*(__be32 *) ipv6h & IPV6_FLOWLABEL_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 if ((dst = ip6_tnl_dst_check(t)) != NULL)
705 dst_hold(dst);
Patrick McHardya57ebc92005-09-08 14:27:47 -0700706 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 dst = ip6_route_output(NULL, &fl);
708
Patrick McHardya57ebc92005-09-08 14:27:47 -0700709 if (dst->error || xfrm_lookup(&dst, &fl, NULL, 0) < 0)
710 goto tx_err_link_failure;
711 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
713 tdev = dst->dev;
714
715 if (tdev == dev) {
716 stats->collisions++;
717 if (net_ratelimit())
718 printk(KERN_WARNING
719 "%s: Local routing loop detected!\n",
720 t->parms.name);
721 goto tx_err_dst_release;
722 }
723 mtu = dst_mtu(dst) - sizeof (*ipv6h);
Ville Nuorvala6fb32dd2006-11-24 17:08:32 -0800724 if (encap_limit >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 max_headroom += 8;
726 mtu -= 8;
727 }
728 if (mtu < IPV6_MIN_MTU)
729 mtu = IPV6_MIN_MTU;
730 if (skb->dst && mtu < dst_mtu(skb->dst)) {
731 struct rt6_info *rt = (struct rt6_info *) skb->dst;
732 rt->rt6i_flags |= RTF_MODIFIED;
733 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
734 }
735 if (skb->len > mtu) {
736 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
737 goto tx_err_dst_release;
738 }
739
740 /*
741 * Okay, now see if we can stuff it in the buffer as-is.
742 */
743 max_headroom += LL_RESERVED_SPACE(tdev);
744
745 if (skb_headroom(skb) < max_headroom ||
746 skb_cloned(skb) || skb_shared(skb)) {
747 struct sk_buff *new_skb;
748
749 if (!(new_skb = skb_realloc_headroom(skb, max_headroom)))
750 goto tx_err_dst_release;
751
752 if (skb->sk)
753 skb_set_owner_w(new_skb, skb->sk);
754 kfree_skb(skb);
755 skb = new_skb;
756 }
757 dst_release(skb->dst);
758 skb->dst = dst_clone(dst);
759
760 skb->h.raw = skb->nh.raw;
761
Ville Nuorvala6fb32dd2006-11-24 17:08:32 -0800762 if (encap_limit >= 0) {
763 init_tel_txopt(&opt, encap_limit);
764 ipv6_push_nfrag_opts(skb, &opt.ops, &proto, NULL);
765 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 skb->nh.raw = skb_push(skb, sizeof(struct ipv6hdr));
767 ipv6h = skb->nh.ipv6h;
Al Viro90bcaf72006-11-08 00:25:17 -0800768 *(__be32*)ipv6h = fl.fl6_flowlabel | htonl(0x60000000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 dsfield = INET_ECN_encapsulate(0, dsfield);
770 ipv6_change_dsfield(ipv6h, ~INET_ECN_MASK, dsfield);
771 ipv6h->payload_len = htons(skb->len - sizeof(struct ipv6hdr));
772 ipv6h->hop_limit = t->parms.hop_limit;
773 ipv6h->nexthdr = proto;
774 ipv6_addr_copy(&ipv6h->saddr, &fl.fl6_src);
775 ipv6_addr_copy(&ipv6h->daddr, &fl.fl6_dst);
776 nf_reset(skb);
777 pkt_len = skb->len;
778 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL,
779 skb->dst->dev, dst_output);
780
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200781 if (net_xmit_eval(err) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 stats->tx_bytes += pkt_len;
783 stats->tx_packets++;
784 } else {
785 stats->tx_errors++;
786 stats->tx_aborted_errors++;
787 }
788 ip6_tnl_dst_store(t, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 t->recursion--;
790 return 0;
791tx_err_link_failure:
792 stats->tx_carrier_errors++;
793 dst_link_failure(skb);
794tx_err_dst_release:
795 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796tx_err:
797 stats->tx_errors++;
798 stats->tx_dropped++;
799 kfree_skb(skb);
800 t->recursion--;
801 return 0;
802}
803
804static void ip6_tnl_set_cap(struct ip6_tnl *t)
805{
806 struct ip6_tnl_parm *p = &t->parms;
Ville Nuorvala09c6bbf2006-11-24 17:06:27 -0800807 int ltype = ipv6_addr_type(&p->laddr);
808 int rtype = ipv6_addr_type(&p->raddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
810 p->flags &= ~(IP6_TNL_F_CAP_XMIT|IP6_TNL_F_CAP_RCV);
811
Ville Nuorvala09c6bbf2006-11-24 17:06:27 -0800812 if (ltype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
813 rtype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
814 !((ltype|rtype) & IPV6_ADDR_LOOPBACK) &&
Ville Nuorvala305d4b32006-11-24 17:06:53 -0800815 (!((ltype|rtype) & IPV6_ADDR_LINKLOCAL) || p->link)) {
Ville Nuorvala09c6bbf2006-11-24 17:06:27 -0800816 if (ltype&IPV6_ADDR_UNICAST)
817 p->flags |= IP6_TNL_F_CAP_XMIT;
818 if (rtype&IPV6_ADDR_UNICAST)
819 p->flags |= IP6_TNL_F_CAP_RCV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 }
821}
822
823static void ip6ip6_tnl_link_config(struct ip6_tnl *t)
824{
825 struct net_device *dev = t->dev;
826 struct ip6_tnl_parm *p = &t->parms;
827 struct flowi *fl = &t->fl;
828
829 memcpy(&dev->dev_addr, &p->laddr, sizeof(struct in6_addr));
830 memcpy(&dev->broadcast, &p->raddr, sizeof(struct in6_addr));
831
832 /* Set up flowi template */
833 ipv6_addr_copy(&fl->fl6_src, &p->laddr);
834 ipv6_addr_copy(&fl->fl6_dst, &p->raddr);
835 fl->oif = p->link;
836 fl->fl6_flowlabel = 0;
837
838 if (!(p->flags&IP6_TNL_F_USE_ORIG_TCLASS))
839 fl->fl6_flowlabel |= IPV6_TCLASS_MASK & p->flowinfo;
840 if (!(p->flags&IP6_TNL_F_USE_ORIG_FLOWLABEL))
841 fl->fl6_flowlabel |= IPV6_FLOWLABEL_MASK & p->flowinfo;
842
843 ip6_tnl_set_cap(t);
844
845 if (p->flags&IP6_TNL_F_CAP_XMIT && p->flags&IP6_TNL_F_CAP_RCV)
846 dev->flags |= IFF_POINTOPOINT;
847 else
848 dev->flags &= ~IFF_POINTOPOINT;
849
850 dev->iflink = p->link;
851
852 if (p->flags & IP6_TNL_F_CAP_XMIT) {
Ville Nuorvala305d4b32006-11-24 17:06:53 -0800853 int strict = (ipv6_addr_type(&p->raddr) &
854 (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));
855
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 struct rt6_info *rt = rt6_lookup(&p->raddr, &p->laddr,
Ville Nuorvala305d4b32006-11-24 17:06:53 -0800857 p->link, strict);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
859 if (rt == NULL)
860 return;
861
862 if (rt->rt6i_dev) {
863 dev->hard_header_len = rt->rt6i_dev->hard_header_len +
864 sizeof (struct ipv6hdr);
865
866 dev->mtu = rt->rt6i_dev->mtu - sizeof (struct ipv6hdr);
867
868 if (dev->mtu < IPV6_MIN_MTU)
869 dev->mtu = IPV6_MIN_MTU;
870 }
871 dst_release(&rt->u.dst);
872 }
873}
874
875/**
876 * ip6ip6_tnl_change - update the tunnel parameters
877 * @t: tunnel to be changed
878 * @p: tunnel configuration parameters
879 * @active: != 0 if tunnel is ready for use
880 *
881 * Description:
882 * ip6ip6_tnl_change() updates the tunnel parameters
883 **/
884
885static int
886ip6ip6_tnl_change(struct ip6_tnl *t, struct ip6_tnl_parm *p)
887{
888 ipv6_addr_copy(&t->parms.laddr, &p->laddr);
889 ipv6_addr_copy(&t->parms.raddr, &p->raddr);
890 t->parms.flags = p->flags;
891 t->parms.hop_limit = p->hop_limit;
892 t->parms.encap_limit = p->encap_limit;
893 t->parms.flowinfo = p->flowinfo;
Gabor Fekete8181b8c2005-06-08 14:54:38 -0700894 t->parms.link = p->link;
Hugo Santos0c088892006-02-24 13:16:25 -0800895 ip6_tnl_dst_reset(t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 ip6ip6_tnl_link_config(t);
897 return 0;
898}
899
900/**
901 * ip6ip6_tnl_ioctl - configure ipv6 tunnels from userspace
902 * @dev: virtual device associated with tunnel
903 * @ifr: parameters passed from userspace
904 * @cmd: command to be performed
905 *
906 * Description:
907 * ip6ip6_tnl_ioctl() is used for managing IPv6 tunnels
908 * from userspace.
909 *
910 * The possible commands are the following:
911 * %SIOCGETTUNNEL: get tunnel parameters for device
912 * %SIOCADDTUNNEL: add tunnel matching given tunnel parameters
913 * %SIOCCHGTUNNEL: change tunnel parameters to those given
914 * %SIOCDELTUNNEL: delete tunnel
915 *
916 * The fallback device "ip6tnl0", created during module
917 * initialization, can be used for creating other tunnel devices.
918 *
919 * Return:
920 * 0 on success,
921 * %-EFAULT if unable to copy data to or from userspace,
922 * %-EPERM if current process hasn't %CAP_NET_ADMIN set
923 * %-EINVAL if passed tunnel parameters are invalid,
924 * %-EEXIST if changing a tunnel's parameters would cause a conflict
925 * %-ENODEV if attempting to change or delete a nonexisting device
926 **/
927
928static int
929ip6ip6_tnl_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
930{
931 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 struct ip6_tnl_parm p;
933 struct ip6_tnl *t = NULL;
934
935 switch (cmd) {
936 case SIOCGETTUNNEL:
937 if (dev == ip6ip6_fb_tnl_dev) {
Ville Nuorvala567131a2006-11-24 17:05:41 -0800938 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof (p))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 err = -EFAULT;
940 break;
941 }
Ville Nuorvala567131a2006-11-24 17:05:41 -0800942 t = ip6ip6_tnl_locate(&p, 0);
943 }
944 if (t == NULL)
Patrick McHardy2941a482006-01-08 22:05:26 -0800945 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 memcpy(&p, &t->parms, sizeof (p));
947 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof (p))) {
948 err = -EFAULT;
949 }
950 break;
951 case SIOCADDTUNNEL:
952 case SIOCCHGTUNNEL:
953 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 if (!capable(CAP_NET_ADMIN))
955 break;
Ville Nuorvala567131a2006-11-24 17:05:41 -0800956 err = -EFAULT;
957 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof (p)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 break;
Ville Nuorvala567131a2006-11-24 17:05:41 -0800959 err = -EINVAL;
960 if (p.proto != IPPROTO_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 break;
Ville Nuorvala567131a2006-11-24 17:05:41 -0800962 t = ip6ip6_tnl_locate(&p, cmd == SIOCADDTUNNEL);
963 if (dev != ip6ip6_fb_tnl_dev && cmd == SIOCCHGTUNNEL) {
964 if (t != NULL) {
965 if (t->dev != dev) {
966 err = -EEXIST;
967 break;
968 }
969 } else
970 t = netdev_priv(dev);
971
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 ip6ip6_tnl_unlink(t);
973 err = ip6ip6_tnl_change(t, &p);
974 ip6ip6_tnl_link(t);
975 netdev_state_change(dev);
976 }
Ville Nuorvala567131a2006-11-24 17:05:41 -0800977 if (t) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 err = 0;
Ville Nuorvala567131a2006-11-24 17:05:41 -0800979 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof (p)))
980 err = -EFAULT;
981
982 } else
983 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 break;
985 case SIOCDELTUNNEL:
986 err = -EPERM;
987 if (!capable(CAP_NET_ADMIN))
988 break;
989
990 if (dev == ip6ip6_fb_tnl_dev) {
Ville Nuorvala567131a2006-11-24 17:05:41 -0800991 err = -EFAULT;
992 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof (p)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 break;
Ville Nuorvala567131a2006-11-24 17:05:41 -0800994 err = -ENOENT;
995 if ((t = ip6ip6_tnl_locate(&p, 0)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 break;
Ville Nuorvala567131a2006-11-24 17:05:41 -0800997 err = -EPERM;
998 if (t->dev == ip6ip6_fb_tnl_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 break;
Ville Nuorvala567131a2006-11-24 17:05:41 -08001000 dev = t->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 }
Ville Nuorvala567131a2006-11-24 17:05:41 -08001002 err = unregister_netdevice(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 break;
1004 default:
1005 err = -EINVAL;
1006 }
1007 return err;
1008}
1009
1010/**
1011 * ip6ip6_tnl_get_stats - return the stats for tunnel device
1012 * @dev: virtual device associated with tunnel
1013 *
1014 * Return: stats for device
1015 **/
1016
1017static struct net_device_stats *
1018ip6ip6_tnl_get_stats(struct net_device *dev)
1019{
Patrick McHardy2941a482006-01-08 22:05:26 -08001020 return &(((struct ip6_tnl *)netdev_priv(dev))->stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021}
1022
1023/**
1024 * ip6ip6_tnl_change_mtu - change mtu manually for tunnel device
1025 * @dev: virtual device associated with tunnel
1026 * @new_mtu: the new mtu
1027 *
1028 * Return:
1029 * 0 on success,
1030 * %-EINVAL if mtu too small
1031 **/
1032
1033static int
1034ip6ip6_tnl_change_mtu(struct net_device *dev, int new_mtu)
1035{
1036 if (new_mtu < IPV6_MIN_MTU) {
1037 return -EINVAL;
1038 }
1039 dev->mtu = new_mtu;
1040 return 0;
1041}
1042
1043/**
1044 * ip6ip6_tnl_dev_setup - setup virtual tunnel device
1045 * @dev: virtual device associated with tunnel
1046 *
1047 * Description:
1048 * Initialize function pointers and device parameters
1049 **/
1050
1051static void ip6ip6_tnl_dev_setup(struct net_device *dev)
1052{
1053 SET_MODULE_OWNER(dev);
1054 dev->uninit = ip6ip6_tnl_dev_uninit;
1055 dev->destructor = free_netdev;
1056 dev->hard_start_xmit = ip6ip6_tnl_xmit;
1057 dev->get_stats = ip6ip6_tnl_get_stats;
1058 dev->do_ioctl = ip6ip6_tnl_ioctl;
1059 dev->change_mtu = ip6ip6_tnl_change_mtu;
1060
1061 dev->type = ARPHRD_TUNNEL6;
1062 dev->hard_header_len = LL_MAX_HEADER + sizeof (struct ipv6hdr);
1063 dev->mtu = ETH_DATA_LEN - sizeof (struct ipv6hdr);
1064 dev->flags |= IFF_NOARP;
1065 dev->addr_len = sizeof(struct in6_addr);
1066}
1067
1068
1069/**
1070 * ip6ip6_tnl_dev_init_gen - general initializer for all tunnel devices
1071 * @dev: virtual device associated with tunnel
1072 **/
1073
1074static inline void
1075ip6ip6_tnl_dev_init_gen(struct net_device *dev)
1076{
Patrick McHardy2941a482006-01-08 22:05:26 -08001077 struct ip6_tnl *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 t->fl.proto = IPPROTO_IPV6;
1079 t->dev = dev;
1080 strcpy(t->parms.name, dev->name);
1081}
1082
1083/**
1084 * ip6ip6_tnl_dev_init - initializer for all non fallback tunnel devices
1085 * @dev: virtual device associated with tunnel
1086 **/
1087
1088static int
1089ip6ip6_tnl_dev_init(struct net_device *dev)
1090{
Patrick McHardy2941a482006-01-08 22:05:26 -08001091 struct ip6_tnl *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 ip6ip6_tnl_dev_init_gen(dev);
1093 ip6ip6_tnl_link_config(t);
1094 return 0;
1095}
1096
1097/**
1098 * ip6ip6_fb_tnl_dev_init - initializer for fallback tunnel device
1099 * @dev: fallback device
1100 *
1101 * Return: 0
1102 **/
1103
1104static int
1105ip6ip6_fb_tnl_dev_init(struct net_device *dev)
1106{
Patrick McHardy2941a482006-01-08 22:05:26 -08001107 struct ip6_tnl *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 ip6ip6_tnl_dev_init_gen(dev);
1109 dev_hold(dev);
1110 tnls_wc[0] = t;
1111 return 0;
1112}
1113
1114static struct xfrm6_tunnel ip6ip6_handler = {
Patrick McHardy03037702005-07-19 14:03:34 -07001115 .handler = ip6ip6_rcv,
1116 .err_handler = ip6ip6_err,
Herbert Xud2acc342006-03-28 01:12:13 -08001117 .priority = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118};
1119
1120/**
1121 * ip6_tunnel_init - register protocol and reserve needed resources
1122 *
1123 * Return: 0 on success
1124 **/
1125
1126static int __init ip6_tunnel_init(void)
1127{
1128 int err;
1129
Herbert Xud2acc342006-03-28 01:12:13 -08001130 if (xfrm6_tunnel_register(&ip6ip6_handler)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 printk(KERN_ERR "ip6ip6 init: can't register tunnel\n");
1132 return -EAGAIN;
1133 }
1134 ip6ip6_fb_tnl_dev = alloc_netdev(sizeof(struct ip6_tnl), "ip6tnl0",
1135 ip6ip6_tnl_dev_setup);
1136
1137 if (!ip6ip6_fb_tnl_dev) {
1138 err = -ENOMEM;
1139 goto fail;
1140 }
1141 ip6ip6_fb_tnl_dev->init = ip6ip6_fb_tnl_dev_init;
1142
1143 if ((err = register_netdev(ip6ip6_fb_tnl_dev))) {
1144 free_netdev(ip6ip6_fb_tnl_dev);
1145 goto fail;
1146 }
1147 return 0;
1148fail:
Herbert Xud2acc342006-03-28 01:12:13 -08001149 xfrm6_tunnel_deregister(&ip6ip6_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 return err;
1151}
1152
Yasuyuki Kozakaib3fdd9f2006-11-06 10:06:22 -08001153static void __exit ip6ip6_destroy_tunnels(void)
1154{
1155 int h;
1156 struct ip6_tnl *t;
1157
1158 for (h = 0; h < HASH_SIZE; h++) {
1159 while ((t = tnls_r_l[h]) != NULL)
1160 unregister_netdevice(t->dev);
1161 }
1162
1163 t = tnls_wc[0];
1164 unregister_netdevice(t->dev);
1165}
1166
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167/**
1168 * ip6_tunnel_cleanup - free resources and unregister protocol
1169 **/
1170
1171static void __exit ip6_tunnel_cleanup(void)
1172{
Herbert Xud2acc342006-03-28 01:12:13 -08001173 if (xfrm6_tunnel_deregister(&ip6ip6_handler))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 printk(KERN_INFO "ip6ip6 close: can't deregister tunnel\n");
1175
Yasuyuki Kozakaib3fdd9f2006-11-06 10:06:22 -08001176 rtnl_lock();
1177 ip6ip6_destroy_tunnels();
1178 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179}
1180
1181module_init(ip6_tunnel_init);
1182module_exit(ip6_tunnel_cleanup);