[net-next-2.6.git] / net / ipv6 / icmp.c

/*
 *	Internet Control Message Protocol (ICMPv6)
 *	Linux INET6 implementation
 *
 *	Authors:
 *	Pedro Roque		<roque@di.fc.ul.pt>
 *
 *	$Id: icmp.c,v 1.38 2002/02/08 03:57:19 davem Exp $
 *
 *	Based on net/ipv4/icmp.c
 *
 *	RFC 1885
 *
 *	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:
 *
 *	Andi Kleen		:	exception handling
 *	Andi Kleen			add rate limits. never reply to a icmp.
 *					add more length checks and other fixes.
 *	yoshfuji		:	ensure to sent parameter problem for
 *					fragments.
 *	YOSHIFUJI Hideaki @USAGI:	added sysctl for icmp rate limit.
 *	Randy Dunlap and
 *	YOSHIFUJI Hideaki @USAGI:	Per-interface statistics support
 *	Kazunori MIYAZAWA @USAGI:       change output process to use ip6_append_data
 */

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/skbuff.h>
#include <linux/init.h>

#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#endif

#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/icmpv6.h>

#include <net/ip.h>
#include <net/sock.h>

#include <net/ipv6.h>
#include <net/ip6_checksum.h>
#include <net/protocol.h>
#include <net/raw.h>
#include <net/rawv6.h>
#include <net/transp_v6.h>
#include <net/ip6_route.h>
#include <net/addrconf.h>
#include <net/icmp.h>

#include <asm/uaccess.h>
#include <asm/system.h>

DEFINE_SNMP_STAT(struct icmpv6_mib, icmpv6_statistics);

/*
 *	The ICMP socket(s). This is the most convenient way to flow control
 *	our ICMP output as well as maintain a clean interface throughout
 *	all layers. All Socketless IP sends will soon be gone.
 *
 *	On SMP we have one ICMP socket per-cpu.
 */
static DEFINE_PER_CPU(struct socket *, __icmpv6_socket) = NULL;
#define icmpv6_socket	__get_cpu_var(__icmpv6_socket)

static int icmpv6_rcv(struct sk_buff **pskb, unsigned int *nhoffp);

static struct inet6_protocol icmpv6_protocol = {
	.handler	=	icmpv6_rcv,
	.flags		=	INET6_PROTO_FINAL,
};

static __inline__ int icmpv6_xmit_lock(void)
{
	local_bh_disable();

	if (unlikely(!spin_trylock(&icmpv6_socket->sk->sk_lock.slock))) {
		/* This can happen if the output path (f.e. SIT or
		 * ip6ip6 tunnel) signals dst_link_failure() for an
		 * outgoing ICMP6 packet.
		 */
		local_bh_enable();
		return 1;
	}
	return 0;
}

static __inline__ void icmpv6_xmit_unlock(void)
{
	spin_unlock_bh(&icmpv6_socket->sk->sk_lock.slock);
}

/* 
 * Slightly more convenient version of icmpv6_send.
 */
void icmpv6_param_prob(struct sk_buff *skb, int code, int pos)
{
	icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos, skb->dev);
	kfree_skb(skb);
}

/*
 * Figure out, may we reply to this packet with icmp error.
 *
 * We do not reply, if:
 *	- it was icmp error message.
 *	- it is truncated, so that it is known, that protocol is ICMPV6
 *	  (i.e. in the middle of some exthdr)
 *
 *	--ANK (980726)
 */

static int is_ineligible(struct sk_buff *skb)
{
	int ptr = (u8*)(skb->nh.ipv6h+1) - skb->data;
	int len = skb->len - ptr;
	__u8 nexthdr = skb->nh.ipv6h->nexthdr;

	if (len < 0)
		return 1;

	ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr);
	if (ptr < 0)
		return 0;
	if (nexthdr == IPPROTO_ICMPV6) {
		u8 _type, *tp;
		tp = skb_header_pointer(skb,
			ptr+offsetof(struct icmp6hdr, icmp6_type),
			sizeof(_type), &_type);
		if (tp == NULL ||
		    !(*tp & ICMPV6_INFOMSG_MASK))
			return 1;
	}
	return 0;
}

static int sysctl_icmpv6_time = 1*HZ; 

/* 
 * Check the ICMP output rate limit 
 */
static inline int icmpv6_xrlim_allow(struct sock *sk, int type,
				     struct flowi *fl)
{
	struct dst_entry *dst;
	int res = 0;

	/* Informational messages are not limited. */
	if (type & ICMPV6_INFOMSG_MASK)
		return 1;

	/* Do not limit pmtu discovery, it would break it. */
	if (type == ICMPV6_PKT_TOOBIG)
		return 1;

	/* 
	 * Look up the output route.
	 * XXX: perhaps the expire for routing entries cloned by
	 * this lookup should be more aggressive (not longer than timeout).
	 */
	dst = ip6_route_output(sk, fl);
	if (dst->error) {
		IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
	} else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
		res = 1;
	} else {
		struct rt6_info *rt = (struct rt6_info *)dst;
		int tmo = sysctl_icmpv6_time;

		/* Give more bandwidth to wider prefixes. */
		if (rt->rt6i_dst.plen < 128)
			tmo >>= ((128 - rt->rt6i_dst.plen)>>5);

		res = xrlim_allow(dst, tmo);
	}
	dst_release(dst);
	return res;
}

/*
 *	an inline helper for the "simple" if statement below
 *	checks if parameter problem report is caused by an
 *	unrecognized IPv6 option that has the Option Type 
 *	highest-order two bits set to 10
 */

static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
{
	u8 _optval, *op;

	offset += skb->nh.raw - skb->data;
	op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
	if (op == NULL)
		return 1;
	return (*op & 0xC0) == 0x80;
}

