]> bbs.cooldavid.org Git - net-next-2.6.git/blame - net/ipv4/ipip.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] capable/capability.h (fs/)
[net-next-2.6.git] / net / ipv4 / ipip.c
CommitLineData
1da177e4
LT		 1/*
2 * Linux NET3: IP/IP protocol decoder.
3 *
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
38
39 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
45
46 -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
55
56*/
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
78 find out how much more space you can allocate by calling
79 "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
95
96#include <linux/config.h>
97#include <linux/module.h>
98#include <linux/types.h>
99#include <linux/sched.h>
100#include <linux/kernel.h>
101#include <asm/uaccess.h>
102#include <linux/skbuff.h>
103#include <linux/netdevice.h>
104#include <linux/in.h>
105#include <linux/tcp.h>
106#include <linux/udp.h>
107#include <linux/if_arp.h>
108#include <linux/mroute.h>
109#include <linux/init.h>
110#include <linux/netfilter_ipv4.h>
46f25dff 111#include <linux/if_ether.h>
1da177e4
LT		 112
113#include <net/sock.h>
114#include <net/ip.h>
115#include <net/icmp.h>
116#include <net/protocol.h>
117#include <net/ipip.h>
118#include <net/inet_ecn.h>
119#include <net/xfrm.h>
120
121#define HASH_SIZE 16
122#define HASH(addr) ((addr^(addr>>4))&0xF)
123
124static int ipip_fb_tunnel_init(struct net_device *dev);
125static int ipip_tunnel_init(struct net_device *dev);
126static void ipip_tunnel_setup(struct net_device *dev);
127
128static struct net_device *ipip_fb_tunnel_dev;
129
130static struct ip_tunnel *tunnels_r_l[HASH_SIZE];
131static struct ip_tunnel *tunnels_r[HASH_SIZE];
132static struct ip_tunnel *tunnels_l[HASH_SIZE];
133static struct ip_tunnel *tunnels_wc[1];
134static struct ip_tunnel **tunnels[4] = { tunnels_wc, tunnels_l, tunnels_r, tunnels_r_l };
135
136static DEFINE_RWLOCK(ipip_lock);
137
138static struct ip_tunnel * ipip_tunnel_lookup(u32 remote, u32 local)
139{
140 unsigned h0 = HASH(remote);
141 unsigned h1 = HASH(local);
142 struct ip_tunnel *t;
143
144 for (t = tunnels_r_l[h0^h1]; t; t = t->next) {
145 if (local == t->parms.iph.saddr &&
146 remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
147 return t;
148 }
149 for (t = tunnels_r[h0]; t; t = t->next) {
150 if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
151 return t;
152 }
153 for (t = tunnels_l[h1]; t; t = t->next) {
154 if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
155 return t;
156 }
157 if ((t = tunnels_wc[0]) != NULL && (t->dev->flags&IFF_UP))
158 return t;
159 return NULL;
160}
161
162static struct ip_tunnel **ipip_bucket(struct ip_tunnel *t)
163{
164 u32 remote = t->parms.iph.daddr;
165 u32 local = t->parms.iph.saddr;
166 unsigned h = 0;
167 int prio = 0;
168
169 if (remote) {
170 prio |= 2;
171 h ^= HASH(remote);
172 }
173 if (local) {
174 prio |= 1;
175 h ^= HASH(local);
176 }
177 return &tunnels[prio][h];
178}
179
180
181static void ipip_tunnel_unlink(struct ip_tunnel *t)
182{
183 struct ip_tunnel **tp;
184
185 for (tp = ipip_bucket(t); *tp; tp = &(*tp)->next) {
186 if (t == *tp) {
187 write_lock_bh(&ipip_lock);
188 *tp = t->next;
189 write_unlock_bh(&ipip_lock);
190 break;
191 }
192 }
193}
194
195static void ipip_tunnel_link(struct ip_tunnel *t)
196{
197 struct ip_tunnel **tp = ipip_bucket(t);
198
199 t->next = *tp;
200 write_lock_bh(&ipip_lock);
201 *tp = t;
202 write_unlock_bh(&ipip_lock);
203}
204
205static struct ip_tunnel * ipip_tunnel_locate(struct ip_tunnel_parm *parms, int create)
206{
207 u32 remote = parms->iph.daddr;
208 u32 local = parms->iph.saddr;
209 struct ip_tunnel *t, **tp, *nt;
210 struct net_device *dev;
211 unsigned h = 0;
212 int prio = 0;
213 char name[IFNAMSIZ];
214
215 if (remote) {
216 prio |= 2;
217 h ^= HASH(remote);
218 }
219 if (local) {
220 prio |= 1;
221 h ^= HASH(local);
222 }
223 for (tp = &tunnels[prio][h]; (t = *tp) != NULL; tp = &t->next) {
224 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
225 return t;
226 }
227 if (!create)
228 return NULL;
229
230 if (parms->name[0])
231 strlcpy(name, parms->name, IFNAMSIZ);
232 else {
233 int i;
234 for (i=1; i<100; i++) {
235 sprintf(name, "tunl%d", i);
236 if (__dev_get_by_name(name) == NULL)
237 break;
238 }
239 if (i==100)
240 goto failed;
241 }
242
243 dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
244 if (dev == NULL)
245 return NULL;
246
2941a486 247 nt = netdev_priv(dev);
1da177e4
LT		 248 SET_MODULE_OWNER(dev);
249 dev->init = ipip_tunnel_init;
250 nt->parms = *parms;
251
252 if (register_netdevice(dev) < 0) {
253 free_netdev(dev);
254 goto failed;
255 }
256
257 dev_hold(dev);
258 ipip_tunnel_link(nt);
1da177e4
LT		 259 return nt;
260
261failed:
262 return NULL;
263}
264
265static void ipip_tunnel_uninit(struct net_device *dev)
266{
267 if (dev == ipip_fb_tunnel_dev) {
268 write_lock_bh(&ipip_lock);
269 tunnels_wc[0] = NULL;
270 write_unlock_bh(&ipip_lock);
271 } else
2941a486 272 ipip_tunnel_unlink(netdev_priv(dev));
1da177e4
LT		 273 dev_put(dev);
274}
275
0303770d 276static void ipip_err(struct sk_buff *skb, u32 info)
1da177e4
LT		 277{
278#ifndef I_WISH_WORLD_WERE_PERFECT
279
280/* It is not :-( All the routers (except for Linux) return only
281 8 bytes of packet payload. It means, that precise relaying of
282 ICMP in the real Internet is absolutely infeasible.
283 */
284 struct iphdr *iph = (struct iphdr*)skb->data;
285 int type = skb->h.icmph->type;
286 int code = skb->h.icmph->code;
287 struct ip_tunnel *t;
288
289 switch (type) {
290 default:
291 case ICMP_PARAMETERPROB:
292 return;
293
294 case ICMP_DEST_UNREACH:
295 switch (code) {
296 case ICMP_SR_FAILED:
297 case ICMP_PORT_UNREACH:
298 /* Impossible event. */
299 return;
300 case ICMP_FRAG_NEEDED:
301 /* Soft state for pmtu is maintained by IP core. */
302 return;
303 default:
304 /* All others are translated to HOST_UNREACH.
305 rfc2003 contains "deep thoughts" about NET_UNREACH,
306 I believe they are just ether pollution. --ANK
307 */
308 break;
309 }
310 break;
311 case ICMP_TIME_EXCEEDED:
312 if (code != ICMP_EXC_TTL)
313 return;
314 break;
315 }
316
317 read_lock(&ipip_lock);
318 t = ipip_tunnel_lookup(iph->daddr, iph->saddr);
319 if (t == NULL || t->parms.iph.daddr == 0)
320 goto out;
321 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
322 goto out;
323
324 if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
325 t->err_count++;
326 else
327 t->err_count = 1;
328 t->err_time = jiffies;
329out:
330 read_unlock(&ipip_lock);
331 return;
332#else
333 struct iphdr *iph = (struct iphdr*)dp;
334 int hlen = iph->ihl<<2;
335 struct iphdr *eiph;
336 int type = skb->h.icmph->type;
337 int code = skb->h.icmph->code;
338 int rel_type = 0;
339 int rel_code = 0;
340 int rel_info = 0;
341 struct sk_buff *skb2;
342 struct flowi fl;
343 struct rtable *rt;
344
345 if (len < hlen + sizeof(struct iphdr))
346 return;
347 eiph = (struct iphdr*)(dp + hlen);
348
349 switch (type) {
350 default:
351 return;
352 case ICMP_PARAMETERPROB:
353 if (skb->h.icmph->un.gateway < hlen)
354 return;
355
356 /* So... This guy found something strange INSIDE encapsulated
357 packet. Well, he is fool, but what can we do ?
358 */
359 rel_type = ICMP_PARAMETERPROB;
360 rel_info = skb->h.icmph->un.gateway - hlen;
361 break;
362
363 case ICMP_DEST_UNREACH:
364 switch (code) {
365 case ICMP_SR_FAILED:
366 case ICMP_PORT_UNREACH:
367 /* Impossible event. */
368 return;
369 case ICMP_FRAG_NEEDED:
370 /* And it is the only really necessary thing :-) */
371 rel_info = ntohs(skb->h.icmph->un.frag.mtu);
372 if (rel_info < hlen+68)
373 return;
374 rel_info -= hlen;
375 /* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
376 if (rel_info > ntohs(eiph->tot_len))
377 return;
378 break;
379 default:
380 /* All others are translated to HOST_UNREACH.
381 rfc2003 contains "deep thoughts" about NET_UNREACH,
382 I believe, it is just ether pollution. --ANK
383 */
384 rel_type = ICMP_DEST_UNREACH;
385 rel_code = ICMP_HOST_UNREACH;
386 break;
387 }
388 break;
389 case ICMP_TIME_EXCEEDED:
390 if (code != ICMP_EXC_TTL)
391 return;
392 break;
393 }
394
395 /* Prepare fake skb to feed it to icmp_send */
396 skb2 = skb_clone(skb, GFP_ATOMIC);
397 if (skb2 == NULL)
398 return;
399 dst_release(skb2->dst);
400 skb2->dst = NULL;
401 skb_pull(skb2, skb->data - (u8*)eiph);
402 skb2->nh.raw = skb2->data;
403
404 /* Try to guess incoming interface */
405 memset(&fl, 0, sizeof(fl));
406 fl.fl4_daddr = eiph->saddr;
407 fl.fl4_tos = RT_TOS(eiph->tos);
408 fl.proto = IPPROTO_IPIP;
409 if (ip_route_output_key(&rt, &key)) {
410 kfree_skb(skb2);
411 return;
412 }
413 skb2->dev = rt->u.dst.dev;
414
415 /* route "incoming" packet */
416 if (rt->rt_flags&RTCF_LOCAL) {
417 ip_rt_put(rt);
418 rt = NULL;
419 fl.fl4_daddr = eiph->daddr;
420 fl.fl4_src = eiph->saddr;
421 fl.fl4_tos = eiph->tos;
422 if (ip_route_output_key(&rt, &fl) ||
423 rt->u.dst.dev->type != ARPHRD_TUNNEL) {
424 ip_rt_put(rt);
425 kfree_skb(skb2);
426 return;
427 }
428 } else {
429 ip_rt_put(rt);
430 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
431 skb2->dst->dev->type != ARPHRD_TUNNEL) {
432 kfree_skb(skb2);
433 return;
434 }
435 }
436
437 /* change mtu on this route */
438 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
439 if (rel_info > dst_mtu(skb2->dst)) {
440 kfree_skb(skb2);
441 return;
442 }
443 skb2->dst->ops->update_pmtu(skb2->dst, rel_info);
444 rel_info = htonl(rel_info);
445 } else if (type == ICMP_TIME_EXCEEDED) {
2941a486 446 struct ip_tunnel *t = netdev_priv(skb2->dev);
1da177e4
LT		 447 if (t->parms.iph.ttl) {
448 rel_type = ICMP_DEST_UNREACH;
449 rel_code = ICMP_HOST_UNREACH;
450 }
451 }
452
453 icmp_send(skb2, rel_type, rel_code, rel_info);
454 kfree_skb(skb2);
455 return;
456#endif
457}
458
459static inline void ipip_ecn_decapsulate(struct iphdr *outer_iph, struct sk_buff *skb)
460{
461 struct iphdr *inner_iph = skb->nh.iph;
462
463 if (INET_ECN_is_ce(outer_iph->tos))
464 IP_ECN_set_ce(inner_iph);
465}
466
467static int ipip_rcv(struct sk_buff *skb)
468{
469 struct iphdr *iph;
470 struct ip_tunnel *tunnel;
471
472 if (!pskb_may_pull(skb, sizeof(struct iphdr)))
473 goto out;
474
475 iph = skb->nh.iph;
476
477 read_lock(&ipip_lock);
478 if ((tunnel = ipip_tunnel_lookup(iph->saddr, iph->daddr)) != NULL) {
479 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
480 read_unlock(&ipip_lock);
481 kfree_skb(skb);
482 return 0;
483 }
484
485 secpath_reset(skb);
486
487 skb->mac.raw = skb->nh.raw;
488 skb->nh.raw = skb->data;
489 memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
490 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
506out:
507 return -1;
508}
509
510/*
511 * This function assumes it is being called from dev_queue_xmit()
512 * and that skb is filled properly by that function.
513 */
514
515static int ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
516{
2941a486 517 struct ip_tunnel *tunnel = netdev_priv(dev);
1da177e4
LT		 518 struct net_device_stats *stats = &tunnel->stat;
519 struct iphdr *tiph = &tunnel->parms.iph;
520 u8 tos = tunnel->parms.iph.tos;
521 u16 df = tiph->frag_off;
522 struct rtable *rt; /* Route to the other host */
523 struct net_device *tdev; /* Device to other host */
524 struct iphdr *old_iph = skb->nh.iph;
525 struct iphdr *iph; /* Our new IP header */
526 int max_headroom; /* The extra header space needed */
527 u32 dst = tiph->daddr;
528 int mtu;
529
530 if (tunnel->recursion++) {
531 tunnel->stat.collisions++;
532 goto tx_error;
533 }
534
535 if (skb->protocol != htons(ETH_P_IP))
536 goto tx_error;
537
538 if (tos&1)
539 tos = old_iph->tos;
540
541 if (!dst) {
542 /* NBMA tunnel */
543 if ((rt = (struct rtable*)skb->dst) == NULL) {
544 tunnel->stat.tx_fifo_errors++;
545 goto tx_error;
546 }
547 if ((dst = rt->rt_gateway) == 0)
548 goto tx_error_icmp;
549 }
550
551 {
552 struct flowi fl = { .oif = tunnel->parms.link,
553 .nl_u = { .ip4_u =
554 { .daddr = dst,
555 .saddr = tiph->saddr,
556 .tos = RT_TOS(tos) } },
557 .proto = IPPROTO_IPIP };
558 if (ip_route_output_key(&rt, &fl)) {
559 tunnel->stat.tx_carrier_errors++;
560 goto tx_error_icmp;
561 }
562 }
563 tdev = rt->u.dst.dev;
564
565 if (tdev == dev) {
566 ip_rt_put(rt);
567 tunnel->stat.collisions++;
568 goto tx_error;
569 }
570
571 if (tiph->frag_off)
572 mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr);
573 else
574 mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
575
576 if (mtu < 68) {
577 tunnel->stat.collisions++;
578 ip_rt_put(rt);
579 goto tx_error;
580 }
581 if (skb->dst)
582 skb->dst->ops->update_pmtu(skb->dst, mtu);
583
584 df |= (old_iph->frag_off&htons(IP_DF));
585
586 if ((old_iph->frag_off&htons(IP_DF)) && mtu < ntohs(old_iph->tot_len)) {
587 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
588 ip_rt_put(rt);
589 goto tx_error;
590 }
591
592 if (tunnel->err_count > 0) {
593 if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
594 tunnel->err_count--;
595 dst_link_failure(skb);
596 } else
597 tunnel->err_count = 0;
598 }
599
600 /*
601 * Okay, now see if we can stuff it in the buffer as-is.
602 */
603 max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
604
605 if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
606 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
607 if (!new_skb) {
608 ip_rt_put(rt);
609 stats->tx_dropped++;
610 dev_kfree_skb(skb);
611 tunnel->recursion--;
612 return 0;
613 }
614 if (skb->sk)
615 skb_set_owner_w(new_skb, skb->sk);
616 dev_kfree_skb(skb);
617 skb = new_skb;
618 old_iph = skb->nh.iph;
619 }
620
621 skb->h.raw = skb->nh.raw;
622 skb->nh.raw = skb_push(skb, sizeof(struct iphdr));
623 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
3e3850e9 624 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE|IPSKB_XFRM_TRANSFORMED);
1da177e4
LT		 625 dst_release(skb->dst);
626 skb->dst = &rt->u.dst;
627
628 /*
629 * Push down and install the IPIP header.
630 */
631
632 iph = skb->nh.iph;
633 iph->version = 4;
634 iph->ihl = sizeof(struct iphdr)>>2;
635 iph->frag_off = df;
636 iph->protocol = IPPROTO_IPIP;
637 iph->tos = INET_ECN_encapsulate(tos, old_iph->tos);
638 iph->daddr = rt->rt_dst;
639 iph->saddr = rt->rt_src;
640
641 if ((iph->ttl = tiph->ttl) == 0)
642 iph->ttl = old_iph->ttl;
643
644 nf_reset(skb);
645
646 IPTUNNEL_XMIT();
647 tunnel->recursion--;
648 return 0;
649
650tx_error_icmp:
651 dst_link_failure(skb);
652tx_error:
653 stats->tx_errors++;
654 dev_kfree_skb(skb);
655 tunnel->recursion--;
656 return 0;
657}
658
659static int
660ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
661{
662 int err = 0;
663 struct ip_tunnel_parm p;
664 struct ip_tunnel *t;
665
666 switch (cmd) {
667 case SIOCGETTUNNEL:
668 t = NULL;
669 if (dev == ipip_fb_tunnel_dev) {
670 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
671 err = -EFAULT;
672 break;
673 }
674 t = ipip_tunnel_locate(&p, 0);
675 }
676 if (t == NULL)
2941a486 677 t = netdev_priv(dev);
1da177e4
LT		 678 memcpy(&p, &t->parms, sizeof(p));
679 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
680 err = -EFAULT;
681 break;
682
683 case SIOCADDTUNNEL:
684 case SIOCCHGTUNNEL:
685 err = -EPERM;
686 if (!capable(CAP_NET_ADMIN))
687 goto done;
688
689 err = -EFAULT;
690 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
691 goto done;
692
693 err = -EINVAL;
694 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
695 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
696 goto done;
697 if (p.iph.ttl)
698 p.iph.frag_off |= htons(IP_DF);
699
700 t = ipip_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
701
702 if (dev != ipip_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
703 if (t != NULL) {
704 if (t->dev != dev) {
705 err = -EEXIST;
706 break;
707 }
708 } else {
709 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
710 (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
711 err = -EINVAL;
712 break;
713 }
2941a486 714 t = netdev_priv(dev);
1da177e4
LT		 715 ipip_tunnel_unlink(t);
716 t->parms.iph.saddr = p.iph.saddr;
717 t->parms.iph.daddr = p.iph.daddr;
718 memcpy(dev->dev_addr, &p.iph.saddr, 4);
719 memcpy(dev->broadcast, &p.iph.daddr, 4);
720 ipip_tunnel_link(t);
721 netdev_state_change(dev);
722 }
723 }
724
725 if (t) {
726 err = 0;
727 if (cmd == SIOCCHGTUNNEL) {
728 t->parms.iph.ttl = p.iph.ttl;
729 t->parms.iph.tos = p.iph.tos;
730 t->parms.iph.frag_off = p.iph.frag_off;
731 }
732 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
733 err = -EFAULT;
734 } else
735 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
736 break;
737
738 case SIOCDELTUNNEL:
739 err = -EPERM;
740 if (!capable(CAP_NET_ADMIN))
741 goto done;
742
743 if (dev == ipip_fb_tunnel_dev) {
744 err = -EFAULT;
745 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
746 goto done;
747 err = -ENOENT;
748 if ((t = ipip_tunnel_locate(&p, 0)) == NULL)
749 goto done;
750 err = -EPERM;
751 if (t->dev == ipip_fb_tunnel_dev)
752 goto done;
753 dev = t->dev;
754 }
755 err = unregister_netdevice(dev);
756 break;
757
758 default:
759 err = -EINVAL;
760 }
761
762done:
763 return err;
764}
765
766static struct net_device_stats *ipip_tunnel_get_stats(struct net_device *dev)
767{
2941a486 768 return &(((struct ip_tunnel*)netdev_priv(dev))->stat);
1da177e4
LT		 769}
770
771static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
772{
773 if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
774 return -EINVAL;
775 dev->mtu = new_mtu;
776 return 0;
777}
778
779static void ipip_tunnel_setup(struct net_device *dev)
780{
781 SET_MODULE_OWNER(dev);
782 dev->uninit = ipip_tunnel_uninit;
783 dev->hard_start_xmit = ipip_tunnel_xmit;
784 dev->get_stats = ipip_tunnel_get_stats;
785 dev->do_ioctl = ipip_tunnel_ioctl;
786 dev->change_mtu = ipip_tunnel_change_mtu;
787 dev->destructor = free_netdev;
788
789 dev->type = ARPHRD_TUNNEL;
790 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr);
46f25dff 791 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr);
1da177e4
LT		 792 dev->flags = IFF_NOARP;
793 dev->iflink = 0;
794 dev->addr_len = 4;
795}
796
797static int ipip_tunnel_init(struct net_device *dev)
798{
799 struct net_device *tdev = NULL;
800 struct ip_tunnel *tunnel;
801 struct iphdr *iph;
802
2941a486 803 tunnel = netdev_priv(dev);
1da177e4
LT		 804 iph = &tunnel->parms.iph;
805
806 tunnel->dev = dev;
807 strcpy(tunnel->parms.name, dev->name);
808
809 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
810 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
811
812 if (iph->daddr) {
813 struct flowi fl = { .oif = tunnel->parms.link,
814 .nl_u = { .ip4_u =
815 { .daddr = iph->daddr,
816 .saddr = iph->saddr,
817 .tos = RT_TOS(iph->tos) } },
818 .proto = IPPROTO_IPIP };
819 struct rtable *rt;
820 if (!ip_route_output_key(&rt, &fl)) {
821 tdev = rt->u.dst.dev;
822 ip_rt_put(rt);
823 }
824 dev->flags |= IFF_POINTOPOINT;
825 }
826
827 if (!tdev && tunnel->parms.link)
828 tdev = __dev_get_by_index(tunnel->parms.link);
829
830 if (tdev) {
831 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
832 dev->mtu = tdev->mtu - sizeof(struct iphdr);
833 }
834 dev->iflink = tunnel->parms.link;
835
836 return 0;
837}
838
839static int __init ipip_fb_tunnel_init(struct net_device *dev)
840{
2941a486 841 struct ip_tunnel *tunnel = netdev_priv(dev);
1da177e4
LT		 842 struct iphdr *iph = &tunnel->parms.iph;
843
844 tunnel->dev = dev;
845 strcpy(tunnel->parms.name, dev->name);
846
847 iph->version = 4;
848 iph->protocol = IPPROTO_IPIP;
849 iph->ihl = 5;
850
851 dev_hold(dev);
852 tunnels_wc[0] = tunnel;
853 return 0;
854}
855
0303770d 856#ifdef CONFIG_INET_TUNNEL
1da177e4
LT		 857static struct xfrm_tunnel ipip_handler = {
858 .handler = ipip_rcv,
859 .err_handler = ipip_err,
860};
861
0303770d
PM		 862static inline int ipip_register(void)
863{
864 return xfrm4_tunnel_register(&ipip_handler);
865}
866
867static inline int ipip_unregister(void)
868{
869 return xfrm4_tunnel_deregister(&ipip_handler);
870}
871#else
872static struct net_protocol ipip_protocol = {
873 .handler = ipip_rcv,
874 .err_handler = ipip_err,
875 .no_policy = 1,
876};
877
878static inline int ipip_register(void)
879{
880 return inet_add_protocol(&ipip_protocol, IPPROTO_IPIP);
881}
882
883static inline int ipip_unregister(void)
884{
885 return inet_del_protocol(&ipip_protocol, IPPROTO_IPIP);
886}
887#endif
888
1da177e4
LT		 889static char banner[] __initdata =
890 KERN_INFO "IPv4 over IPv4 tunneling driver\n";
891
892static int __init ipip_init(void)
893{
894 int err;
895
896 printk(banner);
897
0303770d 898 if (ipip_register() < 0) {
1da177e4
LT		 899 printk(KERN_INFO "ipip init: can't register tunnel\n");
900 return -EAGAIN;
901 }
902
903 ipip_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
904 "tunl0",
905 ipip_tunnel_setup);
906 if (!ipip_fb_tunnel_dev) {
907 err = -ENOMEM;
908 goto err1;
909 }
910
911 ipip_fb_tunnel_dev->init = ipip_fb_tunnel_init;
912
913 if ((err = register_netdev(ipip_fb_tunnel_dev)))
914 goto err2;
915 out:
916 return err;
917 err2:
918 free_netdev(ipip_fb_tunnel_dev);
919 err1:
0303770d 920 ipip_unregister();
1da177e4
LT		 921 goto out;
922}
923
db44575f
AK		 924static void __exit ipip_destroy_tunnels(void)
925{
926 int prio;
927
928 for (prio = 1; prio < 4; prio++) {
929 int h;
930 for (h = 0; h < HASH_SIZE; h++) {
931 struct ip_tunnel *t;
932 while ((t = tunnels[prio][h]) != NULL)
933 unregister_netdevice(t->dev);
934 }
935 }
936}
937
1da177e4
LT		 938static void __exit ipip_fini(void)
939{
0303770d 940 if (ipip_unregister() < 0)
1da177e4
LT		 941 printk(KERN_INFO "ipip close: can't deregister tunnel\n");
942
db44575f
AK		 943 rtnl_lock();
944 ipip_destroy_tunnels();
945 unregister_netdevice(ipip_fb_tunnel_dev);
946 rtnl_unlock();
1da177e4
LT		 947}
948
949module_init(ipip_init);
950module_exit(ipip_fini);
951MODULE_LICENSE("GPL");
Clone of davem's net-next-2.6 tree