1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80#include <asm/system.h>
81#include <asm/uaccess.h>
82#include <asm/ioctls.h>
83#include <linux/bootmem.h>
84#include <linux/highmem.h>
85#include <linux/swap.h>
86#include <linux/types.h>
87#include <linux/fcntl.h>
88#include <linux/module.h>
89#include <linux/socket.h>
90#include <linux/sockios.h>
91#include <linux/igmp.h>
92#include <linux/in.h>
93#include <linux/errno.h>
94#include <linux/timer.h>
95#include <linux/mm.h>
96#include <linux/inet.h>
97#include <linux/netdevice.h>
98#include <linux/slab.h>
99#include <net/tcp_states.h>
100#include <linux/skbuff.h>
101#include <linux/proc_fs.h>
102#include <linux/seq_file.h>
103#include <net/net_namespace.h>
104#include <net/icmp.h>
105#include <net/route.h>
106#include <net/checksum.h>
107#include <net/xfrm.h>
108#include "udp_impl.h"
109
110struct udp_table udp_table __read_mostly;
111EXPORT_SYMBOL(udp_table);
112
113long sysctl_udp_mem[3] __read_mostly;
114EXPORT_SYMBOL(sysctl_udp_mem);
115
116int sysctl_udp_rmem_min __read_mostly;
117EXPORT_SYMBOL(sysctl_udp_rmem_min);
118
119int sysctl_udp_wmem_min __read_mostly;
120EXPORT_SYMBOL(sysctl_udp_wmem_min);
121
122atomic_long_t udp_memory_allocated;
123EXPORT_SYMBOL(udp_memory_allocated);
124
125#define MAX_UDP_PORTS 65536
126#define PORTS_PER_CHAIN (MAX_UDP_PORTS / UDP_HTABLE_SIZE_MIN)
127
128static int udp_lib_lport_inuse(struct net *net, __u16 num,
129 const struct udp_hslot *hslot,
130 unsigned long *bitmap,
131 struct sock *sk,
132 int (*saddr_comp)(const struct sock *sk1,
133 const struct sock *sk2),
134 unsigned int log)
135{
136 struct sock *sk2;
137 struct hlist_nulls_node *node;
138
139 sk_nulls_for_each(sk2, node, &hslot->head)
140 if (net_eq(sock_net(sk2), net) &&
141 sk2 != sk &&
142 (bitmap || udp_sk(sk2)->udp_port_hash == num) &&
143 (!sk2->sk_reuse || !sk->sk_reuse) &&
144 (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
145 sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
146 (*saddr_comp)(sk, sk2)) {
147 if (bitmap)
148 __set_bit(udp_sk(sk2)->udp_port_hash >> log,
149 bitmap);
150 else
151 return 1;
152 }
153 return 0;
154}
155
156
157
158
159
160static int udp_lib_lport_inuse2(struct net *net, __u16 num,
161 struct udp_hslot *hslot2,
162 struct sock *sk,
163 int (*saddr_comp)(const struct sock *sk1,
164 const struct sock *sk2))
165{
166 struct sock *sk2;
167 struct hlist_nulls_node *node;
168 int res = 0;
169
170 spin_lock(&hslot2->lock);
171 udp_portaddr_for_each_entry(sk2, node, &hslot2->head)
172 if (net_eq(sock_net(sk2), net) &&
173 sk2 != sk &&
174 (udp_sk(sk2)->udp_port_hash == num) &&
175 (!sk2->sk_reuse || !sk->sk_reuse) &&
176 (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
177 sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
178 (*saddr_comp)(sk, sk2)) {
179 res = 1;
180 break;
181 }
182 spin_unlock(&hslot2->lock);
183 return res;
184}
185
186
187
188
189
190
191
192
193
194
195int udp_lib_get_port(struct sock *sk, unsigned short snum,
196 int (*saddr_comp)(const struct sock *sk1,
197 const struct sock *sk2),
198 unsigned int hash2_nulladdr)
199{
200 struct udp_hslot *hslot, *hslot2;
201 struct udp_table *udptable = sk->sk_prot->h.udp_table;
202 int error = 1;
203 struct net *net = sock_net(sk);
204
205 if (!snum) {
206 int low, high, remaining;
207 unsigned rand;
208 unsigned short first, last;
209 DECLARE_BITMAP(bitmap, PORTS_PER_CHAIN);
210
211 inet_get_local_port_range(&low, &high);
212 remaining = (high - low) + 1;
213
214 rand = net_random();
215 first = (((u64)rand * remaining) >> 32) + low;
216
217
218
219 rand = (rand | 1) * (udptable->mask + 1);
220 last = first + udptable->mask + 1;
221 do {
222 hslot = udp_hashslot(udptable, net, first);
223 bitmap_zero(bitmap, PORTS_PER_CHAIN);
224 spin_lock_bh(&hslot->lock);
225 udp_lib_lport_inuse(net, snum, hslot, bitmap, sk,
226 saddr_comp, udptable->log);
227
228 snum = first;
229
230
231
232
233
234 do {
235 if (low <= snum && snum <= high &&
236 !test_bit(snum >> udptable->log, bitmap) &&
237 !inet_is_reserved_local_port(snum))
238 goto found;
239 snum += rand;
240 } while (snum != first);
241 spin_unlock_bh(&hslot->lock);
242 } while (++first != last);
243 goto fail;
244 } else {
245 hslot = udp_hashslot(udptable, net, snum);
246 spin_lock_bh(&hslot->lock);
247 if (hslot->count > 10) {
248 int exist;
249 unsigned int slot2 = udp_sk(sk)->udp_portaddr_hash ^ snum;
250
251 slot2 &= udptable->mask;
252 hash2_nulladdr &= udptable->mask;
253
254 hslot2 = udp_hashslot2(udptable, slot2);
255 if (hslot->count < hslot2->count)
256 goto scan_primary_hash;
257
258 exist = udp_lib_lport_inuse2(net, snum, hslot2,
259 sk, saddr_comp);
260 if (!exist && (hash2_nulladdr != slot2)) {
261 hslot2 = udp_hashslot2(udptable, hash2_nulladdr);
262 exist = udp_lib_lport_inuse2(net, snum, hslot2,
263 sk, saddr_comp);
264 }
265 if (exist)
266 goto fail_unlock;
267 else
268 goto found;
269 }
270scan_primary_hash:
271 if (udp_lib_lport_inuse(net, snum, hslot, NULL, sk,
272 saddr_comp, 0))
273 goto fail_unlock;
274 }
275found:
276 inet_sk(sk)->inet_num = snum;
277 udp_sk(sk)->udp_port_hash = snum;
278 udp_sk(sk)->udp_portaddr_hash ^= snum;
279 if (sk_unhashed(sk)) {
280 sk_nulls_add_node_rcu(sk, &hslot->head);
281 hslot->count++;
282 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
283
284 hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
285 spin_lock(&hslot2->lock);
286 hlist_nulls_add_head_rcu(&udp_sk(sk)->udp_portaddr_node,
287 &hslot2->head);
288 hslot2->count++;
289 spin_unlock(&hslot2->lock);
290 }
291 error = 0;
292fail_unlock:
293 spin_unlock_bh(&hslot->lock);
294fail:
295 return error;
296}
297EXPORT_SYMBOL(udp_lib_get_port);
298
299static int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)
300{
301 struct inet_sock *inet1 = inet_sk(sk1), *inet2 = inet_sk(sk2);
302
303 return (!ipv6_only_sock(sk2) &&
304 (!inet1->inet_rcv_saddr || !inet2->inet_rcv_saddr ||
305 inet1->inet_rcv_saddr == inet2->inet_rcv_saddr));
306}
307
308static unsigned int udp4_portaddr_hash(struct net *net, __be32 saddr,
309 unsigned int port)
310{
311 return jhash_1word((__force u32)saddr, net_hash_mix(net)) ^ port;
312}
313
314int udp_v4_get_port(struct sock *sk, unsigned short snum)
315{
316 unsigned int hash2_nulladdr =
317 udp4_portaddr_hash(sock_net(sk), htonl(INADDR_ANY), snum);
318 unsigned int hash2_partial =
319 udp4_portaddr_hash(sock_net(sk), inet_sk(sk)->inet_rcv_saddr, 0);
320
321
322 udp_sk(sk)->udp_portaddr_hash = hash2_partial;
323 return udp_lib_get_port(sk, snum, ipv4_rcv_saddr_equal, hash2_nulladdr);
324}
325
326static inline int compute_score(struct sock *sk, struct net *net, __be32 saddr,
327 unsigned short hnum,
328 __be16 sport, __be32 daddr, __be16 dport, int dif)
329{
330 int score = -1;
331
332 if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
333 !ipv6_only_sock(sk)) {
334 struct inet_sock *inet = inet_sk(sk);
335
336 score = (sk->sk_family == PF_INET ? 1 : 0);
337 if (inet->inet_rcv_saddr) {
338 if (inet->inet_rcv_saddr != daddr)
339 return -1;
340 score += 2;
341 }
342 if (inet->inet_daddr) {
343 if (inet->inet_daddr != saddr)
344 return -1;
345 score += 2;
346 }
347 if (inet->inet_dport) {
348 if (inet->inet_dport != sport)
349 return -1;
350 score += 2;
351 }
352 if (sk->sk_bound_dev_if) {
353 if (sk->sk_bound_dev_if != dif)
354 return -1;
355 score += 2;
356 }
357 }
358 return score;
359}
360
361
362
363
364#define SCORE2_MAX (1 + 2 + 2 + 2)
365static inline int compute_score2(struct sock *sk, struct net *net,
366 __be32 saddr, __be16 sport,
367 __be32 daddr, unsigned int hnum, int dif)
368{
369 int score = -1;
370
371 if (net_eq(sock_net(sk), net) && !ipv6_only_sock(sk)) {
372 struct inet_sock *inet = inet_sk(sk);
373
374 if (inet->inet_rcv_saddr != daddr)
375 return -1;
376 if (inet->inet_num != hnum)
377 return -1;
378
379 score = (sk->sk_family == PF_INET ? 1 : 0);
380 if (inet->inet_daddr) {
381 if (inet->inet_daddr != saddr)
382 return -1;
383 score += 2;
384 }
385 if (inet->inet_dport) {
386 if (inet->inet_dport != sport)
387 return -1;
388 score += 2;
389 }
390 if (sk->sk_bound_dev_if) {
391 if (sk->sk_bound_dev_if != dif)
392 return -1;
393 score += 2;
394 }
395 }
396 return score;
397}
398
399
400
401static struct sock *udp4_lib_lookup2(struct net *net,
402 __be32 saddr, __be16 sport,
403 __be32 daddr, unsigned int hnum, int dif,
404 struct udp_hslot *hslot2, unsigned int slot2)
405{
406 struct sock *sk, *result;
407 struct hlist_nulls_node *node;
408 int score, badness;
409
410begin:
411 result = NULL;
412 badness = -1;
413 udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
414 score = compute_score2(sk, net, saddr, sport,
415 daddr, hnum, dif);
416 if (score > badness) {
417 result = sk;
418 badness = score;
419 if (score == SCORE2_MAX)
420 goto exact_match;
421 }
422 }
423
424
425
426
427
428 if (get_nulls_value(node) != slot2)
429 goto begin;
430
431 if (result) {
432exact_match:
433 if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
434 result = NULL;
435 else if (unlikely(compute_score2(result, net, saddr, sport,
436 daddr, hnum, dif) < badness)) {
437 sock_put(result);
438 goto begin;
439 }
440 }
441 return result;
442}
443
444
445
446
447static struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,
448 __be16 sport, __be32 daddr, __be16 dport,
449 int dif, struct udp_table *udptable)
450{
451 struct sock *sk, *result;
452 struct hlist_nulls_node *node;
453 unsigned short hnum = ntohs(dport);
454 unsigned int hash2, slot2, slot = udp_hashfn(net, hnum, udptable->mask);
455 struct udp_hslot *hslot2, *hslot = &udptable->hash[slot];
456 int score, badness;
457
458 rcu_read_lock();
459 if (hslot->count > 10) {
460 hash2 = udp4_portaddr_hash(net, daddr, hnum);
461 slot2 = hash2 & udptable->mask;
462 hslot2 = &udptable->hash2[slot2];
463 if (hslot->count < hslot2->count)
464 goto begin;
465
466 result = udp4_lib_lookup2(net, saddr, sport,
467 daddr, hnum, dif,
468 hslot2, slot2);
469 if (!result) {
470 hash2 = udp4_portaddr_hash(net, htonl(INADDR_ANY), hnum);
471 slot2 = hash2 & udptable->mask;
472 hslot2 = &udptable->hash2[slot2];
473 if (hslot->count < hslot2->count)
474 goto begin;
475
476 result = udp4_lib_lookup2(net, saddr, sport,
477 htonl(INADDR_ANY), hnum, dif,
478 hslot2, slot2);
479 }
480 rcu_read_unlock();
481 return result;
482 }
483begin:
484 result = NULL;
485 badness = -1;
486 sk_nulls_for_each_rcu(sk, node, &hslot->head) {
487 score = compute_score(sk, net, saddr, hnum, sport,
488 daddr, dport, dif);
489 if (score > badness) {
490 result = sk;
491 badness = score;
492 }
493 }
494
495
496
497
498
499 if (get_nulls_value(node) != slot)
500 goto begin;
501
502 if (result) {
503 if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
504 result = NULL;
505 else if (unlikely(compute_score(result, net, saddr, hnum, sport,
506 daddr, dport, dif) < badness)) {
507 sock_put(result);
508 goto begin;
509 }
510 }
511 rcu_read_unlock();
512 return result;
513}
514
515static inline struct sock *__udp4_lib_lookup_skb(struct sk_buff *skb,
516 __be16 sport, __be16 dport,
517 struct udp_table *udptable)
518{
519 struct sock *sk;
520 const struct iphdr *iph = ip_hdr(skb);
521
522 if (unlikely(sk = skb_steal_sock(skb)))
523 return sk;
524 else
525 return __udp4_lib_lookup(dev_net(skb_dst(skb)->dev), iph->saddr, sport,
526 iph->daddr, dport, inet_iif(skb),
527 udptable);
528}
529
530struct sock *udp4_lib_lookup(struct net *net, __be32 saddr, __be16 sport,
531 __be32 daddr, __be16 dport, int dif)
532{
533 return __udp4_lib_lookup(net, saddr, sport, daddr, dport, dif, &udp_table);
534}
535EXPORT_SYMBOL_GPL(udp4_lib_lookup);
536
537static inline struct sock *udp_v4_mcast_next(struct net *net, struct sock *sk,
538 __be16 loc_port, __be32 loc_addr,
539 __be16 rmt_port, __be32 rmt_addr,
540 int dif)
541{
542 struct hlist_nulls_node *node;
543 struct sock *s = sk;
544 unsigned short hnum = ntohs(loc_port);
545
546 sk_nulls_for_each_from(s, node) {
547 struct inet_sock *inet = inet_sk(s);
548
549 if (!net_eq(sock_net(s), net) ||
550 udp_sk(s)->udp_port_hash != hnum ||
551 (inet->inet_daddr && inet->inet_daddr != rmt_addr) ||
552 (inet->inet_dport != rmt_port && inet->inet_dport) ||
553 (inet->inet_rcv_saddr &&
554 inet->inet_rcv_saddr != loc_addr) ||
555 ipv6_only_sock(s) ||
556 (s->sk_bound_dev_if && s->sk_bound_dev_if != dif))
557 continue;
558 if (!ip_mc_sf_allow(s, loc_addr, rmt_addr, dif))
559 continue;
560 goto found;
561 }
562 s = NULL;
563found:
564 return s;
565}
566
567
568
569
570
571
572
573
574
575
576
577
578void __udp4_lib_err(struct sk_buff *skb, u32 info, struct udp_table *udptable)
579{
580 struct inet_sock *inet;
581 struct iphdr *iph = (struct iphdr *)skb->data;
582 struct udphdr *uh = (struct udphdr *)(skb->data+(iph->ihl<<2));
583 const int type = icmp_hdr(skb)->type;
584 const int code = icmp_hdr(skb)->code;
585 struct sock *sk;
586 int harderr;
587 int err;
588 struct net *net = dev_net(skb->dev);
589
590 sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,
591 iph->saddr, uh->source, skb->dev->ifindex, udptable);
592 if (sk == NULL) {
593 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
594 return;
595 }
596
597 err = 0;
598 harderr = 0;
599 inet = inet_sk(sk);
600
601 switch (type) {
602 default:
603 case ICMP_TIME_EXCEEDED:
604 err = EHOSTUNREACH;
605 break;
606 case ICMP_SOURCE_QUENCH:
607 goto out;
608 case ICMP_PARAMETERPROB:
609 err = EPROTO;
610 harderr = 1;
611 break;
612 case ICMP_DEST_UNREACH:
613 if (code == ICMP_FRAG_NEEDED) {
614 if (inet->pmtudisc != IP_PMTUDISC_DONT) {
615 err = EMSGSIZE;
616 harderr = 1;
617 break;
618 }
619 goto out;
620 }
621 err = EHOSTUNREACH;
622 if (code <= NR_ICMP_UNREACH) {
623 harderr = icmp_err_convert[code].fatal;
624 err = icmp_err_convert[code].errno;
625 }
626 break;
627 }
628
629
630
631
632
633 if (!inet->recverr) {
634 if (!harderr || sk->sk_state != TCP_ESTABLISHED)
635 goto out;
636 } else
637 ip_icmp_error(sk, skb, err, uh->dest, info, (u8 *)(uh+1));
638
639 sk->sk_err = err;
640 sk->sk_error_report(sk);
641out:
642 sock_put(sk);
643}
644
645void udp_err(struct sk_buff *skb, u32 info)
646{
647 __udp4_lib_err(skb, info, &udp_table);
648}
649
650
651
652
653void udp_flush_pending_frames(struct sock *sk)
654{
655 struct udp_sock *up = udp_sk(sk);
656
657 if (up->pending) {
658 up->len = 0;
659 up->pending = 0;
660 ip_flush_pending_frames(sk);
661 }
662}
663EXPORT_SYMBOL(udp_flush_pending_frames);
664
665
666
667
668
669
670
671static void udp4_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,
672 __be32 src, __be32 dst, int len)
673{
674 unsigned int offset;
675 struct udphdr *uh = udp_hdr(skb);
676 __wsum csum = 0;
677
678 if (skb_queue_len(&sk->sk_write_queue) == 1) {
679
680
681
682 skb->csum_start = skb_transport_header(skb) - skb->head;
683 skb->csum_offset = offsetof(struct udphdr, check);
684 uh->check = ~csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, 0);
685 } else {
686
687
688
689
690
691 offset = skb_transport_offset(skb);
692 skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
693
694 skb->ip_summed = CHECKSUM_NONE;
695
696 skb_queue_walk(&sk->sk_write_queue, skb) {
697 csum = csum_add(csum, skb->csum);
698 }
699
700 uh->check = csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, csum);
701 if (uh->check == 0)
702 uh->check = CSUM_MANGLED_0;
703 }
704}
705
706
707
708
709static int udp_push_pending_frames(struct sock *sk)
710{
711 struct udp_sock *up = udp_sk(sk);
712 struct inet_sock *inet = inet_sk(sk);
713 struct flowi *fl = &inet->cork.fl;
714 struct sk_buff *skb;
715 struct udphdr *uh;
716 int err = 0;
717 int is_udplite = IS_UDPLITE(sk);
718 __wsum csum = 0;
719
720
721 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
722 goto out;
723
724
725
726
727 uh = udp_hdr(skb);
728 uh->source = fl->fl_ip_sport;
729 uh->dest = fl->fl_ip_dport;
730 uh->len = htons(up->len);
731 uh->check = 0;
732
733 if (is_udplite)
734 csum = udplite_csum_outgoing(sk, skb);
735
736 else if (sk->sk_no_check == UDP_CSUM_NOXMIT) {
737
738 skb->ip_summed = CHECKSUM_NONE;
739 goto send;
740
741 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
742
743 udp4_hwcsum_outgoing(sk, skb, fl->fl4_src, fl->fl4_dst, up->len);
744 goto send;
745
746 } else
747 csum = udp_csum_outgoing(sk, skb);
748
749
750 uh->check = csum_tcpudp_magic(fl->fl4_src, fl->fl4_dst, up->len,
751 sk->sk_protocol, csum);
752 if (uh->check == 0)
753 uh->check = CSUM_MANGLED_0;
754
755send:
756 err = ip_push_pending_frames(sk);
757 if (err) {
758 if (err == -ENOBUFS && !inet->recverr) {
759 UDP_INC_STATS_USER(sock_net(sk),
760 UDP_MIB_SNDBUFERRORS, is_udplite);
761 err = 0;
762 }
763 } else
764 UDP_INC_STATS_USER(sock_net(sk),
765 UDP_MIB_OUTDATAGRAMS, is_udplite);
766out:
767 up->len = 0;
768 up->pending = 0;
769 return err;
770}
771
772int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
773 size_t len)
774{
775 struct inet_sock *inet = inet_sk(sk);
776 struct udp_sock *up = udp_sk(sk);
777 int ulen = len;
778 struct ipcm_cookie ipc;
779 struct rtable *rt = NULL;
780 int free = 0;
781 int connected = 0;
782 __be32 daddr, faddr, saddr;
783 __be16 dport;
784 u8 tos;
785 int err, is_udplite = IS_UDPLITE(sk);
786 int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
787 int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
788
789 if (len > 0xFFFF)
790 return -EMSGSIZE;
791
792
793
794
795
796 if (msg->msg_flags & MSG_OOB)
797 return -EOPNOTSUPP;
798
799 ipc.opt = NULL;
800 ipc.tx_flags = 0;
801
802 if (up->pending) {
803
804
805
806
807 lock_sock(sk);
808 if (likely(up->pending)) {
809 if (unlikely(up->pending != AF_INET)) {
810 release_sock(sk);
811 return -EINVAL;
812 }
813 goto do_append_data;
814 }
815 release_sock(sk);
816 }
817 ulen += sizeof(struct udphdr);
818
819
820
821
822 if (msg->msg_name) {
823 struct sockaddr_in * usin = (struct sockaddr_in *)msg->msg_name;
824 if (msg->msg_namelen < sizeof(*usin))
825 return -EINVAL;
826 if (usin->sin_family != AF_INET) {
827 if (usin->sin_family != AF_UNSPEC)
828 return -EAFNOSUPPORT;
829 }
830
831 daddr = usin->sin_addr.s_addr;
832 dport = usin->sin_port;
833 if (dport == 0)
834 return -EINVAL;
835 } else {
836 if (sk->sk_state != TCP_ESTABLISHED)
837 return -EDESTADDRREQ;
838 daddr = inet->inet_daddr;
839 dport = inet->inet_dport;
840
841
842
843 connected = 1;
844 }
845 ipc.addr = inet->inet_saddr;
846
847 ipc.oif = sk->sk_bound_dev_if;
848 err = sock_tx_timestamp(sk, &ipc.tx_flags);
849 if (err)
850 return err;
851 if (msg->msg_controllen) {
852 err = ip_cmsg_send(sock_net(sk), msg, &ipc);
853 if (err)
854 return err;
855 if (ipc.opt)
856 free = 1;
857 connected = 0;
858 }
859 if (!ipc.opt)
860 ipc.opt = inet->opt;
861
862 saddr = ipc.addr;
863 ipc.addr = faddr = daddr;
864
865 if (ipc.opt && ipc.opt->srr) {
866 if (!daddr)
867 return -EINVAL;
868 faddr = ipc.opt->faddr;
869 connected = 0;
870 }
871 tos = RT_TOS(inet->tos);
872 if (sock_flag(sk, SOCK_LOCALROUTE) ||
873 (msg->msg_flags & MSG_DONTROUTE) ||
874 (ipc.opt && ipc.opt->is_strictroute)) {
875 tos |= RTO_ONLINK;
876 connected = 0;
877 }
878
879 if (ipv4_is_multicast(daddr)) {
880 if (!ipc.oif)
881 ipc.oif = inet->mc_index;
882 if (!saddr)
883 saddr = inet->mc_addr;
884 connected = 0;
885 }
886
887 if (connected)
888 rt = (struct rtable *)sk_dst_check(sk, 0);
889
890 if (rt == NULL) {
891 struct flowi fl = { .oif = ipc.oif,
892 .mark = sk->sk_mark,
893 .fl4_dst = faddr,
894 .fl4_src = saddr,
895 .fl4_tos = tos,
896 .proto = sk->sk_protocol,
897 .flags = inet_sk_flowi_flags(sk),
898 .fl_ip_sport = inet->inet_sport,
899 .fl_ip_dport = dport };
900 struct net *net = sock_net(sk);
901
902 security_sk_classify_flow(sk, &fl);
903 err = ip_route_output_flow(net, &rt, &fl, sk, 1);
904 if (err) {
905 if (err == -ENETUNREACH)
906 IP_INC_STATS_BH(net, IPSTATS_MIB_OUTNOROUTES);
907 goto out;
908 }
909
910 err = -EACCES;
911 if ((rt->rt_flags & RTCF_BROADCAST) &&
912 !sock_flag(sk, SOCK_BROADCAST))
913 goto out;
914 if (connected)
915 sk_dst_set(sk, dst_clone(&rt->dst));
916 }
917
918 if (msg->msg_flags&MSG_CONFIRM)
919 goto do_confirm;
920back_from_confirm:
921
922 saddr = rt->rt_src;
923 if (!ipc.addr)
924 daddr = ipc.addr = rt->rt_dst;
925
926 lock_sock(sk);
927 if (unlikely(up->pending)) {
928
929
930 release_sock(sk);
931
932 LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
933 err = -EINVAL;
934 goto out;
935 }
936
937
938
939 inet->cork.fl.fl4_dst = daddr;
940 inet->cork.fl.fl_ip_dport = dport;
941 inet->cork.fl.fl4_src = saddr;
942 inet->cork.fl.fl_ip_sport = inet->inet_sport;
943 up->pending = AF_INET;
944
945do_append_data:
946 up->len += ulen;
947 getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag;
948 err = ip_append_data(sk, getfrag, msg->msg_iov, ulen,
949 sizeof(struct udphdr), &ipc, &rt,
950 corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
951 if (err)
952 udp_flush_pending_frames(sk);
953 else if (!corkreq)
954 err = udp_push_pending_frames(sk);
955 else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
956 up->pending = 0;
957 release_sock(sk);
958
959out:
960 ip_rt_put(rt);
961 if (free)
962 kfree(ipc.opt);
963 if (!err)
964 return len;
965
966
967
968
969
970
971
972 if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
973 UDP_INC_STATS_USER(sock_net(sk),
974 UDP_MIB_SNDBUFERRORS, is_udplite);
975 }
976 return err;
977
978do_confirm:
979 dst_confirm(&rt->dst);
980 if (!(msg->msg_flags&MSG_PROBE) || len)
981 goto back_from_confirm;
982 err = 0;
983 goto out;
984}
985EXPORT_SYMBOL(udp_sendmsg);
986
987int udp_sendpage(struct sock *sk, struct page *page, int offset,
988 size_t size, int flags)
989{
990 struct udp_sock *up = udp_sk(sk);
991 int ret;
992
993 if (!up->pending) {
994 struct msghdr msg = { .msg_flags = flags|MSG_MORE };
995
996
997
998
999
1000 ret = udp_sendmsg(NULL, sk, &msg, 0);
1001 if (ret < 0)
1002 return ret;
1003 }
1004
1005 lock_sock(sk);
1006
1007 if (unlikely(!up->pending)) {
1008 release_sock(sk);
1009
1010 LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 3\n");
1011 return -EINVAL;
1012 }
1013
1014 ret = ip_append_page(sk, page, offset, size, flags);
1015 if (ret == -EOPNOTSUPP) {
1016 release_sock(sk);
1017 return sock_no_sendpage(sk->sk_socket, page, offset,
1018 size, flags);
1019 }
1020 if (ret < 0) {
1021 udp_flush_pending_frames(sk);
1022 goto out;
1023 }
1024
1025 up->len += size;
1026 if (!(up->corkflag || (flags&MSG_MORE)))
1027 ret = udp_push_pending_frames(sk);
1028 if (!ret)
1029 ret = size;
1030out:
1031 release_sock(sk);
1032 return ret;
1033}
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043static unsigned int first_packet_length(struct sock *sk)
1044{
1045 struct sk_buff_head list_kill, *rcvq = &sk->sk_receive_queue;
1046 struct sk_buff *skb;
1047 unsigned int res;
1048
1049 __skb_queue_head_init(&list_kill);
1050
1051 spin_lock_bh(&rcvq->lock);
1052 while ((skb = skb_peek(rcvq)) != NULL &&
1053 udp_lib_checksum_complete(skb)) {
1054 UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS,
1055 IS_UDPLITE(sk));
1056 atomic_inc(&sk->sk_drops);
1057 __skb_unlink(skb, rcvq);
1058 __skb_queue_tail(&list_kill, skb);
1059 }
1060 res = skb ? skb->len : 0;
1061 spin_unlock_bh(&rcvq->lock);
1062
1063 if (!skb_queue_empty(&list_kill)) {
1064 bool slow = lock_sock_fast(sk);
1065
1066 __skb_queue_purge(&list_kill);
1067 sk_mem_reclaim_partial(sk);
1068 unlock_sock_fast(sk, slow);
1069 }
1070 return res;
1071}
1072
1073
1074
1075
1076
1077int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
1078{
1079 switch (cmd) {
1080 case SIOCOUTQ:
1081 {
1082 int amount = sk_wmem_alloc_get(sk);
1083
1084 return put_user(amount, (int __user *)arg);
1085 }
1086
1087 case SIOCINQ:
1088 {
1089 unsigned int amount = first_packet_length(sk);
1090
1091 if (amount)
1092
1093
1094
1095
1096
1097 amount -= sizeof(struct udphdr);
1098
1099 return put_user(amount, (int __user *)arg);
1100 }
1101
1102 default:
1103 return -ENOIOCTLCMD;
1104 }
1105
1106 return 0;
1107}
1108EXPORT_SYMBOL(udp_ioctl);
1109
1110
1111
1112
1113
1114
1115int udp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
1116 size_t len, int noblock, int flags, int *addr_len)
1117{
1118 struct inet_sock *inet = inet_sk(sk);
1119 struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
1120 struct sk_buff *skb;
1121 unsigned int ulen;
1122 int peeked;
1123 int err;
1124 int is_udplite = IS_UDPLITE(sk);
1125 bool slow;
1126
1127
1128
1129
1130 if (addr_len)
1131 *addr_len = sizeof(*sin);
1132
1133 if (flags & MSG_ERRQUEUE)
1134 return ip_recv_error(sk, msg, len);
1135
1136try_again:
1137 skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
1138 &peeked, &err);
1139 if (!skb)
1140 goto out;
1141
1142 ulen = skb->len - sizeof(struct udphdr);
1143 if (len > ulen)
1144 len = ulen;
1145 else if (len < ulen)
1146 msg->msg_flags |= MSG_TRUNC;
1147
1148
1149
1150
1151
1152
1153
1154 if (len < ulen || UDP_SKB_CB(skb)->partial_cov) {
1155 if (udp_lib_checksum_complete(skb))
1156 goto csum_copy_err;
1157 }
1158
1159 if (skb_csum_unnecessary(skb))
1160 err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
1161 msg->msg_iov, len);
1162 else {
1163 err = skb_copy_and_csum_datagram_iovec(skb,
1164 sizeof(struct udphdr),
1165 msg->msg_iov);
1166
1167 if (err == -EINVAL)
1168 goto csum_copy_err;
1169 }
1170
1171 if (err)
1172 goto out_free;
1173
1174 if (!peeked)
1175 UDP_INC_STATS_USER(sock_net(sk),
1176 UDP_MIB_INDATAGRAMS, is_udplite);
1177
1178 sock_recv_ts_and_drops(msg, sk, skb);
1179
1180
1181 if (sin) {
1182 sin->sin_family = AF_INET;
1183 sin->sin_port = udp_hdr(skb)->source;
1184 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
1185 memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
1186 }
1187 if (inet->cmsg_flags)
1188 ip_cmsg_recv(msg, skb);
1189
1190 err = len;
1191 if (flags & MSG_TRUNC)
1192 err = ulen;
1193
1194out_free:
1195 skb_free_datagram_locked(sk, skb);
1196out:
1197 return err;
1198
1199csum_copy_err:
1200 slow = lock_sock_fast(sk);
1201 if (!skb_kill_datagram(sk, skb, flags))
1202 UDP_INC_STATS_USER(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
1203 unlock_sock_fast(sk, slow);
1204
1205 if (noblock)
1206 return -EAGAIN;
1207 goto try_again;
1208}
1209
1210
1211int udp_disconnect(struct sock *sk, int flags)
1212{
1213 struct inet_sock *inet = inet_sk(sk);
1214
1215
1216
1217
1218 sk->sk_state = TCP_CLOSE;
1219 inet->inet_daddr = 0;
1220 inet->inet_dport = 0;
1221 sock_rps_save_rxhash(sk, 0);
1222 sk->sk_bound_dev_if = 0;
1223 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
1224 inet_reset_saddr(sk);
1225
1226 if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
1227 sk->sk_prot->unhash(sk);
1228 inet->inet_sport = 0;
1229 }
1230 sk_dst_reset(sk);
1231 return 0;
1232}
1233EXPORT_SYMBOL(udp_disconnect);
1234
1235void udp_lib_unhash(struct sock *sk)
1236{
1237 if (sk_hashed(sk)) {
1238 struct udp_table *udptable = sk->sk_prot->h.udp_table;
1239 struct udp_hslot *hslot, *hslot2;
1240
1241 hslot = udp_hashslot(udptable, sock_net(sk),
1242 udp_sk(sk)->udp_port_hash);
1243 hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
1244
1245 spin_lock_bh(&hslot->lock);
1246 if (sk_nulls_del_node_init_rcu(sk)) {
1247 hslot->count--;
1248 inet_sk(sk)->inet_num = 0;
1249 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
1250
1251 spin_lock(&hslot2->lock);
1252 hlist_nulls_del_init_rcu(&udp_sk(sk)->udp_portaddr_node);
1253 hslot2->count--;
1254 spin_unlock(&hslot2->lock);
1255 }
1256 spin_unlock_bh(&hslot->lock);
1257 }
1258}
1259EXPORT_SYMBOL(udp_lib_unhash);
1260
1261
1262
1263
1264void udp_lib_rehash(struct sock *sk, u16 newhash)
1265{
1266 if (sk_hashed(sk)) {
1267 struct udp_table *udptable = sk->sk_prot->h.udp_table;
1268 struct udp_hslot *hslot, *hslot2, *nhslot2;
1269
1270 hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
1271 nhslot2 = udp_hashslot2(udptable, newhash);
1272 udp_sk(sk)->udp_portaddr_hash = newhash;
1273 if (hslot2 != nhslot2) {
1274 hslot = udp_hashslot(udptable, sock_net(sk),
1275 udp_sk(sk)->udp_port_hash);
1276
1277 spin_lock_bh(&hslot->lock);
1278
1279 spin_lock(&hslot2->lock);
1280 hlist_nulls_del_init_rcu(&udp_sk(sk)->udp_portaddr_node);
1281 hslot2->count--;
1282 spin_unlock(&hslot2->lock);
1283
1284 spin_lock(&nhslot2->lock);
1285 hlist_nulls_add_head_rcu(&udp_sk(sk)->udp_portaddr_node,
1286 &nhslot2->head);
1287 nhslot2->count++;
1288 spin_unlock(&nhslot2->lock);
1289
1290 spin_unlock_bh(&hslot->lock);
1291 }
1292 }
1293}
1294EXPORT_SYMBOL(udp_lib_rehash);
1295
1296static void udp_v4_rehash(struct sock *sk)
1297{
1298 u16 new_hash = udp4_portaddr_hash(sock_net(sk),
1299 inet_sk(sk)->inet_rcv_saddr,
1300 inet_sk(sk)->inet_num);
1301 udp_lib_rehash(sk, new_hash);
1302}
1303
1304static int __udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
1305{
1306 int rc;
1307
1308 if (inet_sk(sk)->inet_daddr)
1309 sock_rps_save_rxhash(sk, skb->rxhash);
1310
1311 rc = ip_queue_rcv_skb(sk, skb);
1312 if (rc < 0) {
1313 int is_udplite = IS_UDPLITE(sk);
1314
1315
1316 if (rc == -ENOMEM)
1317 UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
1318 is_udplite);
1319 UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
1320 kfree_skb(skb);
1321 return -1;
1322 }
1323
1324 return 0;
1325
1326}
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336int udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
1337{
1338 struct udp_sock *up = udp_sk(sk);
1339 int rc;
1340 int is_udplite = IS_UDPLITE(sk);
1341
1342
1343
1344
1345 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1346 goto drop;
1347 nf_reset(skb);
1348
1349 if (up->encap_type) {
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362 if (skb->len > sizeof(struct udphdr) &&
1363 up->encap_rcv != NULL) {
1364 int ret;
1365
1366 ret = (*up->encap_rcv)(sk, skb);
1367 if (ret <= 0) {
1368 UDP_INC_STATS_BH(sock_net(sk),
1369 UDP_MIB_INDATAGRAMS,
1370 is_udplite);
1371 return -ret;
1372 }
1373 }
1374
1375
1376 }
1377
1378
1379
1380
1381 if ((is_udplite & UDPLITE_RECV_CC) && UDP_SKB_CB(skb)->partial_cov) {
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394 if (up->pcrlen == 0) {
1395 LIMIT_NETDEBUG(KERN_WARNING "UDPLITE: partial coverage "
1396 "%d while full coverage %d requested\n",
1397 UDP_SKB_CB(skb)->cscov, skb->len);
1398 goto drop;
1399 }
1400
1401
1402
1403
1404
1405
1406 if (UDP_SKB_CB(skb)->cscov < up->pcrlen) {
1407 LIMIT_NETDEBUG(KERN_WARNING
1408 "UDPLITE: coverage %d too small, need min %d\n",
1409 UDP_SKB_CB(skb)->cscov, up->pcrlen);
1410 goto drop;
1411 }
1412 }
1413
1414 if (rcu_dereference_raw(sk->sk_filter)) {
1415 if (udp_lib_checksum_complete(skb))
1416 goto drop;
1417 }
1418
1419
1420 if (sk_rcvqueues_full(sk, skb))
1421 goto drop;
1422
1423 rc = 0;
1424
1425 bh_lock_sock(sk);
1426 if (!sock_owned_by_user(sk))
1427 rc = __udp_queue_rcv_skb(sk, skb);
1428 else if (sk_add_backlog(sk, skb)) {
1429 bh_unlock_sock(sk);
1430 goto drop;
1431 }
1432 bh_unlock_sock(sk);
1433
1434 return rc;
1435
1436drop:
1437 UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
1438 atomic_inc(&sk->sk_drops);
1439 kfree_skb(skb);
1440 return -1;
1441}
1442
1443
1444static void flush_stack(struct sock **stack, unsigned int count,
1445 struct sk_buff *skb, unsigned int final)
1446{
1447 unsigned int i;
1448 struct sk_buff *skb1 = NULL;
1449 struct sock *sk;
1450
1451 for (i = 0; i < count; i++) {
1452 sk = stack[i];
1453 if (likely(skb1 == NULL))
1454 skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);
1455
1456 if (!skb1) {
1457 atomic_inc(&sk->sk_drops);
1458 UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
1459 IS_UDPLITE(sk));
1460 UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS,
1461 IS_UDPLITE(sk));
1462 }
1463
1464 if (skb1 && udp_queue_rcv_skb(sk, skb1) <= 0)
1465 skb1 = NULL;
1466 }
1467 if (unlikely(skb1))
1468 kfree_skb(skb1);
1469}
1470
1471
1472
1473
1474
1475
1476static int __udp4_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
1477 struct udphdr *uh,
1478 __be32 saddr, __be32 daddr,
1479 struct udp_table *udptable)
1480{
1481 struct sock *sk, *stack[256 / sizeof(struct sock *)];
1482 struct udp_hslot *hslot = udp_hashslot(udptable, net, ntohs(uh->dest));
1483 int dif;
1484 unsigned int i, count = 0;
1485
1486 spin_lock(&hslot->lock);
1487 sk = sk_nulls_head(&hslot->head);
1488 dif = skb->dev->ifindex;
1489 sk = udp_v4_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
1490 while (sk) {
1491 stack[count++] = sk;
1492 sk = udp_v4_mcast_next(net, sk_nulls_next(sk), uh->dest,
1493 daddr, uh->source, saddr, dif);
1494 if (unlikely(count == ARRAY_SIZE(stack))) {
1495 if (!sk)
1496 break;
1497 flush_stack(stack, count, skb, ~0);
1498 count = 0;
1499 }
1500 }
1501
1502
1503
1504 for (i = 0; i < count; i++)
1505 sock_hold(stack[i]);
1506
1507 spin_unlock(&hslot->lock);
1508
1509
1510
1511
1512 if (count) {
1513 flush_stack(stack, count, skb, count - 1);
1514
1515 for (i = 0; i < count; i++)
1516 sock_put(stack[i]);
1517 } else {
1518 kfree_skb(skb);
1519 }
1520 return 0;
1521}
1522
1523
1524
1525
1526
1527
1528static inline int udp4_csum_init(struct sk_buff *skb, struct udphdr *uh,
1529 int proto)
1530{
1531 const struct iphdr *iph;
1532 int err;
1533
1534 UDP_SKB_CB(skb)->partial_cov = 0;
1535 UDP_SKB_CB(skb)->cscov = skb->len;
1536
1537 if (proto == IPPROTO_UDPLITE) {
1538 err = udplite_checksum_init(skb, uh);
1539 if (err)
1540 return err;
1541 }
1542
1543 iph = ip_hdr(skb);
1544 if (uh->check == 0) {
1545 skb->ip_summed = CHECKSUM_UNNECESSARY;
1546 } else if (skb->ip_summed == CHECKSUM_COMPLETE) {
1547 if (!csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
1548 proto, skb->csum))
1549 skb->ip_summed = CHECKSUM_UNNECESSARY;
1550 }
1551 if (!skb_csum_unnecessary(skb))
1552 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
1553 skb->len, proto, 0);
1554
1555
1556
1557
1558 return 0;
1559}
1560
1561
1562
1563
1564
1565int __udp4_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
1566 int proto)
1567{
1568 struct sock *sk;
1569 struct udphdr *uh;
1570 unsigned short ulen;
1571 struct rtable *rt = skb_rtable(skb);
1572 __be32 saddr, daddr;
1573 struct net *net = dev_net(skb->dev);
1574
1575
1576
1577
1578 if (!pskb_may_pull(skb, sizeof(struct udphdr)))
1579 goto drop;
1580
1581 uh = udp_hdr(skb);
1582 ulen = ntohs(uh->len);
1583 saddr = ip_hdr(skb)->saddr;
1584 daddr = ip_hdr(skb)->daddr;
1585
1586 if (ulen > skb->len)
1587 goto short_packet;
1588
1589 if (proto == IPPROTO_UDP) {
1590
1591 if (ulen < sizeof(*uh) || pskb_trim_rcsum(skb, ulen))
1592 goto short_packet;
1593 uh = udp_hdr(skb);
1594 }
1595
1596 if (udp4_csum_init(skb, uh, proto))
1597 goto csum_error;
1598
1599 if (rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST))
1600 return __udp4_lib_mcast_deliver(net, skb, uh,
1601 saddr, daddr, udptable);
1602
1603 sk = __udp4_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
1604
1605 if (sk != NULL) {
1606 int ret = udp_queue_rcv_skb(sk, skb);
1607 sock_put(sk);
1608
1609
1610
1611
1612 if (ret > 0)
1613 return -ret;
1614 return 0;
1615 }
1616
1617 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1618 goto drop;
1619 nf_reset(skb);
1620
1621
1622 if (udp_lib_checksum_complete(skb))
1623 goto csum_error;
1624
1625 UDP_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
1626 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
1627
1628
1629
1630
1631
1632 kfree_skb(skb);
1633 return 0;
1634
1635short_packet:
1636 LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: short packet: From %pI4:%u %d/%d to %pI4:%u\n",
1637 proto == IPPROTO_UDPLITE ? "-Lite" : "",
1638 &saddr,
1639 ntohs(uh->source),
1640 ulen,
1641 skb->len,
1642 &daddr,
1643 ntohs(uh->dest));
1644 goto drop;
1645
1646csum_error:
1647
1648
1649
1650
1651 LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: bad checksum. From %pI4:%u to %pI4:%u ulen %d\n",
1652 proto == IPPROTO_UDPLITE ? "-Lite" : "",
1653 &saddr,
1654 ntohs(uh->source),
1655 &daddr,
1656 ntohs(uh->dest),
1657 ulen);
1658drop:
1659 UDP_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
1660 kfree_skb(skb);
1661 return 0;
1662}
1663
1664int udp_rcv(struct sk_buff *skb)
1665{
1666 return __udp4_lib_rcv(skb, &udp_table, IPPROTO_UDP);
1667}
1668
1669void udp_destroy_sock(struct sock *sk)
1670{
1671 bool slow = lock_sock_fast(sk);
1672 udp_flush_pending_frames(sk);
1673 unlock_sock_fast(sk, slow);
1674}
1675
1676
1677
1678
1679int udp_lib_setsockopt(struct sock *sk, int level, int optname,
1680 char __user *optval, unsigned int optlen,
1681 int (*push_pending_frames)(struct sock *))
1682{
1683 struct udp_sock *up = udp_sk(sk);
1684 int val;
1685 int err = 0;
1686 int is_udplite = IS_UDPLITE(sk);
1687
1688 if (optlen < sizeof(int))
1689 return -EINVAL;
1690
1691 if (get_user(val, (int __user *)optval))
1692 return -EFAULT;
1693
1694 switch (optname) {
1695 case UDP_CORK:
1696 if (val != 0) {
1697 up->corkflag = 1;
1698 } else {
1699 up->corkflag = 0;
1700 lock_sock(sk);
1701 (*push_pending_frames)(sk);
1702 release_sock(sk);
1703 }
1704 break;
1705
1706 case UDP_ENCAP:
1707 switch (val) {
1708 case 0:
1709 case UDP_ENCAP_ESPINUDP:
1710 case UDP_ENCAP_ESPINUDP_NON_IKE:
1711 up->encap_rcv = xfrm4_udp_encap_rcv;
1712
1713 case UDP_ENCAP_L2TPINUDP:
1714 up->encap_type = val;
1715 break;
1716 default:
1717 err = -ENOPROTOOPT;
1718 break;
1719 }
1720 break;
1721
1722
1723
1724
1725
1726
1727 case UDPLITE_SEND_CSCOV:
1728 if (!is_udplite)
1729 return -ENOPROTOOPT;
1730 if (val != 0 && val < 8)
1731 val = 8;
1732 else if (val > USHRT_MAX)
1733 val = USHRT_MAX;
1734 up->pcslen = val;
1735 up->pcflag |= UDPLITE_SEND_CC;
1736 break;
1737
1738
1739
1740
1741 case UDPLITE_RECV_CSCOV:
1742 if (!is_udplite)
1743 return -ENOPROTOOPT;
1744 if (val != 0 && val < 8)
1745 val = 8;
1746 else if (val > USHRT_MAX)
1747 val = USHRT_MAX;
1748 up->pcrlen = val;
1749 up->pcflag |= UDPLITE_RECV_CC;
1750 break;
1751
1752 default:
1753 err = -ENOPROTOOPT;
1754 break;
1755 }
1756
1757 return err;
1758}
1759EXPORT_SYMBOL(udp_lib_setsockopt);
1760
1761int udp_setsockopt(struct sock *sk, int level, int optname,
1762 char __user *optval, unsigned int optlen)
1763{
1764 if (level == SOL_UDP || level == SOL_UDPLITE)
1765 return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1766 udp_push_pending_frames);
1767 return ip_setsockopt(sk, level, optname, optval, optlen);
1768}
1769
1770#ifdef CONFIG_COMPAT
1771int compat_udp_setsockopt(struct sock *sk, int level, int optname,
1772 char __user *optval, unsigned int optlen)
1773{
1774 if (level == SOL_UDP || level == SOL_UDPLITE)
1775 return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1776 udp_push_pending_frames);
1777 return compat_ip_setsockopt(sk, level, optname, optval, optlen);
1778}
1779#endif
1780
1781int udp_lib_getsockopt(struct sock *sk, int level, int optname,
1782 char __user *optval, int __user *optlen)
1783{
1784 struct udp_sock *up = udp_sk(sk);
1785 int val, len;
1786
1787 if (get_user(len, optlen))
1788 return -EFAULT;
1789
1790 len = min_t(unsigned int, len, sizeof(int));
1791
1792 if (len < 0)
1793 return -EINVAL;
1794
1795 switch (optname) {
1796 case UDP_CORK:
1797 val = up->corkflag;
1798 break;
1799
1800 case UDP_ENCAP:
1801 val = up->encap_type;
1802 break;
1803
1804
1805
1806 case UDPLITE_SEND_CSCOV:
1807 val = up->pcslen;
1808 break;
1809
1810 case UDPLITE_RECV_CSCOV:
1811 val = up->pcrlen;
1812 break;
1813
1814 default:
1815 return -ENOPROTOOPT;
1816 }
1817
1818 if (put_user(len, optlen))
1819 return -EFAULT;
1820 if (copy_to_user(optval, &val, len))
1821 return -EFAULT;
1822 return 0;
1823}
1824EXPORT_SYMBOL(udp_lib_getsockopt);
1825
1826int udp_getsockopt(struct sock *sk, int level, int optname,
1827 char __user *optval, int __user *optlen)
1828{
1829 if (level == SOL_UDP || level == SOL_UDPLITE)
1830 return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1831 return ip_getsockopt(sk, level, optname, optval, optlen);
1832}
1833
1834#ifdef CONFIG_COMPAT
1835int compat_udp_getsockopt(struct sock *sk, int level, int optname,
1836 char __user *optval, int __user *optlen)
1837{
1838 if (level == SOL_UDP || level == SOL_UDPLITE)
1839 return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1840 return compat_ip_getsockopt(sk, level, optname, optval, optlen);
1841}
1842#endif
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856unsigned int udp_poll(struct file *file, struct socket *sock, poll_table *wait)
1857{
1858 unsigned int mask = datagram_poll(file, sock, wait);
1859 struct sock *sk = sock->sk;
1860
1861
1862 if ((mask & POLLRDNORM) && !(file->f_flags & O_NONBLOCK) &&
1863 !(sk->sk_shutdown & RCV_SHUTDOWN) && !first_packet_length(sk))
1864 mask &= ~(POLLIN | POLLRDNORM);
1865
1866 return mask;
1867
1868}
1869EXPORT_SYMBOL(udp_poll);
1870
1871struct proto udp_prot = {
1872 .name = "UDP",
1873 .owner = THIS_MODULE,
1874 .close = udp_lib_close,
1875 .connect = ip4_datagram_connect,
1876 .disconnect = udp_disconnect,
1877 .ioctl = udp_ioctl,
1878 .destroy = udp_destroy_sock,
1879 .setsockopt = udp_setsockopt,
1880 .getsockopt = udp_getsockopt,
1881 .sendmsg = udp_sendmsg,
1882 .recvmsg = udp_recvmsg,
1883 .sendpage = udp_sendpage,
1884 .backlog_rcv = __udp_queue_rcv_skb,
1885 .hash = udp_lib_hash,
1886 .unhash = udp_lib_unhash,
1887 .rehash = udp_v4_rehash,
1888 .get_port = udp_v4_get_port,
1889 .memory_allocated = &udp_memory_allocated,
1890 .sysctl_mem = sysctl_udp_mem,
1891 .sysctl_wmem = &sysctl_udp_wmem_min,
1892 .sysctl_rmem = &sysctl_udp_rmem_min,
1893 .obj_size = sizeof(struct udp_sock),
1894 .slab_flags = SLAB_DESTROY_BY_RCU,
1895 .h.udp_table = &udp_table,
1896#ifdef CONFIG_COMPAT
1897 .compat_setsockopt = compat_udp_setsockopt,
1898 .compat_getsockopt = compat_udp_getsockopt,
1899#endif
1900 .clear_sk = sk_prot_clear_portaddr_nulls,
1901};
1902EXPORT_SYMBOL(udp_prot);
1903
1904
1905#ifdef CONFIG_PROC_FS
1906
1907static struct sock *udp_get_first(struct seq_file *seq, int start)
1908{
1909 struct sock *sk;
1910 struct udp_iter_state *state = seq->private;
1911 struct net *net = seq_file_net(seq);
1912
1913 for (state->bucket = start; state->bucket <= state->udp_table->mask;
1914 ++state->bucket) {
1915 struct hlist_nulls_node *node;
1916 struct udp_hslot *hslot = &state->udp_table->hash[state->bucket];
1917
1918 if (hlist_nulls_empty(&hslot->head))
1919 continue;
1920
1921 spin_lock_bh(&hslot->lock);
1922 sk_nulls_for_each(sk, node, &hslot->head) {
1923 if (!net_eq(sock_net(sk), net))
1924 continue;
1925 if (sk->sk_family == state->family)
1926 goto found;
1927 }
1928 spin_unlock_bh(&hslot->lock);
1929 }
1930 sk = NULL;
1931found:
1932 return sk;
1933}
1934
1935static struct sock *udp_get_next(struct seq_file *seq, struct sock *sk)
1936{
1937 struct udp_iter_state *state = seq->private;
1938 struct net *net = seq_file_net(seq);
1939
1940 do {
1941 sk = sk_nulls_next(sk);
1942 } while (sk && (!net_eq(sock_net(sk), net) || sk->sk_family != state->family));
1943
1944 if (!sk) {
1945 if (state->bucket <= state->udp_table->mask)
1946 spin_unlock_bh(&state->udp_table->hash[state->bucket].lock);
1947 return udp_get_first(seq, state->bucket + 1);
1948 }
1949 return sk;
1950}
1951
1952static struct sock *udp_get_idx(struct seq_file *seq, loff_t pos)
1953{
1954 struct sock *sk = udp_get_first(seq, 0);
1955
1956 if (sk)
1957 while (pos && (sk = udp_get_next(seq, sk)) != NULL)
1958 --pos;
1959 return pos ? NULL : sk;
1960}
1961
1962static void *udp_seq_start(struct seq_file *seq, loff_t *pos)
1963{
1964 struct udp_iter_state *state = seq->private;
1965 state->bucket = MAX_UDP_PORTS;
1966
1967 return *pos ? udp_get_idx(seq, *pos-1) : SEQ_START_TOKEN;
1968}
1969
1970static void *udp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1971{
1972 struct sock *sk;
1973
1974 if (v == SEQ_START_TOKEN)
1975 sk = udp_get_idx(seq, 0);
1976 else
1977 sk = udp_get_next(seq, v);
1978
1979 ++*pos;
1980 return sk;
1981}
1982
1983static void udp_seq_stop(struct seq_file *seq, void *v)
1984{
1985 struct udp_iter_state *state = seq->private;
1986
1987 if (state->bucket <= state->udp_table->mask)
1988 spin_unlock_bh(&state->udp_table->hash[state->bucket].lock);
1989}
1990
1991static int udp_seq_open(struct inode *inode, struct file *file)
1992{
1993 struct udp_seq_afinfo *afinfo = PDE(inode)->data;
1994 struct udp_iter_state *s;
1995 int err;
1996
1997 err = seq_open_net(inode, file, &afinfo->seq_ops,
1998 sizeof(struct udp_iter_state));
1999 if (err < 0)
2000 return err;
2001
2002 s = ((struct seq_file *)file->private_data)->private;
2003 s->family = afinfo->family;
2004 s->udp_table = afinfo->udp_table;
2005 return err;
2006}
2007
2008
2009int udp_proc_register(struct net *net, struct udp_seq_afinfo *afinfo)
2010{
2011 struct proc_dir_entry *p;
2012 int rc = 0;
2013
2014 afinfo->seq_fops.open = udp_seq_open;
2015 afinfo->seq_fops.read = seq_read;
2016 afinfo->seq_fops.llseek = seq_lseek;
2017 afinfo->seq_fops.release = seq_release_net;
2018
2019 afinfo->seq_ops.start = udp_seq_start;
2020 afinfo->seq_ops.next = udp_seq_next;
2021 afinfo->seq_ops.stop = udp_seq_stop;
2022
2023 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
2024 &afinfo->seq_fops, afinfo);
2025 if (!p)
2026 rc = -ENOMEM;
2027 return rc;
2028}
2029EXPORT_SYMBOL(udp_proc_register);
2030
2031void udp_proc_unregister(struct net *net, struct udp_seq_afinfo *afinfo)
2032{
2033 proc_net_remove(net, afinfo->name);
2034}
2035EXPORT_SYMBOL(udp_proc_unregister);
2036
2037
2038static void udp4_format_sock(struct sock *sp, struct seq_file *f,
2039 int bucket, int *len)
2040{
2041 struct inet_sock *inet = inet_sk(sp);
2042 __be32 dest = inet->inet_daddr;
2043 __be32 src = inet->inet_rcv_saddr;
2044 __u16 destp = ntohs(inet->inet_dport);
2045 __u16 srcp = ntohs(inet->inet_sport);
2046
2047 seq_printf(f, "%5d: %08X:%04X %08X:%04X"
2048 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d%n",
2049 bucket, src, srcp, dest, destp, sp->sk_state,
2050 sk_wmem_alloc_get(sp),
2051 sk_rmem_alloc_get(sp),
2052 0, 0L, 0, sock_i_uid(sp), 0, sock_i_ino(sp),
2053 atomic_read(&sp->sk_refcnt), sp,
2054 atomic_read(&sp->sk_drops), len);
2055}
2056
2057int udp4_seq_show(struct seq_file *seq, void *v)
2058{
2059 if (v == SEQ_START_TOKEN)
2060 seq_printf(seq, "%-127s\n",
2061 " sl local_address rem_address st tx_queue "
2062 "rx_queue tr tm->when retrnsmt uid timeout "
2063 "inode ref pointer drops");
2064 else {
2065 struct udp_iter_state *state = seq->private;
2066 int len;
2067
2068 udp4_format_sock(v, seq, state->bucket, &len);
2069 seq_printf(seq, "%*s\n", 127 - len, "");
2070 }
2071 return 0;
2072}
2073
2074
2075static struct udp_seq_afinfo udp4_seq_afinfo = {
2076 .name = "udp",
2077 .family = AF_INET,
2078 .udp_table = &udp_table,
2079 .seq_fops = {
2080 .owner = THIS_MODULE,
2081 },
2082 .seq_ops = {
2083 .show = udp4_seq_show,
2084 },
2085};
2086
2087static int __net_init udp4_proc_init_net(struct net *net)
2088{
2089 return udp_proc_register(net, &udp4_seq_afinfo);
2090}
2091
2092static void __net_exit udp4_proc_exit_net(struct net *net)
2093{
2094 udp_proc_unregister(net, &udp4_seq_afinfo);
2095}
2096
2097static struct pernet_operations udp4_net_ops = {
2098 .init = udp4_proc_init_net,
2099 .exit = udp4_proc_exit_net,
2100};
2101
2102int __init udp4_proc_init(void)
2103{
2104 return register_pernet_subsys(&udp4_net_ops);
2105}
2106
2107void udp4_proc_exit(void)
2108{
2109 unregister_pernet_subsys(&udp4_net_ops);
2110}
2111#endif
2112
2113static __initdata unsigned long uhash_entries;
2114static int __init set_uhash_entries(char *str)
2115{
2116 if (!str)
2117 return 0;
2118 uhash_entries = simple_strtoul(str, &str, 0);
2119 if (uhash_entries && uhash_entries < UDP_HTABLE_SIZE_MIN)
2120 uhash_entries = UDP_HTABLE_SIZE_MIN;
2121 return 1;
2122}
2123__setup("uhash_entries=", set_uhash_entries);
2124
2125void __init udp_table_init(struct udp_table *table, const char *name)
2126{
2127 unsigned int i;
2128
2129 if (!CONFIG_BASE_SMALL)
2130 table->hash = alloc_large_system_hash(name,
2131 2 * sizeof(struct udp_hslot),
2132 uhash_entries,
2133 21,
2134 0,
2135 &table->log,
2136 &table->mask,
2137 64 * 1024);
2138
2139
2140
2141 if (CONFIG_BASE_SMALL || table->mask < UDP_HTABLE_SIZE_MIN - 1) {
2142 table->hash = kmalloc(UDP_HTABLE_SIZE_MIN *
2143 2 * sizeof(struct udp_hslot), GFP_KERNEL);
2144 if (!table->hash)
2145 panic(name);
2146 table->log = ilog2(UDP_HTABLE_SIZE_MIN);
2147 table->mask = UDP_HTABLE_SIZE_MIN - 1;
2148 }
2149 table->hash2 = table->hash + (table->mask + 1);
2150 for (i = 0; i <= table->mask; i++) {
2151 INIT_HLIST_NULLS_HEAD(&table->hash[i].head, i);
2152 table->hash[i].count = 0;
2153 spin_lock_init(&table->hash[i].lock);
2154 }
2155 for (i = 0; i <= table->mask; i++) {
2156 INIT_HLIST_NULLS_HEAD(&table->hash2[i].head, i);
2157 table->hash2[i].count = 0;
2158 spin_lock_init(&table->hash2[i].lock);
2159 }
2160}
2161
2162void __init udp_init(void)
2163{
2164 unsigned long nr_pages, limit;
2165
2166 udp_table_init(&udp_table, "UDP");
2167
2168
2169
2170
2171 nr_pages = totalram_pages - totalhigh_pages;
2172 limit = min(nr_pages, 1UL<<(28-PAGE_SHIFT)) >> (20-PAGE_SHIFT);
2173 limit = (limit * (nr_pages >> (20-PAGE_SHIFT))) >> (PAGE_SHIFT-11);
2174 limit = max(limit, 128UL);
2175 sysctl_udp_mem[0] = limit / 4 * 3;
2176 sysctl_udp_mem[1] = limit;
2177 sysctl_udp_mem[2] = sysctl_udp_mem[0] * 2;
2178
2179 sysctl_udp_rmem_min = SK_MEM_QUANTUM;
2180 sysctl_udp_wmem_min = SK_MEM_QUANTUM;
2181}
2182
2183int udp4_ufo_send_check(struct sk_buff *skb)
2184{
2185 const struct iphdr *iph;
2186 struct udphdr *uh;
2187
2188 if (!pskb_may_pull(skb, sizeof(*uh)))
2189 return -EINVAL;
2190
2191 iph = ip_hdr(skb);
2192 uh = udp_hdr(skb);
2193
2194 uh->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
2195 IPPROTO_UDP, 0);
2196 skb->csum_start = skb_transport_header(skb) - skb->head;
2197 skb->csum_offset = offsetof(struct udphdr, check);
2198 skb->ip_summed = CHECKSUM_PARTIAL;
2199 return 0;
2200}
2201
2202struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, int features)
2203{
2204 struct sk_buff *segs = ERR_PTR(-EINVAL);
2205 unsigned int mss;
2206 int offset;
2207 __wsum csum;
2208
2209 mss = skb_shinfo(skb)->gso_size;
2210 if (unlikely(skb->len <= mss))
2211 goto out;
2212
2213 if (skb_gso_ok(skb, features | NETIF_F_GSO_ROBUST)) {
2214
2215 int type = skb_shinfo(skb)->gso_type;
2216
2217 if (unlikely(type & ~(SKB_GSO_UDP | SKB_GSO_DODGY) ||
2218 !(type & (SKB_GSO_UDP))))
2219 goto out;
2220
2221 skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss);
2222
2223 segs = NULL;
2224 goto out;
2225 }
2226
2227
2228
2229
2230 offset = skb_checksum_start_offset(skb);
2231 csum = skb_checksum(skb, offset, skb->len - offset, 0);
2232 offset += skb->csum_offset;
2233 *(__sum16 *)(skb->data + offset) = csum_fold(csum);
2234 skb->ip_summed = CHECKSUM_NONE;
2235
2236
2237
2238
2239 segs = skb_segment(skb, features);
2240out:
2241 return segs;
2242}
2243
2244