static int icmpv6_push_pending_frames(struct sock *sk, struct flowi *fl, struct icmp6hdr *thdr, int len)
{
	struct sk_buff *skb;
	struct icmp6hdr *icmp6h;
	int err = 0;

	if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
		goto out;

	icmp6h = (struct icmp6hdr*) skb->h.raw;
	memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
	icmp6h->icmp6_cksum = 0;

	if (skb_queue_len(&sk->sk_write_queue) == 1) {
		skb->csum = csum_partial((char *)icmp6h,
					sizeof(struct icmp6hdr), skb->csum);
		icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
						      &fl->fl6_dst,
						      len, fl->proto,
						      skb->csum);
	} else {
		u32 tmp_csum = 0;

		skb_queue_walk(&sk->sk_write_queue, skb) {
			tmp_csum = csum_add(tmp_csum, skb->csum);
		}

		tmp_csum = csum_partial((char *)icmp6h,
					sizeof(struct icmp6hdr), tmp_csum);
		tmp_csum = csum_ipv6_magic(&fl->fl6_src,
					   &fl->fl6_dst,
					   len, fl->proto, tmp_csum);
		icmp6h->icmp6_cksum = tmp_csum;
	}
	if (icmp6h->icmp6_cksum == 0)
		icmp6h->icmp6_cksum = -1;
	ip6_push_pending_frames(sk);
out:
	return err;
}

struct icmpv6_msg {
	struct sk_buff	*skb;
	int		offset;
};

static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
{
	struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
	struct sk_buff *org_skb = msg->skb;
	__u32 csum = 0;

	csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
				      to, len, csum);
	skb->csum = csum_block_add(skb->csum, csum, odd);
	return 0;
}

/*
 *	Send an ICMP message in response to a packet in error
 */
void icmpv6_send(struct sk_buff *skb, int type, int code, __u32 info, 
		 struct net_device *dev)
{
	struct inet6_dev *idev = NULL;
	struct ipv6hdr *hdr = skb->nh.ipv6h;
	struct sock *sk;
	struct ipv6_pinfo *np;
	struct in6_addr *saddr = NULL;
	struct dst_entry *dst;
	struct icmp6hdr tmp_hdr;
	struct flowi fl;
	struct icmpv6_msg msg;
	int iif = 0;
	int addr_type = 0;
	int len;
	int hlimit;
	int err = 0;

	if ((u8*)hdr < skb->head || (u8*)(hdr+1) > skb->tail)
		return;

	/*
	 *	Make sure we respect the rules 
	 *	i.e. RFC 1885 2.4(e)
	 *	Rule (e.1) is enforced by not using icmpv6_send
	 *	in any code that processes icmp errors.
	 */
	addr_type = ipv6_addr_type(&hdr->daddr);

	if (ipv6_chk_addr(&hdr->daddr, skb->dev, 0))
		saddr = &hdr->daddr;

	/*
	 *	Dest addr check
	 */

	if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
		if (type != ICMPV6_PKT_TOOBIG &&
		    !(type == ICMPV6_PARAMPROB && 
		      code == ICMPV6_UNK_OPTION && 
		      (opt_unrec(skb, info))))
			return;

		saddr = NULL;
	}

	addr_type = ipv6_addr_type(&hdr->saddr);

	/*
	 *	Source addr check
	 */

	if (addr_type & IPV6_ADDR_LINKLOCAL)
		iif = skb->dev->ifindex;

	/*
	 *	Must not send if we know that source is Anycast also.
	 *	for now we don't know that.
	 */
	if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
		LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
		return;
	}

	/* 
	 *	Never answer to a ICMP packet.
	 */
	if (is_ineligible(skb)) {
		LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
		return;
	}

	memset(&fl, 0, sizeof(fl));
	fl.proto = IPPROTO_ICMPV6;
	ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
	if (saddr)
		ipv6_addr_copy(&fl.fl6_src, saddr);
	fl.oif = iif;
	fl.fl_icmp_type = type;
	fl.fl_icmp_code = code;

	if (icmpv6_xmit_lock())
		return;

	sk = icmpv6_socket->sk;
	np = inet6_sk(sk);

	if (!icmpv6_xrlim_allow(sk, type, &fl))
		goto out;

	tmp_hdr.icmp6_type = type;
	tmp_hdr.icmp6_code = code;
	tmp_hdr.icmp6_cksum = 0;
	tmp_hdr.icmp6_pointer = htonl(info);

	if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
		fl.oif = np->mcast_oif;

	err = ip6_dst_lookup(sk, &dst, &fl);
	if (err)
		goto out;
	if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
		goto out_dst_release;

	if (ipv6_addr_is_multicast(&fl.fl6_dst))
		hlimit = np->mcast_hops;
	else
		hlimit = np->hop_limit;
	if (hlimit < 0)
		hlimit = dst_metric(dst, RTAX_HOPLIMIT);
	if (hlimit < 0)
		hlimit = ipv6_get_hoplimit(dst->dev);

	msg.skb = skb;
	msg.offset = skb->nh.raw - skb->data;

	len = skb->len - msg.offset;
	len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
	if (len < 0) {
		LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
		goto out_dst_release;
	}

	idev = in6_dev_get(skb->dev);

	err = ip6_append_data(sk, icmpv6_getfrag, &msg,
			      len + sizeof(struct icmp6hdr),
			      sizeof(struct icmp6hdr),
			      hlimit, NULL, &fl, (struct rt6_info*)dst,
			      MSG_DONTWAIT);
	if (err) {
		ip6_flush_pending_frames(sk);
		goto out_put;
	}
	err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));

	if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
		ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_OUTDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
	ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);

out_put:
	if (likely(idev != NULL))
		in6_dev_put(idev);
out_dst_release:
	dst_release(dst);
out:
	icmpv6_xmit_unlock();
}

