Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 5d9c5a32920c5c0e6716b0f6ed16157783dc56a4

Authored by Herbert Xu 2006-07-22 05:29:53 +0800

Committed by David S. Miller 2006-07-22 05:29:53 +0800

Exists in master and in 7 other branches

[IPV4]: Get rid of redundant IPCB->opts initialisation

Now that we always zero the IPCB->opts in ip_rcv, it is no longer
necessary to do so before calling netif_rx for tunneled packets.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 6 changed files with 0 additions and 7 deletions Inline Diff

net/ipv4/ip_gre.c
net/ipv4/ip_options.c
net/ipv4/ipip.c
net/ipv4/ipmr.c
net/ipv4/xfrm4_mode_tunnel.c
net/ipv6/sit.c

net/ipv4/ip_gre.c

Diff comments View file @ 5d9c5a3

 /*
  *	Linux NET3:	GRE over IP protocol decoder.
  *
  *	Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
  *
  *	This program is free software; you can redistribute it and/or
  *	modify it under the terms of the GNU General Public License
  *	as published by the Free Software Foundation; either version
  *	2 of the License, or (at your option) any later version.
  *
  */
 #include <linux/capability.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <asm/uaccess.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <linux/in.h>
 #include <linux/tcp.h>
 #include <linux/udp.h>
 #include <linux/if_arp.h>
 #include <linux/mroute.h>
 #include <linux/init.h>
 #include <linux/in6.h>
 #include <linux/inetdevice.h>
 #include <linux/igmp.h>
 #include <linux/netfilter_ipv4.h>
 #include <linux/if_ether.h>
 #include <net/sock.h>
 #include <net/ip.h>
 #include <net/icmp.h>
 #include <net/protocol.h>
 #include <net/ipip.h>
 #include <net/arp.h>
 #include <net/checksum.h>
 #include <net/dsfield.h>
 #include <net/inet_ecn.h>
 #include <net/xfrm.h>
 #ifdef CONFIG_IPV6
 #include <net/ipv6.h>
 #include <net/ip6_fib.h>
 #include <net/ip6_route.h>
 #endif
 /*
    Problems & solutions
    --------------------
    1. The most important issue is detecting local dead loops.
    They would cause complete host lockup in transmit, which
    would be "resolved" by stack overflow or, if queueing is enabled,
    with infinite looping in net_bh.
    We cannot track such dead loops during route installation,
    it is infeasible task. The most general solutions would be
    to keep skb->encapsulation counter (sort of local ttl),
    and silently drop packet when it expires. It is the best
    solution, but it supposes maintaing new variable in ALL
    skb, even if no tunneling is used.
    Current solution: t->recursion lock breaks dead loops. It looks
    like dev->tbusy flag, but I preferred new variable, because
    the semantics is different. One day, when hard_start_xmit
    will be multithreaded we will have to use skb->encapsulation.
    2. Networking dead loops would not kill routers, but would really
    kill network. IP hop limit plays role of "t->recursion" in this case,
    if we copy it from packet being encapsulated to upper header.
    It is very good solution, but it introduces two problems:
    - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
      do not work over tunnels.
    - traceroute does not work. I planned to relay ICMP from tunnel,
      so that this problem would be solved and traceroute output
      would even more informative. This idea appeared to be wrong:
      only Linux complies to rfc1812 now (yes, guys, Linux is the only
      true router now :-)), all routers (at least, in neighbourhood of mine)
      return only 8 bytes of payload. It is the end.
    Hence, if we want that OSPF worked or traceroute said something reasonable,
    we should search for another solution.
    One of them is to parse packet trying to detect inner encapsulation
    made by our node. It is difficult or even impossible, especially,
    taking into account fragmentation. TO be short, tt is not solution at all.
    Current solution: The solution was UNEXPECTEDLY SIMPLE.
    We force DF flag on tunnels with preconfigured hop limit,
    that is ALL. :-) Well, it does not remove the problem completely,
    but exponential growth of network traffic is changed to linear
    (branches, that exceed pmtu are pruned) and tunnel mtu
    fastly degrades to value <68, where looping stops.
    Yes, it is not good if there exists a router in the loop,
    which does not force DF, even when encapsulating packets have DF set.
    But it is not our problem! Nobody could accuse us, we made
    all that we could make. Even if it is your gated who injected
    fatal route to network, even if it were you who configured
    fatal static route: you are innocent. :-)
    3. Really, ipv4/ipip.c, ipv4/ip_gre.c and ipv6/sit.c contain
    practically identical code. It would be good to glue them
    together, but it is not very evident, how to make them modular.
    sit is integral part of IPv6, ipip and gre are naturally modular.
    We could extract common parts (hash table, ioctl etc)
    to a separate module (ip_tunnel.c).
    Alexey Kuznetsov.
  */
 static int ipgre_tunnel_init(struct net_device *dev);
 static void ipgre_tunnel_setup(struct net_device *dev);
 /* Fallback tunnel: no source, no destination, no key, no options */
 static int ipgre_fb_tunnel_init(struct net_device *dev);
 static struct net_device *ipgre_fb_tunnel_dev;
 /* Tunnel hash table */
 /*
    4 hash tables:
    3: (remote,local)
    2: (remote,*)
    1: (*,local)
    0: (*,*)
    We require exact key match i.e. if a key is present in packet
    it will match only tunnel with the same key; if it is not present,
    it will match only keyless tunnel.
    All keysless packets, if not matched configured keyless tunnels
    will match fallback tunnel.
  */
 #define HASH_SIZE  16
 #define HASH(addr) ((addr^(addr>>4))&0xF)
 static struct ip_tunnel *tunnels[4][HASH_SIZE];
 #define tunnels_r_l	(tunnels[3])
 #define tunnels_r	(tunnels[2])
 #define tunnels_l	(tunnels[1])
 #define tunnels_wc	(tunnels[0])
 static DEFINE_RWLOCK(ipgre_lock);
 /* Given src, dst and key, find appropriate for input tunnel. */
 static struct ip_tunnel * ipgre_tunnel_lookup(u32 remote, u32 local, u32 key)
 {
 	unsigned h0 = HASH(remote);
 	unsigned h1 = HASH(key);
 	struct ip_tunnel *t;
 	for (t = tunnels_r_l[h0^h1]; t; t = t->next) {
 		if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
 			if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
 				return t;
 		}
 	}
 	for (t = tunnels_r[h0^h1]; t; t = t->next) {
 		if (remote == t->parms.iph.daddr) {
 			if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
 				return t;
 		}
 	}
 	for (t = tunnels_l[h1]; t; t = t->next) {
 		if (local == t->parms.iph.saddr ||
 		     (local == t->parms.iph.daddr && MULTICAST(local))) {
 			if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
 				return t;
 		}
 	}
 	for (t = tunnels_wc[h1]; t; t = t->next) {
 		if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
 			return t;
 	}
 	if (ipgre_fb_tunnel_dev->flags&IFF_UP)
 		return netdev_priv(ipgre_fb_tunnel_dev);
 	return NULL;
 }
 static struct ip_tunnel **ipgre_bucket(struct ip_tunnel *t)
 {
 	u32 remote = t->parms.iph.daddr;
 	u32 local = t->parms.iph.saddr;
 	u32 key = t->parms.i_key;
 	unsigned h = HASH(key);
 	int prio = 0;
 	if (local)
 		prio |= 1;
 	if (remote && !MULTICAST(remote)) {
 		prio |= 2;
 		h ^= HASH(remote);
 	}
 	return &tunnels[prio][h];
 }
 static void ipgre_tunnel_link(struct ip_tunnel *t)
 {
 	struct ip_tunnel **tp = ipgre_bucket(t);
 	t->next = *tp;
 	write_lock_bh(&ipgre_lock);
 	*tp = t;
 	write_unlock_bh(&ipgre_lock);
 }
 static void ipgre_tunnel_unlink(struct ip_tunnel *t)
 {
 	struct ip_tunnel **tp;
 	for (tp = ipgre_bucket(t); *tp; tp = &(*tp)->next) {
 		if (t == *tp) {
 			write_lock_bh(&ipgre_lock);
 			*tp = t->next;
 			write_unlock_bh(&ipgre_lock);
 			break;
 		}
 	}
 }
 static struct ip_tunnel * ipgre_tunnel_locate(struct ip_tunnel_parm *parms, int create)
 {
 	u32 remote = parms->iph.daddr;
 	u32 local = parms->iph.saddr;
 	u32 key = parms->i_key;
 	struct ip_tunnel *t, **tp, *nt;
 	struct net_device *dev;
 	unsigned h = HASH(key);
 	int prio = 0;
 	char name[IFNAMSIZ];
 	if (local)
 		prio |= 1;
 	if (remote && !MULTICAST(remote)) {
 		prio |= 2;
 		h ^= HASH(remote);
 	}
 	for (tp = &tunnels[prio][h]; (t = *tp) != NULL; tp = &t->next) {
 		if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
 			if (key == t->parms.i_key)
 				return t;
 		}
 	}
 	if (!create)
 		return NULL;
 	if (parms->name[0])
 		strlcpy(name, parms->name, IFNAMSIZ);
 	else {
 		int i;
 		for (i=1; i<100; i++) {
 			sprintf(name, "gre%d", i);
 			if (__dev_get_by_name(name) == NULL)
 				break;
 		}
 		if (i==100)
 			goto failed;
 	}
 	dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
 	if (!dev)
 	  return NULL;
 	dev->init = ipgre_tunnel_init;
 	nt = netdev_priv(dev);
 	nt->parms = *parms;
 	if (register_netdevice(dev) < 0) {
 		free_netdev(dev);
 		goto failed;
 	}
 	dev_hold(dev);
 	ipgre_tunnel_link(nt);
 	return nt;
 failed:
 	return NULL;
 }
 static void ipgre_tunnel_uninit(struct net_device *dev)
 {
 	ipgre_tunnel_unlink(netdev_priv(dev));
 	dev_put(dev);
 }
 static void ipgre_err(struct sk_buff *skb, u32 info)
 {
 #ifndef I_WISH_WORLD_WERE_PERFECT
 /* It is not :-( All the routers (except for Linux) return only
    8 bytes of packet payload. It means, that precise relaying of
    ICMP in the real Internet is absolutely infeasible.
    Moreover, Cisco "wise men" put GRE key to the third word
    in GRE header. It makes impossible maintaining even soft state for keyed
    GRE tunnels with enabled checksum. Tell them "thank you".
    Well, I wonder, rfc1812 was written by Cisco employee,
    what the hell these idiots break standrads established
    by themself???
  */
 	struct iphdr *iph = (struct iphdr*)skb->data;
 	u16	     *p = (u16*)(skb->data+(iph->ihl<<2));
 	int grehlen = (iph->ihl<<2) + 4;
 	int type = skb->h.icmph->type;
 	int code = skb->h.icmph->code;
 	struct ip_tunnel *t;
 	u16 flags;
 	flags = p[0];
 	if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
 		if (flags&(GRE_VERSION|GRE_ROUTING))
 			return;
 		if (flags&GRE_KEY) {
 			grehlen += 4;
 			if (flags&GRE_CSUM)
 				grehlen += 4;
 		}
 	}
 	/* If only 8 bytes returned, keyed message will be dropped here */
 	if (skb_headlen(skb) < grehlen)
 		return;
 	switch (type) {
 	default:
 	case ICMP_PARAMETERPROB:
 		return;
 	case ICMP_DEST_UNREACH:
 		switch (code) {
 		case ICMP_SR_FAILED:
 		case ICMP_PORT_UNREACH:
 			/* Impossible event. */
 			return;
 		case ICMP_FRAG_NEEDED:
 			/* Soft state for pmtu is maintained by IP core. */
 			return;
 		default:
 			/* All others are translated to HOST_UNREACH.
 			   rfc2003 contains "deep thoughts" about NET_UNREACH,
 			   I believe they are just ether pollution. --ANK
 			 */
 			break;
 		}
 		break;
 	case ICMP_TIME_EXCEEDED:
 		if (code != ICMP_EXC_TTL)
 			return;
 		break;
 	}
 	read_lock(&ipgre_lock);
 	t = ipgre_tunnel_lookup(iph->daddr, iph->saddr, (flags&GRE_KEY) ? *(((u32*)p) + (grehlen>>2) - 1) : 0);
 	if (t == NULL || t->parms.iph.daddr == 0 || MULTICAST(t->parms.iph.daddr))
 		goto out;
 	if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 		goto out;
 	if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
 		t->err_count++;
 	else
 		t->err_count = 1;
 	t->err_time = jiffies;
 out:
 	read_unlock(&ipgre_lock);
 	return;
 #else
 	struct iphdr *iph = (struct iphdr*)dp;
 	struct iphdr *eiph;
 	u16	     *p = (u16*)(dp+(iph->ihl<<2));
 	int type = skb->h.icmph->type;
 	int code = skb->h.icmph->code;
 	int rel_type = 0;
 	int rel_code = 0;
 	int rel_info = 0;
 	u16 flags;
 	int grehlen = (iph->ihl<<2) + 4;
 	struct sk_buff *skb2;
 	struct flowi fl;
 	struct rtable *rt;
 	if (p[1] != htons(ETH_P_IP))
 		return;
 	flags = p[0];
 	if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
 		if (flags&(GRE_VERSION|GRE_ROUTING))
 			return;
 		if (flags&GRE_CSUM)
 			grehlen += 4;
 		if (flags&GRE_KEY)
 			grehlen += 4;
 		if (flags&GRE_SEQ)
 			grehlen += 4;
 	}
 	if (len < grehlen + sizeof(struct iphdr))
 		return;
 	eiph = (struct iphdr*)(dp + grehlen);
 	switch (type) {
 	default:
 		return;
 	case ICMP_PARAMETERPROB:
 		if (skb->h.icmph->un.gateway < (iph->ihl<<2))
 			return;
 		/* So... This guy found something strange INSIDE encapsulated
 		   packet. Well, he is fool, but what can we do ?
 		 */
 		rel_type = ICMP_PARAMETERPROB;
 		rel_info = skb->h.icmph->un.gateway - grehlen;
 		break;
 	case ICMP_DEST_UNREACH:
 		switch (code) {
 		case ICMP_SR_FAILED:
 		case ICMP_PORT_UNREACH:
 			/* Impossible event. */
 			return;
 		case ICMP_FRAG_NEEDED:
 			/* And it is the only really necessary thing :-) */
 			rel_info = ntohs(skb->h.icmph->un.frag.mtu);
 			if (rel_info < grehlen+68)
 				return;
 			rel_info -= grehlen;
 			/* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
 			if (rel_info > ntohs(eiph->tot_len))
 				return;
 			break;
 		default:
 			/* All others are translated to HOST_UNREACH.
 			   rfc2003 contains "deep thoughts" about NET_UNREACH,
 			   I believe, it is just ether pollution. --ANK
 			 */
 			rel_type = ICMP_DEST_UNREACH;
 			rel_code = ICMP_HOST_UNREACH;
 			break;
 		}
 		break;
 	case ICMP_TIME_EXCEEDED:
 		if (code != ICMP_EXC_TTL)
 			return;
 		break;
 	}
 	/* Prepare fake skb to feed it to icmp_send */
 	skb2 = skb_clone(skb, GFP_ATOMIC);
 	if (skb2 == NULL)
 		return;
 	dst_release(skb2->dst);
 	skb2->dst = NULL;
 	skb_pull(skb2, skb->data - (u8*)eiph);
 	skb2->nh.raw = skb2->data;
 	/* Try to guess incoming interface */
 	memset(&fl, 0, sizeof(fl));
 	fl.fl4_dst = eiph->saddr;
 	fl.fl4_tos = RT_TOS(eiph->tos);
 	fl.proto = IPPROTO_GRE;
 	if (ip_route_output_key(&rt, &fl)) {
 		kfree_skb(skb2);
 		return;
 	}
 	skb2->dev = rt->u.dst.dev;
 	/* route "incoming" packet */
 	if (rt->rt_flags&RTCF_LOCAL) {
 		ip_rt_put(rt);
 		rt = NULL;
 		fl.fl4_dst = eiph->daddr;
 		fl.fl4_src = eiph->saddr;
 		fl.fl4_tos = eiph->tos;
 		if (ip_route_output_key(&rt, &fl) ||
 		    rt->u.dst.dev->type != ARPHRD_IPGRE) {
 			ip_rt_put(rt);
 			kfree_skb(skb2);
 			return;
 		}
 	} else {
 		ip_rt_put(rt);
 		if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
 		    skb2->dst->dev->type != ARPHRD_IPGRE) {
 			kfree_skb(skb2);
 			return;
 		}
 	}
 	/* change mtu on this route */
 	if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 		if (rel_info > dst_mtu(skb2->dst)) {
 			kfree_skb(skb2);
 			return;
 		}
 		skb2->dst->ops->update_pmtu(skb2->dst, rel_info);
 		rel_info = htonl(rel_info);
 	} else if (type == ICMP_TIME_EXCEEDED) {
 		struct ip_tunnel *t = netdev_priv(skb2->dev);
 		if (t->parms.iph.ttl) {
 			rel_type = ICMP_DEST_UNREACH;
 			rel_code = ICMP_HOST_UNREACH;
 		}
 	}
 	icmp_send(skb2, rel_type, rel_code, rel_info);
 	kfree_skb(skb2);
 #endif
 }
 static inline void ipgre_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
 {
 	if (INET_ECN_is_ce(iph->tos)) {
 		if (skb->protocol == htons(ETH_P_IP)) {
 			IP_ECN_set_ce(skb->nh.iph);
 		} else if (skb->protocol == htons(ETH_P_IPV6)) {
 			IP6_ECN_set_ce(skb->nh.ipv6h);
 		}
 	}
 }
 static inline u8
 ipgre_ecn_encapsulate(u8 tos, struct iphdr *old_iph, struct sk_buff *skb)
 {
 	u8 inner = 0;
 	if (skb->protocol == htons(ETH_P_IP))
 		inner = old_iph->tos;
 	else if (skb->protocol == htons(ETH_P_IPV6))
 		inner = ipv6_get_dsfield((struct ipv6hdr *)old_iph);
 	return INET_ECN_encapsulate(tos, inner);
 }
 static int ipgre_rcv(struct sk_buff *skb)
 {
 	struct iphdr *iph;
 	u8     *h;
 	u16    flags;
 	u16    csum = 0;
 	u32    key = 0;
 	u32    seqno = 0;
 	struct ip_tunnel *tunnel;
 	int    offset = 4;
 	if (!pskb_may_pull(skb, 16))
 		goto drop_nolock;
 	iph = skb->nh.iph;
 	h = skb->data;
 	flags = *(u16*)h;
 	if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
 		/* - Version must be 0.
 		   - We do not support routing headers.
 		 */
 		if (flags&(GRE_VERSION|GRE_ROUTING))
 			goto drop_nolock;
 		if (flags&GRE_CSUM) {
 			switch (skb->ip_summed) {
 			case CHECKSUM_HW:
 				csum = (u16)csum_fold(skb->csum);
 				if (!csum)
 					break;
 				/* fall through */
 			case CHECKSUM_NONE:
 				skb->csum = 0;
 				csum = __skb_checksum_complete(skb);
 				skb->ip_summed = CHECKSUM_HW;
 			}
 			offset += 4;
 		}
 		if (flags&GRE_KEY) {
 			key = *(u32*)(h + offset);
 			offset += 4;
 		}
 		if (flags&GRE_SEQ) {
 			seqno = ntohl(*(u32*)(h + offset));
 			offset += 4;
 		}
 	}
 	read_lock(&ipgre_lock);
 	if ((tunnel = ipgre_tunnel_lookup(iph->saddr, iph->daddr, key)) != NULL) {
 		secpath_reset(skb);
 		skb->protocol = *(u16*)(h + 2);
 		/* WCCP version 1 and 2 protocol decoding.
 		 * - Change protocol to IP
 		 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
 		 */
 		if (flags == 0 &&
 		    skb->protocol == __constant_htons(ETH_P_WCCP)) {
 			skb->protocol = __constant_htons(ETH_P_IP);
 			if ((*(h + offset) & 0xF0) != 0x40)
 				offset += 4;
 		}
 		skb->mac.raw = skb->nh.raw;
 		skb->nh.raw = __pskb_pull(skb, offset);
 		skb_postpull_rcsum(skb, skb->h.raw, offset);
-		memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
 		skb->pkt_type = PACKET_HOST;
 #ifdef CONFIG_NET_IPGRE_BROADCAST
 		if (MULTICAST(iph->daddr)) {
 			/* Looped back packet, drop it! */
 			if (((struct rtable*)skb->dst)->fl.iif == 0)
 				goto drop;
 			tunnel->stat.multicast++;
 			skb->pkt_type = PACKET_BROADCAST;
 		}
 #endif
 		if (((flags&GRE_CSUM) && csum) ||
 		    (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
 			tunnel->stat.rx_crc_errors++;
 			tunnel->stat.rx_errors++;
 			goto drop;
 		}
 		if (tunnel->parms.i_flags&GRE_SEQ) {
 			if (!(flags&GRE_SEQ) ||
 			    (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
 				tunnel->stat.rx_fifo_errors++;
 				tunnel->stat.rx_errors++;
 				goto drop;
 			}
 			tunnel->i_seqno = seqno + 1;
 		}
 		tunnel->stat.rx_packets++;
 		tunnel->stat.rx_bytes += skb->len;
 		skb->dev = tunnel->dev;
 		dst_release(skb->dst);
 		skb->dst = NULL;
 		nf_reset(skb);
 		ipgre_ecn_decapsulate(iph, skb);
 		netif_rx(skb);
 		read_unlock(&ipgre_lock);
 		return(0);
 	}
 	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
 drop:
 	read_unlock(&ipgre_lock);
 drop_nolock:
 	kfree_skb(skb);
 	return(0);
 }
 static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	struct ip_tunnel *tunnel = netdev_priv(dev);
 	struct net_device_stats *stats = &tunnel->stat;
 	struct iphdr  *old_iph = skb->nh.iph;
 	struct iphdr  *tiph;
 	u8     tos;
 	u16    df;
 	struct rtable *rt;     			/* Route to the other host */
 	struct net_device *tdev;			/* Device to other host */
 	struct iphdr  *iph;			/* Our new IP header */
 	int    max_headroom;			/* The extra header space needed */
 	int    gre_hlen;
 	u32    dst;
 	int    mtu;
 	if (tunnel->recursion++) {
 		tunnel->stat.collisions++;
 		goto tx_error;
 	}
 	if (dev->hard_header) {
 		gre_hlen = 0;
 		tiph = (struct iphdr*)skb->data;
 	} else {
 		gre_hlen = tunnel->hlen;
 		tiph = &tunnel->parms.iph;
 	}
 	if ((dst = tiph->daddr) == 0) {
 		/* NBMA tunnel */
 		if (skb->dst == NULL) {
 			tunnel->stat.tx_fifo_errors++;
 			goto tx_error;
 		}
 		if (skb->protocol == htons(ETH_P_IP)) {
 			rt = (struct rtable*)skb->dst;
 			if ((dst = rt->rt_gateway) == 0)
 				goto tx_error_icmp;
 		}
 #ifdef CONFIG_IPV6
 		else if (skb->protocol == htons(ETH_P_IPV6)) {
 			struct in6_addr *addr6;
 			int addr_type;
 			struct neighbour *neigh = skb->dst->neighbour;
 			if (neigh == NULL)
 				goto tx_error;
 			addr6 = (struct in6_addr*)&neigh->primary_key;
 			addr_type = ipv6_addr_type(addr6);
 			if (addr_type == IPV6_ADDR_ANY) {
 				addr6 = &skb->nh.ipv6h->daddr;
 				addr_type = ipv6_addr_type(addr6);
 			}
 			if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
 				goto tx_error_icmp;
 			dst = addr6->s6_addr32[3];
 		}
 #endif
 		else
 			goto tx_error;
 	}
 	tos = tiph->tos;
 	if (tos&1) {
 		if (skb->protocol == htons(ETH_P_IP))
 			tos = old_iph->tos;
 		tos &= ~1;
 	}
 	{
 		struct flowi fl = { .oif = tunnel->parms.link,
 				    .nl_u = { .ip4_u =
 					      { .daddr = dst,
 						.saddr = tiph->saddr,
 						.tos = RT_TOS(tos) } },
 				    .proto = IPPROTO_GRE };
 		if (ip_route_output_key(&rt, &fl)) {
 			tunnel->stat.tx_carrier_errors++;
 			goto tx_error;
 		}
 	}
 	tdev = rt->u.dst.dev;
 	if (tdev == dev) {
 		ip_rt_put(rt);
 		tunnel->stat.collisions++;
 		goto tx_error;
 	}
 	df = tiph->frag_off;
 	if (df)
 		mtu = dst_mtu(&rt->u.dst) - tunnel->hlen;
 	else
 		mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
 	if (skb->dst)
 		skb->dst->ops->update_pmtu(skb->dst, mtu);
 	if (skb->protocol == htons(ETH_P_IP)) {
 		df |= (old_iph->frag_off&htons(IP_DF));
 		if ((old_iph->frag_off&htons(IP_DF)) &&
 		    mtu < ntohs(old_iph->tot_len)) {
 			icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
 			ip_rt_put(rt);
 			goto tx_error;
 		}
 	}
 #ifdef CONFIG_IPV6
 	else if (skb->protocol == htons(ETH_P_IPV6)) {
 		struct rt6_info *rt6 = (struct rt6_info*)skb->dst;
 		if (rt6 && mtu < dst_mtu(skb->dst) && mtu >= IPV6_MIN_MTU) {
 			if ((tunnel->parms.iph.daddr && !MULTICAST(tunnel->parms.iph.daddr)) ||
 			    rt6->rt6i_dst.plen == 128) {
 				rt6->rt6i_flags |= RTF_MODIFIED;
 				skb->dst->metrics[RTAX_MTU-1] = mtu;
 			}
 		}
 		if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
 			icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
 			ip_rt_put(rt);
 			goto tx_error;
 		}
 	}
 #endif
 	if (tunnel->err_count > 0) {
 		if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
 			tunnel->err_count--;
 			dst_link_failure(skb);
 		} else
 			tunnel->err_count = 0;
 	}
 	max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen;
 	if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
 		struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
 		if (!new_skb) {
 			ip_rt_put(rt);
   			stats->tx_dropped++;
 			dev_kfree_skb(skb);
 			tunnel->recursion--;
 			return 0;
 		}
 		if (skb->sk)
 			skb_set_owner_w(new_skb, skb->sk);
 		dev_kfree_skb(skb);
 		skb = new_skb;
 		old_iph = skb->nh.iph;
 	}
 	skb->h.raw = skb->nh.raw;
 	skb->nh.raw = skb_push(skb, gre_hlen);
 	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 	IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
 			      IPSKB_REROUTED);
 	dst_release(skb->dst);
 	skb->dst = &rt->u.dst;
 	/*
 	 *	Push down and install the IPIP header.
 	 */
 	iph 			=	skb->nh.iph;
 	iph->version		=	4;
 	iph->ihl		=	sizeof(struct iphdr) >> 2;
 	iph->frag_off		=	df;
 	iph->protocol		=	IPPROTO_GRE;
 	iph->tos		=	ipgre_ecn_encapsulate(tos, old_iph, skb);
 	iph->daddr		=	rt->rt_dst;
 	iph->saddr		=	rt->rt_src;
 	if ((iph->ttl = tiph->ttl) == 0) {
 		if (skb->protocol == htons(ETH_P_IP))
 			iph->ttl = old_iph->ttl;
 #ifdef CONFIG_IPV6
 		else if (skb->protocol == htons(ETH_P_IPV6))
 			iph->ttl = ((struct ipv6hdr*)old_iph)->hop_limit;
 #endif
 		else
 			iph->ttl = dst_metric(&rt->u.dst, RTAX_HOPLIMIT);
 	}
 	((u16*)(iph+1))[0] = tunnel->parms.o_flags;
 	((u16*)(iph+1))[1] = skb->protocol;
 	if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
 		u32 *ptr = (u32*)(((u8*)iph) + tunnel->hlen - 4);
 		if (tunnel->parms.o_flags&GRE_SEQ) {
 			++tunnel->o_seqno;
 			*ptr = htonl(tunnel->o_seqno);
 			ptr--;
 		}
 		if (tunnel->parms.o_flags&GRE_KEY) {
 			*ptr = tunnel->parms.o_key;
 			ptr--;
 		}
 		if (tunnel->parms.o_flags&GRE_CSUM) {
 			*ptr = 0;
 			*(__u16*)ptr = ip_compute_csum((void*)(iph+1), skb->len - sizeof(struct iphdr));
 		}
 	}
 	nf_reset(skb);
 	IPTUNNEL_XMIT();
 	tunnel->recursion--;
 	return 0;
 tx_error_icmp:
 	dst_link_failure(skb);
 tx_error:
 	stats->tx_errors++;
 	dev_kfree_skb(skb);
 	tunnel->recursion--;
 	return 0;
 }
 static int
 ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
 {
 	int err = 0;
 	struct ip_tunnel_parm p;
 	struct ip_tunnel *t;
 	switch (cmd) {
 	case SIOCGETTUNNEL:
 		t = NULL;
 		if (dev == ipgre_fb_tunnel_dev) {
 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
 				err = -EFAULT;
 				break;
 			}
 			t = ipgre_tunnel_locate(&p, 0);
 		}
 		if (t == NULL)
 			t = netdev_priv(dev);
 		memcpy(&p, &t->parms, sizeof(p));
 		if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 			err = -EFAULT;
 		break;
 	case SIOCADDTUNNEL:
 	case SIOCCHGTUNNEL:
 		err = -EPERM;
 		if (!capable(CAP_NET_ADMIN))
 			goto done;
 		err = -EFAULT;
 		if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 			goto done;
 		err = -EINVAL;
 		if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
 		    p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
 		    ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
 			goto done;
 		if (p.iph.ttl)
 			p.iph.frag_off |= htons(IP_DF);
 		if (!(p.i_flags&GRE_KEY))
 			p.i_key = 0;
 		if (!(p.o_flags&GRE_KEY))
 			p.o_key = 0;
 		t = ipgre_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
 		if (dev != ipgre_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
 			if (t != NULL) {
 				if (t->dev != dev) {
 					err = -EEXIST;
 					break;
 				}
 			} else {
 				unsigned nflags=0;
 				t = netdev_priv(dev);
 				if (MULTICAST(p.iph.daddr))
 					nflags = IFF_BROADCAST;
 				else if (p.iph.daddr)
 					nflags = IFF_POINTOPOINT;
 				if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
 					err = -EINVAL;
 					break;
 				}
 				ipgre_tunnel_unlink(t);
 				t->parms.iph.saddr = p.iph.saddr;
 				t->parms.iph.daddr = p.iph.daddr;
 				t->parms.i_key = p.i_key;
 				t->parms.o_key = p.o_key;
 				memcpy(dev->dev_addr, &p.iph.saddr, 4);
 				memcpy(dev->broadcast, &p.iph.daddr, 4);
 				ipgre_tunnel_link(t);
 				netdev_state_change(dev);
 			}
 		}
 		if (t) {
 			err = 0;
 			if (cmd == SIOCCHGTUNNEL) {
 				t->parms.iph.ttl = p.iph.ttl;
 				t->parms.iph.tos = p.iph.tos;
 				t->parms.iph.frag_off = p.iph.frag_off;
 			}
 			if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
 				err = -EFAULT;
 		} else
 			err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
 		break;
 	case SIOCDELTUNNEL:
 		err = -EPERM;
 		if (!capable(CAP_NET_ADMIN))
 			goto done;
 		if (dev == ipgre_fb_tunnel_dev) {
 			err = -EFAULT;
 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 				goto done;
 			err = -ENOENT;
 			if ((t = ipgre_tunnel_locate(&p, 0)) == NULL)
 				goto done;
 			err = -EPERM;
 			if (t == netdev_priv(ipgre_fb_tunnel_dev))
 				goto done;
 			dev = t->dev;
 		}
 		err = unregister_netdevice(dev);
 		break;
 	default:
 		err = -EINVAL;
 	}
 done:
 	return err;
 }
 static struct net_device_stats *ipgre_tunnel_get_stats(struct net_device *dev)
 {
 	return &(((struct ip_tunnel*)netdev_priv(dev))->stat);
 }
 static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
 {
 	struct ip_tunnel *tunnel = netdev_priv(dev);
 	if (new_mtu < 68 || new_mtu > 0xFFF8 - tunnel->hlen)
 		return -EINVAL;
 	dev->mtu = new_mtu;
 	return 0;
 }
 #ifdef CONFIG_NET_IPGRE_BROADCAST
 /* Nice toy. Unfortunately, useless in real life :-)
    It allows to construct virtual multiprotocol broadcast "LAN"
    over the Internet, provided multicast routing is tuned.
    I have no idea was this bicycle invented before me,
    so that I had to set ARPHRD_IPGRE to a random value.
    I have an impression, that Cisco could make something similar,
    but this feature is apparently missing in IOS<=11.2(8).
    I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
    with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
    ping -t 255 224.66.66.66
    If nobody answers, mbone does not work.
    ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
    ip addr add 10.66.66.<somewhat>/24 dev Universe
    ifconfig Universe up
    ifconfig Universe add fe80::<Your_real_addr>/10
    ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
    ftp 10.66.66.66
    ...
    ftp fec0:6666:6666::193.233.7.65
    ...
  */
 static int ipgre_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
 			void *daddr, void *saddr, unsigned len)
 {
 	struct ip_tunnel *t = netdev_priv(dev);
 	struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
 	u16 *p = (u16*)(iph+1);
 	memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
 	p[0]		= t->parms.o_flags;
 	p[1]		= htons(type);
 	/*
 	 *	Set the source hardware address.
 	 */
 	if (saddr)
 		memcpy(&iph->saddr, saddr, 4);
 	if (daddr) {
 		memcpy(&iph->daddr, daddr, 4);
 		return t->hlen;
 	}
 	if (iph->daddr && !MULTICAST(iph->daddr))
 		return t->hlen;
 	return -t->hlen;
 }
 static int ipgre_open(struct net_device *dev)
 {
 	struct ip_tunnel *t = netdev_priv(dev);
 	if (MULTICAST(t->parms.iph.daddr)) {
 		struct flowi fl = { .oif = t->parms.link,
 				    .nl_u = { .ip4_u =
 					      { .daddr = t->parms.iph.daddr,
 						.saddr = t->parms.iph.saddr,
 						.tos = RT_TOS(t->parms.iph.tos) } },
 				    .proto = IPPROTO_GRE };
 		struct rtable *rt;
 		if (ip_route_output_key(&rt, &fl))
 			return -EADDRNOTAVAIL;
 		dev = rt->u.dst.dev;
 		ip_rt_put(rt);
 		if (__in_dev_get_rtnl(dev) == NULL)
 			return -EADDRNOTAVAIL;
 		t->mlink = dev->ifindex;
 		ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
 	}
 	return 0;
 }
 static int ipgre_close(struct net_device *dev)
 {
 	struct ip_tunnel *t = netdev_priv(dev);
 	if (MULTICAST(t->parms.iph.daddr) && t->mlink) {
 		struct in_device *in_dev = inetdev_by_index(t->mlink);
 		if (in_dev) {
 			ip_mc_dec_group(in_dev, t->parms.iph.daddr);
 			in_dev_put(in_dev);
 		}
 	}
 	return 0;
 }
 #endif
 static void ipgre_tunnel_setup(struct net_device *dev)
 {
 	SET_MODULE_OWNER(dev);
 	dev->uninit		= ipgre_tunnel_uninit;
 	dev->destructor 	= free_netdev;
 	dev->hard_start_xmit	= ipgre_tunnel_xmit;
 	dev->get_stats		= ipgre_tunnel_get_stats;
 	dev->do_ioctl		= ipgre_tunnel_ioctl;
 	dev->change_mtu		= ipgre_tunnel_change_mtu;
 	dev->type		= ARPHRD_IPGRE;
 	dev->hard_header_len 	= LL_MAX_HEADER + sizeof(struct iphdr) + 4;
 	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr) - 4;
 	dev->flags		= IFF_NOARP;
 	dev->iflink		= 0;
 	dev->addr_len		= 4;
 }
 static int ipgre_tunnel_init(struct net_device *dev)
 {
 	struct net_device *tdev = NULL;
 	struct ip_tunnel *tunnel;
 	struct iphdr *iph;
 	int hlen = LL_MAX_HEADER;
 	int mtu = ETH_DATA_LEN;
 	int addend = sizeof(struct iphdr) + 4;
 	tunnel = netdev_priv(dev);
 	iph = &tunnel->parms.iph;
 	tunnel->dev = dev;
 	strcpy(tunnel->parms.name, dev->name);
 	memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
 	memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
 	/* Guess output device to choose reasonable mtu and hard_header_len */
 	if (iph->daddr) {
 		struct flowi fl = { .oif = tunnel->parms.link,
 				    .nl_u = { .ip4_u =
 					      { .daddr = iph->daddr,
 						.saddr = iph->saddr,
 						.tos = RT_TOS(iph->tos) } },
 				    .proto = IPPROTO_GRE };
 		struct rtable *rt;
 		if (!ip_route_output_key(&rt, &fl)) {
 			tdev = rt->u.dst.dev;
 			ip_rt_put(rt);
 		}
 		dev->flags |= IFF_POINTOPOINT;
 #ifdef CONFIG_NET_IPGRE_BROADCAST
 		if (MULTICAST(iph->daddr)) {
 			if (!iph->saddr)
 				return -EINVAL;
 			dev->flags = IFF_BROADCAST;
 			dev->hard_header = ipgre_header;
 			dev->open = ipgre_open;
 			dev->stop = ipgre_close;
 		}
 #endif
 	}
 	if (!tdev && tunnel->parms.link)
 		tdev = __dev_get_by_index(tunnel->parms.link);
 	if (tdev) {
 		hlen = tdev->hard_header_len;
 		mtu = tdev->mtu;
 	}
 	dev->iflink = tunnel->parms.link;
 	/* Precalculate GRE options length */
 	if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
 		if (tunnel->parms.o_flags&GRE_CSUM)
 			addend += 4;
 		if (tunnel->parms.o_flags&GRE_KEY)
 			addend += 4;
 		if (tunnel->parms.o_flags&GRE_SEQ)
 			addend += 4;
 	}
 	dev->hard_header_len = hlen + addend;
 	dev->mtu = mtu - addend;
 	tunnel->hlen = addend;
 	return 0;
 }
 static int __init ipgre_fb_tunnel_init(struct net_device *dev)
 {
 	struct ip_tunnel *tunnel = netdev_priv(dev);
 	struct iphdr *iph = &tunnel->parms.iph;
 	tunnel->dev = dev;
 	strcpy(tunnel->parms.name, dev->name);
 	iph->version		= 4;
 	iph->protocol		= IPPROTO_GRE;
 	iph->ihl		= 5;
 	tunnel->hlen		= sizeof(struct iphdr) + 4;
 	dev_hold(dev);
 	tunnels_wc[0]		= tunnel;
 	return 0;
 }
 static struct net_protocol ipgre_protocol = {
 	.handler	=	ipgre_rcv,
 	.err_handler	=	ipgre_err,
 };
 /*
  *	And now the modules code and kernel interface.
  */
 static int __init ipgre_init(void)
 {
 	int err;
 	printk(KERN_INFO "GRE over IPv4 tunneling driver\n");
 	if (inet_add_protocol(&ipgre_protocol, IPPROTO_GRE) < 0) {
 		printk(KERN_INFO "ipgre init: can't add protocol\n");
 		return -EAGAIN;
 	}
 	ipgre_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
 					   ipgre_tunnel_setup);
 	if (!ipgre_fb_tunnel_dev) {
 		err = -ENOMEM;
 		goto err1;
 	}
 	ipgre_fb_tunnel_dev->init = ipgre_fb_tunnel_init;
 	if ((err = register_netdev(ipgre_fb_tunnel_dev)))
 		goto err2;
 out:
 	return err;
 err2:
 	free_netdev(ipgre_fb_tunnel_dev);
 err1:
 	inet_del_protocol(&ipgre_protocol, IPPROTO_GRE);
 	goto out;
 }
 static void __exit ipgre_destroy_tunnels(void)
 {
 	int prio;
 	for (prio = 0; prio < 4; prio++) {
 		int h;
 		for (h = 0; h < HASH_SIZE; h++) {
 			struct ip_tunnel *t;
 			while ((t = tunnels[prio][h]) != NULL)
 				unregister_netdevice(t->dev);
 		}
 	}
 }
 static void __exit ipgre_fini(void)
 {
 	if (inet_del_protocol(&ipgre_protocol, IPPROTO_GRE) < 0)
 		printk(KERN_INFO "ipgre close: can't remove protocol\n");
 	rtnl_lock();
 	ipgre_destroy_tunnels();
 	rtnl_unlock();
 }
 module_init(ipgre_init);
 module_exit(ipgre_fini);
 MODULE_LICENSE("GPL");

