/*

 * 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 User Datagram Protocol (UDP).

 *

 * Authors:	Ross Biro

 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>

 *		Arnt Gulbrandsen, <agulbra@nvg.unit.no>

 *		Alan Cox, <alan@lxorguk.ukuu.org.uk>

 *		Hirokazu Takahashi, <taka@valinux.co.jp>

 *

 * Fixes:

 *		Alan Cox	:	verify_area() calls

 *		Alan Cox	: 	stopped close while in use off icmp

 *					messages. Not a fix but a botch that

 *					for udp at least is 'valid'.

 *		Alan Cox	:	Fixed icmp handling properly

 *		Alan Cox	: 	Correct error for oversized datagrams

 *		Alan Cox	:	Tidied select() semantics.

 *		Alan Cox	:	udp_err() fixed properly, also now

 *					select and read wake correctly on errors

 *		Alan Cox	:	udp_send verify_area moved to avoid mem leak

 *		Alan Cox	:	UDP can count its memory

 *		Alan Cox	:	send to an unknown connection causes

 *					an ECONNREFUSED off the icmp, but

 *					does NOT close.

 *		Alan Cox	:	Switched to new sk_buff handlers. No more backlog!

 *		Alan Cox	:	Using generic datagram code. Even smaller and the PEEK

 *					bug no longer crashes it.

 *		Fred Van Kempen	: 	Net2e support for sk->broadcast.

 *		Alan Cox	:	Uses skb_free_datagram

 *		Alan Cox	:	Added get/set sockopt support.

 *		Alan Cox	:	Broadcasting without option set returns EACCES.

 *		Alan Cox	:	No wakeup calls. Instead we now use the callbacks.

 *		Alan Cox	:	Use ip_tos and ip_ttl

 *		Alan Cox	:	SNMP Mibs

 *		Alan Cox	:	MSG_DONTROUTE, and 0.0.0.0 support.

 *		Matt Dillon	:	UDP length checks.

 *		Alan Cox	:	Smarter af_inet used properly.

 *		Alan Cox	:	Use new kernel side addressing.

 *		Alan Cox	:	Incorrect return on truncated datagram receive.

 *	Arnt Gulbrandsen 	:	New udp_send and stuff

 *		Alan Cox	:	Cache last socket

 *		Alan Cox	:	Route cache

 *		Jon Peatfield	:	Minor efficiency fix to sendto().

 *		Mike Shaver	:	RFC1122 checks.

 *		Alan Cox	:	Nonblocking error fix.

 *	Willy Konynenberg	:	Transparent proxying support.

 *		Mike McLagan	:	Routing by source

 *		David S. Miller	:	New socket lookup architecture.

 *					Last socket cache retained as it

 *					does have a high hit rate.

 *		Olaf Kirch	:	Don't linearise iovec on sendmsg.

 *		Andi Kleen	:	Some cleanups, cache destination entry

 *					for connect.

 *	Vitaly E. Lavrov	:	Transparent proxy revived after year coma.

 *		Melvin Smith	:	Check msg_name not msg_namelen in sendto(),

 *					return ENOTCONN for unconnected sockets (POSIX)

 *		Janos Farkas	:	don't deliver multi/broadcasts to a different

 *					bound-to-device socket

 *	Hirokazu Takahashi	:	HW checksumming for outgoing UDP

 *					datagrams.

 *	Hirokazu Takahashi	:	sendfile() on UDP works now.

 *		Arnaldo C. Melo :	convert /proc/net/udp to seq_file

 *	YOSHIFUJI Hideaki @USAGI and:	Support IPV6_V6ONLY socket option, which

 *	Alexey Kuznetsov:		allow both IPv4 and IPv6 sockets to bind

 *					a single port at the same time.

 *	Derek Atkins <derek@ihtfp.com>: Add Encapulation Support

 *	James Chapman		:	Add L2TP encapsulation type.

 *

 *

 *		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 <asm/system.h>

#include <asm/uaccess.h>

#include <asm/ioctls.h>

#include <linux/bootmem.h>

#include <linux/types.h>

#include <linux/fcntl.h>

#include <linux/module.h>

#include <linux/socket.h>

#include <linux/sockios.h>

#include <linux/igmp.h>

#include <linux/in.h>

#include <linux/errno.h>

#include <linux/timer.h>

#include <linux/mm.h>

#include <linux/inet.h>

#include <linux/netdevice.h>

#include <net/tcp_states.h>

#include <linux/skbuff.h>

#include <linux/proc_fs.h>

#include <linux/seq_file.h>

#include <net/net_namespace.h>

#include <net/icmp.h>

#include <net/route.h>

#include <net/checksum.h>

#include <net/xfrm.h>

#include "udp_impl.h"

int sysctl_udp_mem[3] __read_mostly;

int sysctl_udp_rmem_min __read_mostly;

int sysctl_udp_wmem_min __read_mostly;

EXPORT_SYMBOL(sysctl_udp_mem);

EXPORT_SYMBOL(sysctl_udp_rmem_min);

EXPORT_SYMBOL(sysctl_udp_wmem_min);

atomic_t udp_memory_allocated;

EXPORT_SYMBOL(udp_memory_allocated);

static int udp_lib_lport_inuse(struct net *net, __u16 num,

			       struct sock *sk,

			       int (*saddr_comp)(const struct sock *sk1,

						 const struct sock *sk2))

{

	struct sock *sk2;

		if (net_eq(sock_net(sk2), net)			&&

		    sk2 != sk					&&

		    (!sk2->sk_reuse || !sk->sk_reuse)		&&

		    (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if

			|| sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&

	return 0;

}

/**

 *  udp_lib_get_port  -  UDP/-Lite port lookup for IPv4 and IPv6

 *

 *  @sk:          socket struct in question

 *  @snum:        port number to look up

 *  @saddr_comp:  AF-dependent comparison of bound local IP addresses

 */