static void icmpv6_echo_reply(struct sk_buff *skb)
{
	struct sock *sk;
	struct inet6_dev *idev;
	struct ipv6_pinfo *np;
	struct in6_addr *saddr = NULL;
	struct icmp6hdr *icmph = (struct icmp6hdr *) skb->h.raw;
	struct icmp6hdr tmp_hdr;
	struct flowi fl;
	struct icmpv6_msg msg;
	struct dst_entry *dst;
	int err = 0;
	int hlimit;

	saddr = &skb->nh.ipv6h->daddr;

	if (!ipv6_unicast_destination(skb))
		saddr = NULL;

	memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
	tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;

	memset(&fl, 0, sizeof(fl));
	fl.proto = IPPROTO_ICMPV6;
	ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
	if (saddr)
		ipv6_addr_copy(&fl.fl6_src, saddr);
	fl.oif = skb->dev->ifindex;
	fl.fl_icmp_type = ICMPV6_ECHO_REPLY;

	if (icmpv6_xmit_lock())
		return;

	sk = icmpv6_socket->sk;
	np = inet6_sk(sk);

	if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
		fl.oif = np->mcast_oif;

	err = ip6_dst_lookup(sk, &dst, &fl);
	if (err)
		goto out;
	if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
		goto out_dst_release;

	if (ipv6_addr_is_multicast(&fl.fl6_dst))
		hlimit = np->mcast_hops;
	else
		hlimit = np->hop_limit;
	if (hlimit < 0)
		hlimit = dst_metric(dst, RTAX_HOPLIMIT);
	if (hlimit < 0)
		hlimit = ipv6_get_hoplimit(dst->dev);

	idev = in6_dev_get(skb->dev);

	msg.skb = skb;
	msg.offset = 0;

	err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
				sizeof(struct icmp6hdr), hlimit, NULL, &fl,
				(struct rt6_info*)dst, MSG_DONTWAIT);

	if (err) {
		ip6_flush_pending_frames(sk);
		goto out_put;
	}
	err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));

        ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTECHOREPLIES);
        ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);

out_put: 
	if (likely(idev != NULL))
		in6_dev_put(idev);
out_dst_release:
	dst_release(dst);
out: 
	icmpv6_xmit_unlock();
}

static void icmpv6_notify(struct sk_buff *skb, int type, int code, u32 info)
{
	struct in6_addr *saddr, *daddr;
	struct inet6_protocol *ipprot;
	struct sock *sk;
	int inner_offset;
	int hash;
	u8 nexthdr;

	if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
		return;

	nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
	if (ipv6_ext_hdr(nexthdr)) {
		/* now skip over extension headers */
		inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
		if (inner_offset<0)
			return;
	} else {
		inner_offset = sizeof(struct ipv6hdr);
	}

	/* Checkin header including 8 bytes of inner protocol header. */
	if (!pskb_may_pull(skb, inner_offset+8))
		return;

	saddr = &skb->nh.ipv6h->saddr;
	daddr = &skb->nh.ipv6h->daddr;

	/* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
	   Without this we will not able f.e. to make source routed
	   pmtu discovery.
	   Corresponding argument (opt) to notifiers is already added.
	   --ANK (980726)
	 */

	hash = nexthdr & (MAX_INET_PROTOS - 1);

	rcu_read_lock();
	ipprot = rcu_dereference(inet6_protos[hash]);
	if (ipprot && ipprot->err_handler)
		ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
	rcu_read_unlock();

	read_lock(&raw_v6_lock);
	if ((sk = sk_head(&raw_v6_htable[hash])) != NULL) {
		while((sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr,
					    skb->dev->ifindex))) {
			rawv6_err(sk, skb, NULL, type, code, inner_offset, info);
			sk = sk_next(sk);
		}
	}
	read_unlock(&raw_v6_lock);
}
  
/*
 *	Handle icmp messages
 */

static int icmpv6_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
{
	struct sk_buff *skb = *pskb;
	struct net_device *dev = skb->dev;
	struct inet6_dev *idev = __in6_dev_get(dev);
	struct in6_addr *saddr, *daddr;
	struct ipv6hdr *orig_hdr;
	struct icmp6hdr *hdr;
	int type;

	ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INMSGS);

	saddr = &skb->nh.ipv6h->saddr;
	daddr = &skb->nh.ipv6h->daddr;

	/* Perform checksum. */
	if (skb->ip_summed == CHECKSUM_HW) {
		skb->ip_summed = CHECKSUM_UNNECESSARY;
		if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
				    skb->csum)) {
			LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 hw checksum failed\n");
			skb->ip_summed = CHECKSUM_NONE;
		}
	}
	if (skb->ip_summed == CHECKSUM_NONE) {
		if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
				    skb_checksum(skb, 0, skb->len, 0))) {
			LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x > %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x]\n",
				       NIP6(*saddr), NIP6(*daddr));
			goto discard_it;
		}
	}

	if (!pskb_pull(skb, sizeof(struct icmp6hdr)))
		goto discard_it;

	hdr = (struct icmp6hdr *) skb->h.raw;

	type = hdr->icmp6_type;

	if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
		ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
	else if (type >= ICMPV6_ECHO_REQUEST && type <= NDISC_REDIRECT)
		ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INECHOS, type - ICMPV6_ECHO_REQUEST);

	switch (type) {
	case ICMPV6_ECHO_REQUEST:
		icmpv6_echo_reply(skb);
		break;

	case ICMPV6_ECHO_REPLY:
		/* we couldn't care less */
		break;

	case ICMPV6_PKT_TOOBIG:
		/* BUGGG_FUTURE: if packet contains rthdr, we cannot update
		   standard destination cache. Seems, only "advanced"
		   destination cache will allow to solve this problem
		   --ANK (980726)
		 */
		if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
			goto discard_it;
		hdr = (struct icmp6hdr *) skb->h.raw;
		orig_hdr = (struct ipv6hdr *) (hdr + 1);
		rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
				   ntohl(hdr->icmp6_mtu));

		/*
		 *	Drop through to notify
		 */

	case ICMPV6_DEST_UNREACH:
	case ICMPV6_TIME_EXCEED:
	case ICMPV6_PARAMPROB:
		icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
		break;

	case NDISC_ROUTER_SOLICITATION:
	case NDISC_ROUTER_ADVERTISEMENT:
	case NDISC_NEIGHBOUR_SOLICITATION:
	case NDISC_NEIGHBOUR_ADVERTISEMENT:
	case NDISC_REDIRECT:
		ndisc_rcv(skb);
		break;

	case ICMPV6_MGM_QUERY:
		igmp6_event_query(skb);
		break;

	case ICMPV6_MGM_REPORT:
		igmp6_event_report(skb);
		break;

	case ICMPV6_MGM_REDUCTION:
	case ICMPV6_NI_QUERY:
	case ICMPV6_NI_REPLY:
	case ICMPV6_MLD2_REPORT:
	case ICMPV6_DHAAD_REQUEST:
	case ICMPV6_DHAAD_REPLY:
	case ICMPV6_MOBILE_PREFIX_SOL:
	case ICMPV6_MOBILE_PREFIX_ADV:
		break;

	default:
		LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");

		/* informational */
		if (type & ICMPV6_INFOMSG_MASK)
			break;

		/* 
		 * error of unknown type. 
		 * must pass to upper level 
		 */

		icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
	};
	kfree_skb(skb);
	return 0;

