2 * Linux NET3: IP/IP protocol decoder.
4 * Version: $Id: ipip.c,v 1.50 2001/10/02 02:22:36 davem Exp $
7 * Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95
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.
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.
29 /* tunnel.c: an IP tunnel driver
31 The purpose of this driver is to provide an IP tunnel through
32 which you can tunnel network traffic transparently across subnets.
34 This was written by looking at Nick Holloway's dummy driver
35 Thanks for the great code!
37 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95
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.
46 -Alan Cox (Alan.Cox@linux.org) 21 March 95
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.
54 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/13/96
58 /* Things I wish I had known when writing the tunnel driver:
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.
64 When we are passed a packet, we are expected to fill in the
65 source address with our source IP address.
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
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.
90 This version of net/ipv4/ipip.c is cloned of net/ipv4/ip_gre.c
92 For comments look at net/ipv4/ip_gre.c --ANK
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>
112 #include <net/sock.h>
114 #include <net/icmp.h>
115 #include <net/protocol.h>
116 #include <net/ipip.h>
117 #include <net/inet_ecn.h>
118 #include <net/xfrm.h>
121 #define HASH(addr) ((addr^(addr>>4))&0xF)
123 static int ipip_fb_tunnel_init(struct net_device *dev);
124 static int ipip_tunnel_init(struct net_device *dev);
125 static void ipip_tunnel_setup(struct net_device *dev);
127 static struct net_device *ipip_fb_tunnel_dev;
129 static struct ip_tunnel *tunnels_r_l[HASH_SIZE];
130 static struct ip_tunnel *tunnels_r[HASH_SIZE];
131 static struct ip_tunnel *tunnels_l[HASH_SIZE];
132 static struct ip_tunnel *tunnels_wc[1];
133 static struct ip_tunnel **tunnels[4] = { tunnels_wc, tunnels_l, tunnels_r, tunnels_r_l };
135 static rwlock_t ipip_lock = RW_LOCK_UNLOCKED;
137 static struct ip_tunnel * ipip_tunnel_lookup(u32 remote, u32 local)
139 unsigned h0 = HASH(remote);
140 unsigned h1 = HASH(local);
143 for (t = tunnels_r_l[h0^h1]; t; t = t->next) {
144 if (local == t->parms.iph.saddr &&
145 remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
148 for (t = tunnels_r[h0]; t; t = t->next) {
149 if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
152 for (t = tunnels_l[h1]; t; t = t->next) {
153 if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
156 if ((t = tunnels_wc[0]) != NULL && (t->dev->flags&IFF_UP))
161 static struct ip_tunnel **ipip_bucket(struct ip_tunnel *t)
163 u32 remote = t->parms.iph.daddr;
164 u32 local = t->parms.iph.saddr;
176 return &tunnels[prio][h];
180 static void ipip_tunnel_unlink(struct ip_tunnel *t)
182 struct ip_tunnel **tp;
184 for (tp = ipip_bucket(t); *tp; tp = &(*tp)->next) {
186 write_lock_bh(&ipip_lock);
188 write_unlock_bh(&ipip_lock);
194 static void ipip_tunnel_link(struct ip_tunnel *t)
196 struct ip_tunnel **tp = ipip_bucket(t);
199 write_lock_bh(&ipip_lock);
201 write_unlock_bh(&ipip_lock);
204 static struct ip_tunnel * ipip_tunnel_locate(struct ip_tunnel_parm *parms, int create)
206 u32 remote = parms->iph.daddr;
207 u32 local = parms->iph.saddr;
208 struct ip_tunnel *t, **tp, *nt;
209 struct net_device *dev;
222 for (tp = &tunnels[prio][h]; (t = *tp) != NULL; tp = &t->next) {
223 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
230 strlcpy(name, parms->name, IFNAMSIZ);
233 for (i=1; i<100; i++) {
234 sprintf(name, "tunl%d", i);
235 if (__dev_get_by_name(name) == NULL)
242 dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
247 SET_MODULE_OWNER(dev);
248 dev->init = ipip_tunnel_init;
249 dev->destructor = free_netdev;
252 if (register_netdevice(dev) < 0) {
258 ipip_tunnel_link(nt);
259 /* Do not decrement MOD_USE_COUNT here. */
266 static void ipip_tunnel_uninit(struct net_device *dev)
268 if (dev == ipip_fb_tunnel_dev) {
269 write_lock_bh(&ipip_lock);
270 tunnels_wc[0] = NULL;
271 write_unlock_bh(&ipip_lock);
273 ipip_tunnel_unlink((struct ip_tunnel*)dev->priv);
277 static void ipip_err(struct sk_buff *skb, void *__unused)
279 #ifndef I_WISH_WORLD_WERE_PERFECT
281 /* It is not :-( All the routers (except for Linux) return only
282 8 bytes of packet payload. It means, that precise relaying of
283 ICMP in the real Internet is absolutely infeasible.
285 struct iphdr *iph = (struct iphdr*)skb->data;
286 int type = skb->h.icmph->type;
287 int code = skb->h.icmph->code;
292 case ICMP_PARAMETERPROB:
295 case ICMP_DEST_UNREACH:
298 case ICMP_PORT_UNREACH:
299 /* Impossible event. */
301 case ICMP_FRAG_NEEDED:
302 /* Soft state for pmtu is maintained by IP core. */
305 /* All others are translated to HOST_UNREACH.
306 rfc2003 contains "deep thoughts" about NET_UNREACH,
307 I believe they are just ether pollution. --ANK
312 case ICMP_TIME_EXCEEDED:
313 if (code != ICMP_EXC_TTL)
318 read_lock(&ipip_lock);
319 t = ipip_tunnel_lookup(iph->daddr, iph->saddr);
320 if (t == NULL || t->parms.iph.daddr == 0)
322 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
325 if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
329 t->err_time = jiffies;
331 read_unlock(&ipip_lock);
334 struct iphdr *iph = (struct iphdr*)dp;
335 int hlen = iph->ihl<<2;
337 int type = skb->h.icmph->type;
338 int code = skb->h.icmph->code;
342 struct sk_buff *skb2;
346 if (len < hlen + sizeof(struct iphdr))
348 eiph = (struct iphdr*)(dp + hlen);
353 case ICMP_PARAMETERPROB:
354 if (skb->h.icmph->un.gateway < hlen)
357 /* So... This guy found something strange INSIDE encapsulated
358 packet. Well, he is fool, but what can we do ?
360 rel_type = ICMP_PARAMETERPROB;
361 rel_info = skb->h.icmph->un.gateway - hlen;
364 case ICMP_DEST_UNREACH:
367 case ICMP_PORT_UNREACH:
368 /* Impossible event. */
370 case ICMP_FRAG_NEEDED:
371 /* And it is the only really necessary thing :-) */
372 rel_info = ntohs(skb->h.icmph->un.frag.mtu);
373 if (rel_info < hlen+68)
376 /* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
377 if (rel_info > ntohs(eiph->tot_len))
381 /* All others are translated to HOST_UNREACH.
382 rfc2003 contains "deep thoughts" about NET_UNREACH,
383 I believe, it is just ether pollution. --ANK
385 rel_type = ICMP_DEST_UNREACH;
386 rel_code = ICMP_HOST_UNREACH;
390 case ICMP_TIME_EXCEEDED:
391 if (code != ICMP_EXC_TTL)
396 /* Prepare fake skb to feed it to icmp_send */
397 skb2 = skb_clone(skb, GFP_ATOMIC);
400 dst_release(skb2->dst);
402 skb_pull(skb2, skb->data - (u8*)eiph);
403 skb2->nh.raw = skb2->data;
405 /* Try to guess incoming interface */
406 memset(&fl, 0, sizeof(fl));
407 fl.fl4_daddr = eiph->saddr;
408 fl.fl4_tos = RT_TOS(eiph->tos);
409 fl.proto = IPPROTO_IPIP;
410 if (ip_route_output_key(&rt, &key)) {
414 skb2->dev = rt->u.dst.dev;
416 /* route "incoming" packet */
417 if (rt->rt_flags&RTCF_LOCAL) {
420 fl.fl4_daddr = eiph->daddr;
421 fl.fl4_src = eiph->saddr;
422 fl.fl4_tos = eiph->tos;
423 if (ip_route_output_key(&rt, &fl) ||
424 rt->u.dst.dev->type != ARPHRD_TUNNEL) {
431 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
432 skb2->dst->dev->type != ARPHRD_TUNNEL) {
438 /* change mtu on this route */
439 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
440 if (rel_info > dst_pmtu(skb2->dst)) {
444 skb2->dst->ops->update_pmtu(skb2->dst, rel_info);
445 rel_info = htonl(rel_info);
446 } else if (type == ICMP_TIME_EXCEEDED) {
447 struct ip_tunnel *t = (struct ip_tunnel*)skb2->dev->priv;
448 if (t->parms.iph.ttl) {
449 rel_type = ICMP_DEST_UNREACH;
450 rel_code = ICMP_HOST_UNREACH;
454 icmp_send(skb2, rel_type, rel_code, rel_info);
460 static inline void ipip_ecn_decapsulate(struct iphdr *outer_iph, struct sk_buff *skb)
462 struct iphdr *inner_iph = skb->nh.iph;
464 if (INET_ECN_is_ce(outer_iph->tos) &&
465 INET_ECN_is_not_ce(inner_iph->tos))
466 IP_ECN_set_ce(inner_iph);
469 static int ipip_rcv(struct sk_buff *skb)
472 struct ip_tunnel *tunnel;
474 if (!pskb_may_pull(skb, sizeof(struct iphdr)))
479 read_lock(&ipip_lock);
480 if ((tunnel = ipip_tunnel_lookup(iph->saddr, iph->daddr)) != NULL) {
481 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
488 skb->mac.raw = skb->nh.raw;
489 skb->nh.raw = skb->data;
490 memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
491 skb->protocol = htons(ETH_P_IP);
492 skb->pkt_type = PACKET_HOST;
494 tunnel->stat.rx_packets++;
495 tunnel->stat.rx_bytes += skb->len;
496 skb->dev = tunnel->dev;
497 dst_release(skb->dst);
499 #ifdef CONFIG_NETFILTER
500 nf_conntrack_put(skb->nfct);
502 #ifdef CONFIG_NETFILTER_DEBUG
506 ipip_ecn_decapsulate(iph, skb);
508 read_unlock(&ipip_lock);
511 read_unlock(&ipip_lock);
518 * This function assumes it is being called from dev_queue_xmit()
519 * and that skb is filled properly by that function.
522 static int ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
524 struct ip_tunnel *tunnel = (struct ip_tunnel*)dev->priv;
525 struct net_device_stats *stats = &tunnel->stat;
526 struct iphdr *tiph = &tunnel->parms.iph;
527 u8 tos = tunnel->parms.iph.tos;
528 u16 df = tiph->frag_off;
529 struct rtable *rt; /* Route to the other host */
530 struct net_device *tdev; /* Device to other host */
531 struct iphdr *old_iph = skb->nh.iph;
532 struct iphdr *iph; /* Our new IP header */
533 int max_headroom; /* The extra header space needed */
534 u32 dst = tiph->daddr;
537 if (tunnel->recursion++) {
538 tunnel->stat.collisions++;
542 if (skb->protocol != htons(ETH_P_IP))
550 if ((rt = (struct rtable*)skb->dst) == NULL) {
551 tunnel->stat.tx_fifo_errors++;
554 if ((dst = rt->rt_gateway) == 0)
559 struct flowi fl = { .oif = tunnel->parms.link,
562 .saddr = tiph->saddr,
563 .tos = RT_TOS(tos) } },
564 .proto = IPPROTO_IPIP };
565 if (ip_route_output_key(&rt, &fl)) {
566 tunnel->stat.tx_carrier_errors++;
570 tdev = rt->u.dst.dev;
574 tunnel->stat.collisions++;
579 mtu = dst_pmtu(&rt->u.dst) - sizeof(struct iphdr);
581 mtu = skb->dst ? dst_pmtu(skb->dst) : dev->mtu;
584 tunnel->stat.collisions++;
589 skb->dst->ops->update_pmtu(skb->dst, mtu);
591 df |= (old_iph->frag_off&htons(IP_DF));
593 if ((old_iph->frag_off&htons(IP_DF)) && mtu < ntohs(old_iph->tot_len)) {
594 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
599 if (tunnel->err_count > 0) {
600 if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
602 dst_link_failure(skb);
604 tunnel->err_count = 0;
608 * Okay, now see if we can stuff it in the buffer as-is.
610 max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
612 if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
613 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
622 skb_set_owner_w(new_skb, skb->sk);
625 old_iph = skb->nh.iph;
628 skb->h.raw = skb->nh.raw;
629 skb->nh.raw = skb_push(skb, sizeof(struct iphdr));
630 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
631 dst_release(skb->dst);
632 skb->dst = &rt->u.dst;
635 * Push down and install the IPIP header.
640 iph->ihl = sizeof(struct iphdr)>>2;
642 iph->protocol = IPPROTO_IPIP;
643 iph->tos = INET_ECN_encapsulate(tos, old_iph->tos);
644 iph->daddr = rt->rt_dst;
645 iph->saddr = rt->rt_src;
647 if ((iph->ttl = tiph->ttl) == 0)
648 iph->ttl = old_iph->ttl;
650 #ifdef CONFIG_NETFILTER
651 nf_conntrack_put(skb->nfct);
653 #ifdef CONFIG_NETFILTER_DEBUG
663 dst_link_failure(skb);
672 ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
675 struct ip_tunnel_parm p;
681 if (dev == ipip_fb_tunnel_dev) {
682 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
686 t = ipip_tunnel_locate(&p, 0);
689 t = (struct ip_tunnel*)dev->priv;
690 memcpy(&p, &t->parms, sizeof(p));
691 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
698 if (!capable(CAP_NET_ADMIN))
702 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
706 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
707 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
710 p.iph.frag_off |= htons(IP_DF);
712 t = ipip_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
714 if (dev != ipip_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
721 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
722 (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
726 t = (struct ip_tunnel*)dev->priv;
727 ipip_tunnel_unlink(t);
728 t->parms.iph.saddr = p.iph.saddr;
729 t->parms.iph.daddr = p.iph.daddr;
730 memcpy(dev->dev_addr, &p.iph.saddr, 4);
731 memcpy(dev->broadcast, &p.iph.daddr, 4);
733 netdev_state_change(dev);
739 if (cmd == SIOCCHGTUNNEL) {
740 t->parms.iph.ttl = p.iph.ttl;
741 t->parms.iph.tos = p.iph.tos;
742 t->parms.iph.frag_off = p.iph.frag_off;
744 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
747 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
752 if (!capable(CAP_NET_ADMIN))
755 if (dev == ipip_fb_tunnel_dev) {
757 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
760 if ((t = ipip_tunnel_locate(&p, 0)) == NULL)
763 if (t->dev == ipip_fb_tunnel_dev)
767 err = unregister_netdevice(dev);
778 static struct net_device_stats *ipip_tunnel_get_stats(struct net_device *dev)
780 return &(((struct ip_tunnel*)dev->priv)->stat);
783 static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
785 if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
791 static void ipip_tunnel_setup(struct net_device *dev)
793 SET_MODULE_OWNER(dev);
794 dev->uninit = ipip_tunnel_uninit;
795 dev->hard_start_xmit = ipip_tunnel_xmit;
796 dev->get_stats = ipip_tunnel_get_stats;
797 dev->do_ioctl = ipip_tunnel_ioctl;
798 dev->change_mtu = ipip_tunnel_change_mtu;
800 dev->type = ARPHRD_TUNNEL;
801 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr);
802 dev->mtu = 1500 - sizeof(struct iphdr);
803 dev->flags = IFF_NOARP;
808 static int ipip_tunnel_init(struct net_device *dev)
810 struct net_device *tdev = NULL;
811 struct ip_tunnel *tunnel;
814 tunnel = (struct ip_tunnel*)dev->priv;
815 iph = &tunnel->parms.iph;
818 strcpy(tunnel->parms.name, dev->name);
820 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
821 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
824 struct flowi fl = { .oif = tunnel->parms.link,
826 { .daddr = iph->daddr,
828 .tos = RT_TOS(iph->tos) } },
829 .proto = IPPROTO_IPIP };
831 if (!ip_route_output_key(&rt, &fl)) {
832 tdev = rt->u.dst.dev;
835 dev->flags |= IFF_POINTOPOINT;
838 if (!tdev && tunnel->parms.link)
839 tdev = __dev_get_by_index(tunnel->parms.link);
842 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
843 dev->mtu = tdev->mtu - sizeof(struct iphdr);
845 dev->iflink = tunnel->parms.link;
850 static int __init ipip_fb_tunnel_init(struct net_device *dev)
852 struct ip_tunnel *tunnel = dev->priv;
853 struct iphdr *iph = &tunnel->parms.iph;
856 strcpy(tunnel->parms.name, dev->name);
859 iph->protocol = IPPROTO_IPIP;
863 tunnels_wc[0] = tunnel;
867 static struct xfrm_tunnel ipip_handler = {
869 .err_handler = ipip_err,
872 static char banner[] __initdata =
873 KERN_INFO "IPv4 over IPv4 tunneling driver\n";
875 static int __init ipip_init(void)
881 if (xfrm4_tunnel_register(&ipip_handler) < 0) {
882 printk(KERN_INFO "ipip init: can't register tunnel\n");
886 ipip_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
889 if (!ipip_fb_tunnel_dev) {
894 ipip_fb_tunnel_dev->init = ipip_fb_tunnel_init;
896 if ((err = register_netdev(ipip_fb_tunnel_dev)))
901 xfrm4_tunnel_deregister(&ipip_handler);
902 free_netdev(ipip_fb_tunnel_dev);
906 static void __exit ipip_fini(void)
908 if (xfrm4_tunnel_deregister(&ipip_handler) < 0)
909 printk(KERN_INFO "ipip close: can't deregister tunnel\n");
911 unregister_netdev(ipip_fb_tunnel_dev);
914 module_init(ipip_init);
915 module_exit(ipip_fini);
916 MODULE_LICENSE("GPL");