int udp_lib_get_port(struct sock *sk, unsigned short snum,

		       int (*saddr_comp)(const struct sock *sk1,

					 const struct sock *sk2 )    )

{

	int    error = 1;

	struct net *net = sock_net(sk);

	if (!snum) {

		int low, high, remaining;

		unsigned rand;

		inet_get_local_port_range(&low, &high);

		remaining = (high - low) + 1;

		rand = net_random();

			do {

		}

		goto fail;

	inet_sk(sk)->num = snum;

	sk->sk_hash = snum;

	if (sk_unhashed(sk)) {

		sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);

	}

	error = 0;

fail:

	return error;

}

static int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)

{

	struct inet_sock *inet1 = inet_sk(sk1), *inet2 = inet_sk(sk2);

	return 	( !ipv6_only_sock(sk2)  &&

		  (!inet1->rcv_saddr || !inet2->rcv_saddr ||

		   inet1->rcv_saddr == inet2->rcv_saddr      ));

}

int udp_v4_get_port(struct sock *sk, unsigned short snum)

{

	return udp_lib_get_port(sk, snum, ipv4_rcv_saddr_equal);

}

/* UDP is nearly always wildcards out the wazoo, it makes no sense to try

 * harder than this. -DaveM

 */

static struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,

		__be16 sport, __be32 daddr, __be16 dport,

{

	unsigned short hnum = ntohs(dport);

		}

	}

	return result;

}

static inline struct sock *__udp4_lib_lookup_skb(struct sk_buff *skb,

						 __be16 sport, __be16 dport,

{

	struct sock *sk;

	const struct iphdr *iph = ip_hdr(skb);

	if (unlikely(sk = skb_steal_sock(skb)))

		return sk;

	else

		return __udp4_lib_lookup(dev_net(skb->dst->dev), iph->saddr, sport,

					 iph->daddr, dport, inet_iif(skb),

					 udptable);

}

struct sock *udp4_lib_lookup(struct net *net, __be32 saddr, __be16 sport,

			     __be32 daddr, __be16 dport, int dif)

{

}

EXPORT_SYMBOL_GPL(udp4_lib_lookup);

static inline struct sock *udp_v4_mcast_next(struct net *net, struct sock *sk,

					     __be16 loc_port, __be32 loc_addr,

					     __be16 rmt_port, __be32 rmt_addr,

					     int dif)

{

	struct sock *s = sk;

	unsigned short hnum = ntohs(loc_port);

		struct inet_sock *inet = inet_sk(s);

		if (!net_eq(sock_net(s), net)				||

		    s->sk_hash != hnum					||

		    (inet->daddr && inet->daddr != rmt_addr)		||

		    (inet->dport != rmt_port && inet->dport)		||

		    (inet->rcv_saddr && inet->rcv_saddr != loc_addr)	||

		    ipv6_only_sock(s)					||

		    (s->sk_bound_dev_if && s->sk_bound_dev_if != dif))

			continue;

		if (!ip_mc_sf_allow(s, loc_addr, rmt_addr, dif))

			continue;

		goto found;

	}

	s = NULL;

found:

	return s;

}