discard_it:
	ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
	kfree_skb(skb);
	return 0;
}

int __init icmpv6_init(struct net_proto_family *ops)
{
	struct sock *sk;
	int err, i, j;

	for (i = 0; i < NR_CPUS; i++) {
		if (!cpu_possible(i))
			continue;

		err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6,
				       &per_cpu(__icmpv6_socket, i));
		if (err < 0) {
			printk(KERN_ERR
			       "Failed to initialize the ICMP6 control socket "
			       "(err %d).\n",
			       err);
			goto fail;
		}

		sk = per_cpu(__icmpv6_socket, i)->sk;
		sk->sk_allocation = GFP_ATOMIC;

		/* Enough space for 2 64K ICMP packets, including
		 * sk_buff struct overhead.
		 */
		sk->sk_sndbuf =
			(2 * ((64 * 1024) + sizeof(struct sk_buff)));

		sk->sk_prot->unhash(sk);
	}


	if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) {
		printk(KERN_ERR "Failed to register ICMP6 protocol\n");
		err = -EAGAIN;
		goto fail;
	}

	return 0;

 fail:
	for (j = 0; j < i; j++) {
		if (!cpu_possible(j))
			continue;
		sock_release(per_cpu(__icmpv6_socket, j));
	}

	return err;
}

void icmpv6_cleanup(void)
{
	int i;

	for (i = 0; i < NR_CPUS; i++) {
		if (!cpu_possible(i))
			continue;
		sock_release(per_cpu(__icmpv6_socket, i));
	}
	inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
}

static struct icmp6_err {
	int err;
	int fatal;
} tab_unreach[] = {
	{	/* NOROUTE */
		.err	= ENETUNREACH,
		.fatal	= 0,
	},
	{	/* ADM_PROHIBITED */
		.err	= EACCES,
		.fatal	= 1,
	},
	{	/* Was NOT_NEIGHBOUR, now reserved */
		.err	= EHOSTUNREACH,
		.fatal	= 0,
	},
	{	/* ADDR_UNREACH	*/
		.err	= EHOSTUNREACH,
		.fatal	= 0,
	},
	{	/* PORT_UNREACH	*/
		.err	= ECONNREFUSED,
		.fatal	= 1,
	},
};

int icmpv6_err_convert(int type, int code, int *err)
{
	int fatal = 0;

	*err = EPROTO;

	switch (type) {
	case ICMPV6_DEST_UNREACH:
		fatal = 1;
		if (code <= ICMPV6_PORT_UNREACH) {
			*err  = tab_unreach[code].err;
			fatal = tab_unreach[code].fatal;
		}
		break;

	case ICMPV6_PKT_TOOBIG:
		*err = EMSGSIZE;
		break;
		
	case ICMPV6_PARAMPROB:
		*err = EPROTO;
		fatal = 1;
		break;

	case ICMPV6_TIME_EXCEED:
		*err = EHOSTUNREACH;
		break;
	};

	return fatal;
}

#ifdef CONFIG_SYSCTL
ctl_table ipv6_icmp_table[] = {
	{
		.ctl_name	= NET_IPV6_ICMP_RATELIMIT,
		.procname	= "ratelimit",
		.data		= &sysctl_icmpv6_time,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= &proc_dointvec
	},
	{ .ctl_name = 0 },
};
#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Internet Control Message Protocol (ICMPv6)
	3	* Linux INET6 implementation
	4	*
	5	* Authors:
	6	* Pedro Roque <roque@di.fc.ul.pt>
	7	*
	8	* $Id: icmp.c,v 1.38 2002/02/08 03:57:19 davem Exp $
	9	*
	10	* Based on net/ipv4/icmp.c
	11	*
	12	* RFC 1885
	13	*
	14	* This program is free software; you can redistribute it and/or
	15	* modify it under the terms of the GNU General Public License
	16	* as published by the Free Software Foundation; either version
	17	* 2 of the License, or (at your option) any later version.
	18	*/
	19
	20	/*
	21	* Changes:
	22	*
	23	* Andi Kleen : exception handling
	24	* Andi Kleen add rate limits. never reply to a icmp.
	25	* add more length checks and other fixes.
	26	* yoshfuji : ensure to sent parameter problem for
	27	* fragments.
	28	* YOSHIFUJI Hideaki @USAGI: added sysctl for icmp rate limit.
	29	* Randy Dunlap and
	30	* YOSHIFUJI Hideaki @USAGI: Per-interface statistics support
	31	* Kazunori MIYAZAWA @USAGI: change output process to use ip6_append_data
	32	*/
	33
	34	#include <linux/module.h>
	35	#include <linux/errno.h>
	36	#include <linux/types.h>
	37	#include <linux/socket.h>
	38	#include <linux/in.h>
	39	#include <linux/kernel.h>
	40	#include <linux/sched.h>
	41	#include <linux/sockios.h>
	42	#include <linux/net.h>
	43	#include <linux/skbuff.h>
	44	#include <linux/init.h>
	45
	46	#ifdef CONFIG_SYSCTL
	47	#include <linux/sysctl.h>
	48	#endif
	49
	50	#include <linux/inet.h>
	51	#include <linux/netdevice.h>
	52	#include <linux/icmpv6.h>
	53
	54	#include <net/ip.h>
	55	#include <net/sock.h>
	56
	57	#include <net/ipv6.h>
	58	#include <net/ip6_checksum.h>
	59	#include <net/protocol.h>
	60	#include <net/raw.h>
	61	#include <net/rawv6.h>
	62	#include <net/transp_v6.h>
	63	#include <net/ip6_route.h>
	64	#include <net/addrconf.h>
