source: src/linux/universal/linux-3.5/net/ipv4/udp.c @ 31863

Last change on this file since 31863 was 31863, checked in by brainslayer, 2 months ago

backport udp checksum fix

File size: 58.2 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 * Authors:     Ross Biro
9 *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10 *              Arnt Gulbrandsen, <agulbra@nvg.unit.no>
11 *              Alan Cox, <alan@lxorguk.ukuu.org.uk>
12 *              Hirokazu Takahashi, <taka@valinux.co.jp>
13 *
14 * Fixes:
15 *              Alan Cox        :       verify_area() calls
16 *              Alan Cox        :       stopped close while in use off icmp
17 *                                      messages. Not a fix but a botch that
18 *                                      for udp at least is 'valid'.
19 *              Alan Cox        :       Fixed icmp handling properly
20 *              Alan Cox        :       Correct error for oversized datagrams
21 *              Alan Cox        :       Tidied select() semantics.
22 *              Alan Cox        :       udp_err() fixed properly, also now
23 *                                      select and read wake correctly on errors
24 *              Alan Cox        :       udp_send verify_area moved to avoid mem leak
25 *              Alan Cox        :       UDP can count its memory
26 *              Alan Cox        :       send to an unknown connection causes
27 *                                      an ECONNREFUSED off the icmp, but
28 *                                      does NOT close.
29 *              Alan Cox        :       Switched to new sk_buff handlers. No more backlog!
30 *              Alan Cox        :       Using generic datagram code. Even smaller and the PEEK
31 *                                      bug no longer crashes it.
32 *              Fred Van Kempen :       Net2e support for sk->broadcast.
33 *              Alan Cox        :       Uses skb_free_datagram
34 *              Alan Cox        :       Added get/set sockopt support.
35 *              Alan Cox        :       Broadcasting without option set returns EACCES.
36 *              Alan Cox        :       No wakeup calls. Instead we now use the callbacks.
37 *              Alan Cox        :       Use ip_tos and ip_ttl
38 *              Alan Cox        :       SNMP Mibs
39 *              Alan Cox        :       MSG_DONTROUTE, and 0.0.0.0 support.
40 *              Matt Dillon     :       UDP length checks.
41 *              Alan Cox        :       Smarter af_inet used properly.
42 *              Alan Cox        :       Use new kernel side addressing.
43 *              Alan Cox        :       Incorrect return on truncated datagram receive.
44 *      Arnt Gulbrandsen        :       New udp_send and stuff
45 *              Alan Cox        :       Cache last socket
46 *              Alan Cox        :       Route cache
47 *              Jon Peatfield   :       Minor efficiency fix to sendto().
48 *              Mike Shaver     :       RFC1122 checks.
49 *              Alan Cox        :       Nonblocking error fix.
50 *      Willy Konynenberg       :       Transparent proxying support.
51 *              Mike McLagan    :       Routing by source
52 *              David S. Miller :       New socket lookup architecture.
53 *                                      Last socket cache retained as it
54 *                                      does have a high hit rate.
55 *              Olaf Kirch      :       Don't linearise iovec on sendmsg.
56 *              Andi Kleen      :       Some cleanups, cache destination entry
57 *                                      for connect.
58 *      Vitaly E. Lavrov        :       Transparent proxy revived after year coma.
59 *              Melvin Smith    :       Check msg_name not msg_namelen in sendto(),
60 *                                      return ENOTCONN for unconnected sockets (POSIX)
61 *              Janos Farkas    :       don't deliver multi/broadcasts to a different
62 *                                      bound-to-device socket
63 *      Hirokazu Takahashi      :       HW checksumming for outgoing UDP
64 *                                      datagrams.
65 *      Hirokazu Takahashi      :       sendfile() on UDP works now.
66 *              Arnaldo C. Melo :       convert /proc/net/udp to seq_file
67 *      YOSHIFUJI Hideaki @USAGI and:   Support IPV6_V6ONLY socket option, which
68 *      Alexey Kuznetsov:               allow both IPv4 and IPv6 sockets to bind
69 *                                      a single port at the same time.
70 *      Derek Atkins <derek@ihtfp.com>: Add Encapulation Support
71 *      James Chapman           :       Add L2TP encapsulation type.
72 *
73 *
74 *              This program is free software; you can redistribute it and/or
75 *              modify it under the terms of the GNU General Public License
76 *              as published by the Free Software Foundation; either version
77 *              2 of the License, or (at your option) any later version.
78 */
79
80#define pr_fmt(fmt) "UDP: " fmt
81
82#include <asm/uaccess.h>
83#include <asm/ioctls.h>
84#include <linux/bootmem.h>
85#include <linux/highmem.h>
86#include <linux/swap.h>
87#include <linux/types.h>
88#include <linux/fcntl.h>
89#include <linux/module.h>
90#include <linux/socket.h>
91#include <linux/sockios.h>
92#include <linux/igmp.h>
93#include <linux/in.h>
94#include <linux/errno.h>
95#include <linux/timer.h>
96#include <linux/mm.h>
97#include <linux/inet.h>
98#include <linux/netdevice.h>
99#include <linux/slab.h>
100#include <net/tcp_states.h>
101#include <linux/skbuff.h>
102#include <linux/proc_fs.h>
103#include <linux/seq_file.h>
104#include <net/net_namespace.h>
105#include <net/icmp.h>
106#include <net/route.h>
107#include <net/checksum.h>
108#include <net/xfrm.h>
109#include <trace/events/udp.h>
110#include <linux/static_key.h>
111#include "udp_impl.h"
112
113#if defined(CONFIG_IFX_UDP_REDIRECT) || defined(CONFIG_IFX_UDP_REDIRECT_MODULE)
114#include <linux/udp_redirect.h>
115#endif
116
117struct udp_table udp_table __read_mostly;
118EXPORT_SYMBOL(udp_table);
119
120long sysctl_udp_mem[3] __read_mostly;
121EXPORT_SYMBOL(sysctl_udp_mem);
122
123int sysctl_udp_rmem_min __read_mostly;
124EXPORT_SYMBOL(sysctl_udp_rmem_min);
125
126int sysctl_udp_wmem_min __read_mostly;
127EXPORT_SYMBOL(sysctl_udp_wmem_min);
128
129atomic_long_t udp_memory_allocated;
130EXPORT_SYMBOL(udp_memory_allocated);
131
132#define MAX_UDP_PORTS 65536
133#define PORTS_PER_CHAIN (MAX_UDP_PORTS / UDP_HTABLE_SIZE_MIN)
134
135static int udp_lib_lport_inuse(struct net *net, __u16 num,
136                               const struct udp_hslot *hslot,
137                               unsigned long *bitmap,
138                               struct sock *sk,
139                               int (*saddr_comp)(const struct sock *sk1,
140                                                 const struct sock *sk2),
141                               unsigned int log)
142{
143        struct sock *sk2;
144        struct hlist_nulls_node *node;
145
146        sk_nulls_for_each(sk2, node, &hslot->head)
147                if (net_eq(sock_net(sk2), net) &&
148                    sk2 != sk &&
149                    (bitmap || udp_sk(sk2)->udp_port_hash == num) &&
150                    (!sk2->sk_reuse || !sk->sk_reuse) &&
151                    (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
152                     sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
153                    (*saddr_comp)(sk, sk2)) {
154                        if (bitmap)
155                                __set_bit(udp_sk(sk2)->udp_port_hash >> log,
156                                          bitmap);
157                        else
158                                return 1;
159                }
160        return 0;
161}
162
163/*
164 * Note: we still hold spinlock of primary hash chain, so no other writer
165 * can insert/delete a socket with local_port == num
166 */
167static int udp_lib_lport_inuse2(struct net *net, __u16 num,
168                               struct udp_hslot *hslot2,
169                               struct sock *sk,
170                               int (*saddr_comp)(const struct sock *sk1,
171                                                 const struct sock *sk2))
172{
173        struct sock *sk2;
174        struct hlist_nulls_node *node;
175        int res = 0;
176
177        spin_lock(&hslot2->lock);
178        udp_portaddr_for_each_entry(sk2, node, &hslot2->head)
179                if (net_eq(sock_net(sk2), net) &&
180                    sk2 != sk &&
181                    (udp_sk(sk2)->udp_port_hash == num) &&
182                    (!sk2->sk_reuse || !sk->sk_reuse) &&
183                    (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
184                     sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
185                    (*saddr_comp)(sk, sk2)) {
186                        res = 1;
187                        break;
188                }
189        spin_unlock(&hslot2->lock);
190        return res;
191}
192
193/**
194 *  udp_lib_get_port  -  UDP/-Lite port lookup for IPv4 and IPv6
195 *
196 *  @sk:          socket struct in question
197 *  @snum:        port number to look up
198 *  @saddr_comp:  AF-dependent comparison of bound local IP addresses
199 *  @hash2_nulladdr: AF-dependent hash value in secondary hash chains,
200 *                   with NULL address
201 */
202int udp_lib_get_port(struct sock *sk, unsigned short snum,
203                       int (*saddr_comp)(const struct sock *sk1,
204                                         const struct sock *sk2),
205                     unsigned int hash2_nulladdr)
206{
207        struct udp_hslot *hslot, *hslot2;
208        struct udp_table *udptable = sk->sk_prot->h.udp_table;
209        int    error = 1;
210        struct net *net = sock_net(sk);
211
212        if (!snum) {
213                int low, high, remaining;
214                unsigned int rand;
215                unsigned short first, last;
216                DECLARE_BITMAP(bitmap, PORTS_PER_CHAIN);
217
218                inet_get_local_port_range(&low, &high);
219                remaining = (high - low) + 1;
220
221                rand = net_random();
222                first = (((u64)rand * remaining) >> 32) + low;
223                /*
224                 * force rand to be an odd multiple of UDP_HTABLE_SIZE
225                 */
226                rand = (rand | 1) * (udptable->mask + 1);
227                last = first + udptable->mask + 1;
228                do {
229                        hslot = udp_hashslot(udptable, net, first);
230                        bitmap_zero(bitmap, PORTS_PER_CHAIN);
231                        spin_lock_bh(&hslot->lock);
232                        udp_lib_lport_inuse(net, snum, hslot, bitmap, sk,
233                                            saddr_comp, udptable->log);
234
235                        snum = first;
236                        /*
237                         * Iterate on all possible values of snum for this hash.
238                         * Using steps of an odd multiple of UDP_HTABLE_SIZE
239                         * give us randomization and full range coverage.
240                         */
241                        do {
242                                if (low <= snum && snum <= high &&
243                                    !test_bit(snum >> udptable->log, bitmap) &&
244                                    !inet_is_reserved_local_port(snum))
245                                        goto found;
246                                snum += rand;
247                        } while (snum != first);
248                        spin_unlock_bh(&hslot->lock);
249                } while (++first != last);
250                goto fail;
251        } else {
252                hslot = udp_hashslot(udptable, net, snum);
253                spin_lock_bh(&hslot->lock);
254                if (hslot->count > 10) {
255                        int exist;
256                        unsigned int slot2 = udp_sk(sk)->udp_portaddr_hash ^ snum;
257
258                        slot2          &= udptable->mask;
259                        hash2_nulladdr &= udptable->mask;
260
261                        hslot2 = udp_hashslot2(udptable, slot2);
262                        if (hslot->count < hslot2->count)
263                                goto scan_primary_hash;
264
265                        exist = udp_lib_lport_inuse2(net, snum, hslot2,
266                                                     sk, saddr_comp);
267                        if (!exist && (hash2_nulladdr != slot2)) {
268                                hslot2 = udp_hashslot2(udptable, hash2_nulladdr);
269                                exist = udp_lib_lport_inuse2(net, snum, hslot2,
270                                                             sk, saddr_comp);
271                        }
272                        if (exist)
273                                goto fail_unlock;
274                        else
275                                goto found;
276                }
277scan_primary_hash:
278                if (udp_lib_lport_inuse(net, snum, hslot, NULL, sk,
279                                        saddr_comp, 0))
280                        goto fail_unlock;
281        }
282found:
283        inet_sk(sk)->inet_num = snum;
284        udp_sk(sk)->udp_port_hash = snum;
285        udp_sk(sk)->udp_portaddr_hash ^= snum;
286        if (sk_unhashed(sk)) {
287                sk_nulls_add_node_rcu(sk, &hslot->head);
288                hslot->count++;
289                sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
290
291                hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
292                spin_lock(&hslot2->lock);
293                hlist_nulls_add_head_rcu(&udp_sk(sk)->udp_portaddr_node,
294                                         &hslot2->head);
295                hslot2->count++;
296                spin_unlock(&hslot2->lock);
297        }
298        error = 0;
299fail_unlock:
300        spin_unlock_bh(&hslot->lock);
301fail:
302        return error;
303}
304EXPORT_SYMBOL(udp_lib_get_port);
305
306static int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)
307{
308        struct inet_sock *inet1 = inet_sk(sk1), *inet2 = inet_sk(sk2);
309
310        return  (!ipv6_only_sock(sk2)  &&
311                 (!inet1->inet_rcv_saddr || !inet2->inet_rcv_saddr ||
312                   inet1->inet_rcv_saddr == inet2->inet_rcv_saddr));
313}
314
315static unsigned int udp4_portaddr_hash(struct net *net, __be32 saddr,
316                                       unsigned int port)
317{
318        return jhash_1word((__force u32)saddr, net_hash_mix(net)) ^ port;
319}
320
321int udp_v4_get_port(struct sock *sk, unsigned short snum)
322{
323        unsigned int hash2_nulladdr =
324                udp4_portaddr_hash(sock_net(sk), htonl(INADDR_ANY), snum);
325        unsigned int hash2_partial =
326                udp4_portaddr_hash(sock_net(sk), inet_sk(sk)->inet_rcv_saddr, 0);
327
328        /* precompute partial secondary hash */
329        udp_sk(sk)->udp_portaddr_hash = hash2_partial;
330        return udp_lib_get_port(sk, snum, ipv4_rcv_saddr_equal, hash2_nulladdr);
331}
332
333static inline int compute_score(struct sock *sk, struct net *net, __be32 saddr,
334                         unsigned short hnum,
335                         __be16 sport, __be32 daddr, __be16 dport, int dif)
336{
337        int score = -1;
338
339        if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
340                        !ipv6_only_sock(sk)) {
341                struct inet_sock *inet = inet_sk(sk);
342
343                score = (sk->sk_family == PF_INET ? 1 : 0);
344                if (inet->inet_rcv_saddr) {
345                        if (inet->inet_rcv_saddr != daddr)
346                                return -1;
347                        score += 2;
348                }
349                if (inet->inet_daddr) {
350                        if (inet->inet_daddr != saddr)
351                                return -1;
352                        score += 2;
353                }
354                if (inet->inet_dport) {
355                        if (inet->inet_dport != sport)
356                                return -1;
357                        score += 2;
358                }
359                if (sk->sk_bound_dev_if) {
360                        if (sk->sk_bound_dev_if != dif)
361                                return -1;
362                        score += 2;
363                }
364        }
365        return score;
366}
367
368/*
369 * In this second variant, we check (daddr, dport) matches (inet_rcv_sadd, inet_num)
370 */
371#define SCORE2_MAX (1 + 2 + 2 + 2)
372static inline int compute_score2(struct sock *sk, struct net *net,
373                                 __be32 saddr, __be16 sport,
374                                 __be32 daddr, unsigned int hnum, int dif)
375{
376        int score = -1;
377
378        if (net_eq(sock_net(sk), net) && !ipv6_only_sock(sk)) {
379                struct inet_sock *inet = inet_sk(sk);
380
381                if (inet->inet_rcv_saddr != daddr)
382                        return -1;
383                if (inet->inet_num != hnum)
384                        return -1;
385
386                score = (sk->sk_family == PF_INET ? 1 : 0);
387                if (inet->inet_daddr) {
388                        if (inet->inet_daddr != saddr)
389                                return -1;
390                        score += 2;
391                }
392                if (inet->inet_dport) {
393                        if (inet->inet_dport != sport)
394                                return -1;
395                        score += 2;
396                }
397                if (sk->sk_bound_dev_if) {
398                        if (sk->sk_bound_dev_if != dif)
399                                return -1;
400                        score += 2;
401                }
402        }
403        return score;
404}
405
406
407/* called with read_rcu_lock() */
408static struct sock *udp4_lib_lookup2(struct net *net,
409                __be32 saddr, __be16 sport,
410                __be32 daddr, unsigned int hnum, int dif,
411                struct udp_hslot *hslot2, unsigned int slot2)
412{
413        struct sock *sk, *result;
414        struct hlist_nulls_node *node;
415        int score, badness;
416
417begin:
418        result = NULL;
419        badness = -1;
420        udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
421                score = compute_score2(sk, net, saddr, sport,
422                                      daddr, hnum, dif);
423                if (score > badness) {
424                        result = sk;
425                        badness = score;
426                        if (score == SCORE2_MAX)
427                                goto exact_match;
428                }
429        }
430        /*
431         * if the nulls value we got at the end of this lookup is
432         * not the expected one, we must restart lookup.
433         * We probably met an item that was moved to another chain.
434         */
435        if (get_nulls_value(node) != slot2)
436                goto begin;
437
438        if (result) {
439exact_match:
440                if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
441                        result = NULL;
442                else if (unlikely(compute_score2(result, net, saddr, sport,
443                                  daddr, hnum, dif) < badness)) {
444                        sock_put(result);
445                        goto begin;
446                }
447        }
448        return result;
449}
450
451/* UDP is nearly always wildcards out the wazoo, it makes no sense to try
452 * harder than this. -DaveM
453 */
454struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,
455                __be16 sport, __be32 daddr, __be16 dport,
456                int dif, struct udp_table *udptable)
457{
458        struct sock *sk, *result;
459        struct hlist_nulls_node *node;
460        unsigned short hnum = ntohs(dport);
461        unsigned int hash2, slot2, slot = udp_hashfn(net, hnum, udptable->mask);
462        struct udp_hslot *hslot2, *hslot = &udptable->hash[slot];
463        int score, badness;
464
465        rcu_read_lock();
466        if (hslot->count > 10) {
467                hash2 = udp4_portaddr_hash(net, daddr, hnum);
468                slot2 = hash2 & udptable->mask;
469                hslot2 = &udptable->hash2[slot2];
470                if (hslot->count < hslot2->count)
471                        goto begin;
472
473                result = udp4_lib_lookup2(net, saddr, sport,
474                                          daddr, hnum, dif,
475                                          hslot2, slot2);
476                if (!result) {
477                        hash2 = udp4_portaddr_hash(net, htonl(INADDR_ANY), hnum);
478                        slot2 = hash2 & udptable->mask;
479                        hslot2 = &udptable->hash2[slot2];
480                        if (hslot->count < hslot2->count)
481                                goto begin;
482
483                        result = udp4_lib_lookup2(net, saddr, sport,
484                                                  htonl(INADDR_ANY), hnum, dif,
485                                                  hslot2, slot2);
486                }
487                rcu_read_unlock();
488                return result;
489        }
490begin:
491        result = NULL;
492        badness = -1;
493        sk_nulls_for_each_rcu(sk, node, &hslot->head) {
494                score = compute_score(sk, net, saddr, hnum, sport,
495                                      daddr, dport, dif);
496                if (score > badness) {
497                        result = sk;
498                        badness = score;
499                }
500        }
501        /*
502         * if the nulls value we got at the end of this lookup is
503         * not the expected one, we must restart lookup.
504         * We probably met an item that was moved to another chain.
505         */
506        if (get_nulls_value(node) != slot)
507                goto begin;
508
509        if (result) {
510                if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
511                        result = NULL;
512                else if (unlikely(compute_score(result, net, saddr, hnum, sport,
513                                  daddr, dport, dif) < badness)) {
514                        sock_put(result);
515                        goto begin;
516                }
517        }
518        rcu_read_unlock();
519        return result;
520}
521EXPORT_SYMBOL_GPL(__udp4_lib_lookup);
522
523static inline struct sock *__udp4_lib_lookup_skb(struct sk_buff *skb,
524                                                 __be16 sport, __be16 dport,
525                                                 struct udp_table *udptable)
526{
527        struct sock *sk;
528        const struct iphdr *iph = ip_hdr(skb);
529
530        if (unlikely(sk = skb_steal_sock(skb)))
531                return sk;
532        else
533                return __udp4_lib_lookup(dev_net(skb_dst(skb)->dev), iph->saddr, sport,
534                                         iph->daddr, dport, inet_iif(skb),
535                                         udptable);
536}
537
538struct sock *udp4_lib_lookup(struct net *net, __be32 saddr, __be16 sport,
539                             __be32 daddr, __be16 dport, int dif)
540{
541        return __udp4_lib_lookup(net, saddr, sport, daddr, dport, dif, &udp_table);
542}
543EXPORT_SYMBOL_GPL(udp4_lib_lookup);
544
545static inline struct sock *udp_v4_mcast_next(struct net *net, struct sock *sk,
546                                             __be16 loc_port, __be32 loc_addr,
547                                             __be16 rmt_port, __be32 rmt_addr,
548                                             int dif)
549{
550        struct hlist_nulls_node *node;
551        struct sock *s = sk;
552        unsigned short hnum = ntohs(loc_port);
553
554        sk_nulls_for_each_from(s, node) {
555                struct inet_sock *inet = inet_sk(s);
556
557                if (!net_eq(sock_net(s), net) ||
558                    udp_sk(s)->udp_port_hash != hnum ||
559                    (inet->inet_daddr && inet->inet_daddr != rmt_addr) ||
560                    (inet->inet_dport != rmt_port && inet->inet_dport) ||
561                    (inet->inet_rcv_saddr &&
562                     inet->inet_rcv_saddr != loc_addr) ||
563                    ipv6_only_sock(s) ||
564                    (s->sk_bound_dev_if && s->sk_bound_dev_if != dif))
565                        continue;
566                if (!ip_mc_sf_allow(s, loc_addr, rmt_addr, dif))
567                        continue;
568                goto found;
569        }
570        s = NULL;
571found:
572        return s;
573}
574
575/*
576 * This routine is called by the ICMP module when it gets some
577 * sort of error condition.  If err < 0 then the socket should
578 * be closed and the error returned to the user.  If err > 0
579 * it's just the icmp type << 8 | icmp code.
580 * Header points to the ip header of the error packet. We move
581 * on past this. Then (as it used to claim before adjustment)
582 * header points to the first 8 bytes of the udp header.  We need
583 * to find the appropriate port.
584 */
585
586void __udp4_lib_err(struct sk_buff *skb, u32 info, struct udp_table *udptable)
587{
588        struct inet_sock *inet;
589        const struct iphdr *iph = (const struct iphdr *)skb->data;
590        struct udphdr *uh = (struct udphdr *)(skb->data+(iph->ihl<<2));
591        const int type = icmp_hdr(skb)->type;
592        const int code = icmp_hdr(skb)->code;
593        struct sock *sk;
594        int harderr;
595        int err;
596        struct net *net = dev_net(skb->dev);
597
598        sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,
599                        iph->saddr, uh->source, skb->dev->ifindex, udptable);
600        if (sk == NULL) {
601                ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
602                return; /* No socket for error */
603        }
604
605        err = 0;
606        harderr = 0;
607        inet = inet_sk(sk);
608
609        switch (type) {
610        default:
611        case ICMP_TIME_EXCEEDED:
612                err = EHOSTUNREACH;
613                break;
614        case ICMP_SOURCE_QUENCH:
615                goto out;
616        case ICMP_PARAMETERPROB:
617                err = EPROTO;
618                harderr = 1;
619                break;
620        case ICMP_DEST_UNREACH:
621                if (code == ICMP_FRAG_NEEDED) { /* Path MTU discovery */
622                        if (inet->pmtudisc != IP_PMTUDISC_DONT) {
623                                err = EMSGSIZE;
624                                harderr = 1;
625                                break;
626                        }
627                        goto out;
628                }
629                err = EHOSTUNREACH;
630                if (code <= NR_ICMP_UNREACH) {
631                        harderr = icmp_err_convert[code].fatal;
632                        err = icmp_err_convert[code].errno;
633                }
634                break;
635        }
636
637        /*
638         *      RFC1122: OK.  Passes ICMP errors back to application, as per
639         *      4.1.3.3.
640         */
641        if (!inet->recverr) {
642                if (!harderr || sk->sk_state != TCP_ESTABLISHED)
643                        goto out;
644        } else
645                ip_icmp_error(sk, skb, err, uh->dest, info, (u8 *)(uh+1));
646
647        sk->sk_err = err;
648        sk->sk_error_report(sk);
649out:
650        sock_put(sk);
651}
652
653void udp_err(struct sk_buff *skb, u32 info)
654{
655        __udp4_lib_err(skb, info, &udp_table);
656}
657
658/*
659 * Throw away all pending data and cancel the corking. Socket is locked.
660 */
661void udp_flush_pending_frames(struct sock *sk)
662{
663        struct udp_sock *up = udp_sk(sk);
664
665        if (up->pending) {
666                up->len = 0;
667                up->pending = 0;
668                ip_flush_pending_frames(sk);
669        }
670}
671EXPORT_SYMBOL(udp_flush_pending_frames);
672
673/**
674 *      udp4_hwcsum  -  handle outgoing HW checksumming
675 *      @skb:   sk_buff containing the filled-in UDP header
676 *              (checksum field must be zeroed out)
677 *      @src:   source IP address
678 *      @dst:   destination IP address
679 */
680static void udp4_hwcsum(struct sk_buff *skb, __be32 src, __be32 dst)
681{
682        struct udphdr *uh = udp_hdr(skb);
683        struct sk_buff *frags = skb_shinfo(skb)->frag_list;
684        int offset = skb_transport_offset(skb);
685        int len = skb->len - offset;
686        int hlen = len;
687        __wsum csum = 0;
688
689        if (!frags) {
690                /*
691                 * Only one fragment on the socket.
692                 */
693                skb->csum_start = skb_transport_header(skb) - skb->head;
694                skb->csum_offset = offsetof(struct udphdr, check);
695                uh->check = ~csum_tcpudp_magic(src, dst, len,
696                                               IPPROTO_UDP, 0);
697        } else {
698                /*
699                 * HW-checksum won't work as there are two or more
700                 * fragments on the socket so that all csums of sk_buffs
701                 * should be together
702                 */
703                do {
704                        csum = csum_add(csum, frags->csum);
705                        hlen -= frags->len;
706                } while ((frags = frags->next));
707
708                csum = skb_checksum(skb, offset, hlen, csum);
709                skb->ip_summed = CHECKSUM_NONE;
710
711                uh->check = csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, csum);
712                if (uh->check == 0)
713                        uh->check = CSUM_MANGLED_0;
714        }
715}
716
717static int udp_send_skb(struct sk_buff *skb, struct flowi4 *fl4)
718{
719        struct sock *sk = skb->sk;
720        struct inet_sock *inet = inet_sk(sk);
721        struct udphdr *uh;
722        int err = 0;
723        int is_udplite = IS_UDPLITE(sk);
724        int offset = skb_transport_offset(skb);
725        int len = skb->len - offset;
726        __wsum csum = 0;
727
728        /*
729         * Create a UDP header
730         */
731        uh = udp_hdr(skb);
732        uh->source = inet->inet_sport;
733        uh->dest = fl4->fl4_dport;
734        uh->len = htons(len);
735        uh->check = 0;
736
737        if (is_udplite)                                  /*     UDP-Lite      */
738                csum = udplite_csum(skb);
739
740        else if (sk->sk_no_check == UDP_CSUM_NOXMIT) {   /* UDP csum disabled */
741
742                skb->ip_summed = CHECKSUM_NONE;
743                goto send;
744
745        } else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
746
747                udp4_hwcsum(skb, fl4->saddr, fl4->daddr);
748                goto send;
749
750        } else
751                csum = udp_csum(skb);
752
753        /* add protocol-dependent pseudo-header */
754        uh->check = csum_tcpudp_magic(fl4->saddr, fl4->daddr, len,
755                                      sk->sk_protocol, csum);
756        if (uh->check == 0)
757                uh->check = CSUM_MANGLED_0;
758
759send:
760        err = ip_send_skb(skb);
761        if (err) {
762                if (err == -ENOBUFS && !inet->recverr) {
763                        UDP_INC_STATS_USER(sock_net(sk),
764                                           UDP_MIB_SNDBUFERRORS, is_udplite);
765                        err = 0;
766                }
767        } else
768                UDP_INC_STATS_USER(sock_net(sk),
769                                   UDP_MIB_OUTDATAGRAMS, is_udplite);
770        return err;
771}
772
773/*
774 * Push out all pending data as one UDP datagram. Socket is locked.
775 */
776int udp_push_pending_frames(struct sock *sk)
777{
778        struct udp_sock  *up = udp_sk(sk);
779        struct inet_sock *inet = inet_sk(sk);
780        struct flowi4 *fl4 = &inet->cork.fl.u.ip4;
781        struct sk_buff *skb;
782        int err = 0;
783
784        skb = ip_finish_skb(sk, fl4);
785        if (!skb)
786                goto out;
787
788        err = udp_send_skb(skb, fl4);
789
790out:
791        up->len = 0;
792        up->pending = 0;
793        return err;
794}
795EXPORT_SYMBOL(udp_push_pending_frames);
796
797int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
798                size_t len)
799{
800        struct inet_sock *inet = inet_sk(sk);
801        struct udp_sock *up = udp_sk(sk);
802        struct flowi4 fl4_stack;
803        struct flowi4 *fl4;
804        int ulen = len;
805        struct ipcm_cookie ipc;
806        struct rtable *rt = NULL;
807        int free = 0;
808        int connected = 0;
809        __be32 daddr, faddr, saddr;
810        __be16 dport;
811        u8  tos;
812        int err, is_udplite = IS_UDPLITE(sk);
813        int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
814        int (*getfrag)(void *, char *, int, int, int, struct sk_buff *) = NULL;
815        struct sk_buff *skb;
816        struct ip_options_data opt_copy;
817
818        if (len > 0xFFFF)
819                return -EMSGSIZE;
820
821        /*
822         *      Check the flags.
823         */
824
825        if (msg->msg_flags & MSG_OOB) /* Mirror BSD error message compatibility */
826                return -EOPNOTSUPP;
827
828        ipc.opt = NULL;
829        ipc.tx_flags = 0;
830
831/* UDPREDIRECT */
832#if defined(CONFIG_IFX_UDP_REDIRECT) || defined(CONFIG_IFX_UDP_REDIRECT_MODULE)
833        if(udpredirect_getfrag_fn && sk->sk_user_data == UDP_REDIRECT_MAGIC)
834                getfrag = udpredirect_getfrag_fn;
835        else
836#endif /* IFX_UDP_REDIRECT */
837                getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag;
838
839        fl4 = &inet->cork.fl.u.ip4;
840        if (up->pending) {
841                /*
842                 * There are pending frames.
843                 * The socket lock must be held while it's corked.
844                 */
845                lock_sock(sk);
846                if (likely(up->pending)) {
847                        if (unlikely(up->pending != AF_INET)) {
848                                release_sock(sk);
849                                return -EINVAL;
850                        }
851                        goto do_append_data;
852                }
853                release_sock(sk);
854        }
855        ulen += sizeof(struct udphdr);
856
857        /*
858         *      Get and verify the address.
859         */
860        if (msg->msg_name) {
861                struct sockaddr_in *usin = (struct sockaddr_in *)msg->msg_name;
862                if (msg->msg_namelen < sizeof(*usin))
863                        return -EINVAL;
864                if (usin->sin_family != AF_INET) {
865                        if (usin->sin_family != AF_UNSPEC)
866                                return -EAFNOSUPPORT;
867                }
868
869                daddr = usin->sin_addr.s_addr;
870                dport = usin->sin_port;
871                if (dport == 0)
872                        return -EINVAL;
873        } else {
874                if (sk->sk_state != TCP_ESTABLISHED)
875                        return -EDESTADDRREQ;
876                daddr = inet->inet_daddr;
877                dport = inet->inet_dport;
878                /* Open fast path for connected socket.
879                   Route will not be used, if at least one option is set.
880                 */
881                connected = 1;
882        }
883        ipc.addr = inet->inet_saddr;
884
885        ipc.oif = sk->sk_bound_dev_if;
886        err = sock_tx_timestamp(sk, &ipc.tx_flags);
887        if (err)
888                return err;
889        if (msg->msg_controllen) {
890                err = ip_cmsg_send(sock_net(sk), msg, &ipc);
891                if (err)
892                        return err;
893                if (ipc.opt)
894                        free = 1;
895                connected = 0;
896        }
897        if (!ipc.opt) {
898                struct ip_options_rcu *inet_opt;
899
900                rcu_read_lock();
901                inet_opt = rcu_dereference(inet->inet_opt);
902                if (inet_opt) {
903                        memcpy(&opt_copy, inet_opt,
904                               sizeof(*inet_opt) + inet_opt->opt.optlen);
905                        ipc.opt = &opt_copy.opt;
906                }
907                rcu_read_unlock();
908        }
909
910        saddr = ipc.addr;
911        ipc.addr = faddr = daddr;
912
913        if (ipc.opt && ipc.opt->opt.srr) {
914                if (!daddr)
915                        return -EINVAL;
916                faddr = ipc.opt->opt.faddr;
917                connected = 0;
918        }
919        tos = RT_TOS(inet->tos);
920        if (sock_flag(sk, SOCK_LOCALROUTE) ||
921            (msg->msg_flags & MSG_DONTROUTE) ||
922            (ipc.opt && ipc.opt->opt.is_strictroute)) {
923                tos |= RTO_ONLINK;
924                connected = 0;
925        }
926
927        if (ipv4_is_multicast(daddr)) {
928                if (!ipc.oif)
929                        ipc.oif = inet->mc_index;
930                if (!saddr)
931                        saddr = inet->mc_addr;
932                connected = 0;
933        } else if (!ipc.oif)
934                ipc.oif = inet->uc_index;
935
936        if (connected)
937                rt = (struct rtable *)sk_dst_check(sk, 0);
938
939        if (rt == NULL) {
940                struct net *net = sock_net(sk);
941
942                fl4 = &fl4_stack;
943                flowi4_init_output(fl4, ipc.oif, sk->sk_mark, tos,
944                                   RT_SCOPE_UNIVERSE, sk->sk_protocol,
945                                   inet_sk_flowi_flags(sk)|FLOWI_FLAG_CAN_SLEEP,
946                                   faddr, saddr, dport, inet->inet_sport);
947
948                security_sk_classify_flow(sk, flowi4_to_flowi(fl4));
949                rt = ip_route_output_flow(net, fl4, sk);
950                if (IS_ERR(rt)) {
951                        err = PTR_ERR(rt);
952                        rt = NULL;
953                        if (err == -ENETUNREACH)
954                                IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES);
955                        goto out;
956                }
957
958                err = -EACCES;
959                if ((rt->rt_flags & RTCF_BROADCAST) &&
960                    !sock_flag(sk, SOCK_BROADCAST))
961                        goto out;
962                if (connected)
963                        sk_dst_set(sk, dst_clone(&rt->dst));
964        }
965
966        if (msg->msg_flags&MSG_CONFIRM)
967                goto do_confirm;
968back_from_confirm:
969
970        saddr = fl4->saddr;
971        if (!ipc.addr)
972                daddr = ipc.addr = fl4->daddr;
973
974        /* Lockless fast path for the non-corking case. */
975        if (!corkreq) {
976                skb = ip_make_skb(sk, fl4, getfrag, msg->msg_iov, ulen,
977                                  sizeof(struct udphdr), &ipc, &rt,
978                                  msg->msg_flags);
979                err = PTR_ERR(skb);
980                if (skb && !IS_ERR(skb))
981                        err = udp_send_skb(skb, fl4);
982                goto out;
983        }
984
985        lock_sock(sk);
986        if (unlikely(up->pending)) {
987                /* The socket is already corked while preparing it. */
988                /* ... which is an evident application bug. --ANK */
989                release_sock(sk);
990
991                LIMIT_NETDEBUG(KERN_DEBUG pr_fmt("cork app bug 2\n"));
992                err = -EINVAL;
993                goto out;
994        }
995        /*
996         *      Now cork the socket to pend data.
997         */
998        fl4 = &inet->cork.fl.u.ip4;
999        fl4->daddr = daddr;
1000        fl4->saddr = saddr;
1001        fl4->fl4_dport = dport;
1002        fl4->fl4_sport = inet->inet_sport;
1003        up->pending = AF_INET;
1004
1005do_append_data:
1006        up->len += ulen;
1007        err = ip_append_data(sk, fl4, getfrag, msg->msg_iov, ulen,
1008                             sizeof(struct udphdr), &ipc, &rt,
1009                             corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
1010        if (err)
1011                udp_flush_pending_frames(sk);
1012        else if (!corkreq)
1013                err = udp_push_pending_frames(sk);
1014        else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
1015                up->pending = 0;
1016        release_sock(sk);
1017
1018out:
1019        ip_rt_put(rt);
1020        if (free)
1021                kfree(ipc.opt);
1022        if (!err)
1023                return len;
1024        /*
1025         * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space.  Reporting
1026         * ENOBUFS might not be good (it's not tunable per se), but otherwise
1027         * we don't have a good statistic (IpOutDiscards but it can be too many
1028         * things).  We could add another new stat but at least for now that
1029         * seems like overkill.
1030         */
1031        if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
1032                UDP_INC_STATS_USER(sock_net(sk),
1033                                UDP_MIB_SNDBUFERRORS, is_udplite);
1034        }
1035        return err;
1036
1037do_confirm:
1038        dst_confirm(&rt->dst);
1039        if (!(msg->msg_flags&MSG_PROBE) || len)
1040                goto back_from_confirm;
1041        err = 0;
1042        goto out;
1043}
1044EXPORT_SYMBOL(udp_sendmsg);
1045
1046int udp_sendpage(struct sock *sk, struct page *page, int offset,
1047                 size_t size, int flags)
1048{
1049        struct inet_sock *inet = inet_sk(sk);
1050        struct udp_sock *up = udp_sk(sk);
1051        int ret;
1052
1053        if (flags & MSG_SENDPAGE_NOTLAST)
1054                flags |= MSG_MORE;
1055
1056        if (!up->pending) {
1057                struct msghdr msg = {   .msg_flags = flags|MSG_MORE };
1058
1059                /* Call udp_sendmsg to specify destination address which
1060                 * sendpage interface can't pass.
1061                 * This will succeed only when the socket is connected.
1062                 */
1063                ret = udp_sendmsg(NULL, sk, &msg, 0);
1064                if (ret < 0)
1065                        return ret;
1066        }
1067
1068        lock_sock(sk);
1069
1070        if (unlikely(!up->pending)) {
1071                release_sock(sk);
1072
1073                LIMIT_NETDEBUG(KERN_DEBUG pr_fmt("udp cork app bug 3\n"));
1074                return -EINVAL;
1075        }
1076
1077        ret = ip_append_page(sk, &inet->cork.fl.u.ip4,
1078                             page, offset, size, flags);
1079        if (ret == -EOPNOTSUPP) {
1080                release_sock(sk);
1081                return sock_no_sendpage(sk->sk_socket, page, offset,
1082                                        size, flags);
1083        }
1084        if (ret < 0) {
1085                udp_flush_pending_frames(sk);
1086                goto out;
1087        }
1088
1089        up->len += size;
1090        if (!(up->corkflag || (flags&MSG_MORE)))
1091                ret = udp_push_pending_frames(sk);
1092        if (!ret)
1093                ret = size;
1094out:
1095        release_sock(sk);
1096        return ret;
1097}
1098
1099
1100/**
1101 *      first_packet_length     - return length of first packet in receive queue
1102 *      @sk: socket
1103 *
1104 *      Drops all bad checksum frames, until a valid one is found.
1105 *      Returns the length of found skb, or 0 if none is found.
1106 */
1107static unsigned int first_packet_length(struct sock *sk)
1108{
1109        struct sk_buff_head list_kill, *rcvq = &sk->sk_receive_queue;
1110        struct sk_buff *skb;
1111        unsigned int res;
1112
1113        __skb_queue_head_init(&list_kill);
1114
1115        spin_lock_bh(&rcvq->lock);
1116        while ((skb = skb_peek(rcvq)) != NULL &&
1117                udp_lib_checksum_complete(skb)) {
1118                UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS,
1119                                 IS_UDPLITE(sk));
1120                atomic_inc(&sk->sk_drops);
1121                __skb_unlink(skb, rcvq);
1122                __skb_queue_tail(&list_kill, skb);
1123        }
1124        res = skb ? skb->len : 0;
1125        spin_unlock_bh(&rcvq->lock);
1126
1127        if (!skb_queue_empty(&list_kill)) {
1128                bool slow = lock_sock_fast(sk);
1129
1130                __skb_queue_purge(&list_kill);
1131                sk_mem_reclaim_partial(sk);
1132                unlock_sock_fast(sk, slow);
1133        }
1134        return res;
1135}
1136
1137/*
1138 *      IOCTL requests applicable to the UDP protocol
1139 */
1140
1141int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
1142{
1143        switch (cmd) {
1144        case SIOCOUTQ:
1145        {
1146                int amount = sk_wmem_alloc_get(sk);
1147
1148                return put_user(amount, (int __user *)arg);
1149        }
1150
1151        case SIOCINQ:
1152        {
1153                unsigned int amount = first_packet_length(sk);
1154
1155                if (amount)
1156                        /*
1157                         * We will only return the amount
1158                         * of this packet since that is all
1159                         * that will be read.
1160                         */
1161                        amount -= sizeof(struct udphdr);
1162
1163                return put_user(amount, (int __user *)arg);
1164        }
1165
1166        default:
1167                return -ENOIOCTLCMD;
1168        }
1169
1170        return 0;
1171}
1172EXPORT_SYMBOL(udp_ioctl);
1173
1174/*
1175 *      This should be easy, if there is something there we
1176 *      return it, otherwise we block.
1177 */
1178
1179int udp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
1180                size_t len, int noblock, int flags, int *addr_len)
1181{
1182        struct inet_sock *inet = inet_sk(sk);
1183        struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
1184        struct sk_buff *skb;
1185        unsigned int ulen, copied;
1186        int peeked, off = 0;
1187        int err;
1188        int is_udplite = IS_UDPLITE(sk);
1189        bool checksum_valid = false;
1190        bool slow;
1191
1192        if (flags & MSG_ERRQUEUE)
1193                return ip_recv_error(sk, msg, len, addr_len);
1194
1195try_again:
1196        skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
1197                                  &peeked, &off, &err);
1198        if (!skb)
1199                goto out;
1200
1201        ulen = skb->len - sizeof(struct udphdr);
1202        copied = len;
1203        if (copied > ulen)
1204                copied = ulen;
1205        else if (copied < ulen)
1206                msg->msg_flags |= MSG_TRUNC;
1207
1208        /*
1209         * If checksum is needed at all, try to do it while copying the
1210         * data.  If the data is truncated, or if we only want a partial
1211         * coverage checksum (UDP-Lite), do it before the copy.
1212         */
1213
1214        if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) {
1215                checksum_valid = !udp_lib_checksum_complete(skb);
1216                if (!checksum_valid)
1217                        goto csum_copy_err;
1218        }
1219
1220        if (skb_csum_unnecessary(skb))
1221                err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
1222                                              msg->msg_iov, copied);
1223        else {
1224                err = skb_copy_and_csum_datagram_iovec(skb,
1225                                                       sizeof(struct udphdr),
1226                                                       msg->msg_iov);
1227
1228                if (err == -EINVAL)
1229                        goto csum_copy_err;
1230        }
1231
1232        if (err)
1233                goto out_free;
1234
1235        if (!peeked)
1236                UDP_INC_STATS_USER(sock_net(sk),
1237                                UDP_MIB_INDATAGRAMS, is_udplite);
1238
1239        sock_recv_ts_and_drops(msg, sk, skb);
1240
1241        /* Copy the address. */
1242        if (sin) {
1243                sin->sin_family = AF_INET;
1244                sin->sin_port = udp_hdr(skb)->source;
1245                sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
1246                memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
1247                *addr_len = sizeof(*sin);
1248        }
1249        if (inet->cmsg_flags)
1250                ip_cmsg_recv(msg, skb);
1251
1252        err = copied;
1253        if (flags & MSG_TRUNC)
1254                err = ulen;
1255
1256out_free:
1257        skb_free_datagram_locked(sk, skb);
1258out:
1259        return err;
1260
1261csum_copy_err:
1262        slow = lock_sock_fast(sk);
1263        if (!skb_kill_datagram(sk, skb, flags))
1264                UDP_INC_STATS_USER(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
1265        unlock_sock_fast(sk, slow);
1266
1267        if (noblock)
1268                return -EAGAIN;
1269
1270        /* starting over for a new packet */
1271        msg->msg_flags &= ~MSG_TRUNC;
1272        goto try_again;
1273}
1274
1275
1276int udp_disconnect(struct sock *sk, int flags)
1277{
1278        struct inet_sock *inet = inet_sk(sk);
1279        /*
1280         *      1003.1g - break association.
1281         */
1282
1283        sk->sk_state = TCP_CLOSE;
1284        inet->inet_daddr = 0;
1285        inet->inet_dport = 0;
1286        sock_rps_reset_rxhash(sk);
1287        sk->sk_bound_dev_if = 0;
1288        if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
1289                inet_reset_saddr(sk);
1290
1291        if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
1292                sk->sk_prot->unhash(sk);
1293                inet->inet_sport = 0;
1294        }
1295        sk_dst_reset(sk);
1296        return 0;
1297}
1298EXPORT_SYMBOL(udp_disconnect);
1299
1300void udp_lib_unhash(struct sock *sk)
1301{
1302        if (sk_hashed(sk)) {
1303                struct udp_table *udptable = sk->sk_prot->h.udp_table;
1304                struct udp_hslot *hslot, *hslot2;
1305
1306                hslot  = udp_hashslot(udptable, sock_net(sk),
1307                                      udp_sk(sk)->udp_port_hash);
1308                hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
1309
1310                spin_lock_bh(&hslot->lock);
1311                if (sk_nulls_del_node_init_rcu(sk)) {
1312                        hslot->count--;
1313                        inet_sk(sk)->inet_num = 0;
1314                        sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
1315
1316                        spin_lock(&hslot2->lock);
1317                        hlist_nulls_del_init_rcu(&udp_sk(sk)->udp_portaddr_node);
1318                        hslot2->count--;
1319                        spin_unlock(&hslot2->lock);
1320                }
1321                spin_unlock_bh(&hslot->lock);
1322        }
1323}
1324EXPORT_SYMBOL(udp_lib_unhash);
1325
1326/*
1327 * inet_rcv_saddr was changed, we must rehash secondary hash
1328 */
1329void udp_lib_rehash(struct sock *sk, u16 newhash)
1330{
1331        if (sk_hashed(sk)) {
1332                struct udp_table *udptable = sk->sk_prot->h.udp_table;
1333                struct udp_hslot *hslot, *hslot2, *nhslot2;
1334
1335                hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
1336                nhslot2 = udp_hashslot2(udptable, newhash);
1337                udp_sk(sk)->udp_portaddr_hash = newhash;
1338                if (hslot2 != nhslot2) {
1339                        hslot = udp_hashslot(udptable, sock_net(sk),
1340                                             udp_sk(sk)->udp_port_hash);
1341                        /* we must lock primary chain too */
1342                        spin_lock_bh(&hslot->lock);
1343
1344                        spin_lock(&hslot2->lock);
1345                        hlist_nulls_del_init_rcu(&udp_sk(sk)->udp_portaddr_node);
1346                        hslot2->count--;
1347                        spin_unlock(&hslot2->lock);
1348
1349                        spin_lock(&nhslot2->lock);
1350                        hlist_nulls_add_head_rcu(&udp_sk(sk)->udp_portaddr_node,
1351                                                 &nhslot2->head);
1352                        nhslot2->count++;
1353                        spin_unlock(&nhslot2->lock);
1354
1355                        spin_unlock_bh(&hslot->lock);
1356                }
1357        }
1358}
1359EXPORT_SYMBOL(udp_lib_rehash);
1360
1361static void udp_v4_rehash(struct sock *sk)
1362{
1363        u16 new_hash = udp4_portaddr_hash(sock_net(sk),
1364                                          inet_sk(sk)->inet_rcv_saddr,
1365                                          inet_sk(sk)->inet_num);
1366        udp_lib_rehash(sk, new_hash);
1367}
1368
1369static int __udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
1370{
1371        int rc;
1372
1373        if (inet_sk(sk)->inet_daddr)
1374                sock_rps_save_rxhash(sk, skb);
1375
1376        rc = sock_queue_rcv_skb(sk, skb);
1377        if (rc < 0) {
1378                int is_udplite = IS_UDPLITE(sk);
1379
1380                /* Note that an ENOMEM error is charged twice */
1381                if (rc == -ENOMEM)
1382                        UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
1383                                         is_udplite);
1384                UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
1385                kfree_skb(skb);
1386                trace_udp_fail_queue_rcv_skb(rc, sk);
1387                return -1;
1388        }
1389
1390        return 0;
1391
1392}
1393
1394static struct static_key udp_encap_needed __read_mostly;
1395void udp_encap_enable(void)
1396{
1397        if (!static_key_enabled(&udp_encap_needed))
1398                static_key_slow_inc(&udp_encap_needed);
1399}
1400EXPORT_SYMBOL(udp_encap_enable);
1401
1402/* returns:
1403 *  -1: error
1404 *   0: success
1405 *  >0: "udp encap" protocol resubmission
1406 *
1407 * Note that in the success and error cases, the skb is assumed to
1408 * have either been requeued or freed.
1409 */
1410int udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
1411{
1412        struct udp_sock *up = udp_sk(sk);
1413        int rc;
1414        int is_udplite = IS_UDPLITE(sk);
1415
1416        /*
1417         *      Charge it to the socket, dropping if the queue is full.
1418         */
1419        if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1420                goto drop;
1421        nf_reset(skb);
1422
1423        if (static_key_false(&udp_encap_needed) && up->encap_type) {
1424                int (*encap_rcv)(struct sock *sk, struct sk_buff *skb);
1425
1426                /*
1427                 * This is an encapsulation socket so pass the skb to
1428                 * the socket's udp_encap_rcv() hook. Otherwise, just
1429                 * fall through and pass this up the UDP socket.
1430                 * up->encap_rcv() returns the following value:
1431                 * =0 if skb was successfully passed to the encap
1432                 *    handler or was discarded by it.
1433                 * >0 if skb should be passed on to UDP.
1434                 * <0 if skb should be resubmitted as proto -N
1435                 */
1436
1437                /* if we're overly short, let UDP handle it */
1438                encap_rcv = ACCESS_ONCE(up->encap_rcv);
1439                if (skb->len > sizeof(struct udphdr) && encap_rcv != NULL) {
1440                        int ret;
1441
1442                        ret = encap_rcv(sk, skb);
1443                        if (ret <= 0) {
1444                                UDP_INC_STATS_BH(sock_net(sk),
1445                                                 UDP_MIB_INDATAGRAMS,
1446                                                 is_udplite);
1447                                return -ret;
1448                        }
1449                }
1450
1451                /* FALLTHROUGH -- it's a UDP Packet */
1452        }
1453
1454        /*
1455         *      UDP-Lite specific tests, ignored on UDP sockets
1456         */
1457        if ((is_udplite & UDPLITE_RECV_CC)  &&  UDP_SKB_CB(skb)->partial_cov) {
1458
1459                /*
1460                 * MIB statistics other than incrementing the error count are
1461                 * disabled for the following two types of errors: these depend
1462                 * on the application settings, not on the functioning of the
1463                 * protocol stack as such.
1464                 *
1465                 * RFC 3828 here recommends (sec 3.3): "There should also be a
1466                 * way ... to ... at least let the receiving application block
1467                 * delivery of packets with coverage values less than a value
1468                 * provided by the application."
1469                 */
1470                if (up->pcrlen == 0) {          /* full coverage was set  */
1471                        LIMIT_NETDEBUG(KERN_WARNING "UDPLite: partial coverage %d while full coverage %d requested\n",
1472                                       UDP_SKB_CB(skb)->cscov, skb->len);
1473                        goto drop;
1474                }
1475                /* The next case involves violating the min. coverage requested
1476                 * by the receiver. This is subtle: if receiver wants x and x is
1477                 * greater than the buffersize/MTU then receiver will complain
1478                 * that it wants x while sender emits packets of smaller size y.
1479                 * Therefore the above ...()->partial_cov statement is essential.
1480                 */
1481                if (UDP_SKB_CB(skb)->cscov  <  up->pcrlen) {
1482                        LIMIT_NETDEBUG(KERN_WARNING "UDPLite: coverage %d too small, need min %d\n",
1483                                       UDP_SKB_CB(skb)->cscov, up->pcrlen);
1484                        goto drop;
1485                }
1486        }
1487
1488        if (rcu_access_pointer(sk->sk_filter) &&
1489            udp_lib_checksum_complete(skb))
1490                goto drop;
1491
1492
1493        if (sk_rcvqueues_full(sk, skb, sk->sk_rcvbuf))
1494                goto drop;
1495
1496        rc = 0;
1497
1498        ipv4_pktinfo_prepare(skb);
1499        bh_lock_sock(sk);
1500        if (!sock_owned_by_user(sk))
1501                rc = __udp_queue_rcv_skb(sk, skb);
1502        else if (sk_add_backlog(sk, skb, sk->sk_rcvbuf)) {
1503                bh_unlock_sock(sk);
1504                goto drop;
1505        }
1506        bh_unlock_sock(sk);
1507
1508        return rc;
1509
1510drop:
1511        UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
1512        atomic_inc(&sk->sk_drops);
1513        kfree_skb(skb);
1514        return -1;
1515}
1516
1517
1518static void flush_stack(struct sock **stack, unsigned int count,
1519                        struct sk_buff *skb, unsigned int final)
1520{
1521        unsigned int i;
1522        struct sk_buff *skb1 = NULL;
1523        struct sock *sk;
1524
1525        for (i = 0; i < count; i++) {
1526                sk = stack[i];
1527                if (likely(skb1 == NULL))
1528                        skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);
1529
1530                if (!skb1) {
1531                        atomic_inc(&sk->sk_drops);
1532                        UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
1533                                         IS_UDPLITE(sk));
1534                        UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS,
1535                                         IS_UDPLITE(sk));
1536                }
1537
1538                if (skb1 && udp_queue_rcv_skb(sk, skb1) <= 0)
1539                        skb1 = NULL;
1540        }
1541        if (unlikely(skb1))
1542                kfree_skb(skb1);
1543}
1544
1545/*
1546 *      Multicasts and broadcasts go to each listener.
1547 *
1548 *      Note: called only from the BH handler context.
1549 */
1550static int __udp4_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
1551                                    struct udphdr  *uh,
1552                                    __be32 saddr, __be32 daddr,
1553                                    struct udp_table *udptable)
1554{
1555        struct sock *sk, *stack[256 / sizeof(struct sock *)];
1556        struct udp_hslot *hslot = udp_hashslot(udptable, net, ntohs(uh->dest));
1557        int dif;
1558        unsigned int i, count = 0;
1559
1560        spin_lock(&hslot->lock);
1561        sk = sk_nulls_head(&hslot->head);
1562        dif = skb->dev->ifindex;
1563        sk = udp_v4_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
1564        while (sk) {
1565                stack[count++] = sk;
1566                sk = udp_v4_mcast_next(net, sk_nulls_next(sk), uh->dest,
1567                                       daddr, uh->source, saddr, dif);
1568                if (unlikely(count == ARRAY_SIZE(stack))) {
1569                        if (!sk)
1570                                break;
1571                        flush_stack(stack, count, skb, ~0);
1572                        count = 0;
1573                }
1574        }
1575        /*
1576         * before releasing chain lock, we must take a reference on sockets
1577         */
1578        for (i = 0; i < count; i++)
1579                sock_hold(stack[i]);
1580
1581        spin_unlock(&hslot->lock);
1582
1583        /*
1584         * do the slow work with no lock held
1585         */
1586        if (count) {
1587                flush_stack(stack, count, skb, count - 1);
1588
1589                for (i = 0; i < count; i++)
1590                        sock_put(stack[i]);
1591        } else {
1592                kfree_skb(skb);
1593        }
1594        return 0;
1595}
1596
1597/* Initialize UDP checksum. If exited with zero value (success),
1598 * CHECKSUM_UNNECESSARY means, that no more checks are required.
1599 * Otherwise, csum completion requires chacksumming packet body,
1600 * including udp header and folding it to skb->csum.
1601 */
1602static inline int udp4_csum_init(struct sk_buff *skb, struct udphdr *uh,
1603                                 int proto)
1604{
1605        const struct iphdr *iph;
1606        int err;
1607
1608        UDP_SKB_CB(skb)->partial_cov = 0;
1609        UDP_SKB_CB(skb)->cscov = skb->len;
1610
1611        if (proto == IPPROTO_UDPLITE) {
1612                err = udplite_checksum_init(skb, uh);
1613                if (err)
1614                        return err;
1615        }
1616
1617        iph = ip_hdr(skb);
1618        if (uh->check == 0) {
1619                skb->ip_summed = CHECKSUM_UNNECESSARY;
1620        } else if (skb->ip_summed == CHECKSUM_COMPLETE) {
1621                if (!csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
1622                                      proto, skb->csum))
1623                        skb->ip_summed = CHECKSUM_UNNECESSARY;
1624        }
1625        if (!skb_csum_unnecessary(skb))
1626                skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
1627                                               skb->len, proto, 0);
1628        /* Probably, we should checksum udp header (it should be in cache
1629         * in any case) and data in tiny packets (< rx copybreak).
1630         */
1631
1632        return 0;
1633}
1634
1635/*
1636 *      All we need to do is get the socket, and then do a checksum.
1637 */
1638
1639int __udp4_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
1640                   int proto)
1641{
1642        struct sock *sk;
1643        struct udphdr *uh;
1644        unsigned short ulen;
1645        struct rtable *rt = skb_rtable(skb);
1646        __be32 saddr, daddr;
1647        struct net *net = dev_net(skb->dev);
1648        int ret = 0;
1649
1650        /*
1651         *  Validate the packet.
1652         */
1653        if (!pskb_may_pull(skb, sizeof(struct udphdr)))
1654                goto drop;              /* No space for header. */
1655
1656        uh   = udp_hdr(skb);
1657        ulen = ntohs(uh->len);
1658        saddr = ip_hdr(skb)->saddr;
1659        daddr = ip_hdr(skb)->daddr;
1660
1661        if (ulen > skb->len)
1662                goto short_packet;
1663
1664        if (proto == IPPROTO_UDP) {
1665                /* UDP validates ulen. */
1666                if (ulen < sizeof(*uh) || pskb_trim_rcsum(skb, ulen))
1667                        goto short_packet;
1668                uh = udp_hdr(skb);
1669        }
1670
1671        if (udp4_csum_init(skb, uh, proto))
1672                goto csum_error;
1673
1674        if (rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST))
1675                return __udp4_lib_mcast_deliver(net, skb, uh,
1676                                saddr, daddr, udptable);
1677
1678        sk = __udp4_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
1679
1680        if (sk != NULL) {
1681        /* UDPREDIRECT */
1682#if defined(CONFIG_IFX_UDP_REDIRECT) || defined(CONFIG_IFX_UDP_REDIRECT_MODULE)
1683      if(udp_do_redirect_fn && sk->sk_user_data == UDP_REDIRECT_MAGIC)
1684      {
1685         udp_do_redirect_fn(sk,skb);
1686         kfree_skb(skb);
1687         return(0);
1688      }
1689#endif
1690                ret = udp_queue_rcv_skb(sk, skb);
1691                sock_put(sk);
1692
1693                /* a return value > 0 means to resubmit the input, but
1694                 * it wants the return to be -protocol, or 0
1695                 */
1696                if (ret > 0)
1697                        return -ret;
1698                return 0;
1699        }
1700
1701        if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1702                goto drop;
1703        nf_reset(skb);
1704
1705        /* No socket. Drop packet silently, if checksum is wrong */
1706        if (udp_lib_checksum_complete(skb))
1707                goto csum_error;
1708
1709        UDP_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
1710        icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
1711
1712        /*
1713         * Hmm.  We got an UDP packet to a port to which we
1714         * don't wanna listen.  Ignore it.
1715         */
1716        kfree_skb(skb);
1717        return 0;
1718
1719short_packet:
1720        LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: short packet: From %pI4:%u %d/%d to %pI4:%u\n",
1721                       proto == IPPROTO_UDPLITE ? "Lite" : "",
1722                       &saddr, ntohs(uh->source),
1723                       ulen, skb->len,
1724                       &daddr, ntohs(uh->dest));
1725        goto drop;
1726
1727csum_error:
1728        /*
1729         * RFC1122: OK.  Discards the bad packet silently (as far as
1730         * the network is concerned, anyway) as per 4.1.3.4 (MUST).
1731         */
1732        LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: bad checksum. From %pI4:%u to %pI4:%u ulen %d\n",
1733                       proto == IPPROTO_UDPLITE ? "Lite" : "",
1734                       &saddr, ntohs(uh->source), &daddr, ntohs(uh->dest),
1735                       ulen);
1736drop:
1737        UDP_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
1738        kfree_skb(skb);
1739        return 0;
1740}
1741
1742int udp_rcv(struct sk_buff *skb)
1743{
1744        return __udp4_lib_rcv(skb, &udp_table, IPPROTO_UDP);
1745}
1746
1747void udp_destroy_sock(struct sock *sk)
1748{
1749        bool slow = lock_sock_fast(sk);
1750        udp_flush_pending_frames(sk);
1751        unlock_sock_fast(sk, slow);
1752}
1753
1754/*
1755 *      Socket option code for UDP
1756 */
1757int udp_lib_setsockopt(struct sock *sk, int level, int optname,
1758                       char __user *optval, unsigned int optlen,
1759                       int (*push_pending_frames)(struct sock *))
1760{
1761        struct udp_sock *up = udp_sk(sk);
1762        int val;
1763        int err = 0;
1764        int is_udplite = IS_UDPLITE(sk);
1765
1766        if (optlen < sizeof(int))
1767                return -EINVAL;
1768
1769        if (get_user(val, (int __user *)optval))
1770                return -EFAULT;
1771
1772        switch (optname) {
1773        case UDP_CORK:
1774                if (val != 0) {
1775                        up->corkflag = 1;
1776                } else {
1777                        up->corkflag = 0;
1778                        lock_sock(sk);
1779                        (*push_pending_frames)(sk);
1780                        release_sock(sk);
1781                }
1782                break;
1783
1784        case UDP_ENCAP:
1785                switch (val) {
1786                case 0:
1787                case UDP_ENCAP_ESPINUDP:
1788                case UDP_ENCAP_ESPINUDP_NON_IKE:
1789                        up->encap_rcv = xfrm4_udp_encap_rcv;
1790                        /* FALLTHROUGH */
1791                case UDP_ENCAP_L2TPINUDP:
1792                        up->encap_type = val;
1793                        udp_encap_enable();
1794                        break;
1795                default:
1796                        err = -ENOPROTOOPT;
1797                        break;
1798                }
1799                break;
1800
1801        /*
1802         *      UDP-Lite's partial checksum coverage (RFC 3828).
1803         */
1804        /* The sender sets actual checksum coverage length via this option.
1805         * The case coverage > packet length is handled by send module. */
1806        case UDPLITE_SEND_CSCOV:
1807                if (!is_udplite)         /* Disable the option on UDP sockets */
1808                        return -ENOPROTOOPT;
1809                if (val != 0 && val < 8) /* Illegal coverage: use default (8) */
1810                        val = 8;
1811                else if (val > USHRT_MAX)
1812                        val = USHRT_MAX;
1813                up->pcslen = val;
1814                up->pcflag |= UDPLITE_SEND_CC;
1815                break;
1816
1817        /* The receiver specifies a minimum checksum coverage value. To make
1818         * sense, this should be set to at least 8 (as done below). If zero is
1819         * used, this again means full checksum coverage.                     */
1820        case UDPLITE_RECV_CSCOV:
1821                if (!is_udplite)         /* Disable the option on UDP sockets */
1822                        return -ENOPROTOOPT;
1823                if (val != 0 && val < 8) /* Avoid silly minimal values.       */
1824                        val = 8;
1825                else if (val > USHRT_MAX)
1826                        val = USHRT_MAX;
1827                up->pcrlen = val;
1828                up->pcflag |= UDPLITE_RECV_CC;
1829                break;
1830
1831        default:
1832                err = -ENOPROTOOPT;
1833                break;
1834        }
1835
1836        return err;
1837}
1838EXPORT_SYMBOL(udp_lib_setsockopt);
1839
1840int udp_setsockopt(struct sock *sk, int level, int optname,
1841                   char __user *optval, unsigned int optlen)
1842{
1843        if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1844                return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1845                                          udp_push_pending_frames);
1846        return ip_setsockopt(sk, level, optname, optval, optlen);
1847}
1848
1849#ifdef CONFIG_COMPAT
1850int compat_udp_setsockopt(struct sock *sk, int level, int optname,
1851                          char __user *optval, unsigned int optlen)
1852{
1853        if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1854                return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1855                                          udp_push_pending_frames);
1856        return compat_ip_setsockopt(sk, level, optname, optval, optlen);
1857}
1858#endif
1859
1860int udp_lib_getsockopt(struct sock *sk, int level, int optname,
1861                       char __user *optval, int __user *optlen)
1862{
1863        struct udp_sock *up = udp_sk(sk);
1864        int val, len;
1865
1866        if (get_user(len, optlen))
1867                return -EFAULT;
1868
1869        len = min_t(unsigned int, len, sizeof(int));
1870
1871        if (len < 0)
1872                return -EINVAL;
1873
1874        switch (optname) {
1875        case UDP_CORK:
1876                val = up->corkflag;
1877                break;
1878
1879        case UDP_ENCAP:
1880                val = up->encap_type;
1881                break;
1882
1883        /* The following two cannot be changed on UDP sockets, the return is
1884         * always 0 (which corresponds to the full checksum coverage of UDP). */
1885        case UDPLITE_SEND_CSCOV:
1886                val = up->pcslen;
1887                break;
1888
1889        case UDPLITE_RECV_CSCOV:
1890                val = up->pcrlen;
1891                break;
1892
1893        default:
1894                return -ENOPROTOOPT;
1895        }
1896
1897        if (put_user(len, optlen))
1898                return -EFAULT;
1899        if (copy_to_user(optval, &val, len))
1900                return -EFAULT;
1901        return 0;
1902}
1903EXPORT_SYMBOL(udp_lib_getsockopt);
1904
1905int udp_getsockopt(struct sock *sk, int level, int optname,
1906                   char __user *optval, int __user *optlen)
1907{
1908        if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1909                return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1910        return ip_getsockopt(sk, level, optname, optval, optlen);
1911}
1912
1913#ifdef CONFIG_COMPAT
1914int compat_udp_getsockopt(struct sock *sk, int level, int optname,
1915                                 char __user *optval, int __user *optlen)
1916{
1917        if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1918                return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1919        return compat_ip_getsockopt(sk, level, optname, optval, optlen);
1920}
1921#endif
1922/**
1923 *      udp_poll - wait for a UDP event.
1924 *      @file - file struct
1925 *      @sock - socket
1926 *      @wait - poll table
1927 *
1928 *      This is same as datagram poll, except for the special case of
1929 *      blocking sockets. If application is using a blocking fd
1930 *      and a packet with checksum error is in the queue;
1931 *      then it could get return from select indicating data available
1932 *      but then block when reading it. Add special case code
1933 *      to work around these arguably broken applications.
1934 */
1935unsigned int udp_poll(struct file *file, struct socket *sock, poll_table *wait)
1936{
1937        unsigned int mask = datagram_poll(file, sock, wait);
1938        struct sock *sk = sock->sk;
1939
1940        /* Check for false positives due to checksum errors */
1941        if ((mask & POLLRDNORM) && !(file->f_flags & O_NONBLOCK) &&
1942            !(sk->sk_shutdown & RCV_SHUTDOWN) && !first_packet_length(sk))
1943                mask &= ~(POLLIN | POLLRDNORM);
1944
1945        return mask;
1946
1947}
1948EXPORT_SYMBOL(udp_poll);
1949
1950struct proto udp_prot = {
1951        .name              = "UDP",
1952        .owner             = THIS_MODULE,
1953        .close             = udp_lib_close,
1954        .connect           = ip4_datagram_connect,
1955        .disconnect        = udp_disconnect,
1956        .ioctl             = udp_ioctl,
1957        .destroy           = udp_destroy_sock,
1958        .setsockopt        = udp_setsockopt,
1959        .getsockopt        = udp_getsockopt,
1960        .sendmsg           = udp_sendmsg,
1961        .recvmsg           = udp_recvmsg,
1962        .sendpage          = udp_sendpage,
1963        .backlog_rcv       = __udp_queue_rcv_skb,
1964        .hash              = udp_lib_hash,
1965        .unhash            = udp_lib_unhash,
1966        .rehash            = udp_v4_rehash,
1967        .get_port          = udp_v4_get_port,
1968        .memory_allocated  = &udp_memory_allocated,
1969        .sysctl_mem        = sysctl_udp_mem,
1970        .sysctl_wmem       = &sysctl_udp_wmem_min,
1971        .sysctl_rmem       = &sysctl_udp_rmem_min,
1972        .obj_size          = sizeof(struct udp_sock),
1973        .slab_flags        = SLAB_DESTROY_BY_RCU,
1974        .h.udp_table       = &udp_table,
1975#ifdef CONFIG_COMPAT
1976        .compat_setsockopt = compat_udp_setsockopt,
1977        .compat_getsockopt = compat_udp_getsockopt,
1978#endif
1979        .clear_sk          = sk_prot_clear_portaddr_nulls,
1980};
1981EXPORT_SYMBOL(udp_prot);
1982EXPORT_SYMBOL(udp_rcv);
1983/* ------------------------------------------------------------------------ */
1984#ifdef CONFIG_PROC_FS
1985
1986static struct sock *udp_get_first(struct seq_file *seq, int start)
1987{
1988        struct sock *sk;
1989        struct udp_iter_state *state = seq->private;
1990        struct net *net = seq_file_net(seq);
1991
1992        for (state->bucket = start; state->bucket <= state->udp_table->mask;
1993             ++state->bucket) {
1994                struct hlist_nulls_node *node;
1995                struct udp_hslot *hslot = &state->udp_table->hash[state->bucket];
1996
1997                if (hlist_nulls_empty(&hslot->head))
1998                        continue;
1999
2000                spin_lock_bh(&hslot->lock);
2001                sk_nulls_for_each(sk, node, &hslot->head) {
2002                        if (!net_eq(sock_net(sk), net))
2003                                continue;
2004                        if (sk->sk_family == state->family)
2005                                goto found;
2006                }
2007                spin_unlock_bh(&hslot->lock);
2008        }
2009        sk = NULL;
2010found:
2011        return sk;
2012}
2013
2014static struct sock *udp_get_next(struct seq_file *seq, struct sock *sk)
2015{
2016        struct udp_iter_state *state = seq->private;
2017        struct net *net = seq_file_net(seq);
2018
2019        do {
2020                sk = sk_nulls_next(sk);
2021        } while (sk && (!net_eq(sock_net(sk), net) || sk->sk_family != state->family));
2022
2023        if (!sk) {
2024                if (state->bucket <= state->udp_table->mask)
2025                        spin_unlock_bh(&state->udp_table->hash[state->bucket].lock);
2026                return udp_get_first(seq, state->bucket + 1);
2027        }
2028        return sk;
2029}
2030
2031static struct sock *udp_get_idx(struct seq_file *seq, loff_t pos)
2032{
2033        struct sock *sk = udp_get_first(seq, 0);
2034
2035        if (sk)
2036                while (pos && (sk = udp_get_next(seq, sk)) != NULL)
2037                        --pos;
2038        return pos ? NULL : sk;
2039}
2040
2041static void *udp_seq_start(struct seq_file *seq, loff_t *pos)
2042{
2043        struct udp_iter_state *state = seq->private;
2044        state->bucket = MAX_UDP_PORTS;
2045
2046        return *pos ? udp_get_idx(seq, *pos-1) : SEQ_START_TOKEN;
2047}
2048
2049static void *udp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2050{
2051        struct sock *sk;
2052
2053        if (v == SEQ_START_TOKEN)
2054                sk = udp_get_idx(seq, 0);
2055        else
2056                sk = udp_get_next(seq, v);
2057
2058        ++*pos;
2059        return sk;
2060}
2061
2062static void udp_seq_stop(struct seq_file *seq, void *v)
2063{
2064        struct udp_iter_state *state = seq->private;
2065
2066        if (state->bucket <= state->udp_table->mask)
2067                spin_unlock_bh(&state->udp_table->hash[state->bucket].lock);
2068}
2069
2070int udp_seq_open(struct inode *inode, struct file *file)
2071{
2072        struct udp_seq_afinfo *afinfo = PDE(inode)->data;
2073        struct udp_iter_state *s;
2074        int err;
2075
2076        err = seq_open_net(inode, file, &afinfo->seq_ops,
2077                           sizeof(struct udp_iter_state));
2078        if (err < 0)
2079                return err;
2080
2081        s = ((struct seq_file *)file->private_data)->private;
2082        s->family               = afinfo->family;
2083        s->udp_table            = afinfo->udp_table;
2084        return err;
2085}
2086EXPORT_SYMBOL(udp_seq_open);
2087
2088/* ------------------------------------------------------------------------ */
2089int udp_proc_register(struct net *net, struct udp_seq_afinfo *afinfo)
2090{
2091        struct proc_dir_entry *p;
2092        int rc = 0;
2093
2094        afinfo->seq_ops.start           = udp_seq_start;
2095        afinfo->seq_ops.next            = udp_seq_next;
2096        afinfo->seq_ops.stop            = udp_seq_stop;
2097
2098        p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
2099                             afinfo->seq_fops, afinfo);
2100        if (!p)
2101                rc = -ENOMEM;
2102        return rc;
2103}
2104EXPORT_SYMBOL(udp_proc_register);
2105
2106void udp_proc_unregister(struct net *net, struct udp_seq_afinfo *afinfo)
2107{
2108        proc_net_remove(net, afinfo->name);
2109}
2110EXPORT_SYMBOL(udp_proc_unregister);
2111
2112/* ------------------------------------------------------------------------ */
2113static void udp4_format_sock(struct sock *sp, struct seq_file *f,
2114                int bucket, int *len)
2115{
2116        struct inet_sock *inet = inet_sk(sp);
2117        __be32 dest = inet->inet_daddr;
2118        __be32 src  = inet->inet_rcv_saddr;
2119        __u16 destp       = ntohs(inet->inet_dport);
2120        __u16 srcp        = ntohs(inet->inet_sport);
2121
2122        seq_printf(f, "%5d: %08X:%04X %08X:%04X"
2123                " %02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %pK %d%n",
2124                bucket, src, srcp, dest, destp, sp->sk_state,
2125                sk_wmem_alloc_get(sp),
2126                sk_rmem_alloc_get(sp),
2127                0, 0L, 0, sock_i_uid(sp), 0, sock_i_ino(sp),
2128                atomic_read(&sp->sk_refcnt), sp,
2129                atomic_read(&sp->sk_drops), len);
2130}
2131
2132int udp4_seq_show(struct seq_file *seq, void *v)
2133{
2134        if (v == SEQ_START_TOKEN)
2135                seq_printf(seq, "%-127s\n",
2136                           "  sl  local_address rem_address   st tx_queue "
2137                           "rx_queue tr tm->when retrnsmt   uid  timeout "
2138                           "inode ref pointer drops");
2139        else {
2140                struct udp_iter_state *state = seq->private;
2141                int len;
2142
2143                udp4_format_sock(v, seq, state->bucket, &len);
2144                seq_printf(seq, "%*s\n", 127 - len, "");
2145        }
2146        return 0;
2147}
2148
2149static const struct file_operations udp_afinfo_seq_fops = {
2150        .owner    = THIS_MODULE,
2151        .open     = udp_seq_open,
2152        .read     = seq_read,
2153        .llseek   = seq_lseek,
2154        .release  = seq_release_net
2155};
2156
2157/* ------------------------------------------------------------------------ */
2158static struct udp_seq_afinfo udp4_seq_afinfo = {
2159        .name           = "udp",
2160        .family         = AF_INET,
2161        .udp_table      = &udp_table,
2162        .seq_fops       = &udp_afinfo_seq_fops,
2163        .seq_ops        = {
2164                .show           = udp4_seq_show,
2165        },
2166};
2167
2168static int __net_init udp4_proc_init_net(struct net *net)
2169{
2170        return udp_proc_register(net, &udp4_seq_afinfo);
2171}
2172
2173static void __net_exit udp4_proc_exit_net(struct net *net)
2174{
2175        udp_proc_unregister(net, &udp4_seq_afinfo);
2176}
2177
2178static struct pernet_operations udp4_net_ops = {
2179        .init = udp4_proc_init_net,
2180        .exit = udp4_proc_exit_net,
2181};
2182
2183int __init udp4_proc_init(void)
2184{
2185        return register_pernet_subsys(&udp4_net_ops);
2186}
2187
2188void udp4_proc_exit(void)
2189{
2190        unregister_pernet_subsys(&udp4_net_ops);
2191}
2192#endif /* CONFIG_PROC_FS */
2193
2194static __initdata unsigned long uhash_entries;
2195static int __init set_uhash_entries(char *str)
2196{
2197        ssize_t ret;
2198
2199        if (!str)
2200                return 0;
2201
2202        ret = kstrtoul(str, 0, &uhash_entries);
2203        if (ret)
2204                return 0;
2205
2206        if (uhash_entries && uhash_entries < UDP_HTABLE_SIZE_MIN)
2207                uhash_entries = UDP_HTABLE_SIZE_MIN;
2208        return 1;
2209}
2210__setup("uhash_entries=", set_uhash_entries);
2211
2212void __init udp_table_init(struct udp_table *table, const char *name)
2213{
2214        unsigned int i;
2215
2216        table->hash = alloc_large_system_hash(name,
2217                                              2 * sizeof(struct udp_hslot),
2218                                              uhash_entries,
2219                                              21, /* one slot per 2 MB */
2220                                              0,
2221                                              &table->log,
2222                                              &table->mask,
2223                                              UDP_HTABLE_SIZE_MIN,
2224                                              64 * 1024);
2225
2226        table->hash2 = table->hash + (table->mask + 1);
2227        for (i = 0; i <= table->mask; i++) {
2228                INIT_HLIST_NULLS_HEAD(&table->hash[i].head, i);
2229                table->hash[i].count = 0;
2230                spin_lock_init(&table->hash[i].lock);
2231        }
2232        for (i = 0; i <= table->mask; i++) {
2233                INIT_HLIST_NULLS_HEAD(&table->hash2[i].head, i);
2234                table->hash2[i].count = 0;
2235                spin_lock_init(&table->hash2[i].lock);
2236        }
2237}
2238
2239void __init udp_init(void)
2240{
2241        unsigned long limit;
2242
2243        udp_table_init(&udp_table, "UDP");
2244        limit = nr_free_buffer_pages() / 8;
2245        limit = max(limit, 128UL);
2246        sysctl_udp_mem[0] = limit / 4 * 3;
2247        sysctl_udp_mem[1] = limit;
2248        sysctl_udp_mem[2] = sysctl_udp_mem[0] * 2;
2249
2250        sysctl_udp_rmem_min = SK_MEM_QUANTUM;
2251        sysctl_udp_wmem_min = SK_MEM_QUANTUM;
2252}
2253
2254int udp4_ufo_send_check(struct sk_buff *skb)
2255{
2256        const struct iphdr *iph;
2257        struct udphdr *uh;
2258
2259        if (!pskb_may_pull(skb, sizeof(*uh)))
2260                return -EINVAL;
2261
2262        iph = ip_hdr(skb);
2263        uh = udp_hdr(skb);
2264
2265        uh->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
2266                                       IPPROTO_UDP, 0);
2267        skb->csum_start = skb_transport_header(skb) - skb->head;
2268        skb->csum_offset = offsetof(struct udphdr, check);
2269        skb->ip_summed = CHECKSUM_PARTIAL;
2270        return 0;
2271}
2272
2273struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb,
2274        netdev_features_t features)
2275{
2276        struct sk_buff *segs = ERR_PTR(-EINVAL);
2277        unsigned int mss;
2278        int offset;
2279        __wsum csum;
2280
2281        mss = skb_shinfo(skb)->gso_size;
2282        if (unlikely(skb->len <= mss))
2283                goto out;
2284
2285        if (skb_gso_ok(skb, features | NETIF_F_GSO_ROBUST)) {
2286                /* Packet is from an untrusted source, reset gso_segs. */
2287                int type = skb_shinfo(skb)->gso_type;
2288
2289                if (unlikely(type & ~(SKB_GSO_UDP | SKB_GSO_DODGY) ||
2290                             !(type & (SKB_GSO_UDP))))
2291                        goto out;
2292
2293                skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss);
2294
2295                segs = NULL;
2296                goto out;
2297        }
2298
2299        /* Do software UFO. Complete and fill in the UDP checksum as HW cannot
2300         * do checksum of UDP packets sent as multiple IP fragments.
2301         */
2302        offset = skb_checksum_start_offset(skb);
2303        csum = skb_checksum(skb, offset, skb->len - offset, 0);
2304        offset += skb->csum_offset;
2305        *(__sum16 *)(skb->data + offset) = csum_fold(csum);
2306        skb->ip_summed = CHECKSUM_NONE;
2307
2308        /* Fragment the skb. IP headers of the fragments are updated in
2309         * inet_gso_segment()
2310         */
2311        segs = skb_segment(skb, features);
2312out:
2313        return segs;
2314}
2315
Note: See TracBrowser for help on using the repository browser.