source: src/linux/brcm/linux-2.6.23/net/ipv4/udp.c @ 31864

Last change on this file since 31864 was 31864, checked in by brainslayer, 6 weeks ago

backport udp checksum fix

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