65	#include <net/icmp.h>
66
67	#include <asm/uaccess.h>
68	#include <asm/system.h>
69
70	DEFINE_SNMP_STAT(struct icmpv6_mib, icmpv6_statistics);
71
72	/*
73	* The ICMP socket(s). This is the most convenient way to flow control
74	* our ICMP output as well as maintain a clean interface throughout
75	* all layers. All Socketless IP sends will soon be gone.
76	*
77	* On SMP we have one ICMP socket per-cpu.
78	*/
79	static DEFINE_PER_CPU(struct socket *, __icmpv6_socket) = NULL;
80	#define icmpv6_socket __get_cpu_var(__icmpv6_socket)
81
82	static int icmpv6_rcv(struct sk_buff *pskb, unsigned int nhoffp);
83
84	static struct inet6_protocol icmpv6_protocol = {
85	.handler = icmpv6_rcv,
86	.flags = INET6_PROTO_FINAL,
87	};
88
89	static __inline__ int icmpv6_xmit_lock(void)
90	{
91	local_bh_disable();
92
93	if (unlikely(!spin_trylock(&icmpv6_socket->sk->sk_lock.slock))) {
94	/* This can happen if the output path (f.e. SIT or
95	* ip6ip6 tunnel) signals dst_link_failure() for an
96	* outgoing ICMP6 packet.
97	*/
98	local_bh_enable();
99	return 1;
100	}
101	return 0;
102	}
103
104	static __inline__ void icmpv6_xmit_unlock(void)
105	{
106	spin_unlock_bh(&icmpv6_socket->sk->sk_lock.slock);
107	}
108
109	/*
110	* Slightly more convenient version of icmpv6_send.
111	*/
112	void icmpv6_param_prob(struct sk_buff *skb, int code, int pos)
113	{
114	icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos, skb->dev);
115	kfree_skb(skb);
116	}
117
118	/*
119	* Figure out, may we reply to this packet with icmp error.
120	*
121	* We do not reply, if:
122	* - it was icmp error message.
123	* - it is truncated, so that it is known, that protocol is ICMPV6
124	* (i.e. in the middle of some exthdr)
125	*
126	* --ANK (980726)
127	*/
128
129	static int is_ineligible(struct sk_buff *skb)
130	{
131	int ptr = (u8*)(skb->nh.ipv6h+1) - skb->data;
132	int len = skb->len - ptr;
133	__u8 nexthdr = skb->nh.ipv6h->nexthdr;
134
135	if (len < 0)
136	return 1;
137
0d3d077c	138	ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr);
1da177e4 LT	139	if (ptr < 0)
	140	return 0;
	141	if (nexthdr == IPPROTO_ICMPV6) {
	142	u8 _type, *tp;
	143	tp = skb_header_pointer(skb,
	144	ptr+offsetof(struct icmp6hdr, icmp6_type),
	145	sizeof(_type), &_type);
	146	if (tp == NULL \|\|
	147	!(*tp & ICMPV6_INFOMSG_MASK))
	148	return 1;
	149	}
	150	return 0;
	151	}
	152
	153	static int sysctl_icmpv6_time = 1*HZ;
	154
	155	/*
	156	* Check the ICMP output rate limit
	157	*/
	158	static inline int icmpv6_xrlim_allow(struct sock *sk, int type,
	159	struct flowi *fl)
	160	{
	161	struct dst_entry *dst;
	162	int res = 0;
	163
	164	/* Informational messages are not limited. */
	165	if (type & ICMPV6_INFOMSG_MASK)
	166	return 1;
	167
	168	/* Do not limit pmtu discovery, it would break it. */
	169	if (type == ICMPV6_PKT_TOOBIG)
	170	return 1;
	171
	172	/*
	173	* Look up the output route.
	174	* XXX: perhaps the expire for routing entries cloned by
	175	* this lookup should be more aggressive (not longer than timeout).
	176	*/
	177	dst = ip6_route_output(sk, fl);
	178	if (dst->error) {
	179	IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
	180	} else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
	181	res = 1;
	182	} else {
	183	struct rt6_info rt = (struct rt6_info )dst;
	184	int tmo = sysctl_icmpv6_time;
	185
	186	/* Give more bandwidth to wider prefixes. */
	187	if (rt->rt6i_dst.plen < 128)
	188	tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
	189
	190	res = xrlim_allow(dst, tmo);
	191	}
	192	dst_release(dst);
	193	return res;
	194	}
	195
	196	/*
	197	* an inline helper for the "simple" if statement below
	198	* checks if parameter problem report is caused by an
	199	* unrecognized IPv6 option that has the Option Type
	200	* highest-order two bits set to 10
	201	*/
	202
