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