net/ipv4/ip_options.c

Diff comments View file @ 5d9c5a3

 /*
  * INET		An implementation of the TCP/IP protocol suite for the LINUX
  *		operating system.  INET is implemented using the  BSD Socket
  *		interface as the means of communication with the user level.
  *
  *		The options processing module for ip.c
  *
  * Version:	$Id: ip_options.c,v 1.21 2001/09/01 00:31:50 davem Exp $
  *
  * Authors:	A.N.Kuznetsov
  *
  */
 #include <linux/capability.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <asm/uaccess.h>
 #include <linux/skbuff.h>
 #include <linux/ip.h>
 #include <linux/icmp.h>
 #include <linux/netdevice.h>
 #include <linux/rtnetlink.h>
 #include <net/sock.h>
 #include <net/ip.h>
 #include <net/icmp.h>
 #include <net/route.h>
 /*
  * Write options to IP header, record destination address to
  * source route option, address of outgoing interface
  * (we should already know it, so that this  function is allowed be
  * called only after routing decision) and timestamp,
  * if we originate this datagram.
  *
  * daddr is real destination address, next hop is recorded in IP header.
  * saddr is address of outgoing interface.
  */
 void ip_options_build(struct sk_buff * skb, struct ip_options * opt,
 			    u32 daddr, struct rtable *rt, int is_frag)
 {
 	unsigned char * iph = skb->nh.raw;
 	memcpy(&(IPCB(skb)->opt), opt, sizeof(struct ip_options));
 	memcpy(iph+sizeof(struct iphdr), opt->__data, opt->optlen);
 	opt = &(IPCB(skb)->opt);
 	opt->is_data = 0;
 	if (opt->srr)
 		memcpy(iph+opt->srr+iph[opt->srr+1]-4, &daddr, 4);
 	if (!is_frag) {
 		if (opt->rr_needaddr)
 			ip_rt_get_source(iph+opt->rr+iph[opt->rr+2]-5, rt);
 		if (opt->ts_needaddr)
 			ip_rt_get_source(iph+opt->ts+iph[opt->ts+2]-9, rt);
 		if (opt->ts_needtime) {
 			struct timeval tv;
 			__u32 midtime;
 			do_gettimeofday(&tv);
 			midtime = htonl((tv.tv_sec % 86400) * 1000 + tv.tv_usec / 1000);
 			memcpy(iph+opt->ts+iph[opt->ts+2]-5, &midtime, 4);
 		}
 		return;
 	}
 	if (opt->rr) {
 		memset(iph+opt->rr, IPOPT_NOP, iph[opt->rr+1]);
 		opt->rr = 0;
 		opt->rr_needaddr = 0;
 	}
 	if (opt->ts) {
 		memset(iph+opt->ts, IPOPT_NOP, iph[opt->ts+1]);
 		opt->ts = 0;
 		opt->ts_needaddr = opt->ts_needtime = 0;
 	}
 }
 /*
  * Provided (sopt, skb) points to received options,
  * build in dopt compiled option set appropriate for answering.
  * i.e. invert SRR option, copy anothers,
  * and grab room in RR/TS options.
  *
  * NOTE: dopt cannot point to skb.
  */
 int ip_options_echo(struct ip_options * dopt, struct sk_buff * skb)
 {
 	struct ip_options *sopt;
 	unsigned char *sptr, *dptr;
 	int soffset, doffset;
 	int	optlen;
 	u32	daddr;
 	memset(dopt, 0, sizeof(struct ip_options));
 	dopt->is_data = 1;
 	sopt = &(IPCB(skb)->opt);
 	if (sopt->optlen == 0) {
 		dopt->optlen = 0;
 		return 0;
 	}
 	sptr = skb->nh.raw;
 	dptr = dopt->__data;
 	if (skb->dst)
 		daddr = ((struct rtable*)skb->dst)->rt_spec_dst;
 	else
 		daddr = skb->nh.iph->daddr;
 	if (sopt->rr) {
 		optlen  = sptr[sopt->rr+1];
 		soffset = sptr[sopt->rr+2];
 		dopt->rr = dopt->optlen + sizeof(struct iphdr);
 		memcpy(dptr, sptr+sopt->rr, optlen);
 		if (sopt->rr_needaddr && soffset <= optlen) {
 			if (soffset + 3 > optlen)
 				return -EINVAL;
 			dptr[2] = soffset + 4;
 			dopt->rr_needaddr = 1;
 		}
 		dptr += optlen;
 		dopt->optlen += optlen;
 	}
 	if (sopt->ts) {
 		optlen = sptr[sopt->ts+1];
 		soffset = sptr[sopt->ts+2];
 		dopt->ts = dopt->optlen + sizeof(struct iphdr);
 		memcpy(dptr, sptr+sopt->ts, optlen);
 		if (soffset <= optlen) {
 			if (sopt->ts_needaddr) {
 				if (soffset + 3 > optlen)
 					return -EINVAL;
 				dopt->ts_needaddr = 1;
 				soffset += 4;
 			}
 			if (sopt->ts_needtime) {
 				if (soffset + 3 > optlen)
 					return -EINVAL;
 				if ((dptr[3]&0xF) != IPOPT_TS_PRESPEC) {
 					dopt->ts_needtime = 1;
 					soffset += 4;
 				} else {
 					dopt->ts_needtime = 0;
 					if (soffset + 8 <= optlen) {
 						__u32 addr;
 						memcpy(&addr, sptr+soffset-1, 4);
 						if (inet_addr_type(addr) != RTN_LOCAL) {
 							dopt->ts_needtime = 1;
 							soffset += 8;
 						}
 					}
 				}
 			}
 			dptr[2] = soffset;
 		}
 		dptr += optlen;
 		dopt->optlen += optlen;
 	}
 	if (sopt->srr) {
 		unsigned char * start = sptr+sopt->srr;
 		u32 faddr;
 		optlen  = start[1];
 		soffset = start[2];
 		doffset = 0;
 		if (soffset > optlen)
 			soffset = optlen + 1;
 		soffset -= 4;
 		if (soffset > 3) {
 			memcpy(&faddr, &start[soffset-1], 4);
 			for (soffset-=4, doffset=4; soffset > 3; soffset-=4, doffset+=4)
 				memcpy(&dptr[doffset-1], &start[soffset-1], 4);
 			/*
 			 * RFC1812 requires to fix illegal source routes.
 			 */
 			if (memcmp(&skb->nh.iph->saddr, &start[soffset+3], 4) == 0)
 				doffset -= 4;
 		}
 		if (doffset > 3) {
 			memcpy(&start[doffset-1], &daddr, 4);
 			dopt->faddr = faddr;
 			dptr[0] = start[0];
 			dptr[1] = doffset+3;
 			dptr[2] = 4;
 			dptr += doffset+3;
 			dopt->srr = dopt->optlen + sizeof(struct iphdr);
 			dopt->optlen += doffset+3;
 			dopt->is_strictroute = sopt->is_strictroute;
 		}
 	}
 	while (dopt->optlen & 3) {
 		*dptr++ = IPOPT_END;
 		dopt->optlen++;
 	}
 	return 0;
 }
 /*
  *	Options "fragmenting", just fill options not
  *	allowed in fragments with NOOPs.
  *	Simple and stupid 8), but the most efficient way.
  */
 void ip_options_fragment(struct sk_buff * skb)
 {
 	unsigned char * optptr = skb->nh.raw + sizeof(struct iphdr);
 	struct ip_options * opt = &(IPCB(skb)->opt);
 	int  l = opt->optlen;
 	int  optlen;
 	while (l > 0) {
 		switch (*optptr) {
 		case IPOPT_END:
 			return;
 		case IPOPT_NOOP:
 			l--;
 			optptr++;
 			continue;
 		}
 		optlen = optptr[1];
 		if (optlen<2 || optlen>l)
 		  return;
 		if (!IPOPT_COPIED(*optptr))
 			memset(optptr, IPOPT_NOOP, optlen);
 		l -= optlen;
 		optptr += optlen;
 	}
 	opt->ts = 0;
 	opt->rr = 0;
 	opt->rr_needaddr = 0;
 	opt->ts_needaddr = 0;
 	opt->ts_needtime = 0;
 	return;
 }
 /*
  * Verify options and fill pointers in struct options.
  * Caller should clear *opt, and set opt->data.
  * If opt == NULL, then skb->data should point to IP header.
  */
 int ip_options_compile(struct ip_options * opt, struct sk_buff * skb)
 {
 	int l;
 	unsigned char * iph;
 	unsigned char * optptr;
 	int optlen;
 	unsigned char * pp_ptr = NULL;
 	struct rtable *rt = skb ? (struct rtable*)skb->dst : NULL;
 	if (!opt) {
 		opt = &(IPCB(skb)->opt);
-		memset(opt, 0, sizeof(struct ip_options));
 		iph = skb->nh.raw;
 		opt->optlen = ((struct iphdr *)iph)->ihl*4 - sizeof(struct iphdr);
 		optptr = iph + sizeof(struct iphdr);
 		opt->is_data = 0;
 	} else {
 		optptr = opt->is_data ? opt->__data : (unsigned char*)&(skb->nh.iph[1]);
 		iph = optptr - sizeof(struct iphdr);
 	}
 	for (l = opt->optlen; l > 0; ) {
 		switch (*optptr) {
 		      case IPOPT_END:
 			for (optptr++, l--; l>0; optptr++, l--) {
 				if (*optptr != IPOPT_END) {
 					*optptr = IPOPT_END;
 					opt->is_changed = 1;
 				}
 			}
 			goto eol;
 		      case IPOPT_NOOP:
 			l--;
 			optptr++;
 			continue;
 		}
 		optlen = optptr[1];
 		if (optlen<2 || optlen>l) {
 			pp_ptr = optptr;
 			goto error;
 		}
 		switch (*optptr) {
 		      case IPOPT_SSRR:
 		      case IPOPT_LSRR:
 			if (optlen < 3) {
 				pp_ptr = optptr + 1;
 				goto error;
 			}
 			if (optptr[2] < 4) {
 				pp_ptr = optptr + 2;
 				goto error;
 			}
 			/* NB: cf RFC-1812 5.2.4.1 */
 			if (opt->srr) {
 				pp_ptr = optptr;
 				goto error;
 			}
 			if (!skb) {
 				if (optptr[2] != 4 || optlen < 7 || ((optlen-3) & 3)) {
 					pp_ptr = optptr + 1;
 					goto error;
 				}
 				memcpy(&opt->faddr, &optptr[3], 4);
 				if (optlen > 7)
 					memmove(&optptr[3], &optptr[7], optlen-7);
 			}
 			opt->is_strictroute = (optptr[0] == IPOPT_SSRR);
 			opt->srr = optptr - iph;
 			break;
 		      case IPOPT_RR:
 			if (opt->rr) {
 				pp_ptr = optptr;
 				goto error;
 			}
 			if (optlen < 3) {
 				pp_ptr = optptr + 1;
 				goto error;
 			}
 			if (optptr[2] < 4) {
 				pp_ptr = optptr + 2;
 				goto error;
 			}
 			if (optptr[2] <= optlen) {
 				if (optptr[2]+3 > optlen) {
 					pp_ptr = optptr + 2;
 					goto error;
 				}
 				if (skb) {
 					memcpy(&optptr[optptr[2]-1], &rt->rt_spec_dst, 4);
 					opt->is_changed = 1;
 				}
 				optptr[2] += 4;
 				opt->rr_needaddr = 1;
 			}
 			opt->rr = optptr - iph;
 			break;
 		      case IPOPT_TIMESTAMP:
 			if (opt->ts) {
 				pp_ptr = optptr;
 				goto error;
 			}
 			if (optlen < 4) {
 				pp_ptr = optptr + 1;
 				goto error;
 			}
 			if (optptr[2] < 5) {
 				pp_ptr = optptr + 2;
 				goto error;
 			}
 			if (optptr[2] <= optlen) {
 				__u32 * timeptr = NULL;
 				if (optptr[2]+3 > optptr[1]) {
 					pp_ptr = optptr + 2;
 					goto error;
 				}
 				switch (optptr[3]&0xF) {
 				      case IPOPT_TS_TSONLY:
 					opt->ts = optptr - iph;
 					if (skb)
 						timeptr = (__u32*)&optptr[optptr[2]-1];
 					opt->ts_needtime = 1;
 					optptr[2] += 4;
 					break;
 				      case IPOPT_TS_TSANDADDR:
 					if (optptr[2]+7 > optptr[1]) {
 						pp_ptr = optptr + 2;
 						goto error;
 					}
 					opt->ts = optptr - iph;
 					if (skb) {
 						memcpy(&optptr[optptr[2]-1], &rt->rt_spec_dst, 4);
 						timeptr = (__u32*)&optptr[optptr[2]+3];
 					}
 					opt->ts_needaddr = 1;
 					opt->ts_needtime = 1;
 					optptr[2] += 8;
 					break;
 				      case IPOPT_TS_PRESPEC:
 					if (optptr[2]+7 > optptr[1]) {
 						pp_ptr = optptr + 2;
 						goto error;
 					}
 					opt->ts = optptr - iph;
 					{
 						u32 addr;
 						memcpy(&addr, &optptr[optptr[2]-1], 4);
 						if (inet_addr_type(addr) == RTN_UNICAST)
 							break;
 						if (skb)
 							timeptr = (__u32*)&optptr[optptr[2]+3];
 					}
 					opt->ts_needtime = 1;
 					optptr[2] += 8;
 					break;
 				      default:
 					if (!skb && !capable(CAP_NET_RAW)) {
 						pp_ptr = optptr + 3;
 						goto error;
 					}
 					break;
 				}
 				if (timeptr) {
 					struct timeval tv;
 					__u32  midtime;
 					do_gettimeofday(&tv);
 					midtime = htonl((tv.tv_sec % 86400) * 1000 + tv.tv_usec / 1000);
 					memcpy(timeptr, &midtime, sizeof(__u32));
 					opt->is_changed = 1;
 				}
 			} else {
 				unsigned overflow = optptr[3]>>4;
 				if (overflow == 15) {
 					pp_ptr = optptr + 3;
 					goto error;
 				}
 				opt->ts = optptr - iph;
 				if (skb) {
 					optptr[3] = (optptr[3]&0xF)|((overflow+1)<<4);
 					opt->is_changed = 1;
 				}
 			}
 			break;
 		      case IPOPT_RA:
 			if (optlen < 4) {
 				pp_ptr = optptr + 1;
 				goto error;
 			}
 			if (optptr[2] == 0 && optptr[3] == 0)
 				opt->router_alert = optptr - iph;
 			break;
 		      case IPOPT_SEC:
 		      case IPOPT_SID:
 		      default:
 			if (!skb && !capable(CAP_NET_RAW)) {
 				pp_ptr = optptr;
 				goto error;
 			}
 			break;
 		}
 		l -= optlen;
 		optptr += optlen;
 	}
 eol:
 	if (!pp_ptr)
 		return 0;
 error:
 	if (skb) {
 		icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((pp_ptr-iph)<<24));
 	}
 	return -EINVAL;
 }
 /*
  *	Undo all the changes done by ip_options_compile().
  */
 void ip_options_undo(struct ip_options * opt)
 {
 	if (opt->srr) {
 		unsigned  char * optptr = opt->__data+opt->srr-sizeof(struct  iphdr);
 		memmove(optptr+7, optptr+3, optptr[1]-7);
 		memcpy(optptr+3, &opt->faddr, 4);
 	}
 	if (opt->rr_needaddr) {
 		unsigned  char * optptr = opt->__data+opt->rr-sizeof(struct  iphdr);
 		optptr[2] -= 4;
 		memset(&optptr[optptr[2]-1], 0, 4);
 	}
 	if (opt->ts) {
 		unsigned  char * optptr = opt->__data+opt->ts-sizeof(struct  iphdr);
 		if (opt->ts_needtime) {
 			optptr[2] -= 4;
 			memset(&optptr[optptr[2]-1], 0, 4);
 			if ((optptr[3]&0xF) == IPOPT_TS_PRESPEC)
 				optptr[2] -= 4;
 		}
 		if (opt->ts_needaddr) {
 			optptr[2] -= 4;
 			memset(&optptr[optptr[2]-1], 0, 4);
 		}
 	}
 }
 static struct ip_options *ip_options_get_alloc(const int optlen)
 {
 	struct ip_options *opt = kmalloc(sizeof(*opt) + ((optlen + 3) & ~3),
 					 GFP_KERNEL);
 	if (opt)
 		memset(opt, 0, sizeof(*opt));
 	return opt;
 }
 static int ip_options_get_finish(struct ip_options **optp,
 				 struct ip_options *opt, int optlen)
 {
 	while (optlen & 3)
 		opt->__data[optlen++] = IPOPT_END;
 	opt->optlen = optlen;
 	opt->is_data = 1;
 	opt->is_setbyuser = 1;
 	if (optlen && ip_options_compile(opt, NULL)) {
 		kfree(opt);
 		return -EINVAL;
 	}
 	kfree(*optp);
 	*optp = opt;
 	return 0;
 }
 int ip_options_get_from_user(struct ip_options **optp, unsigned char __user *data, int optlen)
 {
 	struct ip_options *opt = ip_options_get_alloc(optlen);
 	if (!opt)
 		return -ENOMEM;
 	if (optlen && copy_from_user(opt->__data, data, optlen)) {
 		kfree(opt);
 		return -EFAULT;
 	}
 	return ip_options_get_finish(optp, opt, optlen);
 }
 int ip_options_get(struct ip_options **optp, unsigned char *data, int optlen)
 {
 	struct ip_options *opt = ip_options_get_alloc(optlen);
 	if (!opt)
 		return -ENOMEM;
 	if (optlen)
 		memcpy(opt->__data, data, optlen);
 	return ip_options_get_finish(optp, opt, optlen);
 }
 void ip_forward_options(struct sk_buff *skb)
 {
 	struct   ip_options * opt	= &(IPCB(skb)->opt);
 	unsigned char * optptr;
 	struct rtable *rt = (struct rtable*)skb->dst;
 	unsigned char *raw = skb->nh.raw;
 	if (opt->rr_needaddr) {
 		optptr = (unsigned char *)raw + opt->rr;
 		ip_rt_get_source(&optptr[optptr[2]-5], rt);
 		opt->is_changed = 1;
 	}
 	if (opt->srr_is_hit) {
 		int srrptr, srrspace;
 		optptr = raw + opt->srr;
 		for ( srrptr=optptr[2], srrspace = optptr[1];
 		     srrptr <= srrspace;
 		     srrptr += 4
 		     ) {
 			if (srrptr + 3 > srrspace)
 				break;
 			if (memcmp(&rt->rt_dst, &optptr[srrptr-1], 4) == 0)
 				break;
 		}
 		if (srrptr + 3 <= srrspace) {
 			opt->is_changed = 1;
 			ip_rt_get_source(&optptr[srrptr-1], rt);
 			skb->nh.iph->daddr = rt->rt_dst;
 			optptr[2] = srrptr+4;
 		} else if (net_ratelimit())
 			printk(KERN_CRIT "ip_forward(): Argh! Destination lost!\n");
 		if (opt->ts_needaddr) {
 			optptr = raw + opt->ts;
 			ip_rt_get_source(&optptr[optptr[2]-9], rt);
 			opt->is_changed = 1;
 		}
 	}
 	if (opt->is_changed) {
 		opt->is_changed = 0;
 		ip_send_check(skb->nh.iph);
 	}
 }
 int ip_options_rcv_srr(struct sk_buff *skb)
 {
 	struct ip_options *opt = &(IPCB(skb)->opt);
 	int srrspace, srrptr;
 	u32 nexthop;
 	struct iphdr *iph = skb->nh.iph;
 	unsigned char * optptr = skb->nh.raw + opt->srr;
 	struct rtable *rt = (struct rtable*)skb->dst;
 	struct rtable *rt2;
 	int err;
 	if (!opt->srr)
 		return 0;
 	if (skb->pkt_type != PACKET_HOST)
 		return -EINVAL;
 	if (rt->rt_type == RTN_UNICAST) {
 		if (!opt->is_strictroute)
 			return 0;
 		icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl(16<<24));
 		return -EINVAL;
 	}
 	if (rt->rt_type != RTN_LOCAL)
 		return -EINVAL;
 	for (srrptr=optptr[2], srrspace = optptr[1]; srrptr <= srrspace; srrptr += 4) {
 		if (srrptr + 3 > srrspace) {
 			icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((opt->srr+2)<<24));
 			return -EINVAL;
 		}
 		memcpy(&nexthop, &optptr[srrptr-1], 4);
 		rt = (struct rtable*)skb->dst;
 		skb->dst = NULL;
 		err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, skb->dev);
 		rt2 = (struct rtable*)skb->dst;
 		if (err || (rt2->rt_type != RTN_UNICAST && rt2->rt_type != RTN_LOCAL)) {
 			ip_rt_put(rt2);
 			skb->dst = &rt->u.dst;
 			return -EINVAL;
 		}
 		ip_rt_put(rt);
 		if (rt2->rt_type != RTN_LOCAL)
 			break;
 		/* Superfast 8) loopback forward */
 		memcpy(&iph->daddr, &optptr[srrptr-1], 4);
 		opt->is_changed = 1;
 	}
 	if (srrptr <= srrspace) {
 		opt->srr_is_hit = 1;
 		opt->is_changed = 1;
 	}
 	return 0;
 }

