blob: 37ab39170175f543142dff2c816469c4f04a9b16 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002 * Linux NET3: IP/IP protocol decoder.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Version: $Id: ipip.c,v 1.50 2001/10/02 02:22:36 davem Exp $
5 *
6 * Authors:
7 * Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95
8 *
9 * Fixes:
10 * Alan Cox : Merged and made usable non modular (its so tiny its silly as
11 * a module taking up 2 pages).
12 * Alan Cox : Fixed bug with 1.3.18 and IPIP not working (now needs to set skb->h.iph)
13 * to keep ip_forward happy.
14 * Alan Cox : More fixes for 1.3.21, and firewall fix. Maybe this will work soon 8).
15 * Kai Schulte : Fixed #defines for IP_FIREWALL->FIREWALL
16 * David Woodhouse : Perform some basic ICMP handling.
17 * IPIP Routing without decapsulation.
18 * Carlos Picoto : GRE over IP support
19 * Alexey Kuznetsov: Reworked. Really, now it is truncated version of ipv4/ip_gre.c.
20 * I do not want to merge them together.
21 *
22 * This program is free software; you can redistribute it and/or
23 * modify it under the terms of the GNU General Public License
24 * as published by the Free Software Foundation; either version
25 * 2 of the License, or (at your option) any later version.
26 *
27 */
28
29/* tunnel.c: an IP tunnel driver
30
31 The purpose of this driver is to provide an IP tunnel through
32 which you can tunnel network traffic transparently across subnets.
33
34 This was written by looking at Nick Holloway's dummy driver
35 Thanks for the great code!
36
37 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090038
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 Minor tweaks:
40 Cleaned up the code a little and added some pre-1.3.0 tweaks.
41 dev->hard_header/hard_header_len changed to use no headers.
42 Comments/bracketing tweaked.
43 Made the tunnels use dev->name not tunnel: when error reporting.
44 Added tx_dropped stat
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090045
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 -Alan Cox (Alan.Cox@linux.org) 21 March 95
47
48 Reworked:
49 Changed to tunnel to destination gateway in addition to the
50 tunnel's pointopoint address
51 Almost completely rewritten
52 Note: There is currently no firewall or ICMP handling done.
53
54 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/13/96
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090055
Linus Torvalds1da177e2005-04-16 15:20:36 -070056*/
57
58/* Things I wish I had known when writing the tunnel driver:
59
60 When the tunnel_xmit() function is called, the skb contains the
61 packet to be sent (plus a great deal of extra info), and dev
62 contains the tunnel device that _we_ are.
63
64 When we are passed a packet, we are expected to fill in the
65 source address with our source IP address.
66
67 What is the proper way to allocate, copy and free a buffer?
68 After you allocate it, it is a "0 length" chunk of memory
69 starting at zero. If you want to add headers to the buffer
70 later, you'll have to call "skb_reserve(skb, amount)" with
71 the amount of memory you want reserved. Then, you call
72 "skb_put(skb, amount)" with the amount of space you want in
73 the buffer. skb_put() returns a pointer to the top (#0) of
74 that buffer. skb->len is set to the amount of space you have
75 "allocated" with skb_put(). You can then write up to skb->len
76 bytes to that buffer. If you need more, you can call skb_put()
77 again with the additional amount of space you need. You can
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090078 find out how much more space you can allocate by calling
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 "skb_tailroom(skb)".
80 Now, to add header space, call "skb_push(skb, header_len)".
81 This creates space at the beginning of the buffer and returns
82 a pointer to this new space. If later you need to strip a
83 header from a buffer, call "skb_pull(skb, header_len)".
84 skb_headroom() will return how much space is left at the top
85 of the buffer (before the main data). Remember, this headroom
86 space must be reserved before the skb_put() function is called.
87 */
88
89/*
90 This version of net/ipv4/ipip.c is cloned of net/ipv4/ip_gre.c
91
92 For comments look at net/ipv4/ip_gre.c --ANK
93 */
94
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090095
Randy Dunlap4fc268d2006-01-11 12:17:47 -080096#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070097#include <linux/module.h>
98#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070099#include <linux/kernel.h>
100#include <asm/uaccess.h>
101#include <linux/skbuff.h>
102#include <linux/netdevice.h>
103#include <linux/in.h>
104#include <linux/tcp.h>
105#include <linux/udp.h>
106#include <linux/if_arp.h>
107#include <linux/mroute.h>
108#include <linux/init.h>
109#include <linux/netfilter_ipv4.h>
Kris Katterjohn46f25df2006-01-05 16:35:42 -0800110#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
112#include <net/sock.h>
113#include <net/ip.h>
114#include <net/icmp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115#include <net/ipip.h>
116#include <net/inet_ecn.h>
117#include <net/xfrm.h>
118
119#define HASH_SIZE 16
Al Virod5a0a1e2006-11-08 00:23:14 -0800120#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
122static int ipip_fb_tunnel_init(struct net_device *dev);
123static int ipip_tunnel_init(struct net_device *dev);
124static void ipip_tunnel_setup(struct net_device *dev);
125
126static struct net_device *ipip_fb_tunnel_dev;
127
128static struct ip_tunnel *tunnels_r_l[HASH_SIZE];
129static struct ip_tunnel *tunnels_r[HASH_SIZE];
130static struct ip_tunnel *tunnels_l[HASH_SIZE];
131static struct ip_tunnel *tunnels_wc[1];
132static struct ip_tunnel **tunnels[4] = { tunnels_wc, tunnels_l, tunnels_r, tunnels_r_l };
133
134static DEFINE_RWLOCK(ipip_lock);
135
Al Virod5a0a1e2006-11-08 00:23:14 -0800136static struct ip_tunnel * ipip_tunnel_lookup(__be32 remote, __be32 local)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137{
138 unsigned h0 = HASH(remote);
139 unsigned h1 = HASH(local);
140 struct ip_tunnel *t;
141
142 for (t = tunnels_r_l[h0^h1]; t; t = t->next) {
143 if (local == t->parms.iph.saddr &&
144 remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
145 return t;
146 }
147 for (t = tunnels_r[h0]; t; t = t->next) {
148 if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
149 return t;
150 }
151 for (t = tunnels_l[h1]; t; t = t->next) {
152 if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
153 return t;
154 }
155 if ((t = tunnels_wc[0]) != NULL && (t->dev->flags&IFF_UP))
156 return t;
157 return NULL;
158}
159
160static struct ip_tunnel **ipip_bucket(struct ip_tunnel *t)
161{
Al Virod5a0a1e2006-11-08 00:23:14 -0800162 __be32 remote = t->parms.iph.daddr;
163 __be32 local = t->parms.iph.saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 unsigned h = 0;
165 int prio = 0;
166
167 if (remote) {
168 prio |= 2;
169 h ^= HASH(remote);
170 }
171 if (local) {
172 prio |= 1;
173 h ^= HASH(local);
174 }
175 return &tunnels[prio][h];
176}
177
178
179static void ipip_tunnel_unlink(struct ip_tunnel *t)
180{
181 struct ip_tunnel **tp;
182
183 for (tp = ipip_bucket(t); *tp; tp = &(*tp)->next) {
184 if (t == *tp) {
185 write_lock_bh(&ipip_lock);
186 *tp = t->next;
187 write_unlock_bh(&ipip_lock);
188 break;
189 }
190 }
191}
192
193static void ipip_tunnel_link(struct ip_tunnel *t)
194{
195 struct ip_tunnel **tp = ipip_bucket(t);
196
197 t->next = *tp;
198 write_lock_bh(&ipip_lock);
199 *tp = t;
200 write_unlock_bh(&ipip_lock);
201}
202
203static struct ip_tunnel * ipip_tunnel_locate(struct ip_tunnel_parm *parms, int create)
204{
Al Virod5a0a1e2006-11-08 00:23:14 -0800205 __be32 remote = parms->iph.daddr;
206 __be32 local = parms->iph.saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 struct ip_tunnel *t, **tp, *nt;
208 struct net_device *dev;
209 unsigned h = 0;
210 int prio = 0;
211 char name[IFNAMSIZ];
212
213 if (remote) {
214 prio |= 2;
215 h ^= HASH(remote);
216 }
217 if (local) {
218 prio |= 1;
219 h ^= HASH(local);
220 }
221 for (tp = &tunnels[prio][h]; (t = *tp) != NULL; tp = &t->next) {
222 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
223 return t;
224 }
225 if (!create)
226 return NULL;
227
228 if (parms->name[0])
229 strlcpy(name, parms->name, IFNAMSIZ);
230 else {
231 int i;
232 for (i=1; i<100; i++) {
233 sprintf(name, "tunl%d", i);
234 if (__dev_get_by_name(name) == NULL)
235 break;
236 }
237 if (i==100)
238 goto failed;
239 }
240
241 dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
242 if (dev == NULL)
243 return NULL;
244
Patrick McHardy2941a482006-01-08 22:05:26 -0800245 nt = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 SET_MODULE_OWNER(dev);
247 dev->init = ipip_tunnel_init;
248 nt->parms = *parms;
249
250 if (register_netdevice(dev) < 0) {
251 free_netdev(dev);
252 goto failed;
253 }
254
255 dev_hold(dev);
256 ipip_tunnel_link(nt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 return nt;
258
259failed:
260 return NULL;
261}
262
263static void ipip_tunnel_uninit(struct net_device *dev)
264{
265 if (dev == ipip_fb_tunnel_dev) {
266 write_lock_bh(&ipip_lock);
267 tunnels_wc[0] = NULL;
268 write_unlock_bh(&ipip_lock);
269 } else
Patrick McHardy2941a482006-01-08 22:05:26 -0800270 ipip_tunnel_unlink(netdev_priv(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 dev_put(dev);
272}
273
Herbert Xud2acc342006-03-28 01:12:13 -0800274static int ipip_err(struct sk_buff *skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275{
276#ifndef I_WISH_WORLD_WERE_PERFECT
277
278/* It is not :-( All the routers (except for Linux) return only
279 8 bytes of packet payload. It means, that precise relaying of
280 ICMP in the real Internet is absolutely infeasible.
281 */
282 struct iphdr *iph = (struct iphdr*)skb->data;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300283 const int type = icmp_hdr(skb)->type;
284 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 struct ip_tunnel *t;
Herbert Xud2acc342006-03-28 01:12:13 -0800286 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 switch (type) {
289 default:
290 case ICMP_PARAMETERPROB:
Herbert Xud2acc342006-03-28 01:12:13 -0800291 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
293 case ICMP_DEST_UNREACH:
294 switch (code) {
295 case ICMP_SR_FAILED:
296 case ICMP_PORT_UNREACH:
297 /* Impossible event. */
Herbert Xud2acc342006-03-28 01:12:13 -0800298 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 case ICMP_FRAG_NEEDED:
300 /* Soft state for pmtu is maintained by IP core. */
Herbert Xud2acc342006-03-28 01:12:13 -0800301 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 default:
303 /* All others are translated to HOST_UNREACH.
304 rfc2003 contains "deep thoughts" about NET_UNREACH,
305 I believe they are just ether pollution. --ANK
306 */
307 break;
308 }
309 break;
310 case ICMP_TIME_EXCEEDED:
311 if (code != ICMP_EXC_TTL)
Herbert Xud2acc342006-03-28 01:12:13 -0800312 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 break;
314 }
315
Herbert Xud2acc342006-03-28 01:12:13 -0800316 err = -ENOENT;
317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 read_lock(&ipip_lock);
319 t = ipip_tunnel_lookup(iph->daddr, iph->saddr);
320 if (t == NULL || t->parms.iph.daddr == 0)
321 goto out;
Herbert Xud2acc342006-03-28 01:12:13 -0800322
323 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
325 goto out;
326
327 if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
328 t->err_count++;
329 else
330 t->err_count = 1;
331 t->err_time = jiffies;
332out:
333 read_unlock(&ipip_lock);
Herbert Xud2acc342006-03-28 01:12:13 -0800334 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335#else
336 struct iphdr *iph = (struct iphdr*)dp;
337 int hlen = iph->ihl<<2;
338 struct iphdr *eiph;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300339 const int type = icmp_hdr(skb)->type;
340 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 int rel_type = 0;
342 int rel_code = 0;
Al Viroc55e2f42006-09-19 13:23:19 -0700343 __be32 rel_info = 0;
344 __u32 n = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 struct sk_buff *skb2;
346 struct flowi fl;
347 struct rtable *rt;
348
349 if (len < hlen + sizeof(struct iphdr))
Herbert Xud2acc342006-03-28 01:12:13 -0800350 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 eiph = (struct iphdr*)(dp + hlen);
352
353 switch (type) {
354 default:
Herbert Xud2acc342006-03-28 01:12:13 -0800355 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 case ICMP_PARAMETERPROB:
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300357 n = ntohl(icmp_hdr(skb)->un.gateway) >> 24;
Al Viroc55e2f42006-09-19 13:23:19 -0700358 if (n < hlen)
Herbert Xud2acc342006-03-28 01:12:13 -0800359 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
361 /* So... This guy found something strange INSIDE encapsulated
362 packet. Well, he is fool, but what can we do ?
363 */
364 rel_type = ICMP_PARAMETERPROB;
Al Viroc55e2f42006-09-19 13:23:19 -0700365 rel_info = htonl((n - hlen) << 24);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 break;
367
368 case ICMP_DEST_UNREACH:
369 switch (code) {
370 case ICMP_SR_FAILED:
371 case ICMP_PORT_UNREACH:
372 /* Impossible event. */
Herbert Xud2acc342006-03-28 01:12:13 -0800373 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 case ICMP_FRAG_NEEDED:
375 /* And it is the only really necessary thing :-) */
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300376 n = ntohs(icmp_hdr(skb)->un.frag.mtu);
Al Viroc55e2f42006-09-19 13:23:19 -0700377 if (n < hlen+68)
Herbert Xud2acc342006-03-28 01:12:13 -0800378 return 0;
Al Viroc55e2f42006-09-19 13:23:19 -0700379 n -= hlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 /* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
Al Viroc55e2f42006-09-19 13:23:19 -0700381 if (n > ntohs(eiph->tot_len))
Herbert Xud2acc342006-03-28 01:12:13 -0800382 return 0;
Al Viroc55e2f42006-09-19 13:23:19 -0700383 rel_info = htonl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 break;
385 default:
386 /* All others are translated to HOST_UNREACH.
387 rfc2003 contains "deep thoughts" about NET_UNREACH,
388 I believe, it is just ether pollution. --ANK
389 */
390 rel_type = ICMP_DEST_UNREACH;
391 rel_code = ICMP_HOST_UNREACH;
392 break;
393 }
394 break;
395 case ICMP_TIME_EXCEEDED:
396 if (code != ICMP_EXC_TTL)
Herbert Xud2acc342006-03-28 01:12:13 -0800397 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 break;
399 }
400
401 /* Prepare fake skb to feed it to icmp_send */
402 skb2 = skb_clone(skb, GFP_ATOMIC);
403 if (skb2 == NULL)
Herbert Xud2acc342006-03-28 01:12:13 -0800404 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 dst_release(skb2->dst);
406 skb2->dst = NULL;
407 skb_pull(skb2, skb->data - (u8*)eiph);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700408 skb_reset_network_header(skb2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
410 /* Try to guess incoming interface */
411 memset(&fl, 0, sizeof(fl));
412 fl.fl4_daddr = eiph->saddr;
413 fl.fl4_tos = RT_TOS(eiph->tos);
414 fl.proto = IPPROTO_IPIP;
415 if (ip_route_output_key(&rt, &key)) {
416 kfree_skb(skb2);
Herbert Xud2acc342006-03-28 01:12:13 -0800417 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 }
419 skb2->dev = rt->u.dst.dev;
420
421 /* route "incoming" packet */
422 if (rt->rt_flags&RTCF_LOCAL) {
423 ip_rt_put(rt);
424 rt = NULL;
425 fl.fl4_daddr = eiph->daddr;
426 fl.fl4_src = eiph->saddr;
427 fl.fl4_tos = eiph->tos;
428 if (ip_route_output_key(&rt, &fl) ||
429 rt->u.dst.dev->type != ARPHRD_TUNNEL) {
430 ip_rt_put(rt);
431 kfree_skb(skb2);
Herbert Xud2acc342006-03-28 01:12:13 -0800432 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 }
434 } else {
435 ip_rt_put(rt);
436 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
437 skb2->dst->dev->type != ARPHRD_TUNNEL) {
438 kfree_skb(skb2);
Herbert Xud2acc342006-03-28 01:12:13 -0800439 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 }
441 }
442
443 /* change mtu on this route */
444 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
Al Viroc55e2f42006-09-19 13:23:19 -0700445 if (n > dst_mtu(skb2->dst)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 kfree_skb(skb2);
Herbert Xud2acc342006-03-28 01:12:13 -0800447 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 }
Al Viroc55e2f42006-09-19 13:23:19 -0700449 skb2->dst->ops->update_pmtu(skb2->dst, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 } else if (type == ICMP_TIME_EXCEEDED) {
Patrick McHardy2941a482006-01-08 22:05:26 -0800451 struct ip_tunnel *t = netdev_priv(skb2->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 if (t->parms.iph.ttl) {
453 rel_type = ICMP_DEST_UNREACH;
454 rel_code = ICMP_HOST_UNREACH;
455 }
456 }
457
458 icmp_send(skb2, rel_type, rel_code, rel_info);
459 kfree_skb(skb2);
Herbert Xud2acc342006-03-28 01:12:13 -0800460 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461#endif
462}
463
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700464static inline void ipip_ecn_decapsulate(const struct iphdr *outer_iph,
465 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700467 struct iphdr *inner_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
469 if (INET_ECN_is_ce(outer_iph->tos))
470 IP_ECN_set_ce(inner_iph);
471}
472
473static int ipip_rcv(struct sk_buff *skb)
474{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 struct ip_tunnel *tunnel;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700476 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
478 read_lock(&ipip_lock);
479 if ((tunnel = ipip_tunnel_lookup(iph->saddr, iph->daddr)) != NULL) {
480 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
481 read_unlock(&ipip_lock);
482 kfree_skb(skb);
483 return 0;
484 }
485
486 secpath_reset(skb);
487
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700488 skb->mac_header = skb->network_header;
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700489 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 skb->protocol = htons(ETH_P_IP);
491 skb->pkt_type = PACKET_HOST;
492
493 tunnel->stat.rx_packets++;
494 tunnel->stat.rx_bytes += skb->len;
495 skb->dev = tunnel->dev;
496 dst_release(skb->dst);
497 skb->dst = NULL;
498 nf_reset(skb);
499 ipip_ecn_decapsulate(iph, skb);
500 netif_rx(skb);
501 read_unlock(&ipip_lock);
502 return 0;
503 }
504 read_unlock(&ipip_lock);
505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 return -1;
507}
508
509/*
510 * This function assumes it is being called from dev_queue_xmit()
511 * and that skb is filled properly by that function.
512 */
513
514static int ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
515{
Patrick McHardy2941a482006-01-08 22:05:26 -0800516 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 struct net_device_stats *stats = &tunnel->stat;
518 struct iphdr *tiph = &tunnel->parms.iph;
519 u8 tos = tunnel->parms.iph.tos;
Al Virod5a0a1e2006-11-08 00:23:14 -0800520 __be16 df = tiph->frag_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 struct rtable *rt; /* Route to the other host */
522 struct net_device *tdev; /* Device to other host */
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700523 struct iphdr *old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 struct iphdr *iph; /* Our new IP header */
525 int max_headroom; /* The extra header space needed */
Al Virod5a0a1e2006-11-08 00:23:14 -0800526 __be32 dst = tiph->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 int mtu;
528
529 if (tunnel->recursion++) {
530 tunnel->stat.collisions++;
531 goto tx_error;
532 }
533
534 if (skb->protocol != htons(ETH_P_IP))
535 goto tx_error;
536
537 if (tos&1)
538 tos = old_iph->tos;
539
540 if (!dst) {
541 /* NBMA tunnel */
542 if ((rt = (struct rtable*)skb->dst) == NULL) {
543 tunnel->stat.tx_fifo_errors++;
544 goto tx_error;
545 }
546 if ((dst = rt->rt_gateway) == 0)
547 goto tx_error_icmp;
548 }
549
550 {
551 struct flowi fl = { .oif = tunnel->parms.link,
552 .nl_u = { .ip4_u =
553 { .daddr = dst,
554 .saddr = tiph->saddr,
555 .tos = RT_TOS(tos) } },
556 .proto = IPPROTO_IPIP };
557 if (ip_route_output_key(&rt, &fl)) {
558 tunnel->stat.tx_carrier_errors++;
559 goto tx_error_icmp;
560 }
561 }
562 tdev = rt->u.dst.dev;
563
564 if (tdev == dev) {
565 ip_rt_put(rt);
566 tunnel->stat.collisions++;
567 goto tx_error;
568 }
569
570 if (tiph->frag_off)
571 mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr);
572 else
573 mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
574
575 if (mtu < 68) {
576 tunnel->stat.collisions++;
577 ip_rt_put(rt);
578 goto tx_error;
579 }
580 if (skb->dst)
581 skb->dst->ops->update_pmtu(skb->dst, mtu);
582
583 df |= (old_iph->frag_off&htons(IP_DF));
584
585 if ((old_iph->frag_off&htons(IP_DF)) && mtu < ntohs(old_iph->tot_len)) {
586 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
587 ip_rt_put(rt);
588 goto tx_error;
589 }
590
591 if (tunnel->err_count > 0) {
592 if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
593 tunnel->err_count--;
594 dst_link_failure(skb);
595 } else
596 tunnel->err_count = 0;
597 }
598
599 /*
600 * Okay, now see if we can stuff it in the buffer as-is.
601 */
602 max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
603
604 if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
605 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
606 if (!new_skb) {
607 ip_rt_put(rt);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900608 stats->tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 dev_kfree_skb(skb);
610 tunnel->recursion--;
611 return 0;
612 }
613 if (skb->sk)
614 skb_set_owner_w(new_skb, skb->sk);
615 dev_kfree_skb(skb);
616 skb = new_skb;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700617 old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 }
619
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700620 skb->transport_header = skb->network_header;
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700621 skb_push(skb, sizeof(struct iphdr));
622 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
Patrick McHardy48d5cad2006-02-15 15:10:22 -0800624 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
625 IPSKB_REROUTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 dst_release(skb->dst);
627 skb->dst = &rt->u.dst;
628
629 /*
630 * Push down and install the IPIP header.
631 */
632
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700633 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 iph->version = 4;
635 iph->ihl = sizeof(struct iphdr)>>2;
636 iph->frag_off = df;
637 iph->protocol = IPPROTO_IPIP;
638 iph->tos = INET_ECN_encapsulate(tos, old_iph->tos);
639 iph->daddr = rt->rt_dst;
640 iph->saddr = rt->rt_src;
641
642 if ((iph->ttl = tiph->ttl) == 0)
643 iph->ttl = old_iph->ttl;
644
645 nf_reset(skb);
646
647 IPTUNNEL_XMIT();
648 tunnel->recursion--;
649 return 0;
650
651tx_error_icmp:
652 dst_link_failure(skb);
653tx_error:
654 stats->tx_errors++;
655 dev_kfree_skb(skb);
656 tunnel->recursion--;
657 return 0;
658}
659
660static int
661ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
662{
663 int err = 0;
664 struct ip_tunnel_parm p;
665 struct ip_tunnel *t;
666
667 switch (cmd) {
668 case SIOCGETTUNNEL:
669 t = NULL;
670 if (dev == ipip_fb_tunnel_dev) {
671 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
672 err = -EFAULT;
673 break;
674 }
675 t = ipip_tunnel_locate(&p, 0);
676 }
677 if (t == NULL)
Patrick McHardy2941a482006-01-08 22:05:26 -0800678 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 memcpy(&p, &t->parms, sizeof(p));
680 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
681 err = -EFAULT;
682 break;
683
684 case SIOCADDTUNNEL:
685 case SIOCCHGTUNNEL:
686 err = -EPERM;
687 if (!capable(CAP_NET_ADMIN))
688 goto done;
689
690 err = -EFAULT;
691 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
692 goto done;
693
694 err = -EINVAL;
695 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
696 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
697 goto done;
698 if (p.iph.ttl)
699 p.iph.frag_off |= htons(IP_DF);
700
701 t = ipip_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
702
703 if (dev != ipip_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
704 if (t != NULL) {
705 if (t->dev != dev) {
706 err = -EEXIST;
707 break;
708 }
709 } else {
710 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
711 (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
712 err = -EINVAL;
713 break;
714 }
Patrick McHardy2941a482006-01-08 22:05:26 -0800715 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 ipip_tunnel_unlink(t);
717 t->parms.iph.saddr = p.iph.saddr;
718 t->parms.iph.daddr = p.iph.daddr;
719 memcpy(dev->dev_addr, &p.iph.saddr, 4);
720 memcpy(dev->broadcast, &p.iph.daddr, 4);
721 ipip_tunnel_link(t);
722 netdev_state_change(dev);
723 }
724 }
725
726 if (t) {
727 err = 0;
728 if (cmd == SIOCCHGTUNNEL) {
729 t->parms.iph.ttl = p.iph.ttl;
730 t->parms.iph.tos = p.iph.tos;
731 t->parms.iph.frag_off = p.iph.frag_off;
732 }
733 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
734 err = -EFAULT;
735 } else
736 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
737 break;
738
739 case SIOCDELTUNNEL:
740 err = -EPERM;
741 if (!capable(CAP_NET_ADMIN))
742 goto done;
743
744 if (dev == ipip_fb_tunnel_dev) {
745 err = -EFAULT;
746 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
747 goto done;
748 err = -ENOENT;
749 if ((t = ipip_tunnel_locate(&p, 0)) == NULL)
750 goto done;
751 err = -EPERM;
752 if (t->dev == ipip_fb_tunnel_dev)
753 goto done;
754 dev = t->dev;
755 }
Stephen Hemminger22f8cde2007-02-07 00:09:58 -0800756 unregister_netdevice(dev);
757 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 break;
759
760 default:
761 err = -EINVAL;
762 }
763
764done:
765 return err;
766}
767
768static struct net_device_stats *ipip_tunnel_get_stats(struct net_device *dev)
769{
Patrick McHardy2941a482006-01-08 22:05:26 -0800770 return &(((struct ip_tunnel*)netdev_priv(dev))->stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771}
772
773static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
774{
775 if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
776 return -EINVAL;
777 dev->mtu = new_mtu;
778 return 0;
779}
780
781static void ipip_tunnel_setup(struct net_device *dev)
782{
783 SET_MODULE_OWNER(dev);
784 dev->uninit = ipip_tunnel_uninit;
785 dev->hard_start_xmit = ipip_tunnel_xmit;
786 dev->get_stats = ipip_tunnel_get_stats;
787 dev->do_ioctl = ipip_tunnel_ioctl;
788 dev->change_mtu = ipip_tunnel_change_mtu;
789 dev->destructor = free_netdev;
790
791 dev->type = ARPHRD_TUNNEL;
792 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr);
Kris Katterjohn46f25df2006-01-05 16:35:42 -0800793 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 dev->flags = IFF_NOARP;
795 dev->iflink = 0;
796 dev->addr_len = 4;
797}
798
799static int ipip_tunnel_init(struct net_device *dev)
800{
801 struct net_device *tdev = NULL;
802 struct ip_tunnel *tunnel;
803 struct iphdr *iph;
804
Patrick McHardy2941a482006-01-08 22:05:26 -0800805 tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 iph = &tunnel->parms.iph;
807
808 tunnel->dev = dev;
809 strcpy(tunnel->parms.name, dev->name);
810
811 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
812 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
813
814 if (iph->daddr) {
815 struct flowi fl = { .oif = tunnel->parms.link,
816 .nl_u = { .ip4_u =
817 { .daddr = iph->daddr,
818 .saddr = iph->saddr,
819 .tos = RT_TOS(iph->tos) } },
820 .proto = IPPROTO_IPIP };
821 struct rtable *rt;
822 if (!ip_route_output_key(&rt, &fl)) {
823 tdev = rt->u.dst.dev;
824 ip_rt_put(rt);
825 }
826 dev->flags |= IFF_POINTOPOINT;
827 }
828
829 if (!tdev && tunnel->parms.link)
830 tdev = __dev_get_by_index(tunnel->parms.link);
831
832 if (tdev) {
833 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
834 dev->mtu = tdev->mtu - sizeof(struct iphdr);
835 }
836 dev->iflink = tunnel->parms.link;
837
838 return 0;
839}
840
841static int __init ipip_fb_tunnel_init(struct net_device *dev)
842{
Patrick McHardy2941a482006-01-08 22:05:26 -0800843 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 struct iphdr *iph = &tunnel->parms.iph;
845
846 tunnel->dev = dev;
847 strcpy(tunnel->parms.name, dev->name);
848
849 iph->version = 4;
850 iph->protocol = IPPROTO_IPIP;
851 iph->ihl = 5;
852
853 dev_hold(dev);
854 tunnels_wc[0] = tunnel;
855 return 0;
856}
857
858static struct xfrm_tunnel ipip_handler = {
859 .handler = ipip_rcv,
860 .err_handler = ipip_err,
Herbert Xud2acc342006-03-28 01:12:13 -0800861 .priority = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862};
863
864static char banner[] __initdata =
865 KERN_INFO "IPv4 over IPv4 tunneling driver\n";
866
867static int __init ipip_init(void)
868{
869 int err;
870
871 printk(banner);
872
Kazunori MIYAZAWAc0d56402007-02-13 12:54:47 -0800873 if (xfrm4_tunnel_register(&ipip_handler, AF_INET)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 printk(KERN_INFO "ipip init: can't register tunnel\n");
875 return -EAGAIN;
876 }
877
878 ipip_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
879 "tunl0",
880 ipip_tunnel_setup);
881 if (!ipip_fb_tunnel_dev) {
882 err = -ENOMEM;
883 goto err1;
884 }
885
886 ipip_fb_tunnel_dev->init = ipip_fb_tunnel_init;
887
888 if ((err = register_netdev(ipip_fb_tunnel_dev)))
889 goto err2;
890 out:
891 return err;
892 err2:
893 free_netdev(ipip_fb_tunnel_dev);
894 err1:
Kazunori MIYAZAWAc0d56402007-02-13 12:54:47 -0800895 xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 goto out;
897}
898
Alexey Kuznetsovdb445752005-07-30 17:46:44 -0700899static void __exit ipip_destroy_tunnels(void)
900{
901 int prio;
902
903 for (prio = 1; prio < 4; prio++) {
904 int h;
905 for (h = 0; h < HASH_SIZE; h++) {
906 struct ip_tunnel *t;
907 while ((t = tunnels[prio][h]) != NULL)
908 unregister_netdevice(t->dev);
909 }
910 }
911}
912
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913static void __exit ipip_fini(void)
914{
Kazunori MIYAZAWAc0d56402007-02-13 12:54:47 -0800915 if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 printk(KERN_INFO "ipip close: can't deregister tunnel\n");
917
Alexey Kuznetsovdb445752005-07-30 17:46:44 -0700918 rtnl_lock();
919 ipip_destroy_tunnels();
920 unregister_netdevice(ipip_fb_tunnel_dev);
921 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922}
923
924module_init(ipip_init);
925module_exit(ipip_fini);
926MODULE_LICENSE("GPL");