203	static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
204	{
205	u8 _optval, *op;
206
207	offset += skb->nh.raw - skb->data;
208	op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
209	if (op == NULL)
210	return 1;
211	return (*op & 0xC0) == 0x80;
212	}
213
214	static int icmpv6_push_pending_frames(struct sock sk, struct flowi fl, struct icmp6hdr *thdr, int len)
215	{
216	struct sk_buff *skb;
217	struct icmp6hdr *icmp6h;
218	int err = 0;
219
220	if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
221	goto out;
222
223	icmp6h = (struct icmp6hdr*) skb->h.raw;
224	memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
225	icmp6h->icmp6_cksum = 0;
226
227	if (skb_queue_len(&sk->sk_write_queue) == 1) {
228	skb->csum = csum_partial((char *)icmp6h,
229	sizeof(struct icmp6hdr), skb->csum);
230	icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
231	&fl->fl6_dst,
232	len, fl->proto,
233	skb->csum);
234	} else {
235	u32 tmp_csum = 0;
236
237	skb_queue_walk(&sk->sk_write_queue, skb) {
238	tmp_csum = csum_add(tmp_csum, skb->csum);
239	}
240
241	tmp_csum = csum_partial((char *)icmp6h,
242	sizeof(struct icmp6hdr), tmp_csum);
243	tmp_csum = csum_ipv6_magic(&fl->fl6_src,
244	&fl->fl6_dst,
245	len, fl->proto, tmp_csum);
246	icmp6h->icmp6_cksum = tmp_csum;
247	}
248	if (icmp6h->icmp6_cksum == 0)
249	icmp6h->icmp6_cksum = -1;
250	ip6_push_pending_frames(sk);
251	out:
252	return err;
253	}
254
255	struct icmpv6_msg {
256	struct sk_buff *skb;
257	int offset;
258	};
259
260	static int icmpv6_getfrag(void from, char to, int offset, int len, int odd, struct sk_buff *skb)
261	{
262	struct icmpv6_msg msg = (struct icmpv6_msg ) from;
263	struct sk_buff *org_skb = msg->skb;
264	__u32 csum = 0;
265
266	csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
267	to, len, csum);
268	skb->csum = csum_block_add(skb->csum, csum, odd);
269	return 0;
270	}
271
272	/*
273	* Send an ICMP message in response to a packet in error
274	*/
275	void icmpv6_send(struct sk_buff *skb, int type, int code, __u32 info,
276	struct net_device *dev)
277	{
278	struct inet6_dev *idev = NULL;
279	struct ipv6hdr *hdr = skb->nh.ipv6h;
84427d53 YH	280	struct sock *sk;
84427d53 YH	281	struct ipv6_pinfo *np;
1da177e4 LT	282	struct in6_addr *saddr = NULL;
	283	struct dst_entry *dst;
	284	struct icmp6hdr tmp_hdr;
	285	struct flowi fl;
	286	struct icmpv6_msg msg;
	287	int iif = 0;
	288	int addr_type = 0;
	289	int len;
	290	int hlimit;
	291	int err = 0;
	292
	293	if ((u8)hdr < skb->head \|\| (u8)(hdr+1) > skb->tail)
	294	return;
	295
	296	/*
	297	* Make sure we respect the rules
	298	* i.e. RFC 1885 2.4(e)
	299	* Rule (e.1) is enforced by not using icmpv6_send
	300	* in any code that processes icmp errors.
	301	*/
	302	addr_type = ipv6_addr_type(&hdr->daddr);
	303
	304	if (ipv6_chk_addr(&hdr->daddr, skb->dev, 0))
	305	saddr = &hdr->daddr;
	306
	307	/*
	308	* Dest addr check
	309	*/
	310
	311	if ((addr_type & IPV6_ADDR_MULTICAST \|\| skb->pkt_type != PACKET_HOST)) {
	312	if (type != ICMPV6_PKT_TOOBIG &&
	313	!(type == ICMPV6_PARAMPROB &&
	314	code == ICMPV6_UNK_OPTION &&
	315	(opt_unrec(skb, info))))
	316	return;
	317
	318	saddr = NULL;
	319	}
	320
	321	addr_type = ipv6_addr_type(&hdr->saddr);
	322
	323	/*
	324	* Source addr check
	325	*/
	326
	327	if (addr_type & IPV6_ADDR_LINKLOCAL)
	328	iif = skb->dev->ifindex;
	329
	330	/*
	331	* Must not send if we know that source is Anycast also.
	332	* for now we don't know that.
	333	*/
	334	if ((addr_type == IPV6_ADDR_ANY) \|\| (addr_type & IPV6_ADDR_MULTICAST)) {
64ce2073	335	LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
1da177e4 LT	336	return;
	337	}
	338
	339	/*
	340	* Never answer to a ICMP packet.
	341	*/
	342	if (is_ineligible(skb)) {
64ce2073	343	LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
1da177e4 LT	344	return;
	345	}
	346
	347	memset(&fl, 0, sizeof(fl));
	348	fl.proto = IPPROTO_ICMPV6;
	349	ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
	350	if (saddr)
	351	ipv6_addr_copy(&fl.fl6_src, saddr);
	352	fl.oif = iif;
	353	fl.fl_icmp_type = type;
	354	fl.fl_icmp_code = code;
	355
	356	if (icmpv6_xmit_lock())
	357	return;
	358
84427d53 YH	359	sk = icmpv6_socket->sk;
	360	np = inet6_sk(sk);
	361
1da177e4 LT	362	if (!icmpv6_xrlim_allow(sk, type, &fl))
	363	goto out;
	364
	365	tmp_hdr.icmp6_type = type;
	366	tmp_hdr.icmp6_code = code;
	367	tmp_hdr.icmp6_cksum = 0;
	368	tmp_hdr.icmp6_pointer = htonl(info);
	369
	370	if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
	371	fl.oif = np->mcast_oif;
	372
	373	err = ip6_dst_lookup(sk, &dst, &fl);
	374	if (err)
	375	goto out;
	376	if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
	377	goto out_dst_release;
	378
	379	if (ipv6_addr_is_multicast(&fl.fl6_dst))
	380	hlimit = np->mcast_hops;
	381	else
	382	hlimit = np->hop_limit;
	383	if (hlimit < 0)
	384	hlimit = dst_metric(dst, RTAX_HOPLIMIT);
	385	if (hlimit < 0)
	386	hlimit = ipv6_get_hoplimit(dst->dev);
	387
	388	msg.skb = skb;
	389	msg.offset = skb->nh.raw - skb->data;
	390
	391	len = skb->len - msg.offset;
	392	len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
	393	if (len < 0) {
64ce2073	394	LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
1da177e4 LT	395	goto out_dst_release;
	396	}
	397
	398	idev = in6_dev_get(skb->dev);
	399
	400	err = ip6_append_data(sk, icmpv6_getfrag, &msg,
	401	len + sizeof(struct icmp6hdr),
	402	sizeof(struct icmp6hdr),
	403	hlimit, NULL, &fl, (struct rt6_info*)dst,
	404	MSG_DONTWAIT);
	405	if (err) {
	406	ip6_flush_pending_frames(sk);
	407	goto out_put;
	408	}
	409	err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
	410
	411	if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
	412	ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_OUTDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
	413	ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
	414
	415	out_put:
	416	if (likely(idev != NULL))
	417	in6_dev_put(idev);
	418	out_dst_release:
	419	dst_release(dst);
	420	out:
	421	icmpv6_xmit_unlock();
	422	}
	423
	424	static void icmpv6_echo_reply(struct sk_buff *skb)
	425	{
84427d53	426	struct sock *sk;
1da177e4	427	struct inet6_dev *idev;
84427d53	428	struct ipv6_pinfo *np;
1da177e4 LT	429	struct in6_addr *saddr = NULL;
	430	struct icmp6hdr icmph = (struct icmp6hdr ) skb->h.raw;
	431	struct icmp6hdr tmp_hdr;
	432	struct flowi fl;
	433	struct icmpv6_msg msg;
	434	struct dst_entry *dst;
	435	int err = 0;
	436	int hlimit;
	437
	438	saddr = &skb->nh.ipv6h->daddr;
	439
	440	if (!ipv6_unicast_destination(skb))
	441	saddr = NULL;
	442
	443	memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
	444	tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
	445
	446	memset(&fl, 0, sizeof(fl));
	447	fl.proto = IPPROTO_ICMPV6;
	448	ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
	449	if (saddr)
	450	ipv6_addr_copy(&fl.fl6_src, saddr);
	451	fl.oif = skb->dev->ifindex;
	452	fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
	453
	454	if (icmpv6_xmit_lock())
	455	return;
	456
84427d53 YH	457	sk = icmpv6_socket->sk;
	458	np = inet6_sk(sk);
	459
1da177e4 LT	460	if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
	461	fl.oif = np->mcast_oif;
	462
	463	err = ip6_dst_lookup(sk, &dst, &fl);
	464	if (err)
	465	goto out;
	466	if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
	467	goto out_dst_release;
	468
	469	if (ipv6_addr_is_multicast(&fl.fl6_dst))
	470	hlimit = np->mcast_hops;
	471	else
	472	hlimit = np->hop_limit;
	473	if (hlimit < 0)
	474	hlimit = dst_metric(dst, RTAX_HOPLIMIT);
	475	if (hlimit < 0)
	476	hlimit = ipv6_get_hoplimit(dst->dev);
	477
	478	idev = in6_dev_get(skb->dev);
	479
	480	msg.skb = skb;
	481	msg.offset = 0;
	482
	483	err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
	484	sizeof(struct icmp6hdr), hlimit, NULL, &fl,
	485	(struct rt6_info*)dst, MSG_DONTWAIT);
	486
	487	if (err) {
	488	ip6_flush_pending_frames(sk);
	489	goto out_put;
	490	}
	491	err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
	492
	493	ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTECHOREPLIES);
	494	ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
	495
	496	out_put:
	497	if (likely(idev != NULL))
	498	in6_dev_put(idev);
	499	out_dst_release:
	500	dst_release(dst);
	501	out:
	502	icmpv6_xmit_unlock();
	503	}
	504
	505	static void icmpv6_notify(struct sk_buff *skb, int type, int code, u32 info)
	506	{
	507	struct in6_addr saddr, daddr;
	508	struct inet6_protocol *ipprot;
	509	struct sock *sk;
	510	int inner_offset;
	511	int hash;
	512	u8 nexthdr;
	513
	514	if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
	515	return;
	516
	517	nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
	518	if (ipv6_ext_hdr(nexthdr)) {
	519	/* now skip over extension headers */
0d3d077c	520	inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
1da177e4 LT	521	if (inner_offset<0)
	522	return;
	523	} else {
	524	inner_offset = sizeof(struct ipv6hdr);
	525	}
	526
	527	/* Checkin header including 8 bytes of inner protocol header. */
	528	if (!pskb_may_pull(skb, inner_offset+8))
	529	return;
	530
	531	saddr = &skb->nh.ipv6h->saddr;
	532	daddr = &skb->nh.ipv6h->daddr;
	533
	534	/* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
	535	Without this we will not able f.e. to make source routed
	536	pmtu discovery.
	537	Corresponding argument (opt) to notifiers is already added.
	538	--ANK (980726)
	539	*/
	540
	541	hash = nexthdr & (MAX_INET_PROTOS - 1);
	542
	543	rcu_read_lock();
	544	ipprot = rcu_dereference(inet6_protos[hash]);
	545	if (ipprot && ipprot->err_handler)
	546	ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
	547	rcu_read_unlock();
	548
	549	read_lock(&raw_v6_lock);
	550	if ((sk = sk_head(&raw_v6_htable[hash])) != NULL) {
0bd1b59b AM	551	while((sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr,
0bd1b59b AM	552	skb->dev->ifindex))) {
1da177e4 LT	553	rawv6_err(sk, skb, NULL, type, code, inner_offset, info);
	554	sk = sk_next(sk);
	555	}
	556	}
	557	read_unlock(&raw_v6_lock);
	558	}
	559
	560	/*
	561	* Handle icmp messages
	562	*/
	563
	564	static int icmpv6_rcv(struct sk_buff *pskb, unsigned int nhoffp)
	565	{
	566	struct sk_buff skb = pskb;
	567	struct net_device *dev = skb->dev;
	568	struct inet6_dev *idev = __in6_dev_get(dev);
	569	struct in6_addr saddr, daddr;
	570	struct ipv6hdr *orig_hdr;
	571	struct icmp6hdr *hdr;
	572	int type;
	573
	574	ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INMSGS);
	575
	576	saddr = &skb->nh.ipv6h->saddr;
	577	daddr = &skb->nh.ipv6h->daddr;
	578
	579	/* Perform checksum. */
	580	if (skb->ip_summed == CHECKSUM_HW) {
	581	skb->ip_summed = CHECKSUM_UNNECESSARY;
	582	if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
	583	skb->csum)) {
64ce2073	584	LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 hw checksum failed\n");
1da177e4 LT	585	skb->ip_summed = CHECKSUM_NONE;
	586	}
	587	}
	588	if (skb->ip_summed == CHECKSUM_NONE) {
	589	if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
	590	skb_checksum(skb, 0, skb->len, 0))) {
64ce2073 PM	591	LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x > %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x]\n",
64ce2073 PM	592	NIP6(saddr), NIP6(daddr));
1da177e4 LT	593	goto discard_it;
	594	}
	595	}
	596
	597	if (!pskb_pull(skb, sizeof(struct icmp6hdr)))
	598	goto discard_it;
	599
	600	hdr = (struct icmp6hdr *) skb->h.raw;
	601
	602	type = hdr->icmp6_type;
	603
	604	if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
	605	ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
	606	else if (type >= ICMPV6_ECHO_REQUEST && type <= NDISC_REDIRECT)
	607	ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INECHOS, type - ICMPV6_ECHO_REQUEST);
	608
	609	switch (type) {
	610	case ICMPV6_ECHO_REQUEST:
	611	icmpv6_echo_reply(skb);
	612	break;
	613
	614	case ICMPV6_ECHO_REPLY:
	615	/* we couldn't care less */
	616	break;
	617
	618	case ICMPV6_PKT_TOOBIG:
	619	/* BUGGG_FUTURE: if packet contains rthdr, we cannot update
	620	standard destination cache. Seems, only "advanced"
	621	destination cache will allow to solve this problem
	622	--ANK (980726)
	623	*/
	624	if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
	625	goto discard_it;
	626	hdr = (struct icmp6hdr *) skb->h.raw;
	627	orig_hdr = (struct ipv6hdr *) (hdr + 1);
	628	rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
	629	ntohl(hdr->icmp6_mtu));
	630
	631	/*
	632	* Drop through to notify
	633	*/
	634
	635	case ICMPV6_DEST_UNREACH:
	636	case ICMPV6_TIME_EXCEED:
	637	case ICMPV6_PARAMPROB:
	638	icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
	639	break;
	640
	641	case NDISC_ROUTER_SOLICITATION:
	642	case NDISC_ROUTER_ADVERTISEMENT:
	643	case NDISC_NEIGHBOUR_SOLICITATION:
	644	case NDISC_NEIGHBOUR_ADVERTISEMENT:
	645	case NDISC_REDIRECT:
	646	ndisc_rcv(skb);
	647	break;
	648
	649	case ICMPV6_MGM_QUERY:
	650	igmp6_event_query(skb);
	651	break;
	652
	653	case ICMPV6_MGM_REPORT:
	654	igmp6_event_report(skb);
	655	break;
	656