net/ipv4/ipip.c

Diff comments View file @ 5d9c5a3

 /*
  *	Linux NET3:	IP/IP protocol decoder.
  *
  *	Version: $Id: ipip.c,v 1.50 2001/10/02 02:22:36 davem Exp $
  *
  *	Authors:
  *		Sam Lantinga (slouken@cs.ucdavis.edu)  02/01/95
  *
  *	Fixes:
  *		Alan Cox	:	Merged and made usable non modular (its so tiny its silly as
  *					a module taking up 2 pages).
  *		Alan Cox	: 	Fixed bug with 1.3.18 and IPIP not working (now needs to set skb->h.iph)
  *					to keep ip_forward happy.
  *		Alan Cox	:	More fixes for 1.3.21, and firewall fix. Maybe this will work soon 8).
  *		Kai Schulte	:	Fixed #defines for IP_FIREWALL->FIREWALL
  *              David Woodhouse :       Perform some basic ICMP handling.
  *                                      IPIP Routing without decapsulation.
  *              Carlos Picoto   :       GRE over IP support
  *		Alexey Kuznetsov:	Reworked. Really, now it is truncated version of ipv4/ip_gre.c.
  *					I do not want to merge them together.
  *
  *	This program is free software; you can redistribute it and/or
  *	modify it under the terms of the GNU General Public License
  *	as published by the Free Software Foundation; either version
  *	2 of the License, or (at your option) any later version.
  *
  */
 /* tunnel.c: an IP tunnel driver
 	The purpose of this driver is to provide an IP tunnel through
 	which you can tunnel network traffic transparently across subnets.
 	This was written by looking at Nick Holloway's dummy driver
 	Thanks for the great code!
 		-Sam Lantinga	(slouken@cs.ucdavis.edu)  02/01/95
 	Minor tweaks:
 		Cleaned up the code a little and added some pre-1.3.0 tweaks.
 		dev->hard_header/hard_header_len changed to use no headers.
 		Comments/bracketing tweaked.
 		Made the tunnels use dev->name not tunnel: when error reporting.
 		Added tx_dropped stat
 		-Alan Cox	(Alan.Cox@linux.org) 21 March 95
 	Reworked:
 		Changed to tunnel to destination gateway in addition to the
 			tunnel's pointopoint address
 		Almost completely rewritten
 		Note:  There is currently no firewall or ICMP handling done.
 		-Sam Lantinga	(slouken@cs.ucdavis.edu) 02/13/96
 */
 /* Things I wish I had known when writing the tunnel driver:
 	When the tunnel_xmit() function is called, the skb contains the
 	packet to be sent (plus a great deal of extra info), and dev
 	contains the tunnel device that _we_ are.
 	When we are passed a packet, we are expected to fill in the
 	source address with our source IP address.
 	What is the proper way to allocate, copy and free a buffer?
 	After you allocate it, it is a "0 length" chunk of memory
 	starting at zero.  If you want to add headers to the buffer
 	later, you'll have to call "skb_reserve(skb, amount)" with
 	the amount of memory you want reserved.  Then, you call
 	"skb_put(skb, amount)" with the amount of space you want in
 	the buffer.  skb_put() returns a pointer to the top (#0) of
 	that buffer.  skb->len is set to the amount of space you have
 	"allocated" with skb_put().  You can then write up to skb->len
 	bytes to that buffer.  If you need more, you can call skb_put()
 	again with the additional amount of space you need.  You can
 	find out how much more space you can allocate by calling
 	"skb_tailroom(skb)".
 	Now, to add header space, call "skb_push(skb, header_len)".
 	This creates space at the beginning of the buffer and returns
 	a pointer to this new space.  If later you need to strip a
 	header from a buffer, call "skb_pull(skb, header_len)".
 	skb_headroom() will return how much space is left at the top
 	of the buffer (before the main data).  Remember, this headroom
 	space must be reserved before the skb_put() function is called.
 	*/
 /*
    This version of net/ipv4/ipip.c is cloned of net/ipv4/ip_gre.c
    For comments look at net/ipv4/ip_gre.c --ANK
  */
 #include <linux/capability.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <asm/uaccess.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <linux/in.h>
 #include <linux/tcp.h>
 #include <linux/udp.h>
 #include <linux/if_arp.h>
 #include <linux/mroute.h>
 #include <linux/init.h>
 #include <linux/netfilter_ipv4.h>
 #include <linux/if_ether.h>
 #include <net/sock.h>
 #include <net/ip.h>
 #include <net/icmp.h>
 #include <net/ipip.h>
 #include <net/inet_ecn.h>
 #include <net/xfrm.h>
 #define HASH_SIZE  16
 #define HASH(addr) ((addr^(addr>>4))&0xF)
 static int ipip_fb_tunnel_init(struct net_device *dev);
 static int ipip_tunnel_init(struct net_device *dev);
 static void ipip_tunnel_setup(struct net_device *dev);
 static struct net_device *ipip_fb_tunnel_dev;
 static struct ip_tunnel *tunnels_r_l[HASH_SIZE];
 static struct ip_tunnel *tunnels_r[HASH_SIZE];
 static struct ip_tunnel *tunnels_l[HASH_SIZE];
 static struct ip_tunnel *tunnels_wc[1];
 static struct ip_tunnel **tunnels[4] = { tunnels_wc, tunnels_l, tunnels_r, tunnels_r_l };
 static DEFINE_RWLOCK(ipip_lock);
 static struct ip_tunnel * ipip_tunnel_lookup(u32 remote, u32 local)
 {
 	unsigned h0 = HASH(remote);
 	unsigned h1 = HASH(local);
 	struct ip_tunnel *t;
 	for (t = tunnels_r_l[h0^h1]; t; t = t->next) {
 		if (local == t->parms.iph.saddr &&
 		    remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
 			return t;
 	}
 	for (t = tunnels_r[h0]; t; t = t->next) {
 		if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
 			return t;
 	}
 	for (t = tunnels_l[h1]; t; t = t->next) {
 		if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
 			return t;
 	}
 	if ((t = tunnels_wc[0]) != NULL && (t->dev->flags&IFF_UP))
 		return t;
 	return NULL;
 }
 static struct ip_tunnel **ipip_bucket(struct ip_tunnel *t)
 {
 	u32 remote = t->parms.iph.daddr;
 	u32 local = t->parms.iph.saddr;
 	unsigned h = 0;
 	int prio = 0;
 	if (remote) {
 		prio |= 2;
 		h ^= HASH(remote);
 	}
 	if (local) {
 		prio |= 1;
 		h ^= HASH(local);
 	}
 	return &tunnels[prio][h];
 }
 static void ipip_tunnel_unlink(struct ip_tunnel *t)
 {
 	struct ip_tunnel **tp;
 	for (tp = ipip_bucket(t); *tp; tp = &(*tp)->next) {
 		if (t == *tp) {
 			write_lock_bh(&ipip_lock);
 			*tp = t->next;
 			write_unlock_bh(&ipip_lock);
 			break;
 		}
 	}
 }
 static void ipip_tunnel_link(struct ip_tunnel *t)
 {
 	struct ip_tunnel **tp = ipip_bucket(t);
 	t->next = *tp;
 	write_lock_bh(&ipip_lock);
 	*tp = t;
 	write_unlock_bh(&ipip_lock);
 }
 static struct ip_tunnel * ipip_tunnel_locate(struct ip_tunnel_parm *parms, int create)
 {
 	u32 remote = parms->iph.daddr;
 	u32 local = parms->iph.saddr;
 	struct ip_tunnel *t, **tp, *nt;
 	struct net_device *dev;
 	unsigned h = 0;
 	int prio = 0;
 	char name[IFNAMSIZ];
 	if (remote) {
 		prio |= 2;
 		h ^= HASH(remote);
 	}
 	if (local) {
 		prio |= 1;
 		h ^= HASH(local);
 	}
 	for (tp = &tunnels[prio][h]; (t = *tp) != NULL; tp = &t->next) {
 		if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
 			return t;
 	}
 	if (!create)
 		return NULL;
 	if (parms->name[0])
 		strlcpy(name, parms->name, IFNAMSIZ);
 	else {
 		int i;
 		for (i=1; i<100; i++) {
 			sprintf(name, "tunl%d", i);
 			if (__dev_get_by_name(name) == NULL)
 				break;
 		}
 		if (i==100)
 			goto failed;
 	}
 	dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
 	if (dev == NULL)
 		return NULL;
 	nt = netdev_priv(dev);
 	SET_MODULE_OWNER(dev);
 	dev->init = ipip_tunnel_init;
 	nt->parms = *parms;
 	if (register_netdevice(dev) < 0) {
 		free_netdev(dev);
 		goto failed;
 	}
 	dev_hold(dev);
 	ipip_tunnel_link(nt);
 	return nt;
 failed:
 	return NULL;
 }
 static void ipip_tunnel_uninit(struct net_device *dev)
 {
 	if (dev == ipip_fb_tunnel_dev) {
 		write_lock_bh(&ipip_lock);
 		tunnels_wc[0] = NULL;
 		write_unlock_bh(&ipip_lock);
 	} else
 		ipip_tunnel_unlink(netdev_priv(dev));
 	dev_put(dev);
 }
 static int ipip_err(struct sk_buff *skb, u32 info)
 {
 #ifndef I_WISH_WORLD_WERE_PERFECT
 /* It is not :-( All the routers (except for Linux) return only
    8 bytes of packet payload. It means, that precise relaying of
    ICMP in the real Internet is absolutely infeasible.
  */
 	struct iphdr *iph = (struct iphdr*)skb->data;
 	int type = skb->h.icmph->type;
 	int code = skb->h.icmph->code;
 	struct ip_tunnel *t;
 	int err;
 	switch (type) {
 	default:
 	case ICMP_PARAMETERPROB:
 		return 0;
 	case ICMP_DEST_UNREACH:
 		switch (code) {
 		case ICMP_SR_FAILED:
 		case ICMP_PORT_UNREACH:
 			/* Impossible event. */
 			return 0;
 		case ICMP_FRAG_NEEDED:
 			/* Soft state for pmtu is maintained by IP core. */
 			return 0;
 		default:
 			/* All others are translated to HOST_UNREACH.
 			   rfc2003 contains "deep thoughts" about NET_UNREACH,
 			   I believe they are just ether pollution. --ANK
 			 */
 			break;
 		}
 		break;
 	case ICMP_TIME_EXCEEDED:
 		if (code != ICMP_EXC_TTL)
 			return 0;
 		break;
 	}
 	err = -ENOENT;
 	read_lock(&ipip_lock);
 	t = ipip_tunnel_lookup(iph->daddr, iph->saddr);
 	if (t == NULL || t->parms.iph.daddr == 0)
 		goto out;
 	err = 0;
 	if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 		goto out;
 	if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
 		t->err_count++;
 	else
 		t->err_count = 1;
 	t->err_time = jiffies;
 out:
 	read_unlock(&ipip_lock);
 	return err;
 #else
 	struct iphdr *iph = (struct iphdr*)dp;
 	int hlen = iph->ihl<<2;
 	struct iphdr *eiph;
 	int type = skb->h.icmph->type;
 	int code = skb->h.icmph->code;
 	int rel_type = 0;
 	int rel_code = 0;
 	int rel_info = 0;
 	struct sk_buff *skb2;
 	struct flowi fl;
 	struct rtable *rt;
 	if (len < hlen + sizeof(struct iphdr))
 		return 0;
 	eiph = (struct iphdr*)(dp + hlen);
 	switch (type) {
 	default:
 		return 0;
 	case ICMP_PARAMETERPROB:
 		if (skb->h.icmph->un.gateway < hlen)
 			return 0;
 		/* So... This guy found something strange INSIDE encapsulated
 		   packet. Well, he is fool, but what can we do ?
 		 */
 		rel_type = ICMP_PARAMETERPROB;
 		rel_info = skb->h.icmph->un.gateway - hlen;
 		break;
 	case ICMP_DEST_UNREACH:
 		switch (code) {
 		case ICMP_SR_FAILED:
 		case ICMP_PORT_UNREACH:
 			/* Impossible event. */
 			return 0;
 		case ICMP_FRAG_NEEDED:
 			/* And it is the only really necessary thing :-) */
 			rel_info = ntohs(skb->h.icmph->un.frag.mtu);
 			if (rel_info < hlen+68)
 				return 0;
 			rel_info -= hlen;
 			/* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
 			if (rel_info > ntohs(eiph->tot_len))
 				return 0;
 			break;
 		default:
 			/* All others are translated to HOST_UNREACH.
 			   rfc2003 contains "deep thoughts" about NET_UNREACH,
 			   I believe, it is just ether pollution. --ANK
 			 */
 			rel_type = ICMP_DEST_UNREACH;
 			rel_code = ICMP_HOST_UNREACH;
 			break;
 		}
 		break;
 	case ICMP_TIME_EXCEEDED:
 		if (code != ICMP_EXC_TTL)
 			return 0;
 		break;
 	}
 	/* Prepare fake skb to feed it to icmp_send */
 	skb2 = skb_clone(skb, GFP_ATOMIC);
 	if (skb2 == NULL)
 		return 0;
 	dst_release(skb2->dst);
 	skb2->dst = NULL;
 	skb_pull(skb2, skb->data - (u8*)eiph);
 	skb2->nh.raw = skb2->data;
 	/* Try to guess incoming interface */
 	memset(&fl, 0, sizeof(fl));
 	fl.fl4_daddr = eiph->saddr;
 	fl.fl4_tos = RT_TOS(eiph->tos);
 	fl.proto = IPPROTO_IPIP;
 	if (ip_route_output_key(&rt, &key)) {
 		kfree_skb(skb2);
 		return 0;
 	}
 	skb2->dev = rt->u.dst.dev;
 	/* route "incoming" packet */
 	if (rt->rt_flags&RTCF_LOCAL) {
 		ip_rt_put(rt);
 		rt = NULL;
 		fl.fl4_daddr = eiph->daddr;
 		fl.fl4_src = eiph->saddr;
 		fl.fl4_tos = eiph->tos;
 		if (ip_route_output_key(&rt, &fl) ||
 		    rt->u.dst.dev->type != ARPHRD_TUNNEL) {
 			ip_rt_put(rt);
 			kfree_skb(skb2);
 			return 0;
 		}
 	} else {
 		ip_rt_put(rt);
 		if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
 		    skb2->dst->dev->type != ARPHRD_TUNNEL) {
 			kfree_skb(skb2);
 			return 0;
 		}
 	}
 	/* change mtu on this route */
 	if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 		if (rel_info > dst_mtu(skb2->dst)) {
 			kfree_skb(skb2);
 			return 0;
 		}
 		skb2->dst->ops->update_pmtu(skb2->dst, rel_info);
 		rel_info = htonl(rel_info);
 	} else if (type == ICMP_TIME_EXCEEDED) {
 		struct ip_tunnel *t = netdev_priv(skb2->dev);
 		if (t->parms.iph.ttl) {
 			rel_type = ICMP_DEST_UNREACH;
 			rel_code = ICMP_HOST_UNREACH;
 		}
 	}
 	icmp_send(skb2, rel_type, rel_code, rel_info);
 	kfree_skb(skb2);
 	return 0;
 #endif
 }
 static inline void ipip_ecn_decapsulate(struct iphdr *outer_iph, struct sk_buff *skb)
 {
 	struct iphdr *inner_iph = skb->nh.iph;
 	if (INET_ECN_is_ce(outer_iph->tos))
 		IP_ECN_set_ce(inner_iph);
 }
 static int ipip_rcv(struct sk_buff *skb)
 {
 	struct iphdr *iph;
 	struct ip_tunnel *tunnel;
 	iph = skb->nh.iph;
 	read_lock(&ipip_lock);
 	if ((tunnel = ipip_tunnel_lookup(iph->saddr, iph->daddr)) != NULL) {
 		if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
 			read_unlock(&ipip_lock);
 			kfree_skb(skb);
 			return 0;
 		}
 		secpath_reset(skb);
 		skb->mac.raw = skb->nh.raw;
 		skb->nh.raw = skb->data;
-		memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
 		skb->protocol = htons(ETH_P_IP);
 		skb->pkt_type = PACKET_HOST;
 		tunnel->stat.rx_packets++;
 		tunnel->stat.rx_bytes += skb->len;
 		skb->dev = tunnel->dev;
 		dst_release(skb->dst);
 		skb->dst = NULL;
 		nf_reset(skb);
 		ipip_ecn_decapsulate(iph, skb);
 		netif_rx(skb);
 		read_unlock(&ipip_lock);
 		return 0;
 	}
 	read_unlock(&ipip_lock);
 	return -1;
 }
 /*
  *	This function assumes it is being called from dev_queue_xmit()
  *	and that skb is filled properly by that function.
  */
 static int ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	struct ip_tunnel *tunnel = netdev_priv(dev);
 	struct net_device_stats *stats = &tunnel->stat;
 	struct iphdr  *tiph = &tunnel->parms.iph;
 	u8     tos = tunnel->parms.iph.tos;
 	u16    df = tiph->frag_off;
 	struct rtable *rt;     			/* Route to the other host */
 	struct net_device *tdev;			/* Device to other host */
 	struct iphdr  *old_iph = skb->nh.iph;
 	struct iphdr  *iph;			/* Our new IP header */
 	int    max_headroom;			/* The extra header space needed */
 	u32    dst = tiph->daddr;
 	int    mtu;
 	if (tunnel->recursion++) {
 		tunnel->stat.collisions++;
 		goto tx_error;
 	}
 	if (skb->protocol != htons(ETH_P_IP))
 		goto tx_error;
 	if (tos&1)
 		tos = old_iph->tos;
 	if (!dst) {
 		/* NBMA tunnel */
 		if ((rt = (struct rtable*)skb->dst) == NULL) {
 			tunnel->stat.tx_fifo_errors++;
 			goto tx_error;
 		}
 		if ((dst = rt->rt_gateway) == 0)
 			goto tx_error_icmp;
 	}
 	{
 		struct flowi fl = { .oif = tunnel->parms.link,
 				    .nl_u = { .ip4_u =
 					      { .daddr = dst,
 						.saddr = tiph->saddr,
 						.tos = RT_TOS(tos) } },
 				    .proto = IPPROTO_IPIP };
 		if (ip_route_output_key(&rt, &fl)) {
 			tunnel->stat.tx_carrier_errors++;
 			goto tx_error_icmp;
 		}
 	}
 	tdev = rt->u.dst.dev;
 	if (tdev == dev) {
 		ip_rt_put(rt);
 		tunnel->stat.collisions++;
 		goto tx_error;
 	}
 	if (tiph->frag_off)
 		mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr);
 	else
 		mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
 	if (mtu < 68) {
 		tunnel->stat.collisions++;
 		ip_rt_put(rt);
 		goto tx_error;
 	}
 	if (skb->dst)
 		skb->dst->ops->update_pmtu(skb->dst, mtu);
 	df |= (old_iph->frag_off&htons(IP_DF));
 	if ((old_iph->frag_off&htons(IP_DF)) && mtu < ntohs(old_iph->tot_len)) {
 		icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
 		ip_rt_put(rt);
 		goto tx_error;
 	}
 	if (tunnel->err_count > 0) {
 		if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
 			tunnel->err_count--;
 			dst_link_failure(skb);
 		} else
 			tunnel->err_count = 0;
 	}
 	/*
 	 * Okay, now see if we can stuff it in the buffer as-is.
 	 */
 	max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
 	if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
 		struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
 		if (!new_skb) {
 			ip_rt_put(rt);
   			stats->tx_dropped++;
 			dev_kfree_skb(skb);
 			tunnel->recursion--;
 			return 0;
 		}
 		if (skb->sk)
 			skb_set_owner_w(new_skb, skb->sk);
 		dev_kfree_skb(skb);
 		skb = new_skb;
 		old_iph = skb->nh.iph;
 	}
 	skb->h.raw = skb->nh.raw;
 	skb->nh.raw = skb_push(skb, sizeof(struct iphdr));
 	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 	IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
 			      IPSKB_REROUTED);
 	dst_release(skb->dst);
 	skb->dst = &rt->u.dst;
 	/*
 	 *	Push down and install the IPIP header.
 	 */
 	iph 			=	skb->nh.iph;
 	iph->version		=	4;
 	iph->ihl		=	sizeof(struct iphdr)>>2;
 	iph->frag_off		=	df;
 	iph->protocol		=	IPPROTO_IPIP;
 	iph->tos		=	INET_ECN_encapsulate(tos, old_iph->tos);
 	iph->daddr		=	rt->rt_dst;
 	iph->saddr		=	rt->rt_src;
 	if ((iph->ttl = tiph->ttl) == 0)
 		iph->ttl	=	old_iph->ttl;
 	nf_reset(skb);
 	IPTUNNEL_XMIT();
 	tunnel->recursion--;
 	return 0;
 tx_error_icmp:
 	dst_link_failure(skb);
 tx_error:
 	stats->tx_errors++;
 	dev_kfree_skb(skb);
 	tunnel->recursion--;
 	return 0;
 }
 static int
 ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
 {
 	int err = 0;
 	struct ip_tunnel_parm p;
 	struct ip_tunnel *t;
 	switch (cmd) {
 	case SIOCGETTUNNEL:
 		t = NULL;
 		if (dev == ipip_fb_tunnel_dev) {
 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
 				err = -EFAULT;
 				break;
 			}
 			t = ipip_tunnel_locate(&p, 0);
 		}
 		if (t == NULL)
 			t = netdev_priv(dev);
 		memcpy(&p, &t->parms, sizeof(p));
 		if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 			err = -EFAULT;
 		break;
 	case SIOCADDTUNNEL:
 	case SIOCCHGTUNNEL:
 		err = -EPERM;
 		if (!capable(CAP_NET_ADMIN))
 			goto done;
 		err = -EFAULT;
 		if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 			goto done;
 		err = -EINVAL;
 		if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
 		    p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
 			goto done;
 		if (p.iph.ttl)
 			p.iph.frag_off |= htons(IP_DF);
 		t = ipip_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
 		if (dev != ipip_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
 			if (t != NULL) {
 				if (t->dev != dev) {
 					err = -EEXIST;
 					break;
 				}
 			} else {
 				if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
 				    (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
 					err = -EINVAL;
 					break;
 				}
 				t = netdev_priv(dev);
 				ipip_tunnel_unlink(t);
 				t->parms.iph.saddr = p.iph.saddr;
 				t->parms.iph.daddr = p.iph.daddr;
 				memcpy(dev->dev_addr, &p.iph.saddr, 4);
 				memcpy(dev->broadcast, &p.iph.daddr, 4);
 				ipip_tunnel_link(t);
 				netdev_state_change(dev);
 			}
 		}
 		if (t) {
 			err = 0;
 			if (cmd == SIOCCHGTUNNEL) {
 				t->parms.iph.ttl = p.iph.ttl;
 				t->parms.iph.tos = p.iph.tos;
 				t->parms.iph.frag_off = p.iph.frag_off;
 			}
 			if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
 				err = -EFAULT;
 		} else
 			err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
 		break;
 	case SIOCDELTUNNEL:
 		err = -EPERM;
 		if (!capable(CAP_NET_ADMIN))
 			goto done;
 		if (dev == ipip_fb_tunnel_dev) {
 			err = -EFAULT;
 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 				goto done;
 			err = -ENOENT;
 			if ((t = ipip_tunnel_locate(&p, 0)) == NULL)
 				goto done;
 			err = -EPERM;
 			if (t->dev == ipip_fb_tunnel_dev)
 				goto done;
 			dev = t->dev;
 		}
 		err = unregister_netdevice(dev);
 		break;
 	default:
 		err = -EINVAL;
 	}
 done:
 	return err;
 }
 static struct net_device_stats *ipip_tunnel_get_stats(struct net_device *dev)
 {
 	return &(((struct ip_tunnel*)netdev_priv(dev))->stat);
 }
 static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
 {
 	if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
 		return -EINVAL;
 	dev->mtu = new_mtu;
 	return 0;
 }
 static void ipip_tunnel_setup(struct net_device *dev)
 {
 	SET_MODULE_OWNER(dev);
 	dev->uninit		= ipip_tunnel_uninit;
 	dev->hard_start_xmit	= ipip_tunnel_xmit;
 	dev->get_stats		= ipip_tunnel_get_stats;
 	dev->do_ioctl		= ipip_tunnel_ioctl;
 	dev->change_mtu		= ipip_tunnel_change_mtu;
 	dev->destructor		= free_netdev;
 	dev->type		= ARPHRD_TUNNEL;
 	dev->hard_header_len 	= LL_MAX_HEADER + sizeof(struct iphdr);
 	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr);
 	dev->flags		= IFF_NOARP;
 	dev->iflink		= 0;
 	dev->addr_len		= 4;
 }
 static int ipip_tunnel_init(struct net_device *dev)
 {
 	struct net_device *tdev = NULL;
 	struct ip_tunnel *tunnel;
 	struct iphdr *iph;
 	tunnel = netdev_priv(dev);
 	iph = &tunnel->parms.iph;
 	tunnel->dev = dev;
 	strcpy(tunnel->parms.name, dev->name);
 	memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
 	memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
 	if (iph->daddr) {
 		struct flowi fl = { .oif = tunnel->parms.link,
 				    .nl_u = { .ip4_u =
 					      { .daddr = iph->daddr,
 						.saddr = iph->saddr,
 						.tos = RT_TOS(iph->tos) } },
 				    .proto = IPPROTO_IPIP };
 		struct rtable *rt;
 		if (!ip_route_output_key(&rt, &fl)) {
 			tdev = rt->u.dst.dev;
 			ip_rt_put(rt);
 		}
 		dev->flags |= IFF_POINTOPOINT;
 	}
 	if (!tdev && tunnel->parms.link)
 		tdev = __dev_get_by_index(tunnel->parms.link);
 	if (tdev) {
 		dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
 		dev->mtu = tdev->mtu - sizeof(struct iphdr);
 	}
 	dev->iflink = tunnel->parms.link;
 	return 0;
 }
 static int __init ipip_fb_tunnel_init(struct net_device *dev)
 {
 	struct ip_tunnel *tunnel = netdev_priv(dev);
 	struct iphdr *iph = &tunnel->parms.iph;
 	tunnel->dev = dev;
 	strcpy(tunnel->parms.name, dev->name);
 	iph->version		= 4;
 	iph->protocol		= IPPROTO_IPIP;
 	iph->ihl		= 5;
 	dev_hold(dev);
 	tunnels_wc[0]		= tunnel;
 	return 0;
 }
 static struct xfrm_tunnel ipip_handler = {
 	.handler	=	ipip_rcv,
 	.err_handler	=	ipip_err,
 	.priority	=	1,
 };
 static char banner[] __initdata =
 	KERN_INFO "IPv4 over IPv4 tunneling driver\n";
 static int __init ipip_init(void)
 {
 	int err;
 	printk(banner);
 	if (xfrm4_tunnel_register(&ipip_handler)) {
 		printk(KERN_INFO "ipip init: can't register tunnel\n");
 		return -EAGAIN;
 	}
 	ipip_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
 					   "tunl0",
 					   ipip_tunnel_setup);
 	if (!ipip_fb_tunnel_dev) {
 		err = -ENOMEM;
 		goto err1;
 	}
 	ipip_fb_tunnel_dev->init = ipip_fb_tunnel_init;
 	if ((err = register_netdev(ipip_fb_tunnel_dev)))
 		goto err2;
  out:
 	return err;
  err2:
 	free_netdev(ipip_fb_tunnel_dev);
  err1:
 	xfrm4_tunnel_deregister(&ipip_handler);
 	goto out;
 }
 static void __exit ipip_destroy_tunnels(void)
 {
 	int prio;
 	for (prio = 1; prio < 4; prio++) {
 		int h;
 		for (h = 0; h < HASH_SIZE; h++) {
 			struct ip_tunnel *t;
 			while ((t = tunnels[prio][h]) != NULL)
 				unregister_netdevice(t->dev);
 		}
 	}
 }
 static void __exit ipip_fini(void)
 {
 	if (xfrm4_tunnel_deregister(&ipip_handler))
 		printk(KERN_INFO "ipip close: can't deregister tunnel\n");
 	rtnl_lock();
 	ipip_destroy_tunnels();
 	unregister_netdevice(ipip_fb_tunnel_dev);
 	rtnl_unlock();
 }
 module_init(ipip_init);
 module_exit(ipip_fini);
 MODULE_LICENSE("GPL");

