xref: /openbmc/linux/net/ipv4/udp.c (revision 545e4006)
1 /*
2  * INET		An implementation of the TCP/IP protocol suite for the LINUX
3  *		operating system.  INET is implemented using the  BSD Socket
4  *		interface as the means of communication with the user level.
5  *
6  *		The User Datagram Protocol (UDP).
7  *
8  * Authors:	Ross Biro
9  *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10  *		Arnt Gulbrandsen, <agulbra@nvg.unit.no>
11  *		Alan Cox, <Alan.Cox@linux.org>
12  *		Hirokazu Takahashi, <taka@valinux.co.jp>
13  *
14  * Fixes:
15  *		Alan Cox	:	verify_area() calls
16  *		Alan Cox	: 	stopped close while in use off icmp
17  *					messages. Not a fix but a botch that
18  *					for udp at least is 'valid'.
19  *		Alan Cox	:	Fixed icmp handling properly
20  *		Alan Cox	: 	Correct error for oversized datagrams
21  *		Alan Cox	:	Tidied select() semantics.
22  *		Alan Cox	:	udp_err() fixed properly, also now
23  *					select and read wake correctly on errors
24  *		Alan Cox	:	udp_send verify_area moved to avoid mem leak
25  *		Alan Cox	:	UDP can count its memory
26  *		Alan Cox	:	send to an unknown connection causes
27  *					an ECONNREFUSED off the icmp, but
28  *					does NOT close.
29  *		Alan Cox	:	Switched to new sk_buff handlers. No more backlog!
30  *		Alan Cox	:	Using generic datagram code. Even smaller and the PEEK
31  *					bug no longer crashes it.
32  *		Fred Van Kempen	: 	Net2e support for sk->broadcast.
33  *		Alan Cox	:	Uses skb_free_datagram
34  *		Alan Cox	:	Added get/set sockopt support.
35  *		Alan Cox	:	Broadcasting without option set returns EACCES.
36  *		Alan Cox	:	No wakeup calls. Instead we now use the callbacks.
37  *		Alan Cox	:	Use ip_tos and ip_ttl
38  *		Alan Cox	:	SNMP Mibs
39  *		Alan Cox	:	MSG_DONTROUTE, and 0.0.0.0 support.
40  *		Matt Dillon	:	UDP length checks.
41  *		Alan Cox	:	Smarter af_inet used properly.
42  *		Alan Cox	:	Use new kernel side addressing.
43  *		Alan Cox	:	Incorrect return on truncated datagram receive.
44  *	Arnt Gulbrandsen 	:	New udp_send and stuff
45  *		Alan Cox	:	Cache last socket
46  *		Alan Cox	:	Route cache
47  *		Jon Peatfield	:	Minor efficiency fix to sendto().
48  *		Mike Shaver	:	RFC1122 checks.
49  *		Alan Cox	:	Nonblocking error fix.
50  *	Willy Konynenberg	:	Transparent proxying support.
51  *		Mike McLagan	:	Routing by source
52  *		David S. Miller	:	New socket lookup architecture.
53  *					Last socket cache retained as it
54  *					does have a high hit rate.
55  *		Olaf Kirch	:	Don't linearise iovec on sendmsg.
56  *		Andi Kleen	:	Some cleanups, cache destination entry
57  *					for connect.
58  *	Vitaly E. Lavrov	:	Transparent proxy revived after year coma.
59  *		Melvin Smith	:	Check msg_name not msg_namelen in sendto(),
60  *					return ENOTCONN for unconnected sockets (POSIX)
61  *		Janos Farkas	:	don't deliver multi/broadcasts to a different
62  *					bound-to-device socket
63  *	Hirokazu Takahashi	:	HW checksumming for outgoing UDP
64  *					datagrams.
65  *	Hirokazu Takahashi	:	sendfile() on UDP works now.
66  *		Arnaldo C. Melo :	convert /proc/net/udp to seq_file
67  *	YOSHIFUJI Hideaki @USAGI and:	Support IPV6_V6ONLY socket option, which
68  *	Alexey Kuznetsov:		allow both IPv4 and IPv6 sockets to bind
69  *					a single port at the same time.
70  *	Derek Atkins <derek@ihtfp.com>: Add Encapulation Support
71  *	James Chapman		:	Add L2TP encapsulation type.
72  *
73  *
74  *		This program is free software; you can redistribute it and/or
75  *		modify it under the terms of the GNU General Public License
76  *		as published by the Free Software Foundation; either version
77  *		2 of the License, or (at your option) any later version.
78  */
79 
80 #include <asm/system.h>
81 #include <asm/uaccess.h>
82 #include <asm/ioctls.h>
83 #include <linux/bootmem.h>
84 #include <linux/types.h>
85 #include <linux/fcntl.h>
86 #include <linux/module.h>
87 #include <linux/socket.h>
88 #include <linux/sockios.h>
89 #include <linux/igmp.h>
90 #include <linux/in.h>
91 #include <linux/errno.h>
92 #include <linux/timer.h>
93 #include <linux/mm.h>
94 #include <linux/inet.h>
95 #include <linux/netdevice.h>
96 #include <net/tcp_states.h>
97 #include <linux/skbuff.h>
98 #include <linux/proc_fs.h>
99 #include <linux/seq_file.h>
100 #include <net/net_namespace.h>
101 #include <net/icmp.h>
102 #include <net/route.h>
103 #include <net/checksum.h>
104 #include <net/xfrm.h>
105 #include "udp_impl.h"
106 
107 /*
108  *	Snmp MIB for the UDP layer
109  */
110 
111 DEFINE_SNMP_STAT(struct udp_mib, udp_stats_in6) __read_mostly;
112 EXPORT_SYMBOL(udp_stats_in6);
113 
114 struct hlist_head udp_hash[UDP_HTABLE_SIZE];
115 DEFINE_RWLOCK(udp_hash_lock);
116 
117 int sysctl_udp_mem[3] __read_mostly;
118 int sysctl_udp_rmem_min __read_mostly;
119 int sysctl_udp_wmem_min __read_mostly;
120 
121 EXPORT_SYMBOL(sysctl_udp_mem);
122 EXPORT_SYMBOL(sysctl_udp_rmem_min);
123 EXPORT_SYMBOL(sysctl_udp_wmem_min);
124 
125 atomic_t udp_memory_allocated;
126 EXPORT_SYMBOL(udp_memory_allocated);
127 
128 static inline int __udp_lib_lport_inuse(struct net *net, __u16 num,
129 					const struct hlist_head udptable[])
130 {
131 	struct sock *sk;
132 	struct hlist_node *node;
133 
134 	sk_for_each(sk, node, &udptable[udp_hashfn(net, num)])
135 		if (net_eq(sock_net(sk), net) && sk->sk_hash == num)
136 			return 1;
137 	return 0;
138 }
139 
140 /**
141  *  udp_lib_get_port  -  UDP/-Lite port lookup for IPv4 and IPv6
142  *
143  *  @sk:          socket struct in question
144  *  @snum:        port number to look up
145  *  @saddr_comp:  AF-dependent comparison of bound local IP addresses
146  */
147 int udp_lib_get_port(struct sock *sk, unsigned short snum,
148 		       int (*saddr_comp)(const struct sock *sk1,
149 					 const struct sock *sk2 )    )
150 {
151 	struct hlist_head *udptable = sk->sk_prot->h.udp_hash;
152 	struct hlist_node *node;
153 	struct hlist_head *head;
154 	struct sock *sk2;
155 	int    error = 1;
156 	struct net *net = sock_net(sk);
157 
158 	write_lock_bh(&udp_hash_lock);
159 
160 	if (!snum) {
161 		int i, low, high, remaining;
162 		unsigned rover, best, best_size_so_far;
163 
164 		inet_get_local_port_range(&low, &high);
165 		remaining = (high - low) + 1;
166 
167 		best_size_so_far = UINT_MAX;
168 		best = rover = net_random() % remaining + low;
169 
170 		/* 1st pass: look for empty (or shortest) hash chain */
171 		for (i = 0; i < UDP_HTABLE_SIZE; i++) {
172 			int size = 0;
173 
174 			head = &udptable[udp_hashfn(net, rover)];
175 			if (hlist_empty(head))
176 				goto gotit;
177 
178 			sk_for_each(sk2, node, head) {
179 				if (++size >= best_size_so_far)
180 					goto next;
181 			}
182 			best_size_so_far = size;
183 			best = rover;
184 		next:
185 			/* fold back if end of range */
186 			if (++rover > high)
187 				rover = low + ((rover - low)
188 					       & (UDP_HTABLE_SIZE - 1));
189 
190 
191 		}
192 
193 		/* 2nd pass: find hole in shortest hash chain */
194 		rover = best;
195 		for (i = 0; i < (1 << 16) / UDP_HTABLE_SIZE; i++) {
196 			if (! __udp_lib_lport_inuse(net, rover, udptable))
197 				goto gotit;
198 			rover += UDP_HTABLE_SIZE;
199 			if (rover > high)
200 				rover = low + ((rover - low)
201 					       & (UDP_HTABLE_SIZE - 1));
202 		}
203 
204 
205 		/* All ports in use! */
206 		goto fail;
207 
208 gotit:
209 		snum = rover;
210 	} else {
211 		head = &udptable[udp_hashfn(net, snum)];
212 
213 		sk_for_each(sk2, node, head)
214 			if (sk2->sk_hash == snum                             &&
215 			    sk2 != sk                                        &&
216 			    net_eq(sock_net(sk2), net)			     &&
217 			    (!sk2->sk_reuse        || !sk->sk_reuse)         &&
218 			    (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if
219 			     || sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
220 			    (*saddr_comp)(sk, sk2)                             )
221 				goto fail;
222 	}
223 
224 	inet_sk(sk)->num = snum;
225 	sk->sk_hash = snum;
226 	if (sk_unhashed(sk)) {
227 		head = &udptable[udp_hashfn(net, snum)];
228 		sk_add_node(sk, head);
229 		sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
230 	}
231 	error = 0;
232 fail:
233 	write_unlock_bh(&udp_hash_lock);
234 	return error;
235 }
236 
237 static int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)
238 {
239 	struct inet_sock *inet1 = inet_sk(sk1), *inet2 = inet_sk(sk2);
240 
241 	return 	( !ipv6_only_sock(sk2)  &&
242 		  (!inet1->rcv_saddr || !inet2->rcv_saddr ||
243 		   inet1->rcv_saddr == inet2->rcv_saddr      ));
244 }
245 
246 int udp_v4_get_port(struct sock *sk, unsigned short snum)
247 {
248 	return udp_lib_get_port(sk, snum, ipv4_rcv_saddr_equal);
249 }
250 
251 /* UDP is nearly always wildcards out the wazoo, it makes no sense to try
252  * harder than this. -DaveM
253  */
254 static struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,
255 		__be16 sport, __be32 daddr, __be16 dport,
256 		int dif, struct hlist_head udptable[])
257 {
258 	struct sock *sk, *result = NULL;
259 	struct hlist_node *node;
260 	unsigned short hnum = ntohs(dport);
261 	int badness = -1;
262 
263 	read_lock(&udp_hash_lock);
264 	sk_for_each(sk, node, &udptable[udp_hashfn(net, hnum)]) {
265 		struct inet_sock *inet = inet_sk(sk);
266 
267 		if (net_eq(sock_net(sk), net) && sk->sk_hash == hnum &&
268 				!ipv6_only_sock(sk)) {
269 			int score = (sk->sk_family == PF_INET ? 1 : 0);
270 			if (inet->rcv_saddr) {
271 				if (inet->rcv_saddr != daddr)
272 					continue;
273 				score+=2;
274 			}
275 			if (inet->daddr) {
276 				if (inet->daddr != saddr)
277 					continue;
278 				score+=2;
279 			}
280 			if (inet->dport) {
281 				if (inet->dport != sport)
282 					continue;
283 				score+=2;
284 			}
285 			if (sk->sk_bound_dev_if) {
286 				if (sk->sk_bound_dev_if != dif)
287 					continue;
288 				score+=2;
289 			}
290 			if (score == 9) {
291 				result = sk;
292 				break;
293 			} else if (score > badness) {
294 				result = sk;
295 				badness = score;
296 			}
297 		}
298 	}
299 	if (result)
300 		sock_hold(result);
301 	read_unlock(&udp_hash_lock);
302 	return result;
303 }
304 
305 static inline struct sock *udp_v4_mcast_next(struct sock *sk,
306 					     __be16 loc_port, __be32 loc_addr,
307 					     __be16 rmt_port, __be32 rmt_addr,
308 					     int dif)
309 {
310 	struct hlist_node *node;
311 	struct sock *s = sk;
312 	unsigned short hnum = ntohs(loc_port);
313 
314 	sk_for_each_from(s, node) {
315 		struct inet_sock *inet = inet_sk(s);
316 
317 		if (s->sk_hash != hnum					||
318 		    (inet->daddr && inet->daddr != rmt_addr)		||
319 		    (inet->dport != rmt_port && inet->dport)		||
320 		    (inet->rcv_saddr && inet->rcv_saddr != loc_addr)	||
321 		    ipv6_only_sock(s)					||
322 		    (s->sk_bound_dev_if && s->sk_bound_dev_if != dif))
323 			continue;
324 		if (!ip_mc_sf_allow(s, loc_addr, rmt_addr, dif))
325 			continue;
326 		goto found;
327 	}
328 	s = NULL;
329 found:
330 	return s;
331 }
332 
333 /*
334  * This routine is called by the ICMP module when it gets some
335  * sort of error condition.  If err < 0 then the socket should
336  * be closed and the error returned to the user.  If err > 0
337  * it's just the icmp type << 8 | icmp code.
338  * Header points to the ip header of the error packet. We move
339  * on past this. Then (as it used to claim before adjustment)
340  * header points to the first 8 bytes of the udp header.  We need
341  * to find the appropriate port.
342  */
343 
344 void __udp4_lib_err(struct sk_buff *skb, u32 info, struct hlist_head udptable[])
345 {
346 	struct inet_sock *inet;
347 	struct iphdr *iph = (struct iphdr*)skb->data;
348 	struct udphdr *uh = (struct udphdr*)(skb->data+(iph->ihl<<2));
349 	const int type = icmp_hdr(skb)->type;
350 	const int code = icmp_hdr(skb)->code;
351 	struct sock *sk;
352 	int harderr;
353 	int err;
354 	struct net *net = dev_net(skb->dev);
355 
356 	sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,
357 			iph->saddr, uh->source, skb->dev->ifindex, udptable);
358 	if (sk == NULL) {
359 		ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
360 		return;	/* No socket for error */
361 	}
362 
363 	err = 0;
364 	harderr = 0;
365 	inet = inet_sk(sk);
366 
367 	switch (type) {
368 	default:
369 	case ICMP_TIME_EXCEEDED:
370 		err = EHOSTUNREACH;
371 		break;
372 	case ICMP_SOURCE_QUENCH:
373 		goto out;
374 	case ICMP_PARAMETERPROB:
375 		err = EPROTO;
376 		harderr = 1;
377 		break;
378 	case ICMP_DEST_UNREACH:
379 		if (code == ICMP_FRAG_NEEDED) { /* Path MTU discovery */
380 			if (inet->pmtudisc != IP_PMTUDISC_DONT) {
381 				err = EMSGSIZE;
382 				harderr = 1;
383 				break;
384 			}
385 			goto out;
386 		}
387 		err = EHOSTUNREACH;
388 		if (code <= NR_ICMP_UNREACH) {
389 			harderr = icmp_err_convert[code].fatal;
390 			err = icmp_err_convert[code].errno;
391 		}
392 		break;
393 	}
394 
395 	/*
396 	 *      RFC1122: OK.  Passes ICMP errors back to application, as per
397 	 *	4.1.3.3.
398 	 */
399 	if (!inet->recverr) {
400 		if (!harderr || sk->sk_state != TCP_ESTABLISHED)
401 			goto out;
402 	} else {
403 		ip_icmp_error(sk, skb, err, uh->dest, info, (u8*)(uh+1));
404 	}
405 	sk->sk_err = err;
406 	sk->sk_error_report(sk);
407 out:
408 	sock_put(sk);
409 }
410 
411 void udp_err(struct sk_buff *skb, u32 info)
412 {
413 	__udp4_lib_err(skb, info, udp_hash);
414 }
415 
416 /*
417  * Throw away all pending data and cancel the corking. Socket is locked.
418  */
419 void udp_flush_pending_frames(struct sock *sk)
420 {
421 	struct udp_sock *up = udp_sk(sk);
422 
423 	if (up->pending) {
424 		up->len = 0;
425 		up->pending = 0;
426 		ip_flush_pending_frames(sk);
427 	}
428 }
429 EXPORT_SYMBOL(udp_flush_pending_frames);
430 
431 /**
432  * 	udp4_hwcsum_outgoing  -  handle outgoing HW checksumming
433  * 	@sk: 	socket we are sending on
434  * 	@skb: 	sk_buff containing the filled-in UDP header
435  * 	        (checksum field must be zeroed out)
436  */
437 static void udp4_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,
438 				 __be32 src, __be32 dst, int len      )
439 {
440 	unsigned int offset;
441 	struct udphdr *uh = udp_hdr(skb);
442 	__wsum csum = 0;
443 
444 	if (skb_queue_len(&sk->sk_write_queue) == 1) {
445 		/*
446 		 * Only one fragment on the socket.
447 		 */
448 		skb->csum_start = skb_transport_header(skb) - skb->head;
449 		skb->csum_offset = offsetof(struct udphdr, check);
450 		uh->check = ~csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, 0);
451 	} else {
452 		/*
453 		 * HW-checksum won't work as there are two or more
454 		 * fragments on the socket so that all csums of sk_buffs
455 		 * should be together
456 		 */
457 		offset = skb_transport_offset(skb);
458 		skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
459 
460 		skb->ip_summed = CHECKSUM_NONE;
461 
462 		skb_queue_walk(&sk->sk_write_queue, skb) {
463 			csum = csum_add(csum, skb->csum);
464 		}
465 
466 		uh->check = csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, csum);
467 		if (uh->check == 0)
468 			uh->check = CSUM_MANGLED_0;
469 	}
470 }
471 
472 /*
473  * Push out all pending data as one UDP datagram. Socket is locked.
474  */
475 static int udp_push_pending_frames(struct sock *sk)
476 {
477 	struct udp_sock  *up = udp_sk(sk);
478 	struct inet_sock *inet = inet_sk(sk);
479 	struct flowi *fl = &inet->cork.fl;
480 	struct sk_buff *skb;
481 	struct udphdr *uh;
482 	int err = 0;
483 	int is_udplite = IS_UDPLITE(sk);
484 	__wsum csum = 0;
485 
486 	/* Grab the skbuff where UDP header space exists. */
487 	if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
488 		goto out;
489 
490 	/*
491 	 * Create a UDP header
492 	 */
493 	uh = udp_hdr(skb);
494 	uh->source = fl->fl_ip_sport;
495 	uh->dest = fl->fl_ip_dport;
496 	uh->len = htons(up->len);
497 	uh->check = 0;
498 
499 	if (is_udplite)  				 /*     UDP-Lite      */
500 		csum  = udplite_csum_outgoing(sk, skb);
501 
502 	else if (sk->sk_no_check == UDP_CSUM_NOXMIT) {   /* UDP csum disabled */
503 
504 		skb->ip_summed = CHECKSUM_NONE;
505 		goto send;
506 
507 	} else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
508 
509 		udp4_hwcsum_outgoing(sk, skb, fl->fl4_src,fl->fl4_dst, up->len);
510 		goto send;
511 
512 	} else						 /*   `normal' UDP    */
513 		csum = udp_csum_outgoing(sk, skb);
514 
515 	/* add protocol-dependent pseudo-header */
516 	uh->check = csum_tcpudp_magic(fl->fl4_src, fl->fl4_dst, up->len,
517 				      sk->sk_protocol, csum             );
518 	if (uh->check == 0)
519 		uh->check = CSUM_MANGLED_0;
520 
521 send:
522 	err = ip_push_pending_frames(sk);
523 out:
524 	up->len = 0;
525 	up->pending = 0;
526 	if (!err)
527 		UDP_INC_STATS_USER(sock_net(sk),
528 				UDP_MIB_OUTDATAGRAMS, is_udplite);
529 	return err;
530 }
531 
532 int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
533 		size_t len)
534 {
535 	struct inet_sock *inet = inet_sk(sk);
536 	struct udp_sock *up = udp_sk(sk);
537 	int ulen = len;
538 	struct ipcm_cookie ipc;
539 	struct rtable *rt = NULL;
540 	int free = 0;
541 	int connected = 0;
542 	__be32 daddr, faddr, saddr;
543 	__be16 dport;
544 	u8  tos;
545 	int err, is_udplite = IS_UDPLITE(sk);
546 	int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
547 	int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
548 
549 	if (len > 0xFFFF)
550 		return -EMSGSIZE;
551 
552 	/*
553 	 *	Check the flags.
554 	 */
555 
556 	if (msg->msg_flags&MSG_OOB)	/* Mirror BSD error message compatibility */
557 		return -EOPNOTSUPP;
558 
559 	ipc.opt = NULL;
560 
561 	if (up->pending) {
562 		/*
563 		 * There are pending frames.
564 		 * The socket lock must be held while it's corked.
565 		 */
566 		lock_sock(sk);
567 		if (likely(up->pending)) {
568 			if (unlikely(up->pending != AF_INET)) {
569 				release_sock(sk);
570 				return -EINVAL;
571 			}
572 			goto do_append_data;
573 		}
574 		release_sock(sk);
575 	}
576 	ulen += sizeof(struct udphdr);
577 
578 	/*
579 	 *	Get and verify the address.
580 	 */
581 	if (msg->msg_name) {
582 		struct sockaddr_in * usin = (struct sockaddr_in*)msg->msg_name;
583 		if (msg->msg_namelen < sizeof(*usin))
584 			return -EINVAL;
585 		if (usin->sin_family != AF_INET) {
586 			if (usin->sin_family != AF_UNSPEC)
587 				return -EAFNOSUPPORT;
588 		}
589 
590 		daddr = usin->sin_addr.s_addr;
591 		dport = usin->sin_port;
592 		if (dport == 0)
593 			return -EINVAL;
594 	} else {
595 		if (sk->sk_state != TCP_ESTABLISHED)
596 			return -EDESTADDRREQ;
597 		daddr = inet->daddr;
598 		dport = inet->dport;
599 		/* Open fast path for connected socket.
600 		   Route will not be used, if at least one option is set.
601 		 */
602 		connected = 1;
603 	}
604 	ipc.addr = inet->saddr;
605 
606 	ipc.oif = sk->sk_bound_dev_if;
607 	if (msg->msg_controllen) {
608 		err = ip_cmsg_send(sock_net(sk), msg, &ipc);
609 		if (err)
610 			return err;
611 		if (ipc.opt)
612 			free = 1;
613 		connected = 0;
614 	}
615 	if (!ipc.opt)
616 		ipc.opt = inet->opt;
617 
618 	saddr = ipc.addr;
619 	ipc.addr = faddr = daddr;
620 
621 	if (ipc.opt && ipc.opt->srr) {
622 		if (!daddr)
623 			return -EINVAL;
624 		faddr = ipc.opt->faddr;
625 		connected = 0;
626 	}
627 	tos = RT_TOS(inet->tos);
628 	if (sock_flag(sk, SOCK_LOCALROUTE) ||
629 	    (msg->msg_flags & MSG_DONTROUTE) ||
630 	    (ipc.opt && ipc.opt->is_strictroute)) {
631 		tos |= RTO_ONLINK;
632 		connected = 0;
633 	}
634 
635 	if (ipv4_is_multicast(daddr)) {
636 		if (!ipc.oif)
637 			ipc.oif = inet->mc_index;
638 		if (!saddr)
639 			saddr = inet->mc_addr;
640 		connected = 0;
641 	}
642 
643 	if (connected)
644 		rt = (struct rtable*)sk_dst_check(sk, 0);
645 
646 	if (rt == NULL) {
647 		struct flowi fl = { .oif = ipc.oif,
648 				    .nl_u = { .ip4_u =
649 					      { .daddr = faddr,
650 						.saddr = saddr,
651 						.tos = tos } },
652 				    .proto = sk->sk_protocol,
653 				    .uli_u = { .ports =
654 					       { .sport = inet->sport,
655 						 .dport = dport } } };
656 		struct net *net = sock_net(sk);
657 
658 		security_sk_classify_flow(sk, &fl);
659 		err = ip_route_output_flow(net, &rt, &fl, sk, 1);
660 		if (err) {
661 			if (err == -ENETUNREACH)
662 				IP_INC_STATS_BH(net, IPSTATS_MIB_OUTNOROUTES);
663 			goto out;
664 		}
665 
666 		err = -EACCES;
667 		if ((rt->rt_flags & RTCF_BROADCAST) &&
668 		    !sock_flag(sk, SOCK_BROADCAST))
669 			goto out;
670 		if (connected)
671 			sk_dst_set(sk, dst_clone(&rt->u.dst));
672 	}
673 
674 	if (msg->msg_flags&MSG_CONFIRM)
675 		goto do_confirm;
676 back_from_confirm:
677 
678 	saddr = rt->rt_src;
679 	if (!ipc.addr)
680 		daddr = ipc.addr = rt->rt_dst;
681 
682 	lock_sock(sk);
683 	if (unlikely(up->pending)) {
684 		/* The socket is already corked while preparing it. */
685 		/* ... which is an evident application bug. --ANK */
686 		release_sock(sk);
687 
688 		LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
689 		err = -EINVAL;
690 		goto out;
691 	}
692 	/*
693 	 *	Now cork the socket to pend data.
694 	 */
695 	inet->cork.fl.fl4_dst = daddr;
696 	inet->cork.fl.fl_ip_dport = dport;
697 	inet->cork.fl.fl4_src = saddr;
698 	inet->cork.fl.fl_ip_sport = inet->sport;
699 	up->pending = AF_INET;
700 
701 do_append_data:
702 	up->len += ulen;
703 	getfrag  =  is_udplite ?  udplite_getfrag : ip_generic_getfrag;
704 	err = ip_append_data(sk, getfrag, msg->msg_iov, ulen,
705 			sizeof(struct udphdr), &ipc, rt,
706 			corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
707 	if (err)
708 		udp_flush_pending_frames(sk);
709 	else if (!corkreq)
710 		err = udp_push_pending_frames(sk);
711 	else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
712 		up->pending = 0;
713 	release_sock(sk);
714 
715 out:
716 	ip_rt_put(rt);
717 	if (free)
718 		kfree(ipc.opt);
719 	if (!err)
720 		return len;
721 	/*
722 	 * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space.  Reporting
723 	 * ENOBUFS might not be good (it's not tunable per se), but otherwise
724 	 * we don't have a good statistic (IpOutDiscards but it can be too many
725 	 * things).  We could add another new stat but at least for now that
726 	 * seems like overkill.
727 	 */
728 	if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
729 		UDP_INC_STATS_USER(sock_net(sk),
730 				UDP_MIB_SNDBUFERRORS, is_udplite);
731 	}
732 	return err;
733 
734 do_confirm:
735 	dst_confirm(&rt->u.dst);
736 	if (!(msg->msg_flags&MSG_PROBE) || len)
737 		goto back_from_confirm;
738 	err = 0;
739 	goto out;
740 }
741 
742 int udp_sendpage(struct sock *sk, struct page *page, int offset,
743 		 size_t size, int flags)
744 {
745 	struct udp_sock *up = udp_sk(sk);
746 	int ret;
747 
748 	if (!up->pending) {
749 		struct msghdr msg = {	.msg_flags = flags|MSG_MORE };
750 
751 		/* Call udp_sendmsg to specify destination address which
752 		 * sendpage interface can't pass.
753 		 * This will succeed only when the socket is connected.
754 		 */
755 		ret = udp_sendmsg(NULL, sk, &msg, 0);
756 		if (ret < 0)
757 			return ret;
758 	}
759 
760 	lock_sock(sk);
761 
762 	if (unlikely(!up->pending)) {
763 		release_sock(sk);
764 
765 		LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 3\n");
766 		return -EINVAL;
767 	}
768 
769 	ret = ip_append_page(sk, page, offset, size, flags);
770 	if (ret == -EOPNOTSUPP) {
771 		release_sock(sk);
772 		return sock_no_sendpage(sk->sk_socket, page, offset,
773 					size, flags);
774 	}
775 	if (ret < 0) {
776 		udp_flush_pending_frames(sk);
777 		goto out;
778 	}
779 
780 	up->len += size;
781 	if (!(up->corkflag || (flags&MSG_MORE)))
782 		ret = udp_push_pending_frames(sk);
783 	if (!ret)
784 		ret = size;
785 out:
786 	release_sock(sk);
787 	return ret;
788 }
789 
790 /*
791  *	IOCTL requests applicable to the UDP protocol
792  */
793 
794 int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
795 {
796 	switch (cmd) {
797 	case SIOCOUTQ:
798 	{
799 		int amount = atomic_read(&sk->sk_wmem_alloc);
800 		return put_user(amount, (int __user *)arg);
801 	}
802 
803 	case SIOCINQ:
804 	{
805 		struct sk_buff *skb;
806 		unsigned long amount;
807 
808 		amount = 0;
809 		spin_lock_bh(&sk->sk_receive_queue.lock);
810 		skb = skb_peek(&sk->sk_receive_queue);
811 		if (skb != NULL) {
812 			/*
813 			 * We will only return the amount
814 			 * of this packet since that is all
815 			 * that will be read.
816 			 */
817 			amount = skb->len - sizeof(struct udphdr);
818 		}
819 		spin_unlock_bh(&sk->sk_receive_queue.lock);
820 		return put_user(amount, (int __user *)arg);
821 	}
822 
823 	default:
824 		return -ENOIOCTLCMD;
825 	}
826 
827 	return 0;
828 }
829 
830 /*
831  * 	This should be easy, if there is something there we
832  * 	return it, otherwise we block.
833  */
834 
835 int udp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
836 		size_t len, int noblock, int flags, int *addr_len)
837 {
838 	struct inet_sock *inet = inet_sk(sk);
839 	struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
840 	struct sk_buff *skb;
841 	unsigned int ulen, copied;
842 	int peeked;
843 	int err;
844 	int is_udplite = IS_UDPLITE(sk);
845 
846 	/*
847 	 *	Check any passed addresses
848 	 */
849 	if (addr_len)
850 		*addr_len=sizeof(*sin);
851 
852 	if (flags & MSG_ERRQUEUE)
853 		return ip_recv_error(sk, msg, len);
854 
855 try_again:
856 	skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
857 				  &peeked, &err);
858 	if (!skb)
859 		goto out;
860 
861 	ulen = skb->len - sizeof(struct udphdr);
862 	copied = len;
863 	if (copied > ulen)
864 		copied = ulen;
865 	else if (copied < ulen)
866 		msg->msg_flags |= MSG_TRUNC;
867 
868 	/*
869 	 * If checksum is needed at all, try to do it while copying the
870 	 * data.  If the data is truncated, or if we only want a partial
871 	 * coverage checksum (UDP-Lite), do it before the copy.
872 	 */
873 
874 	if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) {
875 		if (udp_lib_checksum_complete(skb))
876 			goto csum_copy_err;
877 	}
878 
879 	if (skb_csum_unnecessary(skb))
880 		err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
881 					      msg->msg_iov, copied       );
882 	else {
883 		err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);
884 
885 		if (err == -EINVAL)
886 			goto csum_copy_err;
887 	}
888 
889 	if (err)
890 		goto out_free;
891 
892 	if (!peeked)
893 		UDP_INC_STATS_USER(sock_net(sk),
894 				UDP_MIB_INDATAGRAMS, is_udplite);
895 
896 	sock_recv_timestamp(msg, sk, skb);
897 
898 	/* Copy the address. */
899 	if (sin)
900 	{
901 		sin->sin_family = AF_INET;
902 		sin->sin_port = udp_hdr(skb)->source;
903 		sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
904 		memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
905 	}
906 	if (inet->cmsg_flags)
907 		ip_cmsg_recv(msg, skb);
908 
909 	err = copied;
910 	if (flags & MSG_TRUNC)
911 		err = ulen;
912 
913 out_free:
914 	lock_sock(sk);
915 	skb_free_datagram(sk, skb);
916 	release_sock(sk);
917 out:
918 	return err;
919 
920 csum_copy_err:
921 	lock_sock(sk);
922 	if (!skb_kill_datagram(sk, skb, flags))
923 		UDP_INC_STATS_USER(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
924 	release_sock(sk);
925 
926 	if (noblock)
927 		return -EAGAIN;
928 	goto try_again;
929 }
930 
931 
932 int udp_disconnect(struct sock *sk, int flags)
933 {
934 	struct inet_sock *inet = inet_sk(sk);
935 	/*
936 	 *	1003.1g - break association.
937 	 */
938 
939 	sk->sk_state = TCP_CLOSE;
940 	inet->daddr = 0;
941 	inet->dport = 0;
942 	sk->sk_bound_dev_if = 0;
943 	if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
944 		inet_reset_saddr(sk);
945 
946 	if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
947 		sk->sk_prot->unhash(sk);
948 		inet->sport = 0;
949 	}
950 	sk_dst_reset(sk);
951 	return 0;
952 }
953 
954 /* returns:
955  *  -1: error
956  *   0: success
957  *  >0: "udp encap" protocol resubmission
958  *
959  * Note that in the success and error cases, the skb is assumed to
960  * have either been requeued or freed.
961  */
962 int udp_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
963 {
964 	struct udp_sock *up = udp_sk(sk);
965 	int rc;
966 	int is_udplite = IS_UDPLITE(sk);
967 
968 	/*
969 	 *	Charge it to the socket, dropping if the queue is full.
970 	 */
971 	if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
972 		goto drop;
973 	nf_reset(skb);
974 
975 	if (up->encap_type) {
976 		/*
977 		 * This is an encapsulation socket so pass the skb to
978 		 * the socket's udp_encap_rcv() hook. Otherwise, just
979 		 * fall through and pass this up the UDP socket.
980 		 * up->encap_rcv() returns the following value:
981 		 * =0 if skb was successfully passed to the encap
982 		 *    handler or was discarded by it.
983 		 * >0 if skb should be passed on to UDP.
984 		 * <0 if skb should be resubmitted as proto -N
985 		 */
986 
987 		/* if we're overly short, let UDP handle it */
988 		if (skb->len > sizeof(struct udphdr) &&
989 		    up->encap_rcv != NULL) {
990 			int ret;
991 
992 			ret = (*up->encap_rcv)(sk, skb);
993 			if (ret <= 0) {
994 				UDP_INC_STATS_BH(sock_net(sk),
995 						 UDP_MIB_INDATAGRAMS,
996 						 is_udplite);
997 				return -ret;
998 			}
999 		}
1000 
1001 		/* FALLTHROUGH -- it's a UDP Packet */
1002 	}
1003 
1004 	/*
1005 	 * 	UDP-Lite specific tests, ignored on UDP sockets
1006 	 */
1007 	if ((is_udplite & UDPLITE_RECV_CC)  &&  UDP_SKB_CB(skb)->partial_cov) {
1008 
1009 		/*
1010 		 * MIB statistics other than incrementing the error count are
1011 		 * disabled for the following two types of errors: these depend
1012 		 * on the application settings, not on the functioning of the
1013 		 * protocol stack as such.
1014 		 *
1015 		 * RFC 3828 here recommends (sec 3.3): "There should also be a
1016 		 * way ... to ... at least let the receiving application block
1017 		 * delivery of packets with coverage values less than a value
1018 		 * provided by the application."
1019 		 */
1020 		if (up->pcrlen == 0) {          /* full coverage was set  */
1021 			LIMIT_NETDEBUG(KERN_WARNING "UDPLITE: partial coverage "
1022 				"%d while full coverage %d requested\n",
1023 				UDP_SKB_CB(skb)->cscov, skb->len);
1024 			goto drop;
1025 		}
1026 		/* The next case involves violating the min. coverage requested
1027 		 * by the receiver. This is subtle: if receiver wants x and x is
1028 		 * greater than the buffersize/MTU then receiver will complain
1029 		 * that it wants x while sender emits packets of smaller size y.
1030 		 * Therefore the above ...()->partial_cov statement is essential.
1031 		 */
1032 		if (UDP_SKB_CB(skb)->cscov  <  up->pcrlen) {
1033 			LIMIT_NETDEBUG(KERN_WARNING
1034 				"UDPLITE: coverage %d too small, need min %d\n",
1035 				UDP_SKB_CB(skb)->cscov, up->pcrlen);
1036 			goto drop;
1037 		}
1038 	}
1039 
1040 	if (sk->sk_filter) {
1041 		if (udp_lib_checksum_complete(skb))
1042 			goto drop;
1043 	}
1044 
1045 	if ((rc = sock_queue_rcv_skb(sk,skb)) < 0) {
1046 		/* Note that an ENOMEM error is charged twice */
1047 		if (rc == -ENOMEM) {
1048 			UDP_INC_STATS_BH(sock_net(sk),
1049 					UDP_MIB_RCVBUFERRORS, is_udplite);
1050 			atomic_inc(&sk->sk_drops);
1051 		}
1052 		goto drop;
1053 	}
1054 
1055 	return 0;
1056 
1057 drop:
1058 	UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
1059 	kfree_skb(skb);
1060 	return -1;
1061 }
1062 
1063 /*
1064  *	Multicasts and broadcasts go to each listener.
1065  *
1066  *	Note: called only from the BH handler context,
1067  *	so we don't need to lock the hashes.
1068  */
1069 static int __udp4_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
1070 				    struct udphdr  *uh,
1071 				    __be32 saddr, __be32 daddr,
1072 				    struct hlist_head udptable[])
1073 {
1074 	struct sock *sk;
1075 	int dif;
1076 
1077 	read_lock(&udp_hash_lock);
1078 	sk = sk_head(&udptable[udp_hashfn(net, ntohs(uh->dest))]);
1079 	dif = skb->dev->ifindex;
1080 	sk = udp_v4_mcast_next(sk, uh->dest, daddr, uh->source, saddr, dif);
1081 	if (sk) {
1082 		struct sock *sknext = NULL;
1083 
1084 		do {
1085 			struct sk_buff *skb1 = skb;
1086 
1087 			sknext = udp_v4_mcast_next(sk_next(sk), uh->dest, daddr,
1088 						   uh->source, saddr, dif);
1089 			if (sknext)
1090 				skb1 = skb_clone(skb, GFP_ATOMIC);
1091 
1092 			if (skb1) {
1093 				int ret = 0;
1094 
1095 				bh_lock_sock_nested(sk);
1096 				if (!sock_owned_by_user(sk))
1097 					ret = udp_queue_rcv_skb(sk, skb1);
1098 				else
1099 					sk_add_backlog(sk, skb1);
1100 				bh_unlock_sock(sk);
1101 
1102 				if (ret > 0)
1103 					/* we should probably re-process instead
1104 					 * of dropping packets here. */
1105 					kfree_skb(skb1);
1106 			}
1107 			sk = sknext;
1108 		} while (sknext);
1109 	} else
1110 		kfree_skb(skb);
1111 	read_unlock(&udp_hash_lock);
1112 	return 0;
1113 }
1114 
1115 /* Initialize UDP checksum. If exited with zero value (success),
1116  * CHECKSUM_UNNECESSARY means, that no more checks are required.
1117  * Otherwise, csum completion requires chacksumming packet body,
1118  * including udp header and folding it to skb->csum.
1119  */
1120 static inline int udp4_csum_init(struct sk_buff *skb, struct udphdr *uh,
1121 				 int proto)
1122 {
1123 	const struct iphdr *iph;
1124 	int err;
1125 
1126 	UDP_SKB_CB(skb)->partial_cov = 0;
1127 	UDP_SKB_CB(skb)->cscov = skb->len;
1128 
1129 	if (proto == IPPROTO_UDPLITE) {
1130 		err = udplite_checksum_init(skb, uh);
1131 		if (err)
1132 			return err;
1133 	}
1134 
1135 	iph = ip_hdr(skb);
1136 	if (uh->check == 0) {
1137 		skb->ip_summed = CHECKSUM_UNNECESSARY;
1138 	} else if (skb->ip_summed == CHECKSUM_COMPLETE) {
1139 	       if (!csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
1140 				      proto, skb->csum))
1141 			skb->ip_summed = CHECKSUM_UNNECESSARY;
1142 	}
1143 	if (!skb_csum_unnecessary(skb))
1144 		skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
1145 					       skb->len, proto, 0);
1146 	/* Probably, we should checksum udp header (it should be in cache
1147 	 * in any case) and data in tiny packets (< rx copybreak).
1148 	 */
1149 
1150 	return 0;
1151 }
1152 
1153 /*
1154  *	All we need to do is get the socket, and then do a checksum.
1155  */
1156 
1157 int __udp4_lib_rcv(struct sk_buff *skb, struct hlist_head udptable[],
1158 		   int proto)
1159 {
1160 	struct sock *sk;
1161 	struct udphdr *uh = udp_hdr(skb);
1162 	unsigned short ulen;
1163 	struct rtable *rt = (struct rtable*)skb->dst;
1164 	__be32 saddr = ip_hdr(skb)->saddr;
1165 	__be32 daddr = ip_hdr(skb)->daddr;
1166 	struct net *net = dev_net(skb->dev);
1167 
1168 	/*
1169 	 *  Validate the packet.
1170 	 */
1171 	if (!pskb_may_pull(skb, sizeof(struct udphdr)))
1172 		goto drop;		/* No space for header. */
1173 
1174 	ulen = ntohs(uh->len);
1175 	if (ulen > skb->len)
1176 		goto short_packet;
1177 
1178 	if (proto == IPPROTO_UDP) {
1179 		/* UDP validates ulen. */
1180 		if (ulen < sizeof(*uh) || pskb_trim_rcsum(skb, ulen))
1181 			goto short_packet;
1182 		uh = udp_hdr(skb);
1183 	}
1184 
1185 	if (udp4_csum_init(skb, uh, proto))
1186 		goto csum_error;
1187 
1188 	if (rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST))
1189 		return __udp4_lib_mcast_deliver(net, skb, uh,
1190 				saddr, daddr, udptable);
1191 
1192 	sk = __udp4_lib_lookup(net, saddr, uh->source, daddr,
1193 			uh->dest, inet_iif(skb), udptable);
1194 
1195 	if (sk != NULL) {
1196 		int ret = 0;
1197 		bh_lock_sock_nested(sk);
1198 		if (!sock_owned_by_user(sk))
1199 			ret = udp_queue_rcv_skb(sk, skb);
1200 		else
1201 			sk_add_backlog(sk, skb);
1202 		bh_unlock_sock(sk);
1203 		sock_put(sk);
1204 
1205 		/* a return value > 0 means to resubmit the input, but
1206 		 * it wants the return to be -protocol, or 0
1207 		 */
1208 		if (ret > 0)
1209 			return -ret;
1210 		return 0;
1211 	}
1212 
1213 	if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1214 		goto drop;
1215 	nf_reset(skb);
1216 
1217 	/* No socket. Drop packet silently, if checksum is wrong */
1218 	if (udp_lib_checksum_complete(skb))
1219 		goto csum_error;
1220 
1221 	UDP_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
1222 	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
1223 
1224 	/*
1225 	 * Hmm.  We got an UDP packet to a port to which we
1226 	 * don't wanna listen.  Ignore it.
1227 	 */
1228 	kfree_skb(skb);
1229 	return 0;
1230 
1231 short_packet:
1232 	LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: short packet: From " NIPQUAD_FMT ":%u %d/%d to " NIPQUAD_FMT ":%u\n",
1233 		       proto == IPPROTO_UDPLITE ? "-Lite" : "",
1234 		       NIPQUAD(saddr),
1235 		       ntohs(uh->source),
1236 		       ulen,
1237 		       skb->len,
1238 		       NIPQUAD(daddr),
1239 		       ntohs(uh->dest));
1240 	goto drop;
1241 
1242 csum_error:
1243 	/*
1244 	 * RFC1122: OK.  Discards the bad packet silently (as far as
1245 	 * the network is concerned, anyway) as per 4.1.3.4 (MUST).
1246 	 */
1247 	LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: bad checksum. From " NIPQUAD_FMT ":%u to " NIPQUAD_FMT ":%u ulen %d\n",
1248 		       proto == IPPROTO_UDPLITE ? "-Lite" : "",
1249 		       NIPQUAD(saddr),
1250 		       ntohs(uh->source),
1251 		       NIPQUAD(daddr),
1252 		       ntohs(uh->dest),
1253 		       ulen);
1254 drop:
1255 	UDP_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
1256 	kfree_skb(skb);
1257 	return 0;
1258 }
1259 
1260 int udp_rcv(struct sk_buff *skb)
1261 {
1262 	return __udp4_lib_rcv(skb, udp_hash, IPPROTO_UDP);
1263 }
1264 
1265 void udp_destroy_sock(struct sock *sk)
1266 {
1267 	lock_sock(sk);
1268 	udp_flush_pending_frames(sk);
1269 	release_sock(sk);
1270 }
1271 
1272 /*
1273  *	Socket option code for UDP
1274  */
1275 int udp_lib_setsockopt(struct sock *sk, int level, int optname,
1276 		       char __user *optval, int optlen,
1277 		       int (*push_pending_frames)(struct sock *))
1278 {
1279 	struct udp_sock *up = udp_sk(sk);
1280 	int val;
1281 	int err = 0;
1282 	int is_udplite = IS_UDPLITE(sk);
1283 
1284 	if (optlen<sizeof(int))
1285 		return -EINVAL;
1286 
1287 	if (get_user(val, (int __user *)optval))
1288 		return -EFAULT;
1289 
1290 	switch (optname) {
1291 	case UDP_CORK:
1292 		if (val != 0) {
1293 			up->corkflag = 1;
1294 		} else {
1295 			up->corkflag = 0;
1296 			lock_sock(sk);
1297 			(*push_pending_frames)(sk);
1298 			release_sock(sk);
1299 		}
1300 		break;
1301 
1302 	case UDP_ENCAP:
1303 		switch (val) {
1304 		case 0:
1305 		case UDP_ENCAP_ESPINUDP:
1306 		case UDP_ENCAP_ESPINUDP_NON_IKE:
1307 			up->encap_rcv = xfrm4_udp_encap_rcv;
1308 			/* FALLTHROUGH */
1309 		case UDP_ENCAP_L2TPINUDP:
1310 			up->encap_type = val;
1311 			break;
1312 		default:
1313 			err = -ENOPROTOOPT;
1314 			break;
1315 		}
1316 		break;
1317 
1318 	/*
1319 	 * 	UDP-Lite's partial checksum coverage (RFC 3828).
1320 	 */
1321 	/* The sender sets actual checksum coverage length via this option.
1322 	 * The case coverage > packet length is handled by send module. */
1323 	case UDPLITE_SEND_CSCOV:
1324 		if (!is_udplite)         /* Disable the option on UDP sockets */
1325 			return -ENOPROTOOPT;
1326 		if (val != 0 && val < 8) /* Illegal coverage: use default (8) */
1327 			val = 8;
1328 		else if (val > USHORT_MAX)
1329 			val = USHORT_MAX;
1330 		up->pcslen = val;
1331 		up->pcflag |= UDPLITE_SEND_CC;
1332 		break;
1333 
1334 	/* The receiver specifies a minimum checksum coverage value. To make
1335 	 * sense, this should be set to at least 8 (as done below). If zero is
1336 	 * used, this again means full checksum coverage.                     */
1337 	case UDPLITE_RECV_CSCOV:
1338 		if (!is_udplite)         /* Disable the option on UDP sockets */
1339 			return -ENOPROTOOPT;
1340 		if (val != 0 && val < 8) /* Avoid silly minimal values.       */
1341 			val = 8;
1342 		else if (val > USHORT_MAX)
1343 			val = USHORT_MAX;
1344 		up->pcrlen = val;
1345 		up->pcflag |= UDPLITE_RECV_CC;
1346 		break;
1347 
1348 	default:
1349 		err = -ENOPROTOOPT;
1350 		break;
1351 	}
1352 
1353 	return err;
1354 }
1355 
1356 int udp_setsockopt(struct sock *sk, int level, int optname,
1357 		   char __user *optval, int optlen)
1358 {
1359 	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1360 		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1361 					  udp_push_pending_frames);
1362 	return ip_setsockopt(sk, level, optname, optval, optlen);
1363 }
1364 
1365 #ifdef CONFIG_COMPAT
1366 int compat_udp_setsockopt(struct sock *sk, int level, int optname,
1367 			  char __user *optval, int optlen)
1368 {
1369 	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1370 		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1371 					  udp_push_pending_frames);
1372 	return compat_ip_setsockopt(sk, level, optname, optval, optlen);
1373 }
1374 #endif
1375 
1376 int udp_lib_getsockopt(struct sock *sk, int level, int optname,
1377 		       char __user *optval, int __user *optlen)
1378 {
1379 	struct udp_sock *up = udp_sk(sk);
1380 	int val, len;
1381 
1382 	if (get_user(len,optlen))
1383 		return -EFAULT;
1384 
1385 	len = min_t(unsigned int, len, sizeof(int));
1386 
1387 	if (len < 0)
1388 		return -EINVAL;
1389 
1390 	switch (optname) {
1391 	case UDP_CORK:
1392 		val = up->corkflag;
1393 		break;
1394 
1395 	case UDP_ENCAP:
1396 		val = up->encap_type;
1397 		break;
1398 
1399 	/* The following two cannot be changed on UDP sockets, the return is
1400 	 * always 0 (which corresponds to the full checksum coverage of UDP). */
1401 	case UDPLITE_SEND_CSCOV:
1402 		val = up->pcslen;
1403 		break;
1404 
1405 	case UDPLITE_RECV_CSCOV:
1406 		val = up->pcrlen;
1407 		break;
1408 
1409 	default:
1410 		return -ENOPROTOOPT;
1411 	}
1412 
1413 	if (put_user(len, optlen))
1414 		return -EFAULT;
1415 	if (copy_to_user(optval, &val,len))
1416 		return -EFAULT;
1417 	return 0;
1418 }
1419 
1420 int udp_getsockopt(struct sock *sk, int level, int optname,
1421 		   char __user *optval, int __user *optlen)
1422 {
1423 	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1424 		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1425 	return ip_getsockopt(sk, level, optname, optval, optlen);
1426 }
1427 
1428 #ifdef CONFIG_COMPAT
1429 int compat_udp_getsockopt(struct sock *sk, int level, int optname,
1430 				 char __user *optval, int __user *optlen)
1431 {
1432 	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1433 		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1434 	return compat_ip_getsockopt(sk, level, optname, optval, optlen);
1435 }
1436 #endif
1437 /**
1438  * 	udp_poll - wait for a UDP event.
1439  *	@file - file struct
1440  *	@sock - socket
1441  *	@wait - poll table
1442  *
1443  *	This is same as datagram poll, except for the special case of
1444  *	blocking sockets. If application is using a blocking fd
1445  *	and a packet with checksum error is in the queue;
1446  *	then it could get return from select indicating data available
1447  *	but then block when reading it. Add special case code
1448  *	to work around these arguably broken applications.
1449  */
1450 unsigned int udp_poll(struct file *file, struct socket *sock, poll_table *wait)
1451 {
1452 	unsigned int mask = datagram_poll(file, sock, wait);
1453 	struct sock *sk = sock->sk;
1454 	int 	is_lite = IS_UDPLITE(sk);
1455 
1456 	/* Check for false positives due to checksum errors */
1457 	if ( (mask & POLLRDNORM) &&
1458 	     !(file->f_flags & O_NONBLOCK) &&
1459 	     !(sk->sk_shutdown & RCV_SHUTDOWN)){
1460 		struct sk_buff_head *rcvq = &sk->sk_receive_queue;
1461 		struct sk_buff *skb;
1462 
1463 		spin_lock_bh(&rcvq->lock);
1464 		while ((skb = skb_peek(rcvq)) != NULL &&
1465 		       udp_lib_checksum_complete(skb)) {
1466 			UDP_INC_STATS_BH(sock_net(sk),
1467 					UDP_MIB_INERRORS, is_lite);
1468 			__skb_unlink(skb, rcvq);
1469 			kfree_skb(skb);
1470 		}
1471 		spin_unlock_bh(&rcvq->lock);
1472 
1473 		/* nothing to see, move along */
1474 		if (skb == NULL)
1475 			mask &= ~(POLLIN | POLLRDNORM);
1476 	}
1477 
1478 	return mask;
1479 
1480 }
1481 
1482 struct proto udp_prot = {
1483 	.name		   = "UDP",
1484 	.owner		   = THIS_MODULE,
1485 	.close		   = udp_lib_close,
1486 	.connect	   = ip4_datagram_connect,
1487 	.disconnect	   = udp_disconnect,
1488 	.ioctl		   = udp_ioctl,
1489 	.destroy	   = udp_destroy_sock,
1490 	.setsockopt	   = udp_setsockopt,
1491 	.getsockopt	   = udp_getsockopt,
1492 	.sendmsg	   = udp_sendmsg,
1493 	.recvmsg	   = udp_recvmsg,
1494 	.sendpage	   = udp_sendpage,
1495 	.backlog_rcv	   = udp_queue_rcv_skb,
1496 	.hash		   = udp_lib_hash,
1497 	.unhash		   = udp_lib_unhash,
1498 	.get_port	   = udp_v4_get_port,
1499 	.memory_allocated  = &udp_memory_allocated,
1500 	.sysctl_mem	   = sysctl_udp_mem,
1501 	.sysctl_wmem	   = &sysctl_udp_wmem_min,
1502 	.sysctl_rmem	   = &sysctl_udp_rmem_min,
1503 	.obj_size	   = sizeof(struct udp_sock),
1504 	.h.udp_hash	   = udp_hash,
1505 #ifdef CONFIG_COMPAT
1506 	.compat_setsockopt = compat_udp_setsockopt,
1507 	.compat_getsockopt = compat_udp_getsockopt,
1508 #endif
1509 };
1510 
1511 /* ------------------------------------------------------------------------ */
1512 #ifdef CONFIG_PROC_FS
1513 
1514 static struct sock *udp_get_first(struct seq_file *seq)
1515 {
1516 	struct sock *sk;
1517 	struct udp_iter_state *state = seq->private;
1518 	struct net *net = seq_file_net(seq);
1519 
1520 	for (state->bucket = 0; state->bucket < UDP_HTABLE_SIZE; ++state->bucket) {
1521 		struct hlist_node *node;
1522 		sk_for_each(sk, node, state->hashtable + state->bucket) {
1523 			if (!net_eq(sock_net(sk), net))
1524 				continue;
1525 			if (sk->sk_family == state->family)
1526 				goto found;
1527 		}
1528 	}
1529 	sk = NULL;
1530 found:
1531 	return sk;
1532 }
1533 
1534 static struct sock *udp_get_next(struct seq_file *seq, struct sock *sk)
1535 {
1536 	struct udp_iter_state *state = seq->private;
1537 	struct net *net = seq_file_net(seq);
1538 
1539 	do {
1540 		sk = sk_next(sk);
1541 try_again:
1542 		;
1543 	} while (sk && (!net_eq(sock_net(sk), net) || sk->sk_family != state->family));
1544 
1545 	if (!sk && ++state->bucket < UDP_HTABLE_SIZE) {
1546 		sk = sk_head(state->hashtable + state->bucket);
1547 		goto try_again;
1548 	}
1549 	return sk;
1550 }
1551 
1552 static struct sock *udp_get_idx(struct seq_file *seq, loff_t pos)
1553 {
1554 	struct sock *sk = udp_get_first(seq);
1555 
1556 	if (sk)
1557 		while (pos && (sk = udp_get_next(seq, sk)) != NULL)
1558 			--pos;
1559 	return pos ? NULL : sk;
1560 }
1561 
1562 static void *udp_seq_start(struct seq_file *seq, loff_t *pos)
1563 	__acquires(udp_hash_lock)
1564 {
1565 	read_lock(&udp_hash_lock);
1566 	return *pos ? udp_get_idx(seq, *pos-1) : SEQ_START_TOKEN;
1567 }
1568 
1569 static void *udp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1570 {
1571 	struct sock *sk;
1572 
1573 	if (v == SEQ_START_TOKEN)
1574 		sk = udp_get_idx(seq, 0);
1575 	else
1576 		sk = udp_get_next(seq, v);
1577 
1578 	++*pos;
1579 	return sk;
1580 }
1581 
1582 static void udp_seq_stop(struct seq_file *seq, void *v)
1583 	__releases(udp_hash_lock)
1584 {
1585 	read_unlock(&udp_hash_lock);
1586 }
1587 
1588 static int udp_seq_open(struct inode *inode, struct file *file)
1589 {
1590 	struct udp_seq_afinfo *afinfo = PDE(inode)->data;
1591 	struct udp_iter_state *s;
1592 	int err;
1593 
1594 	err = seq_open_net(inode, file, &afinfo->seq_ops,
1595 			   sizeof(struct udp_iter_state));
1596 	if (err < 0)
1597 		return err;
1598 
1599 	s = ((struct seq_file *)file->private_data)->private;
1600 	s->family		= afinfo->family;
1601 	s->hashtable		= afinfo->hashtable;
1602 	return err;
1603 }
1604 
1605 /* ------------------------------------------------------------------------ */
1606 int udp_proc_register(struct net *net, struct udp_seq_afinfo *afinfo)
1607 {
1608 	struct proc_dir_entry *p;
1609 	int rc = 0;
1610 
1611 	afinfo->seq_fops.open		= udp_seq_open;
1612 	afinfo->seq_fops.read		= seq_read;
1613 	afinfo->seq_fops.llseek		= seq_lseek;
1614 	afinfo->seq_fops.release	= seq_release_net;
1615 
1616 	afinfo->seq_ops.start		= udp_seq_start;
1617 	afinfo->seq_ops.next		= udp_seq_next;
1618 	afinfo->seq_ops.stop		= udp_seq_stop;
1619 
1620 	p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
1621 			     &afinfo->seq_fops, afinfo);
1622 	if (!p)
1623 		rc = -ENOMEM;
1624 	return rc;
1625 }
1626 
1627 void udp_proc_unregister(struct net *net, struct udp_seq_afinfo *afinfo)
1628 {
1629 	proc_net_remove(net, afinfo->name);
1630 }
1631 
1632 /* ------------------------------------------------------------------------ */
1633 static void udp4_format_sock(struct sock *sp, struct seq_file *f,
1634 		int bucket, int *len)
1635 {
1636 	struct inet_sock *inet = inet_sk(sp);
1637 	__be32 dest = inet->daddr;
1638 	__be32 src  = inet->rcv_saddr;
1639 	__u16 destp	  = ntohs(inet->dport);
1640 	__u16 srcp	  = ntohs(inet->sport);
1641 
1642 	seq_printf(f, "%4d: %08X:%04X %08X:%04X"
1643 		" %02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d%n",
1644 		bucket, src, srcp, dest, destp, sp->sk_state,
1645 		atomic_read(&sp->sk_wmem_alloc),
1646 		atomic_read(&sp->sk_rmem_alloc),
1647 		0, 0L, 0, sock_i_uid(sp), 0, sock_i_ino(sp),
1648 		atomic_read(&sp->sk_refcnt), sp,
1649 		atomic_read(&sp->sk_drops), len);
1650 }
1651 
1652 int udp4_seq_show(struct seq_file *seq, void *v)
1653 {
1654 	if (v == SEQ_START_TOKEN)
1655 		seq_printf(seq, "%-127s\n",
1656 			   "  sl  local_address rem_address   st tx_queue "
1657 			   "rx_queue tr tm->when retrnsmt   uid  timeout "
1658 			   "inode ref pointer drops");
1659 	else {
1660 		struct udp_iter_state *state = seq->private;
1661 		int len;
1662 
1663 		udp4_format_sock(v, seq, state->bucket, &len);
1664 		seq_printf(seq, "%*s\n", 127 - len ,"");
1665 	}
1666 	return 0;
1667 }
1668 
1669 /* ------------------------------------------------------------------------ */
1670 static struct udp_seq_afinfo udp4_seq_afinfo = {
1671 	.name		= "udp",
1672 	.family		= AF_INET,
1673 	.hashtable	= udp_hash,
1674 	.seq_fops	= {
1675 		.owner	=	THIS_MODULE,
1676 	},
1677 	.seq_ops	= {
1678 		.show		= udp4_seq_show,
1679 	},
1680 };
1681 
1682 static int udp4_proc_init_net(struct net *net)
1683 {
1684 	return udp_proc_register(net, &udp4_seq_afinfo);
1685 }
1686 
1687 static void udp4_proc_exit_net(struct net *net)
1688 {
1689 	udp_proc_unregister(net, &udp4_seq_afinfo);
1690 }
1691 
1692 static struct pernet_operations udp4_net_ops = {
1693 	.init = udp4_proc_init_net,
1694 	.exit = udp4_proc_exit_net,
1695 };
1696 
1697 int __init udp4_proc_init(void)
1698 {
1699 	return register_pernet_subsys(&udp4_net_ops);
1700 }
1701 
1702 void udp4_proc_exit(void)
1703 {
1704 	unregister_pernet_subsys(&udp4_net_ops);
1705 }
1706 #endif /* CONFIG_PROC_FS */
1707 
1708 void __init udp_init(void)
1709 {
1710 	unsigned long limit;
1711 
1712 	/* Set the pressure threshold up by the same strategy of TCP. It is a
1713 	 * fraction of global memory that is up to 1/2 at 256 MB, decreasing
1714 	 * toward zero with the amount of memory, with a floor of 128 pages.
1715 	 */
1716 	limit = min(nr_all_pages, 1UL<<(28-PAGE_SHIFT)) >> (20-PAGE_SHIFT);
1717 	limit = (limit * (nr_all_pages >> (20-PAGE_SHIFT))) >> (PAGE_SHIFT-11);
1718 	limit = max(limit, 128UL);
1719 	sysctl_udp_mem[0] = limit / 4 * 3;
1720 	sysctl_udp_mem[1] = limit;
1721 	sysctl_udp_mem[2] = sysctl_udp_mem[0] * 2;
1722 
1723 	sysctl_udp_rmem_min = SK_MEM_QUANTUM;
1724 	sysctl_udp_wmem_min = SK_MEM_QUANTUM;
1725 }
1726 
1727 EXPORT_SYMBOL(udp_disconnect);
1728 EXPORT_SYMBOL(udp_hash);
1729 EXPORT_SYMBOL(udp_hash_lock);
1730 EXPORT_SYMBOL(udp_ioctl);
1731 EXPORT_SYMBOL(udp_prot);
1732 EXPORT_SYMBOL(udp_sendmsg);
1733 EXPORT_SYMBOL(udp_lib_getsockopt);
1734 EXPORT_SYMBOL(udp_lib_setsockopt);
1735 EXPORT_SYMBOL(udp_poll);
1736 EXPORT_SYMBOL(udp_lib_get_port);
1737 
1738 #ifdef CONFIG_PROC_FS
1739 EXPORT_SYMBOL(udp_proc_register);
1740 EXPORT_SYMBOL(udp_proc_unregister);
1741 #endif
1742