657	case ICMPV6_MGM_REDUCTION:
658	case ICMPV6_NI_QUERY:
659	case ICMPV6_NI_REPLY:
660	case ICMPV6_MLD2_REPORT:
661	case ICMPV6_DHAAD_REQUEST:
662	case ICMPV6_DHAAD_REPLY:
663	case ICMPV6_MOBILE_PREFIX_SOL:
664	case ICMPV6_MOBILE_PREFIX_ADV:
665	break;
666
667	default:
64ce2073	668	LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
1da177e4 LT	669
	670	/* informational */
	671	if (type & ICMPV6_INFOMSG_MASK)
	672	break;
	673
	674	/*
	675	* error of unknown type.
	676	* must pass to upper level
	677	*/
	678
	679	icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
	680	};
	681	kfree_skb(skb);
	682	return 0;
	683
	684	discard_it:
	685	ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
	686	kfree_skb(skb);
	687	return 0;
	688	}
	689
	690	int __init icmpv6_init(struct net_proto_family *ops)
	691	{
	692	struct sock *sk;
	693	int err, i, j;
	694
	695	for (i = 0; i < NR_CPUS; i++) {
	696	if (!cpu_possible(i))
	697	continue;
	698
	699	err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6,
	700	&per_cpu(__icmpv6_socket, i));
	701	if (err < 0) {
	702	printk(KERN_ERR
	703	"Failed to initialize the ICMP6 control socket "
	704	"(err %d).\n",
	705	err);
	706	goto fail;
	707	}
	708
	709	sk = per_cpu(__icmpv6_socket, i)->sk;
	710	sk->sk_allocation = GFP_ATOMIC;
	711
	712	/* Enough space for 2 64K ICMP packets, including
	713	* sk_buff struct overhead.
	714	*/
	715	sk->sk_sndbuf =
	716	(2 * ((64 * 1024) + sizeof(struct sk_buff)));
	717
	718	sk->sk_prot->unhash(sk);
	719	}
	720
	721
	722	if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) {
	723	printk(KERN_ERR "Failed to register ICMP6 protocol\n");
	724	err = -EAGAIN;
	725	goto fail;
	726	}
	727
	728	return 0;
	729
	730	fail:
	731	for (j = 0; j < i; j++) {
	732	if (!cpu_possible(j))
733	continue;
734	sock_release(per_cpu(__icmpv6_socket, j));
735	}
736
737	return err;
738	}
739
740	void icmpv6_cleanup(void)
741	{
742	int i;
743
744	for (i = 0; i < NR_CPUS; i++) {
745	if (!cpu_possible(i))
746	continue;
747	sock_release(per_cpu(__icmpv6_socket, i));
748	}
749	inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
750	}
751
752	static struct icmp6_err {
753	int err;
754	int fatal;
755	} tab_unreach[] = {
756	{ /* NOROUTE */
757	.err = ENETUNREACH,
758	.fatal = 0,
759	},
760	{ /* ADM_PROHIBITED */
761	.err = EACCES,
762	.fatal = 1,
763	},
764	{ /* Was NOT_NEIGHBOUR, now reserved */
765	.err = EHOSTUNREACH,
766	.fatal = 0,
767	},
768	{ /* ADDR_UNREACH */
769	.err = EHOSTUNREACH,
770	.fatal = 0,
771	},
772	{ /* PORT_UNREACH */
773	.err = ECONNREFUSED,
774	.fatal = 1,
775	},
776	};
777
778	int icmpv6_err_convert(int type, int code, int *err)
779	{
780	int fatal = 0;
781
782	*err = EPROTO;
783
784	switch (type) {
785	case ICMPV6_DEST_UNREACH:
786	fatal = 1;
787	if (code <= ICMPV6_PORT_UNREACH) {
788	*err = tab_unreach[code].err;
789	fatal = tab_unreach[code].fatal;
790	}
791	break;
792
793	case ICMPV6_PKT_TOOBIG:
794	*err = EMSGSIZE;
795	break;
796
797	case ICMPV6_PARAMPROB:
798	*err = EPROTO;
799	fatal = 1;
800	break;
801
802	case ICMPV6_TIME_EXCEED:
803	*err = EHOSTUNREACH;
804	break;
805	};
806
807	return fatal;
808	}
809
810	#ifdef CONFIG_SYSCTL
811	ctl_table ipv6_icmp_table[] = {
812	{
813	.ctl_name = NET_IPV6_ICMP_RATELIMIT,
814	.procname = "ratelimit",
815	.data = &sysctl_icmpv6_time,
816	.maxlen = sizeof(int),
817	.mode = 0644,
818	.proc_handler = &proc_dointvec
819	},
820	{ .ctl_name = 0 },
821	};
822	#endif
823