net/ipv4/ipmr.c

Diff comments View file @ 5d9c5a3

 /*
  *	IP multicast routing support for mrouted 3.6/3.8
  *
  *		(c) 1995 Alan Cox, <alan@redhat.com>
  *	  Linux Consultancy and Custom Driver Development
  *
  *	This program is free software; you can redistribute it and/or
  *	modify it under the terms of the GNU General Public License
  *	as published by the Free Software Foundation; either version
  *	2 of the License, or (at your option) any later version.
  *
  *	Version: $Id: ipmr.c,v 1.65 2001/10/31 21:55:54 davem Exp $
  *
  *	Fixes:
  *	Michael Chastain	:	Incorrect size of copying.
  *	Alan Cox		:	Added the cache manager code
  *	Alan Cox		:	Fixed the clone/copy bug and device race.
  *	Mike McLagan		:	Routing by source
  *	Malcolm Beattie		:	Buffer handling fixes.
  *	Alexey Kuznetsov	:	Double buffer free and other fixes.
  *	SVR Anand		:	Fixed several multicast bugs and problems.
  *	Alexey Kuznetsov	:	Status, optimisations and more.
  *	Brad Parker		:	Better behaviour on mrouted upcall
  *					overflow.
  *      Carlos Picoto           :       PIMv1 Support
  *	Pavlin Ivanov Radoslavov:	PIMv2 Registers must checksum only PIM header
  *					Relax this requrement to work with older peers.
  *
  */
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/timer.h>
 #include <linux/mm.h>
 #include <linux/kernel.h>
 #include <linux/fcntl.h>
 #include <linux/stat.h>
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
 #include <linux/inetdevice.h>
 #include <linux/igmp.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/mroute.h>
 #include <linux/init.h>
 #include <linux/if_ether.h>
 #include <net/ip.h>
 #include <net/protocol.h>
 #include <linux/skbuff.h>
 #include <net/route.h>
 #include <net/sock.h>
 #include <net/icmp.h>
 #include <net/udp.h>
 #include <net/raw.h>
 #include <linux/notifier.h>
 #include <linux/if_arp.h>
 #include <linux/netfilter_ipv4.h>
 #include <net/ipip.h>
 #include <net/checksum.h>
 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
 #define CONFIG_IP_PIMSM	1
 #endif
 static struct sock *mroute_socket;
 /* Big lock, protecting vif table, mrt cache and mroute socket state.
    Note that the changes are semaphored via rtnl_lock.
  */
 static DEFINE_RWLOCK(mrt_lock);
 /*
  *	Multicast router control variables
  */
 static struct vif_device vif_table[MAXVIFS];		/* Devices 		*/
 static int maxvif;
 #define VIF_EXISTS(idx) (vif_table[idx].dev != NULL)
 static int mroute_do_assert;				/* Set in PIM assert	*/
 static int mroute_do_pim;
 static struct mfc_cache *mfc_cache_array[MFC_LINES];	/* Forwarding cache	*/
 static struct mfc_cache *mfc_unres_queue;		/* Queue of unresolved entries */
 static atomic_t cache_resolve_queue_len;		/* Size of unresolved	*/
 /* Special spinlock for queue of unresolved entries */
 static DEFINE_SPINLOCK(mfc_unres_lock);
 /* We return to original Alan's scheme. Hash table of resolved
    entries is changed only in process context and protected
    with weak lock mrt_lock. Queue of unresolved entries is protected
    with strong spinlock mfc_unres_lock.
    In this case data path is free of exclusive locks at all.
  */
 static kmem_cache_t *mrt_cachep __read_mostly;
 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local);
 static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert);
 static int ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm);
 #ifdef CONFIG_IP_PIMSM_V2
 static struct net_protocol pim_protocol;
 #endif
 static struct timer_list ipmr_expire_timer;
 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
 static
 struct net_device *ipmr_new_tunnel(struct vifctl *v)
 {
 	struct net_device  *dev;
 	dev = __dev_get_by_name("tunl0");
 	if (dev) {
 		int err;
 		struct ifreq ifr;
 		mm_segment_t	oldfs;
 		struct ip_tunnel_parm p;
 		struct in_device  *in_dev;
 		memset(&p, 0, sizeof(p));
 		p.iph.daddr = v->vifc_rmt_addr.s_addr;
 		p.iph.saddr = v->vifc_lcl_addr.s_addr;
 		p.iph.version = 4;
 		p.iph.ihl = 5;
 		p.iph.protocol = IPPROTO_IPIP;
 		sprintf(p.name, "dvmrp%d", v->vifc_vifi);
 		ifr.ifr_ifru.ifru_data = (void*)&p;
 		oldfs = get_fs(); set_fs(KERNEL_DS);
 		err = dev->do_ioctl(dev, &ifr, SIOCADDTUNNEL);
 		set_fs(oldfs);
 		dev = NULL;
 		if (err == 0 && (dev = __dev_get_by_name(p.name)) != NULL) {
 			dev->flags |= IFF_MULTICAST;
 			in_dev = __in_dev_get_rtnl(dev);
 			if (in_dev == NULL && (in_dev = inetdev_init(dev)) == NULL)
 				goto failure;
 			in_dev->cnf.rp_filter = 0;
 			if (dev_open(dev))
 				goto failure;
 		}
 	}
 	return dev;
 failure:
 	/* allow the register to be completed before unregistering. */
 	rtnl_unlock();
 	rtnl_lock();
 	unregister_netdevice(dev);
 	return NULL;
 }
 #ifdef CONFIG_IP_PIMSM
 static int reg_vif_num = -1;
 static int reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	read_lock(&mrt_lock);
 	((struct net_device_stats*)netdev_priv(dev))->tx_bytes += skb->len;
 	((struct net_device_stats*)netdev_priv(dev))->tx_packets++;
 	ipmr_cache_report(skb, reg_vif_num, IGMPMSG_WHOLEPKT);
 	read_unlock(&mrt_lock);
 	kfree_skb(skb);
 	return 0;
 }
 static struct net_device_stats *reg_vif_get_stats(struct net_device *dev)
 {
 	return (struct net_device_stats*)netdev_priv(dev);
 }
 static void reg_vif_setup(struct net_device *dev)
 {
 	dev->type		= ARPHRD_PIMREG;
 	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr) - 8;
 	dev->flags		= IFF_NOARP;
 	dev->hard_start_xmit	= reg_vif_xmit;
 	dev->get_stats		= reg_vif_get_stats;
 	dev->destructor		= free_netdev;
 }
 static struct net_device *ipmr_reg_vif(void)
 {
 	struct net_device *dev;
 	struct in_device *in_dev;
 	dev = alloc_netdev(sizeof(struct net_device_stats), "pimreg",
 			   reg_vif_setup);
 	if (dev == NULL)
 		return NULL;
 	if (register_netdevice(dev)) {
 		free_netdev(dev);
 		return NULL;
 	}
 	dev->iflink = 0;
 	if ((in_dev = inetdev_init(dev)) == NULL)
 		goto failure;
 	in_dev->cnf.rp_filter = 0;
 	if (dev_open(dev))
 		goto failure;
 	return dev;
 failure:
 	/* allow the register to be completed before unregistering. */
 	rtnl_unlock();
 	rtnl_lock();
 	unregister_netdevice(dev);
 	return NULL;
 }
 #endif
 /*
  *	Delete a VIF entry
  */
 static int vif_delete(int vifi)
 {
 	struct vif_device *v;
 	struct net_device *dev;
 	struct in_device *in_dev;
 	if (vifi < 0 || vifi >= maxvif)
 		return -EADDRNOTAVAIL;
 	v = &vif_table[vifi];
 	write_lock_bh(&mrt_lock);
 	dev = v->dev;
 	v->dev = NULL;
 	if (!dev) {
 		write_unlock_bh(&mrt_lock);
 		return -EADDRNOTAVAIL;
 	}
 #ifdef CONFIG_IP_PIMSM
 	if (vifi == reg_vif_num)
 		reg_vif_num = -1;
 #endif
 	if (vifi+1 == maxvif) {
 		int tmp;
 		for (tmp=vifi-1; tmp>=0; tmp--) {
 			if (VIF_EXISTS(tmp))
 				break;
 		}
 		maxvif = tmp+1;
 	}
 	write_unlock_bh(&mrt_lock);
 	dev_set_allmulti(dev, -1);
 	if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
 		in_dev->cnf.mc_forwarding--;
 		ip_rt_multicast_event(in_dev);
 	}
 	if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER))
 		unregister_netdevice(dev);
 	dev_put(dev);
 	return 0;
 }
 /* Destroy an unresolved cache entry, killing queued skbs
    and reporting error to netlink readers.
  */
 static void ipmr_destroy_unres(struct mfc_cache *c)
 {
 	struct sk_buff *skb;
 	struct nlmsgerr *e;
 	atomic_dec(&cache_resolve_queue_len);
 	while((skb=skb_dequeue(&c->mfc_un.unres.unresolved))) {
 		if (skb->nh.iph->version == 0) {
 			struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
 			nlh->nlmsg_type = NLMSG_ERROR;
 			nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
 			skb_trim(skb, nlh->nlmsg_len);
 			e = NLMSG_DATA(nlh);
 			e->error = -ETIMEDOUT;
 			memset(&e->msg, 0, sizeof(e->msg));
 			netlink_unicast(rtnl, skb, NETLINK_CB(skb).dst_pid, MSG_DONTWAIT);
 		} else
 			kfree_skb(skb);
 	}
 	kmem_cache_free(mrt_cachep, c);
 }
 /* Single timer process for all the unresolved queue. */
 static void ipmr_expire_process(unsigned long dummy)
 {
 	unsigned long now;
 	unsigned long expires;
 	struct mfc_cache *c, **cp;
 	if (!spin_trylock(&mfc_unres_lock)) {
 		mod_timer(&ipmr_expire_timer, jiffies+HZ/10);
 		return;
 	}
 	if (atomic_read(&cache_resolve_queue_len) == 0)
 		goto out;
 	now = jiffies;
 	expires = 10*HZ;
 	cp = &mfc_unres_queue;
 	while ((c=*cp) != NULL) {
 		if (time_after(c->mfc_un.unres.expires, now)) {
 			unsigned long interval = c->mfc_un.unres.expires - now;
 			if (interval < expires)
 				expires = interval;
 			cp = &c->next;
 			continue;
 		}
 		*cp = c->next;
 		ipmr_destroy_unres(c);
 	}
 	if (atomic_read(&cache_resolve_queue_len))
 		mod_timer(&ipmr_expire_timer, jiffies + expires);
 out:
 	spin_unlock(&mfc_unres_lock);
 }
 /* Fill oifs list. It is called under write locked mrt_lock. */
 static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls)
 {
 	int vifi;
 	cache->mfc_un.res.minvif = MAXVIFS;
 	cache->mfc_un.res.maxvif = 0;
 	memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
 	for (vifi=0; vifi<maxvif; vifi++) {
 		if (VIF_EXISTS(vifi) && ttls[vifi] && ttls[vifi] < 255) {
 			cache->mfc_un.res.ttls[vifi] = ttls[vifi];
 			if (cache->mfc_un.res.minvif > vifi)
 				cache->mfc_un.res.minvif = vifi;
 			if (cache->mfc_un.res.maxvif <= vifi)
 				cache->mfc_un.res.maxvif = vifi + 1;
 		}
 	}
 }
 static int vif_add(struct vifctl *vifc, int mrtsock)
 {
 	int vifi = vifc->vifc_vifi;
 	struct vif_device *v = &vif_table[vifi];
 	struct net_device *dev;
 	struct in_device *in_dev;
 	/* Is vif busy ? */
 	if (VIF_EXISTS(vifi))
 		return -EADDRINUSE;
 	switch (vifc->vifc_flags) {
 #ifdef CONFIG_IP_PIMSM
 	case VIFF_REGISTER:
 		/*
 		 * Special Purpose VIF in PIM
 		 * All the packets will be sent to the daemon
 		 */
 		if (reg_vif_num >= 0)
 			return -EADDRINUSE;
 		dev = ipmr_reg_vif();
 		if (!dev)
 			return -ENOBUFS;
 		break;
 #endif
 	case VIFF_TUNNEL:
 		dev = ipmr_new_tunnel(vifc);
 		if (!dev)
 			return -ENOBUFS;
 		break;
 	case 0:
 		dev = ip_dev_find(vifc->vifc_lcl_addr.s_addr);
 		if (!dev)
 			return -EADDRNOTAVAIL;
 		dev_put(dev);
 		break;
 	default:
 		return -EINVAL;
 	}
 	if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
 		return -EADDRNOTAVAIL;
 	in_dev->cnf.mc_forwarding++;
 	dev_set_allmulti(dev, +1);
 	ip_rt_multicast_event(in_dev);
 	/*
 	 *	Fill in the VIF structures
 	 */
 	v->rate_limit=vifc->vifc_rate_limit;
 	v->local=vifc->vifc_lcl_addr.s_addr;
 	v->remote=vifc->vifc_rmt_addr.s_addr;
 	v->flags=vifc->vifc_flags;
 	if (!mrtsock)
 		v->flags |= VIFF_STATIC;
 	v->threshold=vifc->vifc_threshold;
 	v->bytes_in = 0;
 	v->bytes_out = 0;
 	v->pkt_in = 0;
 	v->pkt_out = 0;
 	v->link = dev->ifindex;
 	if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER))
 		v->link = dev->iflink;
 	/* And finish update writing critical data */
 	write_lock_bh(&mrt_lock);
 	dev_hold(dev);
 	v->dev=dev;
 #ifdef CONFIG_IP_PIMSM
 	if (v->flags&VIFF_REGISTER)
 		reg_vif_num = vifi;
 #endif
 	if (vifi+1 > maxvif)
 		maxvif = vifi+1;
 	write_unlock_bh(&mrt_lock);
 	return 0;
 }
 static struct mfc_cache *ipmr_cache_find(__u32 origin, __u32 mcastgrp)
 {
 	int line=MFC_HASH(mcastgrp,origin);
 	struct mfc_cache *c;
 	for (c=mfc_cache_array[line]; c; c = c->next) {
 		if (c->mfc_origin==origin && c->mfc_mcastgrp==mcastgrp)
 			break;
 	}
 	return c;
 }
 /*
  *	Allocate a multicast cache entry
  */
 static struct mfc_cache *ipmr_cache_alloc(void)
 {
 	struct mfc_cache *c=kmem_cache_alloc(mrt_cachep, GFP_KERNEL);
 	if(c==NULL)
 		return NULL;
 	memset(c, 0, sizeof(*c));
 	c->mfc_un.res.minvif = MAXVIFS;
 	return c;
 }
 static struct mfc_cache *ipmr_cache_alloc_unres(void)
 {
 	struct mfc_cache *c=kmem_cache_alloc(mrt_cachep, GFP_ATOMIC);
 	if(c==NULL)
 		return NULL;
 	memset(c, 0, sizeof(*c));
 	skb_queue_head_init(&c->mfc_un.unres.unresolved);
 	c->mfc_un.unres.expires = jiffies + 10*HZ;
 	return c;
 }
 /*
  *	A cache entry has gone into a resolved state from queued
  */
 static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
 {
 	struct sk_buff *skb;
 	struct nlmsgerr *e;
 	/*
 	 *	Play the pending entries through our router
 	 */
 	while((skb=__skb_dequeue(&uc->mfc_un.unres.unresolved))) {
 		if (skb->nh.iph->version == 0) {
 			int err;
 			struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
 			if (ipmr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
 				nlh->nlmsg_len = skb->tail - (u8*)nlh;
 			} else {
 				nlh->nlmsg_type = NLMSG_ERROR;
 				nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
 				skb_trim(skb, nlh->nlmsg_len);
 				e = NLMSG_DATA(nlh);
 				e->error = -EMSGSIZE;
 				memset(&e->msg, 0, sizeof(e->msg));
 			}
 			err = netlink_unicast(rtnl, skb, NETLINK_CB(skb).dst_pid, MSG_DONTWAIT);
 		} else
 			ip_mr_forward(skb, c, 0);
 	}
 }
 /*
  *	Bounce a cache query up to mrouted. We could use netlink for this but mrouted
  *	expects the following bizarre scheme.
  *
  *	Called under mrt_lock.
  */
 static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert)
 {
 	struct sk_buff *skb;
 	int ihl = pkt->nh.iph->ihl<<2;
 	struct igmphdr *igmp;
 	struct igmpmsg *msg;
 	int ret;
 #ifdef CONFIG_IP_PIMSM
 	if (assert == IGMPMSG_WHOLEPKT)
 		skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
 	else
 #endif
 		skb = alloc_skb(128, GFP_ATOMIC);
 	if(!skb)
 		return -ENOBUFS;
 #ifdef CONFIG_IP_PIMSM
 	if (assert == IGMPMSG_WHOLEPKT) {
 		/* Ugly, but we have no choice with this interface.
 		   Duplicate old header, fix ihl, length etc.
 		   And all this only to mangle msg->im_msgtype and
 		   to set msg->im_mbz to "mbz" :-)
 		 */
 		msg = (struct igmpmsg*)skb_push(skb, sizeof(struct iphdr));
 		skb->nh.raw = skb->h.raw = (u8*)msg;
 		memcpy(msg, pkt->nh.raw, sizeof(struct iphdr));
 		msg->im_msgtype = IGMPMSG_WHOLEPKT;
 		msg->im_mbz = 0;
  		msg->im_vif = reg_vif_num;
 		skb->nh.iph->ihl = sizeof(struct iphdr) >> 2;
 		skb->nh.iph->tot_len = htons(ntohs(pkt->nh.iph->tot_len) + sizeof(struct iphdr));
 	} else
 #endif
 	{
 	/*
 	 *	Copy the IP header
 	 */
 	skb->nh.iph = (struct iphdr *)skb_put(skb, ihl);
 	memcpy(skb->data,pkt->data,ihl);
 	skb->nh.iph->protocol = 0;			/* Flag to the kernel this is a route add */
 	msg = (struct igmpmsg*)skb->nh.iph;
 	msg->im_vif = vifi;
 	skb->dst = dst_clone(pkt->dst);
 	/*
 	 *	Add our header
 	 */
 	igmp=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr));
 	igmp->type	=
 	msg->im_msgtype = assert;
 	igmp->code 	=	0;
 	skb->nh.iph->tot_len=htons(skb->len);			/* Fix the length */
 	skb->h.raw = skb->nh.raw;
         }
 	if (mroute_socket == NULL) {
 		kfree_skb(skb);
 		return -EINVAL;
 	}
 	/*
 	 *	Deliver to mrouted
 	 */
 	if ((ret=sock_queue_rcv_skb(mroute_socket,skb))<0) {
 		if (net_ratelimit())
 			printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
 		kfree_skb(skb);
 	}
 	return ret;
 }
 /*
  *	Queue a packet for resolution. It gets locked cache entry!
  */
 static int
 ipmr_cache_unresolved(vifi_t vifi, struct sk_buff *skb)
 {
 	int err;
 	struct mfc_cache *c;
 	spin_lock_bh(&mfc_unres_lock);
 	for (c=mfc_unres_queue; c; c=c->next) {
 		if (c->mfc_mcastgrp == skb->nh.iph->daddr &&
 		    c->mfc_origin == skb->nh.iph->saddr)
 			break;
 	}
 	if (c == NULL) {
 		/*
 		 *	Create a new entry if allowable
 		 */
 		if (atomic_read(&cache_resolve_queue_len)>=10 ||
 		    (c=ipmr_cache_alloc_unres())==NULL) {
 			spin_unlock_bh(&mfc_unres_lock);
 			kfree_skb(skb);
 			return -ENOBUFS;
 		}
 		/*
 		 *	Fill in the new cache entry
 		 */
 		c->mfc_parent=-1;
 		c->mfc_origin=skb->nh.iph->saddr;
 		c->mfc_mcastgrp=skb->nh.iph->daddr;
 		/*
 		 *	Reflect first query at mrouted.
 		 */
 		if ((err = ipmr_cache_report(skb, vifi, IGMPMSG_NOCACHE))<0) {
 			/* If the report failed throw the cache entry
 			   out - Brad Parker
 			 */
 			spin_unlock_bh(&mfc_unres_lock);
 			kmem_cache_free(mrt_cachep, c);
 			kfree_skb(skb);
 			return err;
 		}
 		atomic_inc(&cache_resolve_queue_len);
 		c->next = mfc_unres_queue;
 		mfc_unres_queue = c;
 		mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
 	}
 	/*
 	 *	See if we can append the packet
 	 */
 	if (c->mfc_un.unres.unresolved.qlen>3) {
 		kfree_skb(skb);
 		err = -ENOBUFS;
 	} else {
 		skb_queue_tail(&c->mfc_un.unres.unresolved,skb);
 		err = 0;
 	}
 	spin_unlock_bh(&mfc_unres_lock);
 	return err;
 }
 /*
  *	MFC cache manipulation by user space mroute daemon
  */
 static int ipmr_mfc_delete(struct mfcctl *mfc)
 {
 	int line;
 	struct mfc_cache *c, **cp;
 	line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
 	for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
 		if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
 		    c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
 			write_lock_bh(&mrt_lock);
 			*cp = c->next;
 			write_unlock_bh(&mrt_lock);
 			kmem_cache_free(mrt_cachep, c);
 			return 0;
 		}
 	}
 	return -ENOENT;
 }
 static int ipmr_mfc_add(struct mfcctl *mfc, int mrtsock)
 {
 	int line;
 	struct mfc_cache *uc, *c, **cp;
 	line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
 	for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
 		if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
 		    c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
 			break;
 	}
 	if (c != NULL) {
 		write_lock_bh(&mrt_lock);
 		c->mfc_parent = mfc->mfcc_parent;
 		ipmr_update_thresholds(c, mfc->mfcc_ttls);
 		if (!mrtsock)
 			c->mfc_flags |= MFC_STATIC;
 		write_unlock_bh(&mrt_lock);
 		return 0;
 	}
 	if(!MULTICAST(mfc->mfcc_mcastgrp.s_addr))
 		return -EINVAL;
 	c=ipmr_cache_alloc();
 	if (c==NULL)
 		return -ENOMEM;
 	c->mfc_origin=mfc->mfcc_origin.s_addr;
 	c->mfc_mcastgrp=mfc->mfcc_mcastgrp.s_addr;
 	c->mfc_parent=mfc->mfcc_parent;
 	ipmr_update_thresholds(c, mfc->mfcc_ttls);
 	if (!mrtsock)
 		c->mfc_flags |= MFC_STATIC;
 	write_lock_bh(&mrt_lock);
 	c->next = mfc_cache_array[line];
 	mfc_cache_array[line] = c;
 	write_unlock_bh(&mrt_lock);
 	/*
 	 *	Check to see if we resolved a queued list. If so we
 	 *	need to send on the frames and tidy up.
 	 */
 	spin_lock_bh(&mfc_unres_lock);
 	for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
 	     cp = &uc->next) {
 		if (uc->mfc_origin == c->mfc_origin &&
 		    uc->mfc_mcastgrp == c->mfc_mcastgrp) {
 			*cp = uc->next;
 			if (atomic_dec_and_test(&cache_resolve_queue_len))
 				del_timer(&ipmr_expire_timer);
 			break;
 		}
 	}
 	spin_unlock_bh(&mfc_unres_lock);
 	if (uc) {
 		ipmr_cache_resolve(uc, c);
 		kmem_cache_free(mrt_cachep, uc);
 	}
 	return 0;
 }
 /*
  *	Close the multicast socket, and clear the vif tables etc
  */
 static void mroute_clean_tables(struct sock *sk)
 {
 	int i;
 	/*
 	 *	Shut down all active vif entries
 	 */
 	for(i=0; i<maxvif; i++) {
 		if (!(vif_table[i].flags&VIFF_STATIC))
 			vif_delete(i);
 	}
 	/*
 	 *	Wipe the cache
 	 */
 	for (i=0;i<MFC_LINES;i++) {
 		struct mfc_cache *c, **cp;
 		cp = &mfc_cache_array[i];
 		while ((c = *cp) != NULL) {
 			if (c->mfc_flags&MFC_STATIC) {
 				cp = &c->next;
 				continue;
 			}
 			write_lock_bh(&mrt_lock);
 			*cp = c->next;
 			write_unlock_bh(&mrt_lock);
 			kmem_cache_free(mrt_cachep, c);
 		}
 	}
 	if (atomic_read(&cache_resolve_queue_len) != 0) {
 		struct mfc_cache *c;
 		spin_lock_bh(&mfc_unres_lock);
 		while (mfc_unres_queue != NULL) {
 			c = mfc_unres_queue;
 			mfc_unres_queue = c->next;
 			spin_unlock_bh(&mfc_unres_lock);
 			ipmr_destroy_unres(c);
 			spin_lock_bh(&mfc_unres_lock);
 		}
 		spin_unlock_bh(&mfc_unres_lock);
 	}
 }
 static void mrtsock_destruct(struct sock *sk)
 {
 	rtnl_lock();
 	if (sk == mroute_socket) {
 		ipv4_devconf.mc_forwarding--;
 		write_lock_bh(&mrt_lock);
 		mroute_socket=NULL;
 		write_unlock_bh(&mrt_lock);
 		mroute_clean_tables(sk);
 	}
 	rtnl_unlock();
 }
 /*
  *	Socket options and virtual interface manipulation. The whole
  *	virtual interface system is a complete heap, but unfortunately
  *	that's how BSD mrouted happens to think. Maybe one day with a proper
  *	MOSPF/PIM router set up we can clean this up.
  */
 int ip_mroute_setsockopt(struct sock *sk,int optname,char __user *optval,int optlen)
 {
 	int ret;
 	struct vifctl vif;
 	struct mfcctl mfc;
 	if(optname!=MRT_INIT)
 	{
 		if(sk!=mroute_socket && !capable(CAP_NET_ADMIN))
 			return -EACCES;
 	}
 	switch(optname)
 	{
 		case MRT_INIT:
 			if (sk->sk_type != SOCK_RAW ||
 			    inet_sk(sk)->num != IPPROTO_IGMP)
 				return -EOPNOTSUPP;
 			if(optlen!=sizeof(int))
 				return -ENOPROTOOPT;
 			rtnl_lock();
 			if (mroute_socket) {
 				rtnl_unlock();
 				return -EADDRINUSE;
 			}
 			ret = ip_ra_control(sk, 1, mrtsock_destruct);
 			if (ret == 0) {
 				write_lock_bh(&mrt_lock);
 				mroute_socket=sk;
 				write_unlock_bh(&mrt_lock);
 				ipv4_devconf.mc_forwarding++;
 			}
 			rtnl_unlock();
 			return ret;
 		case MRT_DONE:
 			if (sk!=mroute_socket)
 				return -EACCES;
 			return ip_ra_control(sk, 0, NULL);
 		case MRT_ADD_VIF:
 		case MRT_DEL_VIF:
 			if(optlen!=sizeof(vif))
 				return -EINVAL;
 			if (copy_from_user(&vif,optval,sizeof(vif)))
 				return -EFAULT;
 			if(vif.vifc_vifi >= MAXVIFS)
 				return -ENFILE;
 			rtnl_lock();
 			if (optname==MRT_ADD_VIF) {
 				ret = vif_add(&vif, sk==mroute_socket);
 			} else {
 				ret = vif_delete(vif.vifc_vifi);
 			}
 			rtnl_unlock();
 			return ret;
 		/*
 		 *	Manipulate the forwarding caches. These live
 		 *	in a sort of kernel/user symbiosis.
 		 */
 		case MRT_ADD_MFC:
 		case MRT_DEL_MFC:
 			if(optlen!=sizeof(mfc))
 				return -EINVAL;
 			if (copy_from_user(&mfc,optval, sizeof(mfc)))
 				return -EFAULT;
 			rtnl_lock();
 			if (optname==MRT_DEL_MFC)
 				ret = ipmr_mfc_delete(&mfc);
 			else
 				ret = ipmr_mfc_add(&mfc, sk==mroute_socket);
 			rtnl_unlock();
 			return ret;
 		/*
 		 *	Control PIM assert.
 		 */
 		case MRT_ASSERT:
 		{
 			int v;
 			if(get_user(v,(int __user *)optval))
 				return -EFAULT;
 			mroute_do_assert=(v)?1:0;
 			return 0;
 		}
 #ifdef CONFIG_IP_PIMSM
 		case MRT_PIM:
 		{
 			int v, ret;
 			if(get_user(v,(int __user *)optval))
 				return -EFAULT;
 			v = (v)?1:0;
 			rtnl_lock();
 			ret = 0;
 			if (v != mroute_do_pim) {
 				mroute_do_pim = v;
 				mroute_do_assert = v;
 #ifdef CONFIG_IP_PIMSM_V2
 				if (mroute_do_pim)
 					ret = inet_add_protocol(&pim_protocol,
 								IPPROTO_PIM);
 				else
 					ret = inet_del_protocol(&pim_protocol,
 								IPPROTO_PIM);
 				if (ret < 0)
 					ret = -EAGAIN;
 #endif
 			}
 			rtnl_unlock();
 			return ret;
 		}
 #endif
 		/*
 		 *	Spurious command, or MRT_VERSION which you cannot
 		 *	set.
 		 */
 		default:
 			return -ENOPROTOOPT;
 	}
 }
 /*
  *	Getsock opt support for the multicast routing system.
  */
 int ip_mroute_getsockopt(struct sock *sk,int optname,char __user *optval,int __user *optlen)
 {
 	int olr;
 	int val;
 	if(optname!=MRT_VERSION &&
 #ifdef CONFIG_IP_PIMSM
 	   optname!=MRT_PIM &&
 #endif
 	   optname!=MRT_ASSERT)
 		return -ENOPROTOOPT;
 	if (get_user(olr, optlen))
 		return -EFAULT;
 	olr = min_t(unsigned int, olr, sizeof(int));
 	if (olr < 0)
 		return -EINVAL;
 	if(put_user(olr,optlen))
 		return -EFAULT;
 	if(optname==MRT_VERSION)
 		val=0x0305;
 #ifdef CONFIG_IP_PIMSM
 	else if(optname==MRT_PIM)
 		val=mroute_do_pim;
 #endif
 	else
 		val=mroute_do_assert;
 	if(copy_to_user(optval,&val,olr))
 		return -EFAULT;
 	return 0;
 }
 /*
  *	The IP multicast ioctl support routines.
  */
 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
 {
 	struct sioc_sg_req sr;
 	struct sioc_vif_req vr;
 	struct vif_device *vif;
 	struct mfc_cache *c;
 	switch(cmd)
 	{
 		case SIOCGETVIFCNT:
 			if (copy_from_user(&vr,arg,sizeof(vr)))
 				return -EFAULT;
 			if(vr.vifi>=maxvif)
 				return -EINVAL;
 			read_lock(&mrt_lock);
 			vif=&vif_table[vr.vifi];
 			if(VIF_EXISTS(vr.vifi))	{
 				vr.icount=vif->pkt_in;
 				vr.ocount=vif->pkt_out;
 				vr.ibytes=vif->bytes_in;
 				vr.obytes=vif->bytes_out;
 				read_unlock(&mrt_lock);
 				if (copy_to_user(arg,&vr,sizeof(vr)))
 					return -EFAULT;
 				return 0;
 			}
 			read_unlock(&mrt_lock);
 			return -EADDRNOTAVAIL;
 		case SIOCGETSGCNT:
 			if (copy_from_user(&sr,arg,sizeof(sr)))
 				return -EFAULT;
 			read_lock(&mrt_lock);
 			c = ipmr_cache_find(sr.src.s_addr, sr.grp.s_addr);
 			if (c) {
 				sr.pktcnt = c->mfc_un.res.pkt;
 				sr.bytecnt = c->mfc_un.res.bytes;
 				sr.wrong_if = c->mfc_un.res.wrong_if;
 				read_unlock(&mrt_lock);
 				if (copy_to_user(arg,&sr,sizeof(sr)))
 					return -EFAULT;
 				return 0;
 			}
 			read_unlock(&mrt_lock);
 			return -EADDRNOTAVAIL;
 		default:
 			return -ENOIOCTLCMD;
 	}
 }
 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
 	struct vif_device *v;
 	int ct;
 	if (event != NETDEV_UNREGISTER)
 		return NOTIFY_DONE;
 	v=&vif_table[0];
 	for(ct=0;ct<maxvif;ct++,v++) {
 		if (v->dev==ptr)
 			vif_delete(ct);
 	}
 	return NOTIFY_DONE;
 }
 static struct notifier_block ip_mr_notifier={
 	.notifier_call = ipmr_device_event,
 };
 /*
  * 	Encapsulate a packet by attaching a valid IPIP header to it.
  *	This avoids tunnel drivers and other mess and gives us the speed so
  *	important for multicast video.
  */
 static void ip_encap(struct sk_buff *skb, u32 saddr, u32 daddr)
 {
 	struct iphdr *iph = (struct iphdr *)skb_push(skb,sizeof(struct iphdr));
 	iph->version	= 	4;
 	iph->tos	=	skb->nh.iph->tos;
 	iph->ttl	=	skb->nh.iph->ttl;
 	iph->frag_off	=	0;
 	iph->daddr	=	daddr;
 	iph->saddr	=	saddr;
 	iph->protocol	=	IPPROTO_IPIP;
 	iph->ihl	=	5;
 	iph->tot_len	=	htons(skb->len);
 	ip_select_ident(iph, skb->dst, NULL);
 	ip_send_check(iph);
 	skb->h.ipiph = skb->nh.iph;
 	skb->nh.iph = iph;
 	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 	nf_reset(skb);
 }
 static inline int ipmr_forward_finish(struct sk_buff *skb)
 {
 	struct ip_options * opt	= &(IPCB(skb)->opt);
 	IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS);
 	if (unlikely(opt->optlen))
 		ip_forward_options(skb);
 	return dst_output(skb);
 }
 /*
  *	Processing handlers for ipmr_forward
  */
 static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
 {
 	struct iphdr *iph = skb->nh.iph;
 	struct vif_device *vif = &vif_table[vifi];
 	struct net_device *dev;
 	struct rtable *rt;
 	int    encap = 0;
 	if (vif->dev == NULL)
 		goto out_free;
 #ifdef CONFIG_IP_PIMSM
 	if (vif->flags & VIFF_REGISTER) {
 		vif->pkt_out++;
 		vif->bytes_out+=skb->len;
 		((struct net_device_stats*)netdev_priv(vif->dev))->tx_bytes += skb->len;
 		((struct net_device_stats*)netdev_priv(vif->dev))->tx_packets++;
 		ipmr_cache_report(skb, vifi, IGMPMSG_WHOLEPKT);
 		kfree_skb(skb);
 		return;
 	}
 #endif
 	if (vif->flags&VIFF_TUNNEL) {
 		struct flowi fl = { .oif = vif->link,
 				    .nl_u = { .ip4_u =
 					      { .daddr = vif->remote,
 						.saddr = vif->local,
 						.tos = RT_TOS(iph->tos) } },
 				    .proto = IPPROTO_IPIP };
 		if (ip_route_output_key(&rt, &fl))
 			goto out_free;
 		encap = sizeof(struct iphdr);
 	} else {
 		struct flowi fl = { .oif = vif->link,
 				    .nl_u = { .ip4_u =
 					      { .daddr = iph->daddr,
 						.tos = RT_TOS(iph->tos) } },
 				    .proto = IPPROTO_IPIP };
 		if (ip_route_output_key(&rt, &fl))
 			goto out_free;
 	}
 	dev = rt->u.dst.dev;
 	if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
 		/* Do not fragment multicasts. Alas, IPv4 does not
 		   allow to send ICMP, so that packets will disappear
 		   to blackhole.
 		 */
 		IP_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS);
 		ip_rt_put(rt);
 		goto out_free;
 	}
 	encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
 	if (skb_cow(skb, encap)) {
  		ip_rt_put(rt);
 		goto out_free;
 	}
 	vif->pkt_out++;
 	vif->bytes_out+=skb->len;
 	dst_release(skb->dst);
 	skb->dst = &rt->u.dst;
 	iph = skb->nh.iph;
 	ip_decrease_ttl(iph);
 	/* FIXME: forward and output firewalls used to be called here.
 	 * What do we do with netfilter? -- RR */
 	if (vif->flags & VIFF_TUNNEL) {
 		ip_encap(skb, vif->local, vif->remote);
 		/* FIXME: extra output firewall step used to be here. --RR */
 		((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_packets++;
 		((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_bytes+=skb->len;
 	}
 	IPCB(skb)->flags |= IPSKB_FORWARDED;
 	/*
 	 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
 	 * not only before forwarding, but after forwarding on all output
 	 * interfaces. It is clear, if mrouter runs a multicasting
 	 * program, it should receive packets not depending to what interface
 	 * program is joined.
 	 * If we will not make it, the program will have to join on all
 	 * interfaces. On the other hand, multihoming host (or router, but
 	 * not mrouter) cannot join to more than one interface - it will
 	 * result in receiving multiple packets.
 	 */
 	NF_HOOK(PF_INET, NF_IP_FORWARD, skb, skb->dev, dev,
 		ipmr_forward_finish);
 	return;
 out_free:
 	kfree_skb(skb);
 	return;
 }
 static int ipmr_find_vif(struct net_device *dev)
 {
 	int ct;
 	for (ct=maxvif-1; ct>=0; ct--) {
 		if (vif_table[ct].dev == dev)
 			break;
 	}
 	return ct;
 }
 /* "local" means that we should preserve one skb (for local delivery) */
 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
 {
 	int psend = -1;
 	int vif, ct;
 	vif = cache->mfc_parent;
 	cache->mfc_un.res.pkt++;
 	cache->mfc_un.res.bytes += skb->len;
 	/*
 	 * Wrong interface: drop packet and (maybe) send PIM assert.
 	 */
 	if (vif_table[vif].dev != skb->dev) {
 		int true_vifi;
 		if (((struct rtable*)skb->dst)->fl.iif == 0) {
 			/* It is our own packet, looped back.
 			   Very complicated situation...
 			   The best workaround until routing daemons will be
 			   fixed is not to redistribute packet, if it was
 			   send through wrong interface. It means, that
 			   multicast applications WILL NOT work for
 			   (S,G), which have default multicast route pointing
 			   to wrong oif. In any case, it is not a good
 			   idea to use multicasting applications on router.
 			 */
 			goto dont_forward;
 		}
 		cache->mfc_un.res.wrong_if++;
 		true_vifi = ipmr_find_vif(skb->dev);
 		if (true_vifi >= 0 && mroute_do_assert &&
 		    /* pimsm uses asserts, when switching from RPT to SPT,
 		       so that we cannot check that packet arrived on an oif.
 		       It is bad, but otherwise we would need to move pretty
 		       large chunk of pimd to kernel. Ough... --ANK
 		     */
 		    (mroute_do_pim || cache->mfc_un.res.ttls[true_vifi] < 255) &&
 		    time_after(jiffies,
 			       cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
 			cache->mfc_un.res.last_assert = jiffies;
 			ipmr_cache_report(skb, true_vifi, IGMPMSG_WRONGVIF);
 		}
 		goto dont_forward;
 	}
 	vif_table[vif].pkt_in++;
 	vif_table[vif].bytes_in+=skb->len;
 	/*
 	 *	Forward the frame
 	 */
 	for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
 		if (skb->nh.iph->ttl > cache->mfc_un.res.ttls[ct]) {
 			if (psend != -1) {
 				struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
 				if (skb2)
 					ipmr_queue_xmit(skb2, cache, psend);
 			}
 			psend=ct;
 		}
 	}
 	if (psend != -1) {
 		if (local) {
 			struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
 			if (skb2)
 				ipmr_queue_xmit(skb2, cache, psend);
 		} else {
 			ipmr_queue_xmit(skb, cache, psend);
 			return 0;
 		}
 	}
 dont_forward:
 	if (!local)
 		kfree_skb(skb);
 	return 0;
 }
 /*
  *	Multicast packets for forwarding arrive here
  */
 int ip_mr_input(struct sk_buff *skb)
 {
 	struct mfc_cache *cache;
 	int local = ((struct rtable*)skb->dst)->rt_flags&RTCF_LOCAL;
 	/* Packet is looped back after forward, it should not be
 	   forwarded second time, but still can be delivered locally.
 	 */
 	if (IPCB(skb)->flags&IPSKB_FORWARDED)
 		goto dont_forward;
 	if (!local) {
 		    if (IPCB(skb)->opt.router_alert) {
 			    if (ip_call_ra_chain(skb))
 				    return 0;
 		    } else if (skb->nh.iph->protocol == IPPROTO_IGMP){
 			    /* IGMPv1 (and broken IGMPv2 implementations sort of
 			       Cisco IOS <= 11.2(8)) do not put router alert
 			       option to IGMP packets destined to routable
 			       groups. It is very bad, because it means
 			       that we can forward NO IGMP messages.
 			     */
 			    read_lock(&mrt_lock);
 			    if (mroute_socket) {
 				    nf_reset(skb);
 				    raw_rcv(mroute_socket, skb);
 				    read_unlock(&mrt_lock);
 				    return 0;
 			    }
 			    read_unlock(&mrt_lock);
 		    }
 	}
 	read_lock(&mrt_lock);
 	cache = ipmr_cache_find(skb->nh.iph->saddr, skb->nh.iph->daddr);
 	/*
 	 *	No usable cache entry
 	 */
 	if (cache==NULL) {
 		int vif;
 		if (local) {
 			struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
 			ip_local_deliver(skb);
 			if (skb2 == NULL) {
 				read_unlock(&mrt_lock);
 				return -ENOBUFS;
 			}
 			skb = skb2;
 		}
 		vif = ipmr_find_vif(skb->dev);
 		if (vif >= 0) {
 			int err = ipmr_cache_unresolved(vif, skb);
 			read_unlock(&mrt_lock);
 			return err;
 		}
 		read_unlock(&mrt_lock);
 		kfree_skb(skb);
 		return -ENODEV;
 	}
 	ip_mr_forward(skb, cache, local);
 	read_unlock(&mrt_lock);
 	if (local)
 		return ip_local_deliver(skb);
 	return 0;
 dont_forward:
 	if (local)
 		return ip_local_deliver(skb);
 	kfree_skb(skb);
 	return 0;
 }
 #ifdef CONFIG_IP_PIMSM_V1
 /*
  * Handle IGMP messages of PIMv1
  */
 int pim_rcv_v1(struct sk_buff * skb)
 {
 	struct igmphdr *pim;
 	struct iphdr   *encap;
 	struct net_device  *reg_dev = NULL;
 	if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
 		goto drop;
 	pim = (struct igmphdr*)skb->h.raw;
         if (!mroute_do_pim ||
 	    skb->len < sizeof(*pim) + sizeof(*encap) ||
 	    pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
 		goto drop;
 	encap = (struct iphdr*)(skb->h.raw + sizeof(struct igmphdr));
 	/*
 	   Check that:
 	   a. packet is really destinted to a multicast group
 	   b. packet is not a NULL-REGISTER
 	   c. packet is not truncated
 	 */
 	if (!MULTICAST(encap->daddr) ||
 	    encap->tot_len == 0 ||
 	    ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
 		goto drop;
 	read_lock(&mrt_lock);
 	if (reg_vif_num >= 0)
 		reg_dev = vif_table[reg_vif_num].dev;
 	if (reg_dev)
 		dev_hold(reg_dev);
 	read_unlock(&mrt_lock);
 	if (reg_dev == NULL)
 		goto drop;
 	skb->mac.raw = skb->nh.raw;
 	skb_pull(skb, (u8*)encap - skb->data);
 	skb->nh.iph = (struct iphdr *)skb->data;
 	skb->dev = reg_dev;
-	memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
 	skb->protocol = htons(ETH_P_IP);
 	skb->ip_summed = 0;
 	skb->pkt_type = PACKET_HOST;
 	dst_release(skb->dst);
 	skb->dst = NULL;
 	((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
 	((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
 	nf_reset(skb);
 	netif_rx(skb);
 	dev_put(reg_dev);
 	return 0;
  drop:
 	kfree_skb(skb);
 	return 0;
 }
 #endif
 #ifdef CONFIG_IP_PIMSM_V2
 static int pim_rcv(struct sk_buff * skb)
 {
 	struct pimreghdr *pim;
 	struct iphdr   *encap;
 	struct net_device  *reg_dev = NULL;
 	if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
 		goto drop;
 	pim = (struct pimreghdr*)skb->h.raw;
         if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
 	    (pim->flags&PIM_NULL_REGISTER) ||
 	    (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
 	     (u16)csum_fold(skb_checksum(skb, 0, skb->len, 0))))
 		goto drop;
 	/* check if the inner packet is destined to mcast group */
 	encap = (struct iphdr*)(skb->h.raw + sizeof(struct pimreghdr));
 	if (!MULTICAST(encap->daddr) ||
 	    encap->tot_len == 0 ||
 	    ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
 		goto drop;
 	read_lock(&mrt_lock);
 	if (reg_vif_num >= 0)
 		reg_dev = vif_table[reg_vif_num].dev;
 	if (reg_dev)
 		dev_hold(reg_dev);
 	read_unlock(&mrt_lock);
 	if (reg_dev == NULL)
 		goto drop;
 	skb->mac.raw = skb->nh.raw;
 	skb_pull(skb, (u8*)encap - skb->data);
 	skb->nh.iph = (struct iphdr *)skb->data;
 	skb->dev = reg_dev;
-	memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
 	skb->protocol = htons(ETH_P_IP);
 	skb->ip_summed = 0;
 	skb->pkt_type = PACKET_HOST;
 	dst_release(skb->dst);
 	((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
 	((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
 	skb->dst = NULL;
 	nf_reset(skb);
 	netif_rx(skb);
 	dev_put(reg_dev);
 	return 0;
  drop:
 	kfree_skb(skb);
 	return 0;
 }
 #endif
 static int
 ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
 {
 	int ct;
 	struct rtnexthop *nhp;
 	struct net_device *dev = vif_table[c->mfc_parent].dev;
 	u8 *b = skb->tail;
 	struct rtattr *mp_head;
 	if (dev)
 		RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
 	mp_head = (struct rtattr*)skb_put(skb, RTA_LENGTH(0));
 	for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
 		if (c->mfc_un.res.ttls[ct] < 255) {
 			if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
 				goto rtattr_failure;
 			nhp = (struct rtnexthop*)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
 			nhp->rtnh_flags = 0;
 			nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
 			nhp->rtnh_ifindex = vif_table[ct].dev->ifindex;
 			nhp->rtnh_len = sizeof(*nhp);
 		}
 	}
 	mp_head->rta_type = RTA_MULTIPATH;
 	mp_head->rta_len = skb->tail - (u8*)mp_head;
 	rtm->rtm_type = RTN_MULTICAST;
 	return 1;
 rtattr_failure:
 	skb_trim(skb, b - skb->data);
 	return -EMSGSIZE;
 }
 int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait)
 {
 	int err;
 	struct mfc_cache *cache;
 	struct rtable *rt = (struct rtable*)skb->dst;
 	read_lock(&mrt_lock);
 	cache = ipmr_cache_find(rt->rt_src, rt->rt_dst);
 	if (cache==NULL) {
 		struct net_device *dev;
 		int vif;
 		if (nowait) {
 			read_unlock(&mrt_lock);
 			return -EAGAIN;
 		}
 		dev = skb->dev;
 		if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
 			read_unlock(&mrt_lock);
 			return -ENODEV;
 		}
 		skb->nh.raw = skb_push(skb, sizeof(struct iphdr));
 		skb->nh.iph->ihl = sizeof(struct iphdr)>>2;
 		skb->nh.iph->saddr = rt->rt_src;
 		skb->nh.iph->daddr = rt->rt_dst;
 		skb->nh.iph->version = 0;
 		err = ipmr_cache_unresolved(vif, skb);
 		read_unlock(&mrt_lock);
 		return err;
 	}
 	if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
 		cache->mfc_flags |= MFC_NOTIFY;
 	err = ipmr_fill_mroute(skb, cache, rtm);
 	read_unlock(&mrt_lock);
 	return err;
 }
 #ifdef CONFIG_PROC_FS
 /*
  *	The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
  */
 struct ipmr_vif_iter {
 	int ct;
 };
 static struct vif_device *ipmr_vif_seq_idx(struct ipmr_vif_iter *iter,
 					   loff_t pos)
 {
 	for (iter->ct = 0; iter->ct < maxvif; ++iter->ct) {
 		if(!VIF_EXISTS(iter->ct))
 			continue;
 		if (pos-- == 0)
 			return &vif_table[iter->ct];
 	}
 	return NULL;
 }
 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
 {
 	read_lock(&mrt_lock);
 	return *pos ? ipmr_vif_seq_idx(seq->private, *pos - 1)
 		: SEQ_START_TOKEN;
 }
 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
 	struct ipmr_vif_iter *iter = seq->private;
 	++*pos;
 	if (v == SEQ_START_TOKEN)
 		return ipmr_vif_seq_idx(iter, 0);
 	while (++iter->ct < maxvif) {
 		if(!VIF_EXISTS(iter->ct))
 			continue;
 		return &vif_table[iter->ct];
 	}
 	return NULL;
 }
 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
 {
 	read_unlock(&mrt_lock);
 }
 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
 {
 	if (v == SEQ_START_TOKEN) {
 		seq_puts(seq,
 			 "Interface      BytesIn  PktsIn  BytesOut PktsOut Flags Local    Remote\n");
 	} else {
 		const struct vif_device *vif = v;
 		const char *name =  vif->dev ? vif->dev->name : "none";
 		seq_printf(seq,
 			   "%2Zd %-10s %8ld %7ld  %8ld %7ld %05X %08X %08X\n",
 			   vif - vif_table,
 			   name, vif->bytes_in, vif->pkt_in,
 			   vif->bytes_out, vif->pkt_out,
 			   vif->flags, vif->local, vif->remote);
 	}
 	return 0;
 }
 static struct seq_operations ipmr_vif_seq_ops = {
 	.start = ipmr_vif_seq_start,
 	.next  = ipmr_vif_seq_next,
 	.stop  = ipmr_vif_seq_stop,
 	.show  = ipmr_vif_seq_show,
 };
 static int ipmr_vif_open(struct inode *inode, struct file *file)
 {
 	struct seq_file *seq;
 	int rc = -ENOMEM;
 	struct ipmr_vif_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
 	if (!s)
 		goto out;
 	rc = seq_open(file, &ipmr_vif_seq_ops);
 	if (rc)
 		goto out_kfree;
 	s->ct = 0;
 	seq = file->private_data;
 	seq->private = s;
 out:
 	return rc;
 out_kfree:
 	kfree(s);
 	goto out;
 }
 static struct file_operations ipmr_vif_fops = {
 	.owner	 = THIS_MODULE,
 	.open    = ipmr_vif_open,
 	.read    = seq_read,
 	.llseek  = seq_lseek,
 	.release = seq_release_private,
 };
 struct ipmr_mfc_iter {
 	struct mfc_cache **cache;
 	int ct;
 };
 static struct mfc_cache *ipmr_mfc_seq_idx(struct ipmr_mfc_iter *it, loff_t pos)
 {
 	struct mfc_cache *mfc;
 	it->cache = mfc_cache_array;
 	read_lock(&mrt_lock);
 	for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
 		for(mfc = mfc_cache_array[it->ct]; mfc; mfc = mfc->next)
 			if (pos-- == 0)
 				return mfc;
 	read_unlock(&mrt_lock);
 	it->cache = &mfc_unres_queue;
 	spin_lock_bh(&mfc_unres_lock);
 	for(mfc = mfc_unres_queue; mfc; mfc = mfc->next)
 		if (pos-- == 0)
 			return mfc;
 	spin_unlock_bh(&mfc_unres_lock);
 	it->cache = NULL;
 	return NULL;
 }
 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
 {
 	struct ipmr_mfc_iter *it = seq->private;
 	it->cache = NULL;
 	it->ct = 0;
 	return *pos ? ipmr_mfc_seq_idx(seq->private, *pos - 1)
 		: SEQ_START_TOKEN;
 }
 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
 	struct mfc_cache *mfc = v;
 	struct ipmr_mfc_iter *it = seq->private;
 	++*pos;
 	if (v == SEQ_START_TOKEN)
 		return ipmr_mfc_seq_idx(seq->private, 0);
 	if (mfc->next)
 		return mfc->next;
 	if (it->cache == &mfc_unres_queue)
 		goto end_of_list;
 	BUG_ON(it->cache != mfc_cache_array);
 	while (++it->ct < MFC_LINES) {
 		mfc = mfc_cache_array[it->ct];
 		if (mfc)
 			return mfc;
 	}
 	/* exhausted cache_array, show unresolved */
 	read_unlock(&mrt_lock);
 	it->cache = &mfc_unres_queue;
 	it->ct = 0;
 	spin_lock_bh(&mfc_unres_lock);
 	mfc = mfc_unres_queue;
 	if (mfc)
 		return mfc;
  end_of_list:
 	spin_unlock_bh(&mfc_unres_lock);
 	it->cache = NULL;
 	return NULL;
 }
 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
 {
 	struct ipmr_mfc_iter *it = seq->private;
 	if (it->cache == &mfc_unres_queue)
 		spin_unlock_bh(&mfc_unres_lock);
 	else if (it->cache == mfc_cache_array)
 		read_unlock(&mrt_lock);
 }
 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
 {
 	int n;
 	if (v == SEQ_START_TOKEN) {
 		seq_puts(seq,
 		 "Group    Origin   Iif     Pkts    Bytes    Wrong Oifs\n");
 	} else {
 		const struct mfc_cache *mfc = v;
 		const struct ipmr_mfc_iter *it = seq->private;
 		seq_printf(seq, "%08lX %08lX %-3d %8ld %8ld %8ld",
 			   (unsigned long) mfc->mfc_mcastgrp,
 			   (unsigned long) mfc->mfc_origin,
 			   mfc->mfc_parent,
 			   mfc->mfc_un.res.pkt,
 			   mfc->mfc_un.res.bytes,
 			   mfc->mfc_un.res.wrong_if);
 		if (it->cache != &mfc_unres_queue) {
 			for(n = mfc->mfc_un.res.minvif;
 			    n < mfc->mfc_un.res.maxvif; n++ ) {
 				if(VIF_EXISTS(n)
 				   && mfc->mfc_un.res.ttls[n] < 255)
 				seq_printf(seq,
 					   " %2d:%-3d",
 					   n, mfc->mfc_un.res.ttls[n]);
 			}
 		}
 		seq_putc(seq, '\n');
 	}
 	return 0;
 }
 static struct seq_operations ipmr_mfc_seq_ops = {
 	.start = ipmr_mfc_seq_start,
 	.next  = ipmr_mfc_seq_next,
 	.stop  = ipmr_mfc_seq_stop,
 	.show  = ipmr_mfc_seq_show,
 };
 static int ipmr_mfc_open(struct inode *inode, struct file *file)
 {
 	struct seq_file *seq;
 	int rc = -ENOMEM;
 	struct ipmr_mfc_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
 	if (!s)
 		goto out;
 	rc = seq_open(file, &ipmr_mfc_seq_ops);
 	if (rc)
 		goto out_kfree;
 	seq = file->private_data;
 	seq->private = s;
 out:
 	return rc;
 out_kfree:
 	kfree(s);
 	goto out;
 }
 static struct file_operations ipmr_mfc_fops = {
 	.owner	 = THIS_MODULE,
 	.open    = ipmr_mfc_open,
 	.read    = seq_read,
 	.llseek  = seq_lseek,
 	.release = seq_release_private,
 };
 #endif
 #ifdef CONFIG_IP_PIMSM_V2
 static struct net_protocol pim_protocol = {
 	.handler	=	pim_rcv,
 };
 #endif
 /*
  *	Setup for IP multicast routing
  */
 void __init ip_mr_init(void)
 {
 	mrt_cachep = kmem_cache_create("ip_mrt_cache",
 				       sizeof(struct mfc_cache),
 				       0, SLAB_HWCACHE_ALIGN,
 				       NULL, NULL);
 	if (!mrt_cachep)
 		panic("cannot allocate ip_mrt_cache");
 	init_timer(&ipmr_expire_timer);
 	ipmr_expire_timer.function=ipmr_expire_process;
 	register_netdevice_notifier(&ip_mr_notifier);
 #ifdef CONFIG_PROC_FS
 	proc_net_fops_create("ip_mr_vif", 0, &ipmr_vif_fops);
 	proc_net_fops_create("ip_mr_cache", 0, &ipmr_mfc_fops);
 #endif
 }

net/ipv4/xfrm4_mode_tunnel.c

Diff comments View file @ 5d9c5a3

 /*
  * xfrm4_mode_tunnel.c - Tunnel mode encapsulation for IPv4.
  *
  * Copyright (c) 2004-2006 Herbert Xu <herbert@gondor.apana.org.au>
  */
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/skbuff.h>
 #include <linux/stringify.h>
 #include <net/dst.h>
 #include <net/inet_ecn.h>
 #include <net/ip.h>
 #include <net/xfrm.h>
 static inline void ipip_ecn_decapsulate(struct sk_buff *skb)
 {
 	struct iphdr *outer_iph = skb->nh.iph;
 	struct iphdr *inner_iph = skb->h.ipiph;
 	if (INET_ECN_is_ce(outer_iph->tos))
 		IP_ECN_set_ce(inner_iph);
 }
 /* Add encapsulation header.
  *
  * The top IP header will be constructed per RFC 2401.  The following fields
  * in it shall be filled in by x->type->output:
  *      tot_len
  *      check
  *
  * On exit, skb->h will be set to the start of the payload to be processed
  * by x->type->output and skb->nh will be set to the top IP header.
  */
 static int xfrm4_tunnel_output(struct sk_buff *skb)
 {
 	struct dst_entry *dst = skb->dst;
 	struct xfrm_state *x = dst->xfrm;
 	struct iphdr *iph, *top_iph;
 	int flags;
 	iph = skb->nh.iph;
 	skb->h.ipiph = iph;
 	skb->nh.raw = skb_push(skb, x->props.header_len);
 	top_iph = skb->nh.iph;
 	top_iph->ihl = 5;
 	top_iph->version = 4;
 	/* DS disclosed */
 	top_iph->tos = INET_ECN_encapsulate(iph->tos, iph->tos);
 	flags = x->props.flags;
 	if (flags & XFRM_STATE_NOECN)
 		IP_ECN_clear(top_iph);
 	top_iph->frag_off = (flags & XFRM_STATE_NOPMTUDISC) ?
 		0 : (iph->frag_off & htons(IP_DF));
 	if (!top_iph->frag_off)
 		__ip_select_ident(top_iph, dst->child, 0);
 	top_iph->ttl = dst_metric(dst->child, RTAX_HOPLIMIT);
 	top_iph->saddr = x->props.saddr.a4;
 	top_iph->daddr = x->id.daddr.a4;
 	top_iph->protocol = IPPROTO_IPIP;
 	memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
 	return 0;
 }
 static int xfrm4_tunnel_input(struct xfrm_state *x, struct sk_buff *skb)
 {
 	struct iphdr *iph = skb->nh.iph;
 	int err = -EINVAL;
 	if (iph->protocol != IPPROTO_IPIP)
 		goto out;
 	if (!pskb_may_pull(skb, sizeof(struct iphdr)))
 		goto out;
 	if (skb_cloned(skb) &&
 	    (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
 		goto out;
 	if (x->props.flags & XFRM_STATE_DECAP_DSCP)
 		ipv4_copy_dscp(iph, skb->h.ipiph);
 	if (!(x->props.flags & XFRM_STATE_NOECN))
 		ipip_ecn_decapsulate(skb);
 	skb->mac.raw = memmove(skb->data - skb->mac_len,
 			       skb->mac.raw, skb->mac_len);
 	skb->nh.raw = skb->data;
-	memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
 	err = 0;
 out:
 	return err;
 }
 static struct xfrm_mode xfrm4_tunnel_mode = {
 	.input = xfrm4_tunnel_input,
 	.output = xfrm4_tunnel_output,
 	.owner = THIS_MODULE,
 	.encap = XFRM_MODE_TUNNEL,
 };
 static int __init xfrm4_tunnel_init(void)
 {
 	return xfrm_register_mode(&xfrm4_tunnel_mode, AF_INET);
 }
 static void __exit xfrm4_tunnel_exit(void)
 {
 	int err;
 	err = xfrm_unregister_mode(&xfrm4_tunnel_mode, AF_INET);
 	BUG_ON(err);
 }
 module_init(xfrm4_tunnel_init);
 module_exit(xfrm4_tunnel_exit);
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_XFRM_MODE(AF_INET, XFRM_MODE_TUNNEL);

net/ipv6/sit.c

Diff comments View file @ 5d9c5a3

 /*
  *	IPv6 over IPv4 tunnel device - Simple Internet Transition (SIT)
  *	Linux INET6 implementation
  *
  *	Authors:
  *	Pedro Roque		<roque@di.fc.ul.pt>
  *	Alexey Kuznetsov	<kuznet@ms2.inr.ac.ru>
  *
  *	$Id: sit.c,v 1.53 2001/09/25 05:09:53 davem Exp $
  *
  *	This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  *
  *	Changes:
  * Roger Venning <r.venning@telstra.com>:	6to4 support
  * Nate Thompson <nate@thebog.net>:		6to4 support
  */
 #include <linux/module.h>
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
 #include <linux/sched.h>
 #include <linux/net.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
 #include <linux/if_arp.h>
 #include <linux/icmp.h>
 #include <asm/uaccess.h>
 #include <linux/init.h>
 #include <linux/netfilter_ipv4.h>
 #include <linux/if_ether.h>
 #include <net/sock.h>
 #include <net/snmp.h>
 #include <net/ipv6.h>
 #include <net/protocol.h>
 #include <net/transp_v6.h>
 #include <net/ip6_fib.h>
 #include <net/ip6_route.h>
 #include <net/ndisc.h>
 #include <net/addrconf.h>
 #include <net/ip.h>
 #include <net/udp.h>
 #include <net/icmp.h>
 #include <net/ipip.h>
 #include <net/inet_ecn.h>
 #include <net/xfrm.h>
 #include <net/dsfield.h>
 /*
    This version of net/ipv6/sit.c is cloned of net/ipv4/ip_gre.c
    For comments look at net/ipv4/ip_gre.c --ANK
  */
 #define HASH_SIZE  16
 #define HASH(addr) ((addr^(addr>>4))&0xF)
 static int ipip6_fb_tunnel_init(struct net_device *dev);
 static int ipip6_tunnel_init(struct net_device *dev);
 static void ipip6_tunnel_setup(struct net_device *dev);
 static struct net_device *ipip6_fb_tunnel_dev;
 static struct ip_tunnel *tunnels_r_l[HASH_SIZE];
 static struct ip_tunnel *tunnels_r[HASH_SIZE];
 static struct ip_tunnel *tunnels_l[HASH_SIZE];
 static struct ip_tunnel *tunnels_wc[1];
 static struct ip_tunnel **tunnels[4] = { tunnels_wc, tunnels_l, tunnels_r, tunnels_r_l };
 static DEFINE_RWLOCK(ipip6_lock);
 static struct ip_tunnel * ipip6_tunnel_lookup(u32 remote, u32 local)
 {
 	unsigned h0 = HASH(remote);
 	unsigned h1 = HASH(local);
 	struct ip_tunnel *t;
 	for (t = tunnels_r_l[h0^h1]; t; t = t->next) {
 		if (local == t->parms.iph.saddr &&
 		    remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
 			return t;
 	}
 	for (t = tunnels_r[h0]; t; t = t->next) {
 		if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
 			return t;
 	}
 	for (t = tunnels_l[h1]; t; t = t->next) {
 		if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
 			return t;
 	}
 	if ((t = tunnels_wc[0]) != NULL && (t->dev->flags&IFF_UP))
 		return t;
 	return NULL;
 }
 static struct ip_tunnel ** ipip6_bucket(struct ip_tunnel *t)
 {
 	u32 remote = t->parms.iph.daddr;
 	u32 local = t->parms.iph.saddr;
 	unsigned h = 0;
 	int prio = 0;
 	if (remote) {
 		prio |= 2;
 		h ^= HASH(remote);
 	}
 	if (local) {
 		prio |= 1;
 		h ^= HASH(local);
 	}
 	return &tunnels[prio][h];
 }
 static void ipip6_tunnel_unlink(struct ip_tunnel *t)
 {
 	struct ip_tunnel **tp;
 	for (tp = ipip6_bucket(t); *tp; tp = &(*tp)->next) {
 		if (t == *tp) {
 			write_lock_bh(&ipip6_lock);
 			*tp = t->next;
 			write_unlock_bh(&ipip6_lock);
 			break;
 		}
 	}
 }
 static void ipip6_tunnel_link(struct ip_tunnel *t)
 {
 	struct ip_tunnel **tp = ipip6_bucket(t);
 	t->next = *tp;
 	write_lock_bh(&ipip6_lock);
 	*tp = t;
 	write_unlock_bh(&ipip6_lock);
 }
 static struct ip_tunnel * ipip6_tunnel_locate(struct ip_tunnel_parm *parms, int create)
 {
 	u32 remote = parms->iph.daddr;
 	u32 local = parms->iph.saddr;
 	struct ip_tunnel *t, **tp, *nt;
 	struct net_device *dev;
 	unsigned h = 0;
 	int prio = 0;
 	char name[IFNAMSIZ];
 	if (remote) {
 		prio |= 2;
 		h ^= HASH(remote);
 	}
 	if (local) {
 		prio |= 1;
 		h ^= HASH(local);
 	}
 	for (tp = &tunnels[prio][h]; (t = *tp) != NULL; tp = &t->next) {
 		if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
 			return t;
 	}
 	if (!create)
 		goto failed;
 	if (parms->name[0])
 		strlcpy(name, parms->name, IFNAMSIZ);
 	else {
 		int i;
 		for (i=1; i<100; i++) {
 			sprintf(name, "sit%d", i);
 			if (__dev_get_by_name(name) == NULL)
 				break;
 		}
 		if (i==100)
 			goto failed;
 	}
 	dev = alloc_netdev(sizeof(*t), name, ipip6_tunnel_setup);
 	if (dev == NULL)
 		return NULL;
 	nt = netdev_priv(dev);
 	dev->init = ipip6_tunnel_init;
 	nt->parms = *parms;
 	if (register_netdevice(dev) < 0) {
 		free_netdev(dev);
 		goto failed;
 	}
 	dev_hold(dev);
 	ipip6_tunnel_link(nt);
 	return nt;
 failed:
 	return NULL;
 }
 static void ipip6_tunnel_uninit(struct net_device *dev)
 {
 	if (dev == ipip6_fb_tunnel_dev) {
 		write_lock_bh(&ipip6_lock);
 		tunnels_wc[0] = NULL;
 		write_unlock_bh(&ipip6_lock);
 		dev_put(dev);
 	} else {
 		ipip6_tunnel_unlink(netdev_priv(dev));
 		dev_put(dev);
 	}
 }
 static void ipip6_err(struct sk_buff *skb, u32 info)
 {
 #ifndef I_WISH_WORLD_WERE_PERFECT
 /* It is not :-( All the routers (except for Linux) return only
    8 bytes of packet payload. It means, that precise relaying of
    ICMP in the real Internet is absolutely infeasible.
  */
 	struct iphdr *iph = (struct iphdr*)skb->data;
 	int type = skb->h.icmph->type;
 	int code = skb->h.icmph->code;
 	struct ip_tunnel *t;
 	switch (type) {
 	default:
 	case ICMP_PARAMETERPROB:
 		return;
 	case ICMP_DEST_UNREACH:
 		switch (code) {
 		case ICMP_SR_FAILED:
 		case ICMP_PORT_UNREACH:
 			/* Impossible event. */
 			return;
 		case ICMP_FRAG_NEEDED:
 			/* Soft state for pmtu is maintained by IP core. */
 			return;
 		default:
 			/* All others are translated to HOST_UNREACH.
 			   rfc2003 contains "deep thoughts" about NET_UNREACH,
 			   I believe they are just ether pollution. --ANK
 			 */
 			break;
 		}
 		break;
 	case ICMP_TIME_EXCEEDED:
 		if (code != ICMP_EXC_TTL)
 			return;
 		break;
 	}
 	read_lock(&ipip6_lock);
 	t = ipip6_tunnel_lookup(iph->daddr, iph->saddr);
 	if (t == NULL || t->parms.iph.daddr == 0)
 		goto out;
 	if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 		goto out;
 	if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
 		t->err_count++;
 	else
 		t->err_count = 1;
 	t->err_time = jiffies;
 out:
 	read_unlock(&ipip6_lock);
 	return;
 #else
 	struct iphdr *iph = (struct iphdr*)dp;
 	int hlen = iph->ihl<<2;
 	struct ipv6hdr *iph6;
 	int type = skb->h.icmph->type;
 	int code = skb->h.icmph->code;
 	int rel_type = 0;
 	int rel_code = 0;
 	int rel_info = 0;
 	struct sk_buff *skb2;
 	struct rt6_info *rt6i;
 	if (len < hlen + sizeof(struct ipv6hdr))
 		return;
 	iph6 = (struct ipv6hdr*)(dp + hlen);
 	switch (type) {
 	default:
 		return;
 	case ICMP_PARAMETERPROB:
 		if (skb->h.icmph->un.gateway < hlen)
 			return;
 		/* So... This guy found something strange INSIDE encapsulated
 		   packet. Well, he is fool, but what can we do ?
 		 */
 		rel_type = ICMPV6_PARAMPROB;
 		rel_info = skb->h.icmph->un.gateway - hlen;
 		break;
 	case ICMP_DEST_UNREACH:
 		switch (code) {
 		case ICMP_SR_FAILED:
 		case ICMP_PORT_UNREACH:
 			/* Impossible event. */
 			return;
 		case ICMP_FRAG_NEEDED:
 			/* Too complicated case ... */
 			return;
 		default:
 			/* All others are translated to HOST_UNREACH.
 			   rfc2003 contains "deep thoughts" about NET_UNREACH,
 			   I believe, it is just ether pollution. --ANK
 			 */
 			rel_type = ICMPV6_DEST_UNREACH;
 			rel_code = ICMPV6_ADDR_UNREACH;
 			break;
 		}
 		break;
 	case ICMP_TIME_EXCEEDED:
 		if (code != ICMP_EXC_TTL)
 			return;
 		rel_type = ICMPV6_TIME_EXCEED;
 		rel_code = ICMPV6_EXC_HOPLIMIT;
 		break;
 	}
 	/* Prepare fake skb to feed it to icmpv6_send */
 	skb2 = skb_clone(skb, GFP_ATOMIC);
 	if (skb2 == NULL)
 		return;
 	dst_release(skb2->dst);
 	skb2->dst = NULL;
 	skb_pull(skb2, skb->data - (u8*)iph6);
 	skb2->nh.raw = skb2->data;
 	/* Try to guess incoming interface */
 	rt6i = rt6_lookup(&iph6->saddr, NULL, NULL, 0);
 	if (rt6i && rt6i->rt6i_dev) {
 		skb2->dev = rt6i->rt6i_dev;
 		rt6i = rt6_lookup(&iph6->daddr, &iph6->saddr, NULL, 0);
 		if (rt6i && rt6i->rt6i_dev && rt6i->rt6i_dev->type == ARPHRD_SIT) {
 			struct ip_tunnel *t = netdev_priv(rt6i->rt6i_dev);
 			if (rel_type == ICMPV6_TIME_EXCEED && t->parms.iph.ttl) {
 				rel_type = ICMPV6_DEST_UNREACH;
 				rel_code = ICMPV6_ADDR_UNREACH;
 			}
 			icmpv6_send(skb2, rel_type, rel_code, rel_info, skb2->dev);
 		}
 	}
 	kfree_skb(skb2);
 	return;
 #endif
 }
 static inline void ipip6_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
 {
 	if (INET_ECN_is_ce(iph->tos))
 		IP6_ECN_set_ce(skb->nh.ipv6h);
 }
 static int ipip6_rcv(struct sk_buff *skb)
 {
 	struct iphdr *iph;
 	struct ip_tunnel *tunnel;
 	if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
 		goto out;
 	iph = skb->nh.iph;
 	read_lock(&ipip6_lock);
 	if ((tunnel = ipip6_tunnel_lookup(iph->saddr, iph->daddr)) != NULL) {
 		secpath_reset(skb);
 		skb->mac.raw = skb->nh.raw;
 		skb->nh.raw = skb->data;
-		memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
 		IPCB(skb)->flags = 0;
 		skb->protocol = htons(ETH_P_IPV6);
 		skb->pkt_type = PACKET_HOST;
 		tunnel->stat.rx_packets++;
 		tunnel->stat.rx_bytes += skb->len;
 		skb->dev = tunnel->dev;
 		dst_release(skb->dst);
 		skb->dst = NULL;
 		nf_reset(skb);
 		ipip6_ecn_decapsulate(iph, skb);
 		netif_rx(skb);
 		read_unlock(&ipip6_lock);
 		return 0;
 	}
 	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
 	kfree_skb(skb);
 	read_unlock(&ipip6_lock);
 out:
 	return 0;
 }
 /* Returns the embedded IPv4 address if the IPv6 address
    comes from 6to4 (RFC 3056) addr space */
 static inline u32 try_6to4(struct in6_addr *v6dst)
 {
 	u32 dst = 0;
 	if (v6dst->s6_addr16[0] == htons(0x2002)) {
 	        /* 6to4 v6 addr has 16 bits prefix, 32 v4addr, 16 SLA, ... */
 		memcpy(&dst, &v6dst->s6_addr16[1], 4);
 	}
 	return dst;
 }
 /*
  *	This function assumes it is being called from dev_queue_xmit()
  *	and that skb is filled properly by that function.
  */
 static int ipip6_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	struct ip_tunnel *tunnel = netdev_priv(dev);
 	struct net_device_stats *stats = &tunnel->stat;
 	struct iphdr  *tiph = &tunnel->parms.iph;
 	struct ipv6hdr *iph6 = skb->nh.ipv6h;
 	u8     tos = tunnel->parms.iph.tos;
 	struct rtable *rt;     			/* Route to the other host */
 	struct net_device *tdev;			/* Device to other host */
 	struct iphdr  *iph;			/* Our new IP header */
 	int    max_headroom;			/* The extra header space needed */
 	u32    dst = tiph->daddr;
 	int    mtu;
 	struct in6_addr *addr6;
 	int addr_type;
 	if (tunnel->recursion++) {
 		tunnel->stat.collisions++;
 		goto tx_error;
 	}
 	if (skb->protocol != htons(ETH_P_IPV6))
 		goto tx_error;
 	if (!dst)
 		dst = try_6to4(&iph6->daddr);
 	if (!dst) {
 		struct neighbour *neigh = NULL;
 		if (skb->dst)
 			neigh = skb->dst->neighbour;
 		if (neigh == NULL) {
 			if (net_ratelimit())
 				printk(KERN_DEBUG "sit: nexthop == NULL\n");
 			goto tx_error;
 		}
 		addr6 = (struct in6_addr*)&neigh->primary_key;
 		addr_type = ipv6_addr_type(addr6);
 		if (addr_type == IPV6_ADDR_ANY) {
 			addr6 = &skb->nh.ipv6h->daddr;
 			addr_type = ipv6_addr_type(addr6);
 		}
 		if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
 			goto tx_error_icmp;
 		dst = addr6->s6_addr32[3];
 	}
 	{
 		struct flowi fl = { .nl_u = { .ip4_u =
 					      { .daddr = dst,
 						.saddr = tiph->saddr,
 						.tos = RT_TOS(tos) } },
 				    .oif = tunnel->parms.link,
 				    .proto = IPPROTO_IPV6 };
 		if (ip_route_output_key(&rt, &fl)) {
 			tunnel->stat.tx_carrier_errors++;
 			goto tx_error_icmp;
 		}
 	}
 	if (rt->rt_type != RTN_UNICAST) {
 		ip_rt_put(rt);
 		tunnel->stat.tx_carrier_errors++;
 		goto tx_error_icmp;
 	}
 	tdev = rt->u.dst.dev;
 	if (tdev == dev) {
 		ip_rt_put(rt);
 		tunnel->stat.collisions++;
 		goto tx_error;
 	}
 	if (tiph->frag_off)
 		mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr);
 	else
 		mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
 	if (mtu < 68) {
 		tunnel->stat.collisions++;
 		ip_rt_put(rt);
 		goto tx_error;
 	}
 	if (mtu < IPV6_MIN_MTU)
 		mtu = IPV6_MIN_MTU;
 	if (tunnel->parms.iph.daddr && skb->dst)
 		skb->dst->ops->update_pmtu(skb->dst, mtu);
 	if (skb->len > mtu) {
 		icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
 		ip_rt_put(rt);
 		goto tx_error;
 	}
 	if (tunnel->err_count > 0) {
 		if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
 			tunnel->err_count--;
 			dst_link_failure(skb);
 		} else
 			tunnel->err_count = 0;
 	}
 	/*
 	 * Okay, now see if we can stuff it in the buffer as-is.
 	 */
 	max_headroom = LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr);
 	if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
 		struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
 		if (!new_skb) {
 			ip_rt_put(rt);
   			stats->tx_dropped++;
 			dev_kfree_skb(skb);
 			tunnel->recursion--;
 			return 0;
 		}
 		if (skb->sk)
 			skb_set_owner_w(new_skb, skb->sk);
 		dev_kfree_skb(skb);
 		skb = new_skb;
 		iph6 = skb->nh.ipv6h;
 	}
 	skb->h.raw = skb->nh.raw;
 	skb->nh.raw = skb_push(skb, sizeof(struct iphdr));
 	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 	IPCB(skb)->flags = 0;
 	dst_release(skb->dst);
 	skb->dst = &rt->u.dst;
 	/*
 	 *	Push down and install the IPIP header.
 	 */
 	iph 			=	skb->nh.iph;
 	iph->version		=	4;
 	iph->ihl		=	sizeof(struct iphdr)>>2;
 	if (mtu > IPV6_MIN_MTU)
 		iph->frag_off	=	htons(IP_DF);
 	else
 		iph->frag_off	=	0;
 	iph->protocol		=	IPPROTO_IPV6;
 	iph->tos		=	INET_ECN_encapsulate(tos, ipv6_get_dsfield(iph6));
 	iph->daddr		=	rt->rt_dst;
 	iph->saddr		=	rt->rt_src;
 	if ((iph->ttl = tiph->ttl) == 0)
 		iph->ttl	=	iph6->hop_limit;
 	nf_reset(skb);
 	IPTUNNEL_XMIT();
 	tunnel->recursion--;
 	return 0;
 tx_error_icmp:
 	dst_link_failure(skb);
 tx_error:
 	stats->tx_errors++;
 	dev_kfree_skb(skb);
 	tunnel->recursion--;
 	return 0;
 }
 static int
 ipip6_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
 {
 	int err = 0;
 	struct ip_tunnel_parm p;
 	struct ip_tunnel *t;
 	switch (cmd) {
 	case SIOCGETTUNNEL:
 		t = NULL;
 		if (dev == ipip6_fb_tunnel_dev) {
 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
 				err = -EFAULT;
 				break;
 			}
 			t = ipip6_tunnel_locate(&p, 0);
 		}
 		if (t == NULL)
 			t = netdev_priv(dev);
 		memcpy(&p, &t->parms, sizeof(p));
 		if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 			err = -EFAULT;
 		break;
 	case SIOCADDTUNNEL:
 	case SIOCCHGTUNNEL:
 		err = -EPERM;
 		if (!capable(CAP_NET_ADMIN))
 			goto done;
 		err = -EFAULT;
 		if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 			goto done;
 		err = -EINVAL;
 		if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPV6 ||
 		    p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
 			goto done;
 		if (p.iph.ttl)
 			p.iph.frag_off |= htons(IP_DF);
 		t = ipip6_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
 		if (dev != ipip6_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
 			if (t != NULL) {
 				if (t->dev != dev) {
 					err = -EEXIST;
 					break;
 				}
 			} else {
 				if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
 				    (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
 					err = -EINVAL;
 					break;
 				}
 				t = netdev_priv(dev);
 				ipip6_tunnel_unlink(t);
 				t->parms.iph.saddr = p.iph.saddr;
 				t->parms.iph.daddr = p.iph.daddr;
 				memcpy(dev->dev_addr, &p.iph.saddr, 4);
 				memcpy(dev->broadcast, &p.iph.daddr, 4);
 				ipip6_tunnel_link(t);
 				netdev_state_change(dev);
 			}
 		}
 		if (t) {
 			err = 0;
 			if (cmd == SIOCCHGTUNNEL) {
 				t->parms.iph.ttl = p.iph.ttl;
 				t->parms.iph.tos = p.iph.tos;
 			}
 			if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
 				err = -EFAULT;
 		} else
 			err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
 		break;
 	case SIOCDELTUNNEL:
 		err = -EPERM;
 		if (!capable(CAP_NET_ADMIN))
 			goto done;
 		if (dev == ipip6_fb_tunnel_dev) {
 			err = -EFAULT;
 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 				goto done;
 			err = -ENOENT;
 			if ((t = ipip6_tunnel_locate(&p, 0)) == NULL)
 				goto done;
 			err = -EPERM;
 			if (t == netdev_priv(ipip6_fb_tunnel_dev))
 				goto done;
 			dev = t->dev;
 		}
 		err = unregister_netdevice(dev);
 		break;
 	default:
 		err = -EINVAL;
 	}
 done:
 	return err;
 }
 static struct net_device_stats *ipip6_tunnel_get_stats(struct net_device *dev)
 {
 	return &(((struct ip_tunnel*)netdev_priv(dev))->stat);
 }
 static int ipip6_tunnel_change_mtu(struct net_device *dev, int new_mtu)
 {
 	if (new_mtu < IPV6_MIN_MTU || new_mtu > 0xFFF8 - sizeof(struct iphdr))
 		return -EINVAL;
 	dev->mtu = new_mtu;
 	return 0;
 }
 static void ipip6_tunnel_setup(struct net_device *dev)
 {
 	SET_MODULE_OWNER(dev);
 	dev->uninit		= ipip6_tunnel_uninit;
 	dev->destructor 	= free_netdev;
 	dev->hard_start_xmit	= ipip6_tunnel_xmit;
 	dev->get_stats		= ipip6_tunnel_get_stats;
 	dev->do_ioctl		= ipip6_tunnel_ioctl;
 	dev->change_mtu		= ipip6_tunnel_change_mtu;
 	dev->type		= ARPHRD_SIT;
 	dev->hard_header_len 	= LL_MAX_HEADER + sizeof(struct iphdr);
 	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr);
 	dev->flags		= IFF_NOARP;
 	dev->iflink		= 0;
 	dev->addr_len		= 4;
 }
 static int ipip6_tunnel_init(struct net_device *dev)
 {
 	struct net_device *tdev = NULL;
 	struct ip_tunnel *tunnel;
 	struct iphdr *iph;
 	tunnel = netdev_priv(dev);
 	iph = &tunnel->parms.iph;
 	tunnel->dev = dev;
 	strcpy(tunnel->parms.name, dev->name);
 	memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
 	memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
 	if (iph->daddr) {
 		struct flowi fl = { .nl_u = { .ip4_u =
 					      { .daddr = iph->daddr,
 						.saddr = iph->saddr,
 						.tos = RT_TOS(iph->tos) } },
 				    .oif = tunnel->parms.link,
 				    .proto = IPPROTO_IPV6 };
 		struct rtable *rt;
 		if (!ip_route_output_key(&rt, &fl)) {
 			tdev = rt->u.dst.dev;
 			ip_rt_put(rt);
 		}
 		dev->flags |= IFF_POINTOPOINT;
 	}
 	if (!tdev && tunnel->parms.link)
 		tdev = __dev_get_by_index(tunnel->parms.link);
 	if (tdev) {
 		dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
 		dev->mtu = tdev->mtu - sizeof(struct iphdr);
 		if (dev->mtu < IPV6_MIN_MTU)
 			dev->mtu = IPV6_MIN_MTU;
 	}
 	dev->iflink = tunnel->parms.link;
 	return 0;
 }
 static int __init ipip6_fb_tunnel_init(struct net_device *dev)
 {
 	struct ip_tunnel *tunnel = netdev_priv(dev);
 	struct iphdr *iph = &tunnel->parms.iph;
 	tunnel->dev = dev;
 	strcpy(tunnel->parms.name, dev->name);
 	iph->version		= 4;
 	iph->protocol		= IPPROTO_IPV6;
 	iph->ihl		= 5;
 	iph->ttl		= 64;
 	dev_hold(dev);
 	tunnels_wc[0]		= tunnel;
 	return 0;
 }
 static struct net_protocol sit_protocol = {
 	.handler	=	ipip6_rcv,
 	.err_handler	=	ipip6_err,
 };
 static void __exit sit_destroy_tunnels(void)
 {
 	int prio;
 	for (prio = 1; prio < 4; prio++) {
 		int h;
 		for (h = 0; h < HASH_SIZE; h++) {
 			struct ip_tunnel *t;
 			while ((t = tunnels[prio][h]) != NULL)
 				unregister_netdevice(t->dev);
 		}
 	}
 }
 void __exit sit_cleanup(void)
 {
 	inet_del_protocol(&sit_protocol, IPPROTO_IPV6);
 	rtnl_lock();
 	sit_destroy_tunnels();
 	unregister_netdevice(ipip6_fb_tunnel_dev);
 	rtnl_unlock();
 }
 int __init sit_init(void)
 {
 	int err;
 	printk(KERN_INFO "IPv6 over IPv4 tunneling driver\n");
 	if (inet_add_protocol(&sit_protocol, IPPROTO_IPV6) < 0) {
 		printk(KERN_INFO "sit init: Can't add protocol\n");
 		return -EAGAIN;
 	}
 	ipip6_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "sit0",
 					   ipip6_tunnel_setup);
 	if (!ipip6_fb_tunnel_dev) {
 		err = -ENOMEM;
 		goto err1;
 	}
 	ipip6_fb_tunnel_dev->init = ipip6_fb_tunnel_init;
 	if ((err =  register_netdev(ipip6_fb_tunnel_dev)))
 		goto err2;
  out:
 	return err;
  err2:
 	free_netdev(ipip6_fb_tunnel_dev);
  err1:
 	inet_del_protocol(&sit_protocol, IPPROTO_IPV6);
 	goto out;
 }