/*

 * This routine is called by the ICMP module when it gets some

 * sort of error condition.  If err < 0 then the socket should

 * be closed and the error returned to the user.  If err > 0

 * it's just the icmp type << 8 | icmp code.

 * Header points to the ip header of the error packet. We move

 * on past this. Then (as it used to claim before adjustment)

 * header points to the first 8 bytes of the udp header.  We need

 * to find the appropriate port.

 */

{

	struct inet_sock *inet;

	struct iphdr *iph = (struct iphdr*)skb->data;

	struct udphdr *uh = (struct udphdr*)(skb->data+(iph->ihl<<2));

	const int type = icmp_hdr(skb)->type;

	const int code = icmp_hdr(skb)->code;

	struct sock *sk;

	int harderr;

	int err;

	struct net *net = dev_net(skb->dev);

	sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,

			iph->saddr, uh->source, skb->dev->ifindex, udptable);

	if (sk == NULL) {

		ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);

		return;	/* No socket for error */

	}

	err = 0;

	harderr = 0;

	inet = inet_sk(sk);

	switch (type) {

	default:

	case ICMP_TIME_EXCEEDED:

		err = EHOSTUNREACH;

		break;

	case ICMP_SOURCE_QUENCH:

		goto out;

	case ICMP_PARAMETERPROB:

		err = EPROTO;

		harderr = 1;

		break;

	case ICMP_DEST_UNREACH:

		if (code == ICMP_FRAG_NEEDED) { /* Path MTU discovery */

			if (inet->pmtudisc != IP_PMTUDISC_DONT) {

				err = EMSGSIZE;

				harderr = 1;

				break;

			}

			goto out;

		}

		err = EHOSTUNREACH;

		if (code <= NR_ICMP_UNREACH) {

			harderr = icmp_err_convert[code].fatal;

			err = icmp_err_convert[code].errno;

		}

		break;

	}

	/*

	 *      RFC1122: OK.  Passes ICMP errors back to application, as per

	 *	4.1.3.3.

	 */

	if (!inet->recverr) {

		if (!harderr || sk->sk_state != TCP_ESTABLISHED)

			goto out;

	} else {

		ip_icmp_error(sk, skb, err, uh->dest, info, (u8*)(uh+1));

	}

	sk->sk_err = err;

	sk->sk_error_report(sk);

out:

	sock_put(sk);

}

void udp_err(struct sk_buff *skb, u32 info)

{

}

/*

 * Throw away all pending data and cancel the corking. Socket is locked.

 */

void udp_flush_pending_frames(struct sock *sk)

{

	struct udp_sock *up = udp_sk(sk);

	if (up->pending) {

		up->len = 0;

		up->pending = 0;

		ip_flush_pending_frames(sk);

	}

}

EXPORT_SYMBOL(udp_flush_pending_frames);

/**

 * 	udp4_hwcsum_outgoing  -  handle outgoing HW checksumming

 * 	@sk: 	socket we are sending on

 * 	@skb: 	sk_buff containing the filled-in UDP header

 * 	        (checksum field must be zeroed out)

 */

static void udp4_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,

				 __be32 src, __be32 dst, int len      )

{

	unsigned int offset;

	struct udphdr *uh = udp_hdr(skb);

	__wsum csum = 0;

	if (skb_queue_len(&sk->sk_write_queue) == 1) {

		/*

		 * Only one fragment on the socket.

		 */

		skb->csum_start = skb_transport_header(skb) - skb->head;

		skb->csum_offset = offsetof(struct udphdr, check);

		uh->check = ~csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, 0);

	} else {

		/*

		 * HW-checksum won't work as there are two or more

		 * fragments on the socket so that all csums of sk_buffs

		 * should be together

		 */

		offset = skb_transport_offset(skb);

		skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);

		skb->ip_summed = CHECKSUM_NONE;

		skb_queue_walk(&sk->sk_write_queue, skb) {

			csum = csum_add(csum, skb->csum);

		}

		uh->check = csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, csum);

		if (uh->check == 0)

			uh->check = CSUM_MANGLED_0;

	}

}

/*

 * Push out all pending data as one UDP datagram. Socket is locked.

 */

static int udp_push_pending_frames(struct sock *sk)

{

	struct udp_sock  *up = udp_sk(sk);