Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * INET An implementation of the TCP/IP protocol suite for the LINUX
4 : : * operating system. INET is implemented using the BSD Socket
5 : : * interface as the means of communication with the user level.
6 : : *
7 : : * The User Datagram Protocol (UDP).
8 : : *
9 : : * Authors: Ross Biro
10 : : * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
11 : : * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
12 : : * Alan Cox, <alan@lxorguk.ukuu.org.uk>
13 : : * Hirokazu Takahashi, <taka@valinux.co.jp>
14 : : *
15 : : * Fixes:
16 : : * Alan Cox : verify_area() calls
17 : : * Alan Cox : stopped close while in use off icmp
18 : : * messages. Not a fix but a botch that
19 : : * for udp at least is 'valid'.
20 : : * Alan Cox : Fixed icmp handling properly
21 : : * Alan Cox : Correct error for oversized datagrams
22 : : * Alan Cox : Tidied select() semantics.
23 : : * Alan Cox : udp_err() fixed properly, also now
24 : : * select and read wake correctly on errors
25 : : * Alan Cox : udp_send verify_area moved to avoid mem leak
26 : : * Alan Cox : UDP can count its memory
27 : : * Alan Cox : send to an unknown connection causes
28 : : * an ECONNREFUSED off the icmp, but
29 : : * does NOT close.
30 : : * Alan Cox : Switched to new sk_buff handlers. No more backlog!
31 : : * Alan Cox : Using generic datagram code. Even smaller and the PEEK
32 : : * bug no longer crashes it.
33 : : * Fred Van Kempen : Net2e support for sk->broadcast.
34 : : * Alan Cox : Uses skb_free_datagram
35 : : * Alan Cox : Added get/set sockopt support.
36 : : * Alan Cox : Broadcasting without option set returns EACCES.
37 : : * Alan Cox : No wakeup calls. Instead we now use the callbacks.
38 : : * Alan Cox : Use ip_tos and ip_ttl
39 : : * Alan Cox : SNMP Mibs
40 : : * Alan Cox : MSG_DONTROUTE, and 0.0.0.0 support.
41 : : * Matt Dillon : UDP length checks.
42 : : * Alan Cox : Smarter af_inet used properly.
43 : : * Alan Cox : Use new kernel side addressing.
44 : : * Alan Cox : Incorrect return on truncated datagram receive.
45 : : * Arnt Gulbrandsen : New udp_send and stuff
46 : : * Alan Cox : Cache last socket
47 : : * Alan Cox : Route cache
48 : : * Jon Peatfield : Minor efficiency fix to sendto().
49 : : * Mike Shaver : RFC1122 checks.
50 : : * Alan Cox : Nonblocking error fix.
51 : : * Willy Konynenberg : Transparent proxying support.
52 : : * Mike McLagan : Routing by source
53 : : * David S. Miller : New socket lookup architecture.
54 : : * Last socket cache retained as it
55 : : * does have a high hit rate.
56 : : * Olaf Kirch : Don't linearise iovec on sendmsg.
57 : : * Andi Kleen : Some cleanups, cache destination entry
58 : : * for connect.
59 : : * Vitaly E. Lavrov : Transparent proxy revived after year coma.
60 : : * Melvin Smith : Check msg_name not msg_namelen in sendto(),
61 : : * return ENOTCONN for unconnected sockets (POSIX)
62 : : * Janos Farkas : don't deliver multi/broadcasts to a different
63 : : * bound-to-device socket
64 : : * Hirokazu Takahashi : HW checksumming for outgoing UDP
65 : : * datagrams.
66 : : * Hirokazu Takahashi : sendfile() on UDP works now.
67 : : * Arnaldo C. Melo : convert /proc/net/udp to seq_file
68 : : * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
69 : : * Alexey Kuznetsov: allow both IPv4 and IPv6 sockets to bind
70 : : * a single port at the same time.
71 : : * Derek Atkins <derek@ihtfp.com>: Add Encapulation Support
72 : : * James Chapman : Add L2TP encapsulation type.
73 : : */
74 : :
75 : : #define pr_fmt(fmt) "UDP: " fmt
76 : :
77 : : #include <linux/uaccess.h>
78 : : #include <asm/ioctls.h>
79 : : #include <linux/memblock.h>
80 : : #include <linux/highmem.h>
81 : : #include <linux/swap.h>
82 : : #include <linux/types.h>
83 : : #include <linux/fcntl.h>
84 : : #include <linux/module.h>
85 : : #include <linux/socket.h>
86 : : #include <linux/sockios.h>
87 : : #include <linux/igmp.h>
88 : : #include <linux/inetdevice.h>
89 : : #include <linux/in.h>
90 : : #include <linux/errno.h>
91 : : #include <linux/timer.h>
92 : : #include <linux/mm.h>
93 : : #include <linux/inet.h>
94 : : #include <linux/netdevice.h>
95 : : #include <linux/slab.h>
96 : : #include <net/tcp_states.h>
97 : : #include <linux/skbuff.h>
98 : : #include <linux/proc_fs.h>
99 : : #include <linux/seq_file.h>
100 : : #include <net/net_namespace.h>
101 : : #include <net/icmp.h>
102 : : #include <net/inet_hashtables.h>
103 : : #include <net/ip_tunnels.h>
104 : : #include <net/route.h>
105 : : #include <net/checksum.h>
106 : : #include <net/xfrm.h>
107 : : #include <trace/events/udp.h>
108 : : #include <linux/static_key.h>
109 : : #include <trace/events/skb.h>
110 : : #include <net/busy_poll.h>
111 : : #include "udp_impl.h"
112 : : #include <net/sock_reuseport.h>
113 : : #include <net/addrconf.h>
114 : : #include <net/udp_tunnel.h>
115 : :
116 : : struct udp_table udp_table __read_mostly;
117 : : EXPORT_SYMBOL(udp_table);
118 : :
119 : : long sysctl_udp_mem[3] __read_mostly;
120 : : EXPORT_SYMBOL(sysctl_udp_mem);
121 : :
122 : : atomic_long_t udp_memory_allocated;
123 : : EXPORT_SYMBOL(udp_memory_allocated);
124 : :
125 : : #define MAX_UDP_PORTS 65536
126 : : #define PORTS_PER_CHAIN (MAX_UDP_PORTS / UDP_HTABLE_SIZE_MIN)
127 : :
128 : 3 : static int udp_lib_lport_inuse(struct net *net, __u16 num,
129 : : const struct udp_hslot *hslot,
130 : : unsigned long *bitmap,
131 : : struct sock *sk, unsigned int log)
132 : : {
133 : : struct sock *sk2;
134 : 3 : kuid_t uid = sock_i_uid(sk);
135 : :
136 : 3 : sk_for_each(sk2, &hslot->head) {
137 : 3 : if (net_eq(sock_net(sk2), net) &&
138 : 3 : sk2 != sk &&
139 : 3 : (bitmap || udp_sk(sk2)->udp_port_hash == num) &&
140 : 3 : (!sk2->sk_reuse || !sk->sk_reuse) &&
141 : 3 : (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
142 : 3 : sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
143 : 3 : inet_rcv_saddr_equal(sk, sk2, true)) {
144 : 3 : if (sk2->sk_reuseport && sk->sk_reuseport &&
145 : 0 : !rcu_access_pointer(sk->sk_reuseport_cb) &&
146 : 0 : uid_eq(uid, sock_i_uid(sk2))) {
147 : 0 : if (!bitmap)
148 : : return 0;
149 : : } else {
150 : 3 : if (!bitmap)
151 : : return 1;
152 : 3 : __set_bit(udp_sk(sk2)->udp_port_hash >> log,
153 : : bitmap);
154 : : }
155 : : }
156 : : }
157 : : return 0;
158 : : }
159 : :
160 : : /*
161 : : * Note: we still hold spinlock of primary hash chain, so no other writer
162 : : * can insert/delete a socket with local_port == num
163 : : */
164 : 0 : static int udp_lib_lport_inuse2(struct net *net, __u16 num,
165 : : struct udp_hslot *hslot2,
166 : : struct sock *sk)
167 : : {
168 : : struct sock *sk2;
169 : 0 : kuid_t uid = sock_i_uid(sk);
170 : : int res = 0;
171 : :
172 : : spin_lock(&hslot2->lock);
173 : 0 : udp_portaddr_for_each_entry(sk2, &hslot2->head) {
174 : 0 : if (net_eq(sock_net(sk2), net) &&
175 : 0 : sk2 != sk &&
176 : 0 : (udp_sk(sk2)->udp_port_hash == num) &&
177 : 0 : (!sk2->sk_reuse || !sk->sk_reuse) &&
178 : 0 : (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
179 : 0 : sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
180 : 0 : inet_rcv_saddr_equal(sk, sk2, true)) {
181 : 0 : if (sk2->sk_reuseport && sk->sk_reuseport &&
182 : 0 : !rcu_access_pointer(sk->sk_reuseport_cb) &&
183 : 0 : uid_eq(uid, sock_i_uid(sk2))) {
184 : : res = 0;
185 : : } else {
186 : : res = 1;
187 : : }
188 : : break;
189 : : }
190 : : }
191 : : spin_unlock(&hslot2->lock);
192 : 0 : return res;
193 : : }
194 : :
195 : 1 : static int udp_reuseport_add_sock(struct sock *sk, struct udp_hslot *hslot)
196 : : {
197 : : struct net *net = sock_net(sk);
198 : 1 : kuid_t uid = sock_i_uid(sk);
199 : : struct sock *sk2;
200 : :
201 : 1 : sk_for_each(sk2, &hslot->head) {
202 : 1 : if (net_eq(sock_net(sk2), net) &&
203 : 1 : sk2 != sk &&
204 : 1 : sk2->sk_family == sk->sk_family &&
205 : 1 : ipv6_only_sock(sk2) == ipv6_only_sock(sk) &&
206 : 1 : (udp_sk(sk2)->udp_port_hash == udp_sk(sk)->udp_port_hash) &&
207 : 1 : (sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
208 : 1 : sk2->sk_reuseport && uid_eq(uid, sock_i_uid(sk2)) &&
209 : 1 : inet_rcv_saddr_equal(sk, sk2, false)) {
210 : 1 : return reuseport_add_sock(sk, sk2,
211 : : inet_rcv_saddr_any(sk));
212 : : }
213 : : }
214 : :
215 : 1 : return reuseport_alloc(sk, inet_rcv_saddr_any(sk));
216 : : }
217 : :
218 : : /**
219 : : * udp_lib_get_port - UDP/-Lite port lookup for IPv4 and IPv6
220 : : *
221 : : * @sk: socket struct in question
222 : : * @snum: port number to look up
223 : : * @hash2_nulladdr: AF-dependent hash value in secondary hash chains,
224 : : * with NULL address
225 : : */
226 : 3 : int udp_lib_get_port(struct sock *sk, unsigned short snum,
227 : : unsigned int hash2_nulladdr)
228 : : {
229 : : struct udp_hslot *hslot, *hslot2;
230 : 3 : struct udp_table *udptable = sk->sk_prot->h.udp_table;
231 : : int error = 1;
232 : : struct net *net = sock_net(sk);
233 : :
234 : 3 : if (!snum) {
235 : : int low, high, remaining;
236 : : unsigned int rand;
237 : : unsigned short first, last;
238 : : DECLARE_BITMAP(bitmap, PORTS_PER_CHAIN);
239 : :
240 : 3 : inet_get_local_port_range(net, &low, &high);
241 : 3 : remaining = (high - low) + 1;
242 : :
243 : 3 : rand = prandom_u32();
244 : 3 : first = reciprocal_scale(rand, remaining) + low;
245 : : /*
246 : : * force rand to be an odd multiple of UDP_HTABLE_SIZE
247 : : */
248 : 3 : rand = (rand | 1) * (udptable->mask + 1);
249 : 3 : last = first + udptable->mask + 1;
250 : : do {
251 : 3 : hslot = udp_hashslot(udptable, net, first);
252 : : bitmap_zero(bitmap, PORTS_PER_CHAIN);
253 : : spin_lock_bh(&hslot->lock);
254 : 3 : udp_lib_lport_inuse(net, snum, hslot, bitmap, sk,
255 : : udptable->log);
256 : :
257 : : snum = first;
258 : : /*
259 : : * Iterate on all possible values of snum for this hash.
260 : : * Using steps of an odd multiple of UDP_HTABLE_SIZE
261 : : * give us randomization and full range coverage.
262 : : */
263 : : do {
264 : 3 : if (low <= snum && snum <= high &&
265 : 3 : !test_bit(snum >> udptable->log, bitmap) &&
266 : : !inet_is_local_reserved_port(net, snum))
267 : : goto found;
268 : 0 : snum += rand;
269 : 0 : } while (snum != first);
270 : : spin_unlock_bh(&hslot->lock);
271 : 0 : cond_resched();
272 : 0 : } while (++first != last);
273 : 0 : goto fail;
274 : : } else {
275 : 3 : hslot = udp_hashslot(udptable, net, snum);
276 : : spin_lock_bh(&hslot->lock);
277 : 3 : if (hslot->count > 10) {
278 : : int exist;
279 : 0 : unsigned int slot2 = udp_sk(sk)->udp_portaddr_hash ^ snum;
280 : :
281 : 0 : slot2 &= udptable->mask;
282 : 0 : hash2_nulladdr &= udptable->mask;
283 : :
284 : : hslot2 = udp_hashslot2(udptable, slot2);
285 : 0 : if (hslot->count < hslot2->count)
286 : : goto scan_primary_hash;
287 : :
288 : 0 : exist = udp_lib_lport_inuse2(net, snum, hslot2, sk);
289 : 0 : if (!exist && (hash2_nulladdr != slot2)) {
290 : : hslot2 = udp_hashslot2(udptable, hash2_nulladdr);
291 : 0 : exist = udp_lib_lport_inuse2(net, snum, hslot2,
292 : : sk);
293 : : }
294 : 0 : if (exist)
295 : : goto fail_unlock;
296 : : else
297 : : goto found;
298 : : }
299 : : scan_primary_hash:
300 : 3 : if (udp_lib_lport_inuse(net, snum, hslot, NULL, sk, 0))
301 : : goto fail_unlock;
302 : : }
303 : : found:
304 : 3 : inet_sk(sk)->inet_num = snum;
305 : 3 : udp_sk(sk)->udp_port_hash = snum;
306 : 3 : udp_sk(sk)->udp_portaddr_hash ^= snum;
307 : 3 : if (sk_unhashed(sk)) {
308 : 3 : if (sk->sk_reuseport &&
309 : 1 : udp_reuseport_add_sock(sk, hslot)) {
310 : 0 : inet_sk(sk)->inet_num = 0;
311 : 0 : udp_sk(sk)->udp_port_hash = 0;
312 : 0 : udp_sk(sk)->udp_portaddr_hash ^= snum;
313 : 0 : goto fail_unlock;
314 : : }
315 : :
316 : 3 : sk_add_node_rcu(sk, &hslot->head);
317 : 3 : hslot->count++;
318 : 3 : sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
319 : :
320 : 3 : hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
321 : : spin_lock(&hslot2->lock);
322 : 3 : if (IS_ENABLED(CONFIG_IPV6) && sk->sk_reuseport &&
323 : : sk->sk_family == AF_INET6)
324 : 0 : hlist_add_tail_rcu(&udp_sk(sk)->udp_portaddr_node,
325 : : &hslot2->head);
326 : : else
327 : 3 : hlist_add_head_rcu(&udp_sk(sk)->udp_portaddr_node,
328 : : &hslot2->head);
329 : 3 : hslot2->count++;
330 : : spin_unlock(&hslot2->lock);
331 : : }
332 : : sock_set_flag(sk, SOCK_RCU_FREE);
333 : : error = 0;
334 : : fail_unlock:
335 : : spin_unlock_bh(&hslot->lock);
336 : : fail:
337 : 3 : return error;
338 : : }
339 : : EXPORT_SYMBOL(udp_lib_get_port);
340 : :
341 : 3 : int udp_v4_get_port(struct sock *sk, unsigned short snum)
342 : : {
343 : : unsigned int hash2_nulladdr =
344 : 3 : ipv4_portaddr_hash(sock_net(sk), htonl(INADDR_ANY), snum);
345 : : unsigned int hash2_partial =
346 : 3 : ipv4_portaddr_hash(sock_net(sk), inet_sk(sk)->inet_rcv_saddr, 0);
347 : :
348 : : /* precompute partial secondary hash */
349 : 3 : udp_sk(sk)->udp_portaddr_hash = hash2_partial;
350 : 3 : return udp_lib_get_port(sk, snum, hash2_nulladdr);
351 : : }
352 : :
353 : 3 : static int compute_score(struct sock *sk, struct net *net,
354 : : __be32 saddr, __be16 sport,
355 : : __be32 daddr, unsigned short hnum,
356 : : int dif, int sdif)
357 : : {
358 : : int score;
359 : : struct inet_sock *inet;
360 : : bool dev_match;
361 : :
362 : 3 : if (!net_eq(sock_net(sk), net) ||
363 : 3 : udp_sk(sk)->udp_port_hash != hnum ||
364 : : ipv6_only_sock(sk))
365 : : return -1;
366 : :
367 : 3 : if (sk->sk_rcv_saddr != daddr)
368 : : return -1;
369 : :
370 : 3 : score = (sk->sk_family == PF_INET) ? 2 : 1;
371 : :
372 : : inet = inet_sk(sk);
373 : 3 : if (inet->inet_daddr) {
374 : 0 : if (inet->inet_daddr != saddr)
375 : : return -1;
376 : 0 : score += 4;
377 : : }
378 : :
379 : 3 : if (inet->inet_dport) {
380 : 0 : if (inet->inet_dport != sport)
381 : : return -1;
382 : 0 : score += 4;
383 : : }
384 : :
385 : 3 : dev_match = udp_sk_bound_dev_eq(net, sk->sk_bound_dev_if,
386 : : dif, sdif);
387 : 3 : if (!dev_match)
388 : : return -1;
389 : 3 : score += 4;
390 : :
391 : 3 : if (READ_ONCE(sk->sk_incoming_cpu) == raw_smp_processor_id())
392 : 0 : score++;
393 : 3 : return score;
394 : : }
395 : :
396 : 0 : static u32 udp_ehashfn(const struct net *net, const __be32 laddr,
397 : : const __u16 lport, const __be32 faddr,
398 : : const __be16 fport)
399 : : {
400 : : static u32 udp_ehash_secret __read_mostly;
401 : :
402 : 0 : net_get_random_once(&udp_ehash_secret, sizeof(udp_ehash_secret));
403 : :
404 : 0 : return __inet_ehashfn(laddr, lport, faddr, fport,
405 : : udp_ehash_secret + net_hash_mix(net));
406 : : }
407 : :
408 : : /* called with rcu_read_lock() */
409 : 3 : static struct sock *udp4_lib_lookup2(struct net *net,
410 : : __be32 saddr, __be16 sport,
411 : : __be32 daddr, unsigned int hnum,
412 : : int dif, int sdif,
413 : : struct udp_hslot *hslot2,
414 : : struct sk_buff *skb)
415 : : {
416 : : struct sock *sk, *result, *reuseport_result;
417 : : int score, badness;
418 : : u32 hash = 0;
419 : :
420 : : result = NULL;
421 : : badness = 0;
422 : 3 : udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) {
423 : 3 : score = compute_score(sk, net, saddr, sport,
424 : : daddr, hnum, dif, sdif);
425 : 3 : if (score > badness) {
426 : : reuseport_result = NULL;
427 : :
428 : 3 : if (sk->sk_reuseport &&
429 : 0 : sk->sk_state != TCP_ESTABLISHED) {
430 : 0 : hash = udp_ehashfn(net, daddr, hnum,
431 : : saddr, sport);
432 : 0 : reuseport_result = reuseport_select_sock(sk, hash, skb,
433 : : sizeof(struct udphdr));
434 : 0 : if (reuseport_result && !reuseport_has_conns(sk, false))
435 : 0 : return reuseport_result;
436 : : }
437 : :
438 : 3 : result = reuseport_result ? : sk;
439 : : badness = score;
440 : : }
441 : : }
442 : 3 : return result;
443 : : }
444 : :
445 : : /* UDP is nearly always wildcards out the wazoo, it makes no sense to try
446 : : * harder than this. -DaveM
447 : : */
448 : 3 : struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,
449 : : __be16 sport, __be32 daddr, __be16 dport, int dif,
450 : : int sdif, struct udp_table *udptable, struct sk_buff *skb)
451 : : {
452 : : struct sock *result;
453 : 3 : unsigned short hnum = ntohs(dport);
454 : : unsigned int hash2, slot2;
455 : : struct udp_hslot *hslot2;
456 : :
457 : 3 : hash2 = ipv4_portaddr_hash(net, daddr, hnum);
458 : 3 : slot2 = hash2 & udptable->mask;
459 : 3 : hslot2 = &udptable->hash2[slot2];
460 : :
461 : 3 : result = udp4_lib_lookup2(net, saddr, sport,
462 : : daddr, hnum, dif, sdif,
463 : : hslot2, skb);
464 : 3 : if (!result) {
465 : : hash2 = ipv4_portaddr_hash(net, htonl(INADDR_ANY), hnum);
466 : 3 : slot2 = hash2 & udptable->mask;
467 : 3 : hslot2 = &udptable->hash2[slot2];
468 : :
469 : 3 : result = udp4_lib_lookup2(net, saddr, sport,
470 : : htonl(INADDR_ANY), hnum, dif, sdif,
471 : : hslot2, skb);
472 : : }
473 : 3 : if (IS_ERR(result))
474 : : return NULL;
475 : 3 : return result;
476 : : }
477 : : EXPORT_SYMBOL_GPL(__udp4_lib_lookup);
478 : :
479 : 3 : static inline struct sock *__udp4_lib_lookup_skb(struct sk_buff *skb,
480 : : __be16 sport, __be16 dport,
481 : : struct udp_table *udptable)
482 : : {
483 : : const struct iphdr *iph = ip_hdr(skb);
484 : :
485 : 3 : return __udp4_lib_lookup(dev_net(skb->dev), iph->saddr, sport,
486 : : iph->daddr, dport, inet_iif(skb),
487 : : inet_sdif(skb), udptable, skb);
488 : : }
489 : :
490 : 0 : struct sock *udp4_lib_lookup_skb(struct sk_buff *skb,
491 : : __be16 sport, __be16 dport)
492 : : {
493 : : const struct iphdr *iph = ip_hdr(skb);
494 : :
495 : 0 : return __udp4_lib_lookup(dev_net(skb->dev), iph->saddr, sport,
496 : : iph->daddr, dport, inet_iif(skb),
497 : : inet_sdif(skb), &udp_table, NULL);
498 : : }
499 : : EXPORT_SYMBOL_GPL(udp4_lib_lookup_skb);
500 : :
501 : : /* Must be called under rcu_read_lock().
502 : : * Does increment socket refcount.
503 : : */
504 : : #if IS_ENABLED(CONFIG_NF_TPROXY_IPV4) || IS_ENABLED(CONFIG_NF_SOCKET_IPV4)
505 : 0 : struct sock *udp4_lib_lookup(struct net *net, __be32 saddr, __be16 sport,
506 : : __be32 daddr, __be16 dport, int dif)
507 : : {
508 : : struct sock *sk;
509 : :
510 : 0 : sk = __udp4_lib_lookup(net, saddr, sport, daddr, dport,
511 : : dif, 0, &udp_table, NULL);
512 : 0 : if (sk && !refcount_inc_not_zero(&sk->sk_refcnt))
513 : : sk = NULL;
514 : 0 : return sk;
515 : : }
516 : : EXPORT_SYMBOL_GPL(udp4_lib_lookup);
517 : : #endif
518 : :
519 : 3 : static inline bool __udp_is_mcast_sock(struct net *net, struct sock *sk,
520 : : __be16 loc_port, __be32 loc_addr,
521 : : __be16 rmt_port, __be32 rmt_addr,
522 : : int dif, int sdif, unsigned short hnum)
523 : : {
524 : : struct inet_sock *inet = inet_sk(sk);
525 : :
526 : 3 : if (!net_eq(sock_net(sk), net) ||
527 : 3 : udp_sk(sk)->udp_port_hash != hnum ||
528 : 3 : (inet->inet_daddr && inet->inet_daddr != rmt_addr) ||
529 : 3 : (inet->inet_dport != rmt_port && inet->inet_dport) ||
530 : 3 : (inet->inet_rcv_saddr && inet->inet_rcv_saddr != loc_addr) ||
531 : 3 : ipv6_only_sock(sk) ||
532 : 3 : !udp_sk_bound_dev_eq(net, sk->sk_bound_dev_if, dif, sdif))
533 : : return false;
534 : 3 : if (!ip_mc_sf_allow(sk, loc_addr, rmt_addr, dif, sdif))
535 : : return false;
536 : 3 : return true;
537 : : }
538 : :
539 : : DEFINE_STATIC_KEY_FALSE(udp_encap_needed_key);
540 : 0 : void udp_encap_enable(void)
541 : : {
542 : 0 : static_branch_inc(&udp_encap_needed_key);
543 : 0 : }
544 : : EXPORT_SYMBOL(udp_encap_enable);
545 : :
546 : : /* Handler for tunnels with arbitrary destination ports: no socket lookup, go
547 : : * through error handlers in encapsulations looking for a match.
548 : : */
549 : 0 : static int __udp4_lib_err_encap_no_sk(struct sk_buff *skb, u32 info)
550 : : {
551 : : int i;
552 : :
553 : 0 : for (i = 0; i < MAX_IPTUN_ENCAP_OPS; i++) {
554 : : int (*handler)(struct sk_buff *skb, u32 info);
555 : : const struct ip_tunnel_encap_ops *encap;
556 : :
557 : 0 : encap = rcu_dereference(iptun_encaps[i]);
558 : 0 : if (!encap)
559 : 0 : continue;
560 : 0 : handler = encap->err_handler;
561 : 0 : if (handler && !handler(skb, info))
562 : : return 0;
563 : : }
564 : :
565 : : return -ENOENT;
566 : : }
567 : :
568 : : /* Try to match ICMP errors to UDP tunnels by looking up a socket without
569 : : * reversing source and destination port: this will match tunnels that force the
570 : : * same destination port on both endpoints (e.g. VXLAN, GENEVE). Note that
571 : : * lwtunnels might actually break this assumption by being configured with
572 : : * different destination ports on endpoints, in this case we won't be able to
573 : : * trace ICMP messages back to them.
574 : : *
575 : : * If this doesn't match any socket, probe tunnels with arbitrary destination
576 : : * ports (e.g. FoU, GUE): there, the receiving socket is useless, as the port
577 : : * we've sent packets to won't necessarily match the local destination port.
578 : : *
579 : : * Then ask the tunnel implementation to match the error against a valid
580 : : * association.
581 : : *
582 : : * Return an error if we can't find a match, the socket if we need further
583 : : * processing, zero otherwise.
584 : : */
585 : 0 : static struct sock *__udp4_lib_err_encap(struct net *net,
586 : : const struct iphdr *iph,
587 : : struct udphdr *uh,
588 : : struct udp_table *udptable,
589 : : struct sk_buff *skb, u32 info)
590 : : {
591 : : int network_offset, transport_offset;
592 : : struct sock *sk;
593 : :
594 : : network_offset = skb_network_offset(skb);
595 : : transport_offset = skb_transport_offset(skb);
596 : :
597 : : /* Network header needs to point to the outer IPv4 header inside ICMP */
598 : : skb_reset_network_header(skb);
599 : :
600 : : /* Transport header needs to point to the UDP header */
601 : 0 : skb_set_transport_header(skb, iph->ihl << 2);
602 : :
603 : 0 : sk = __udp4_lib_lookup(net, iph->daddr, uh->source,
604 : 0 : iph->saddr, uh->dest, skb->dev->ifindex, 0,
605 : : udptable, NULL);
606 : 0 : if (sk) {
607 : : int (*lookup)(struct sock *sk, struct sk_buff *skb);
608 : : struct udp_sock *up = udp_sk(sk);
609 : :
610 : 0 : lookup = READ_ONCE(up->encap_err_lookup);
611 : 0 : if (!lookup || lookup(sk, skb))
612 : : sk = NULL;
613 : : }
614 : :
615 : 0 : if (!sk)
616 : 0 : sk = ERR_PTR(__udp4_lib_err_encap_no_sk(skb, info));
617 : :
618 : : skb_set_transport_header(skb, transport_offset);
619 : : skb_set_network_header(skb, network_offset);
620 : :
621 : 0 : return sk;
622 : : }
623 : :
624 : : /*
625 : : * This routine is called by the ICMP module when it gets some
626 : : * sort of error condition. If err < 0 then the socket should
627 : : * be closed and the error returned to the user. If err > 0
628 : : * it's just the icmp type << 8 | icmp code.
629 : : * Header points to the ip header of the error packet. We move
630 : : * on past this. Then (as it used to claim before adjustment)
631 : : * header points to the first 8 bytes of the udp header. We need
632 : : * to find the appropriate port.
633 : : */
634 : :
635 : 1 : int __udp4_lib_err(struct sk_buff *skb, u32 info, struct udp_table *udptable)
636 : : {
637 : : struct inet_sock *inet;
638 : 1 : const struct iphdr *iph = (const struct iphdr *)skb->data;
639 : 1 : struct udphdr *uh = (struct udphdr *)(skb->data+(iph->ihl<<2));
640 : 1 : const int type = icmp_hdr(skb)->type;
641 : 1 : const int code = icmp_hdr(skb)->code;
642 : : bool tunnel = false;
643 : : struct sock *sk;
644 : : int harderr;
645 : : int err;
646 : 1 : struct net *net = dev_net(skb->dev);
647 : :
648 : 1 : sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,
649 : : iph->saddr, uh->source, skb->dev->ifindex,
650 : : inet_sdif(skb), udptable, NULL);
651 : 1 : if (!sk) {
652 : : /* No socket for error: try tunnels before discarding */
653 : : sk = ERR_PTR(-ENOENT);
654 : 0 : if (static_branch_unlikely(&udp_encap_needed_key)) {
655 : 0 : sk = __udp4_lib_err_encap(net, iph, uh, udptable, skb,
656 : : info);
657 : 0 : if (!sk)
658 : : return 0;
659 : : }
660 : :
661 : 0 : if (IS_ERR(sk)) {
662 : 0 : __ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
663 : 0 : return PTR_ERR(sk);
664 : : }
665 : :
666 : : tunnel = true;
667 : : }
668 : :
669 : : err = 0;
670 : : harderr = 0;
671 : : inet = inet_sk(sk);
672 : :
673 : 1 : switch (type) {
674 : : default:
675 : : case ICMP_TIME_EXCEEDED:
676 : : err = EHOSTUNREACH;
677 : : break;
678 : : case ICMP_SOURCE_QUENCH:
679 : : goto out;
680 : : case ICMP_PARAMETERPROB:
681 : : err = EPROTO;
682 : : harderr = 1;
683 : 0 : break;
684 : : case ICMP_DEST_UNREACH:
685 : 1 : if (code == ICMP_FRAG_NEEDED) { /* Path MTU discovery */
686 : 0 : ipv4_sk_update_pmtu(skb, sk, info);
687 : 0 : if (inet->pmtudisc != IP_PMTUDISC_DONT) {
688 : : err = EMSGSIZE;
689 : : harderr = 1;
690 : : break;
691 : : }
692 : : goto out;
693 : : }
694 : : err = EHOSTUNREACH;
695 : 1 : if (code <= NR_ICMP_UNREACH) {
696 : 1 : harderr = icmp_err_convert[code].fatal;
697 : 1 : err = icmp_err_convert[code].errno;
698 : : }
699 : : break;
700 : : case ICMP_REDIRECT:
701 : 0 : ipv4_sk_redirect(skb, sk);
702 : 0 : goto out;
703 : : }
704 : :
705 : : /*
706 : : * RFC1122: OK. Passes ICMP errors back to application, as per
707 : : * 4.1.3.3.
708 : : */
709 : 1 : if (tunnel) {
710 : : /* ...not for tunnels though: we don't have a sending socket */
711 : : goto out;
712 : : }
713 : 1 : if (!inet->recverr) {
714 : 1 : if (!harderr || sk->sk_state != TCP_ESTABLISHED)
715 : : goto out;
716 : : } else
717 : 0 : ip_icmp_error(sk, skb, err, uh->dest, info, (u8 *)(uh+1));
718 : :
719 : 0 : sk->sk_err = err;
720 : 0 : sk->sk_error_report(sk);
721 : : out:
722 : : return 0;
723 : : }
724 : :
725 : 1 : int udp_err(struct sk_buff *skb, u32 info)
726 : : {
727 : 1 : return __udp4_lib_err(skb, info, &udp_table);
728 : : }
729 : :
730 : : /*
731 : : * Throw away all pending data and cancel the corking. Socket is locked.
732 : : */
733 : 0 : void udp_flush_pending_frames(struct sock *sk)
734 : : {
735 : : struct udp_sock *up = udp_sk(sk);
736 : :
737 : 3 : if (up->pending) {
738 : 0 : up->len = 0;
739 : 0 : up->pending = 0;
740 : 0 : ip_flush_pending_frames(sk);
741 : : }
742 : 0 : }
743 : : EXPORT_SYMBOL(udp_flush_pending_frames);
744 : :
745 : : /**
746 : : * udp4_hwcsum - handle outgoing HW checksumming
747 : : * @skb: sk_buff containing the filled-in UDP header
748 : : * (checksum field must be zeroed out)
749 : : * @src: source IP address
750 : : * @dst: destination IP address
751 : : */
752 : 2 : void udp4_hwcsum(struct sk_buff *skb, __be32 src, __be32 dst)
753 : : {
754 : : struct udphdr *uh = udp_hdr(skb);
755 : : int offset = skb_transport_offset(skb);
756 : 2 : int len = skb->len - offset;
757 : : int hlen = len;
758 : : __wsum csum = 0;
759 : :
760 : 2 : if (!skb_has_frag_list(skb)) {
761 : : /*
762 : : * Only one fragment on the socket.
763 : : */
764 : 2 : skb->csum_start = skb_transport_header(skb) - skb->head;
765 : 2 : skb->csum_offset = offsetof(struct udphdr, check);
766 : 2 : uh->check = ~csum_tcpudp_magic(src, dst, len,
767 : : IPPROTO_UDP, 0);
768 : : } else {
769 : : struct sk_buff *frags;
770 : :
771 : : /*
772 : : * HW-checksum won't work as there are two or more
773 : : * fragments on the socket so that all csums of sk_buffs
774 : : * should be together
775 : : */
776 : 0 : skb_walk_frags(skb, frags) {
777 : 0 : csum = csum_add(csum, frags->csum);
778 : 0 : hlen -= frags->len;
779 : : }
780 : :
781 : 0 : csum = skb_checksum(skb, offset, hlen, csum);
782 : 0 : skb->ip_summed = CHECKSUM_NONE;
783 : :
784 : 0 : uh->check = csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, csum);
785 : 0 : if (uh->check == 0)
786 : 0 : uh->check = CSUM_MANGLED_0;
787 : : }
788 : 2 : }
789 : : EXPORT_SYMBOL_GPL(udp4_hwcsum);
790 : :
791 : : /* Function to set UDP checksum for an IPv4 UDP packet. This is intended
792 : : * for the simple case like when setting the checksum for a UDP tunnel.
793 : : */
794 : 0 : void udp_set_csum(bool nocheck, struct sk_buff *skb,
795 : : __be32 saddr, __be32 daddr, int len)
796 : : {
797 : : struct udphdr *uh = udp_hdr(skb);
798 : :
799 : 0 : if (nocheck) {
800 : 0 : uh->check = 0;
801 : 0 : } else if (skb_is_gso(skb)) {
802 : 0 : uh->check = ~udp_v4_check(len, saddr, daddr, 0);
803 : 0 : } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
804 : 0 : uh->check = 0;
805 : 0 : uh->check = udp_v4_check(len, saddr, daddr, lco_csum(skb));
806 : 0 : if (uh->check == 0)
807 : 0 : uh->check = CSUM_MANGLED_0;
808 : : } else {
809 : 0 : skb->ip_summed = CHECKSUM_PARTIAL;
810 : 0 : skb->csum_start = skb_transport_header(skb) - skb->head;
811 : 0 : skb->csum_offset = offsetof(struct udphdr, check);
812 : 0 : uh->check = ~udp_v4_check(len, saddr, daddr, 0);
813 : : }
814 : 0 : }
815 : : EXPORT_SYMBOL(udp_set_csum);
816 : :
817 : 3 : static int udp_send_skb(struct sk_buff *skb, struct flowi4 *fl4,
818 : : struct inet_cork *cork)
819 : : {
820 : 3 : struct sock *sk = skb->sk;
821 : : struct inet_sock *inet = inet_sk(sk);
822 : : struct udphdr *uh;
823 : : int err = 0;
824 : 3 : int is_udplite = IS_UDPLITE(sk);
825 : : int offset = skb_transport_offset(skb);
826 : 3 : int len = skb->len - offset;
827 : 3 : int datalen = len - sizeof(*uh);
828 : : __wsum csum = 0;
829 : :
830 : : /*
831 : : * Create a UDP header
832 : : */
833 : : uh = udp_hdr(skb);
834 : 3 : uh->source = inet->inet_sport;
835 : 3 : uh->dest = fl4->fl4_dport;
836 : 3 : uh->len = htons(len);
837 : 3 : uh->check = 0;
838 : :
839 : 3 : if (cork->gso_size) {
840 : 0 : const int hlen = skb_network_header_len(skb) +
841 : : sizeof(struct udphdr);
842 : :
843 : 0 : if (hlen + cork->gso_size > cork->fragsize) {
844 : 0 : kfree_skb(skb);
845 : 0 : return -EINVAL;
846 : : }
847 : 0 : if (skb->len > cork->gso_size * UDP_MAX_SEGMENTS) {
848 : 0 : kfree_skb(skb);
849 : 0 : return -EINVAL;
850 : : }
851 : 0 : if (sk->sk_no_check_tx) {
852 : 0 : kfree_skb(skb);
853 : 0 : return -EINVAL;
854 : : }
855 : 0 : if (skb->ip_summed != CHECKSUM_PARTIAL || is_udplite ||
856 : : dst_xfrm(skb_dst(skb))) {
857 : 0 : kfree_skb(skb);
858 : 0 : return -EIO;
859 : : }
860 : :
861 : 0 : if (datalen > cork->gso_size) {
862 : 0 : skb_shinfo(skb)->gso_size = cork->gso_size;
863 : 0 : skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4;
864 : 0 : skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(datalen,
865 : : cork->gso_size);
866 : : }
867 : : goto csum_partial;
868 : : }
869 : :
870 : 3 : if (is_udplite) /* UDP-Lite */
871 : 0 : csum = udplite_csum(skb);
872 : :
873 : 3 : else if (sk->sk_no_check_tx) { /* UDP csum off */
874 : :
875 : 0 : skb->ip_summed = CHECKSUM_NONE;
876 : 0 : goto send;
877 : :
878 : 3 : } else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
879 : : csum_partial:
880 : :
881 : 2 : udp4_hwcsum(skb, fl4->saddr, fl4->daddr);
882 : 2 : goto send;
883 : :
884 : : } else
885 : 1 : csum = udp_csum(skb);
886 : :
887 : : /* add protocol-dependent pseudo-header */
888 : 1 : uh->check = csum_tcpudp_magic(fl4->saddr, fl4->daddr, len,
889 : : sk->sk_protocol, csum);
890 : 1 : if (uh->check == 0)
891 : 0 : uh->check = CSUM_MANGLED_0;
892 : :
893 : : send:
894 : 3 : err = ip_send_skb(sock_net(sk), skb);
895 : 3 : if (err) {
896 : 0 : if (err == -ENOBUFS && !inet->recverr) {
897 : 0 : UDP_INC_STATS(sock_net(sk),
898 : : UDP_MIB_SNDBUFERRORS, is_udplite);
899 : : err = 0;
900 : : }
901 : : } else
902 : 3 : UDP_INC_STATS(sock_net(sk),
903 : : UDP_MIB_OUTDATAGRAMS, is_udplite);
904 : 3 : return err;
905 : : }
906 : :
907 : : /*
908 : : * Push out all pending data as one UDP datagram. Socket is locked.
909 : : */
910 : 0 : int udp_push_pending_frames(struct sock *sk)
911 : : {
912 : : struct udp_sock *up = udp_sk(sk);
913 : : struct inet_sock *inet = inet_sk(sk);
914 : 0 : struct flowi4 *fl4 = &inet->cork.fl.u.ip4;
915 : : struct sk_buff *skb;
916 : : int err = 0;
917 : :
918 : : skb = ip_finish_skb(sk, fl4);
919 : 0 : if (!skb)
920 : : goto out;
921 : :
922 : 0 : err = udp_send_skb(skb, fl4, &inet->cork.base);
923 : :
924 : : out:
925 : 0 : up->len = 0;
926 : 0 : up->pending = 0;
927 : 0 : return err;
928 : : }
929 : : EXPORT_SYMBOL(udp_push_pending_frames);
930 : :
931 : : static int __udp_cmsg_send(struct cmsghdr *cmsg, u16 *gso_size)
932 : : {
933 : 0 : switch (cmsg->cmsg_type) {
934 : : case UDP_SEGMENT:
935 : 0 : if (cmsg->cmsg_len != CMSG_LEN(sizeof(__u16)))
936 : : return -EINVAL;
937 : 0 : *gso_size = *(__u16 *)CMSG_DATA(cmsg);
938 : : return 0;
939 : : default:
940 : : return -EINVAL;
941 : : }
942 : : }
943 : :
944 : 3 : int udp_cmsg_send(struct sock *sk, struct msghdr *msg, u16 *gso_size)
945 : : {
946 : : struct cmsghdr *cmsg;
947 : : bool need_ip = false;
948 : : int err;
949 : :
950 : 3 : for_each_cmsghdr(cmsg, msg) {
951 : 3 : if (!CMSG_OK(msg, cmsg))
952 : : return -EINVAL;
953 : :
954 : 3 : if (cmsg->cmsg_level != SOL_UDP) {
955 : : need_ip = true;
956 : 3 : continue;
957 : : }
958 : :
959 : : err = __udp_cmsg_send(cmsg, gso_size);
960 : 0 : if (err)
961 : 0 : return err;
962 : : }
963 : :
964 : 3 : return need_ip;
965 : : }
966 : : EXPORT_SYMBOL_GPL(udp_cmsg_send);
967 : :
968 : 3 : int udp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
969 : : {
970 : : struct inet_sock *inet = inet_sk(sk);
971 : : struct udp_sock *up = udp_sk(sk);
972 : 3 : DECLARE_SOCKADDR(struct sockaddr_in *, usin, msg->msg_name);
973 : : struct flowi4 fl4_stack;
974 : : struct flowi4 *fl4;
975 : 3 : int ulen = len;
976 : : struct ipcm_cookie ipc;
977 : 3 : struct rtable *rt = NULL;
978 : : int free = 0;
979 : : int connected = 0;
980 : : __be32 daddr, faddr, saddr;
981 : : __be16 dport;
982 : : u8 tos;
983 : 3 : int err, is_udplite = IS_UDPLITE(sk);
984 : 3 : int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
985 : : int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
986 : : struct sk_buff *skb;
987 : : struct ip_options_data opt_copy;
988 : :
989 : 3 : if (len > 0xFFFF)
990 : : return -EMSGSIZE;
991 : :
992 : : /*
993 : : * Check the flags.
994 : : */
995 : :
996 : 3 : if (msg->msg_flags & MSG_OOB) /* Mirror BSD error message compatibility */
997 : : return -EOPNOTSUPP;
998 : :
999 : 3 : getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag;
1000 : :
1001 : 3 : fl4 = &inet->cork.fl.u.ip4;
1002 : 3 : if (up->pending) {
1003 : : /*
1004 : : * There are pending frames.
1005 : : * The socket lock must be held while it's corked.
1006 : : */
1007 : : lock_sock(sk);
1008 : 0 : if (likely(up->pending)) {
1009 : 0 : if (unlikely(up->pending != AF_INET)) {
1010 : 0 : release_sock(sk);
1011 : 0 : return -EINVAL;
1012 : : }
1013 : : goto do_append_data;
1014 : : }
1015 : 0 : release_sock(sk);
1016 : : }
1017 : 3 : ulen += sizeof(struct udphdr);
1018 : :
1019 : : /*
1020 : : * Get and verify the address.
1021 : : */
1022 : 3 : if (usin) {
1023 : 3 : if (msg->msg_namelen < sizeof(*usin))
1024 : : return -EINVAL;
1025 : 3 : if (usin->sin_family != AF_INET) {
1026 : 0 : if (usin->sin_family != AF_UNSPEC)
1027 : : return -EAFNOSUPPORT;
1028 : : }
1029 : :
1030 : 3 : daddr = usin->sin_addr.s_addr;
1031 : 3 : dport = usin->sin_port;
1032 : 3 : if (dport == 0)
1033 : : return -EINVAL;
1034 : : } else {
1035 : 3 : if (sk->sk_state != TCP_ESTABLISHED)
1036 : : return -EDESTADDRREQ;
1037 : 3 : daddr = inet->inet_daddr;
1038 : 3 : dport = inet->inet_dport;
1039 : : /* Open fast path for connected socket.
1040 : : Route will not be used, if at least one option is set.
1041 : : */
1042 : : connected = 1;
1043 : : }
1044 : :
1045 : : ipcm_init_sk(&ipc, inet);
1046 : 3 : ipc.gso_size = up->gso_size;
1047 : :
1048 : 3 : if (msg->msg_controllen) {
1049 : 3 : err = udp_cmsg_send(sk, msg, &ipc.gso_size);
1050 : 3 : if (err > 0)
1051 : 3 : err = ip_cmsg_send(sk, msg, &ipc,
1052 : 3 : sk->sk_family == AF_INET6);
1053 : 3 : if (unlikely(err < 0)) {
1054 : 0 : kfree(ipc.opt);
1055 : 0 : return err;
1056 : : }
1057 : 3 : if (ipc.opt)
1058 : : free = 1;
1059 : : connected = 0;
1060 : : }
1061 : 3 : if (!ipc.opt) {
1062 : : struct ip_options_rcu *inet_opt;
1063 : :
1064 : : rcu_read_lock();
1065 : 3 : inet_opt = rcu_dereference(inet->inet_opt);
1066 : 3 : if (inet_opt) {
1067 : 0 : memcpy(&opt_copy, inet_opt,
1068 : 0 : sizeof(*inet_opt) + inet_opt->opt.optlen);
1069 : 0 : ipc.opt = &opt_copy.opt;
1070 : : }
1071 : : rcu_read_unlock();
1072 : : }
1073 : :
1074 : 3 : if (cgroup_bpf_enabled && !connected) {
1075 : 3 : err = BPF_CGROUP_RUN_PROG_UDP4_SENDMSG_LOCK(sk,
1076 : : (struct sockaddr *)usin, &ipc.addr);
1077 : 3 : if (err)
1078 : : goto out_free;
1079 : 3 : if (usin) {
1080 : 3 : if (usin->sin_port == 0) {
1081 : : /* BPF program set invalid port. Reject it. */
1082 : : err = -EINVAL;
1083 : : goto out_free;
1084 : : }
1085 : 3 : daddr = usin->sin_addr.s_addr;
1086 : : dport = usin->sin_port;
1087 : : }
1088 : : }
1089 : :
1090 : 3 : saddr = ipc.addr;
1091 : 3 : ipc.addr = faddr = daddr;
1092 : :
1093 : 3 : if (ipc.opt && ipc.opt->opt.srr) {
1094 : 0 : if (!daddr) {
1095 : : err = -EINVAL;
1096 : : goto out_free;
1097 : : }
1098 : 0 : faddr = ipc.opt->opt.faddr;
1099 : : connected = 0;
1100 : : }
1101 : : tos = get_rttos(&ipc, inet);
1102 : 3 : if (sock_flag(sk, SOCK_LOCALROUTE) ||
1103 : 3 : (msg->msg_flags & MSG_DONTROUTE) ||
1104 : 0 : (ipc.opt && ipc.opt->opt.is_strictroute)) {
1105 : 0 : tos |= RTO_ONLINK;
1106 : : connected = 0;
1107 : : }
1108 : :
1109 : 3 : if (ipv4_is_multicast(daddr)) {
1110 : 3 : if (!ipc.oif || netif_index_is_l3_master(sock_net(sk), ipc.oif))
1111 : 1 : ipc.oif = inet->mc_index;
1112 : 3 : if (!saddr)
1113 : 1 : saddr = inet->mc_addr;
1114 : : connected = 0;
1115 : 3 : } else if (!ipc.oif) {
1116 : 3 : ipc.oif = inet->uc_index;
1117 : 0 : } else if (ipv4_is_lbcast(daddr) && inet->uc_index) {
1118 : : /* oif is set, packet is to local broadcast and
1119 : : * and uc_index is set. oif is most likely set
1120 : : * by sk_bound_dev_if. If uc_index != oif check if the
1121 : : * oif is an L3 master and uc_index is an L3 slave.
1122 : : * If so, we want to allow the send using the uc_index.
1123 : : */
1124 : 0 : if (ipc.oif != inet->uc_index &&
1125 : 0 : ipc.oif == l3mdev_master_ifindex_by_index(sock_net(sk),
1126 : : inet->uc_index)) {
1127 : 0 : ipc.oif = inet->uc_index;
1128 : : }
1129 : : }
1130 : :
1131 : 3 : if (connected)
1132 : 3 : rt = (struct rtable *)sk_dst_check(sk, 0);
1133 : :
1134 : 3 : if (!rt) {
1135 : : struct net *net = sock_net(sk);
1136 : : __u8 flow_flags = inet_sk_flowi_flags(sk);
1137 : :
1138 : : fl4 = &fl4_stack;
1139 : :
1140 : 3 : flowi4_init_output(fl4, ipc.oif, ipc.sockc.mark, tos,
1141 : : RT_SCOPE_UNIVERSE, sk->sk_protocol,
1142 : : flow_flags,
1143 : : faddr, saddr, dport, inet->inet_sport,
1144 : : sk->sk_uid);
1145 : :
1146 : 3 : security_sk_classify_flow(sk, flowi4_to_flowi(fl4));
1147 : 3 : rt = ip_route_output_flow(net, fl4, sk);
1148 : 3 : if (IS_ERR(rt)) {
1149 : : err = PTR_ERR(rt);
1150 : 1 : rt = NULL;
1151 : 1 : if (err == -ENETUNREACH)
1152 : 1 : IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES);
1153 : : goto out;
1154 : : }
1155 : :
1156 : : err = -EACCES;
1157 : 3 : if ((rt->rt_flags & RTCF_BROADCAST) &&
1158 : : !sock_flag(sk, SOCK_BROADCAST))
1159 : : goto out;
1160 : 3 : if (connected)
1161 : 0 : sk_dst_set(sk, dst_clone(&rt->dst));
1162 : : }
1163 : :
1164 : 3 : if (msg->msg_flags&MSG_CONFIRM)
1165 : : goto do_confirm;
1166 : : back_from_confirm:
1167 : :
1168 : 3 : saddr = fl4->saddr;
1169 : 3 : if (!ipc.addr)
1170 : 0 : daddr = ipc.addr = fl4->daddr;
1171 : :
1172 : : /* Lockless fast path for the non-corking case. */
1173 : 3 : if (!corkreq) {
1174 : : struct inet_cork cork;
1175 : :
1176 : 3 : skb = ip_make_skb(sk, fl4, getfrag, msg, ulen,
1177 : : sizeof(struct udphdr), &ipc, &rt,
1178 : : &cork, msg->msg_flags);
1179 : : err = PTR_ERR(skb);
1180 : 3 : if (!IS_ERR_OR_NULL(skb))
1181 : 3 : err = udp_send_skb(skb, fl4, &cork);
1182 : : goto out;
1183 : : }
1184 : :
1185 : : lock_sock(sk);
1186 : 0 : if (unlikely(up->pending)) {
1187 : : /* The socket is already corked while preparing it. */
1188 : : /* ... which is an evident application bug. --ANK */
1189 : 0 : release_sock(sk);
1190 : :
1191 : : net_dbg_ratelimited("socket already corked\n");
1192 : : err = -EINVAL;
1193 : 0 : goto out;
1194 : : }
1195 : : /*
1196 : : * Now cork the socket to pend data.
1197 : : */
1198 : : fl4 = &inet->cork.fl.u.ip4;
1199 : 0 : fl4->daddr = daddr;
1200 : 0 : fl4->saddr = saddr;
1201 : 0 : fl4->fl4_dport = dport;
1202 : 0 : fl4->fl4_sport = inet->inet_sport;
1203 : 0 : up->pending = AF_INET;
1204 : :
1205 : : do_append_data:
1206 : 0 : up->len += ulen;
1207 : 0 : err = ip_append_data(sk, fl4, getfrag, msg, ulen,
1208 : : sizeof(struct udphdr), &ipc, &rt,
1209 : 0 : corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
1210 : 0 : if (err)
1211 : : udp_flush_pending_frames(sk);
1212 : 0 : else if (!corkreq)
1213 : 0 : err = udp_push_pending_frames(sk);
1214 : 0 : else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
1215 : 0 : up->pending = 0;
1216 : 0 : release_sock(sk);
1217 : :
1218 : : out:
1219 : 3 : ip_rt_put(rt);
1220 : : out_free:
1221 : 3 : if (free)
1222 : 0 : kfree(ipc.opt);
1223 : 3 : if (!err)
1224 : : return len;
1225 : : /*
1226 : : * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space. Reporting
1227 : : * ENOBUFS might not be good (it's not tunable per se), but otherwise
1228 : : * we don't have a good statistic (IpOutDiscards but it can be too many
1229 : : * things). We could add another new stat but at least for now that
1230 : : * seems like overkill.
1231 : : */
1232 : 1 : if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
1233 : 0 : UDP_INC_STATS(sock_net(sk),
1234 : : UDP_MIB_SNDBUFERRORS, is_udplite);
1235 : : }
1236 : 1 : return err;
1237 : :
1238 : : do_confirm:
1239 : 0 : if (msg->msg_flags & MSG_PROBE)
1240 : 0 : dst_confirm_neigh(&rt->dst, &fl4->daddr);
1241 : 0 : if (!(msg->msg_flags&MSG_PROBE) || len)
1242 : : goto back_from_confirm;
1243 : : err = 0;
1244 : : goto out;
1245 : : }
1246 : : EXPORT_SYMBOL(udp_sendmsg);
1247 : :
1248 : 0 : int udp_sendpage(struct sock *sk, struct page *page, int offset,
1249 : : size_t size, int flags)
1250 : : {
1251 : : struct inet_sock *inet = inet_sk(sk);
1252 : : struct udp_sock *up = udp_sk(sk);
1253 : : int ret;
1254 : :
1255 : 0 : if (flags & MSG_SENDPAGE_NOTLAST)
1256 : 0 : flags |= MSG_MORE;
1257 : :
1258 : 0 : if (!up->pending) {
1259 : 0 : struct msghdr msg = { .msg_flags = flags|MSG_MORE };
1260 : :
1261 : : /* Call udp_sendmsg to specify destination address which
1262 : : * sendpage interface can't pass.
1263 : : * This will succeed only when the socket is connected.
1264 : : */
1265 : 0 : ret = udp_sendmsg(sk, &msg, 0);
1266 : 0 : if (ret < 0)
1267 : 0 : return ret;
1268 : : }
1269 : :
1270 : : lock_sock(sk);
1271 : :
1272 : 0 : if (unlikely(!up->pending)) {
1273 : 0 : release_sock(sk);
1274 : :
1275 : : net_dbg_ratelimited("cork failed\n");
1276 : 0 : return -EINVAL;
1277 : : }
1278 : :
1279 : 0 : ret = ip_append_page(sk, &inet->cork.fl.u.ip4,
1280 : : page, offset, size, flags);
1281 : 0 : if (ret == -EOPNOTSUPP) {
1282 : 0 : release_sock(sk);
1283 : 0 : return sock_no_sendpage(sk->sk_socket, page, offset,
1284 : : size, flags);
1285 : : }
1286 : 0 : if (ret < 0) {
1287 : : udp_flush_pending_frames(sk);
1288 : : goto out;
1289 : : }
1290 : :
1291 : 0 : up->len += size;
1292 : 0 : if (!(up->corkflag || (flags&MSG_MORE)))
1293 : 0 : ret = udp_push_pending_frames(sk);
1294 : 0 : if (!ret)
1295 : 0 : ret = size;
1296 : : out:
1297 : 0 : release_sock(sk);
1298 : 0 : return ret;
1299 : : }
1300 : :
1301 : : #define UDP_SKB_IS_STATELESS 0x80000000
1302 : :
1303 : : /* all head states (dst, sk, nf conntrack) except skb extensions are
1304 : : * cleared by udp_rcv().
1305 : : *
1306 : : * We need to preserve secpath, if present, to eventually process
1307 : : * IP_CMSG_PASSSEC at recvmsg() time.
1308 : : *
1309 : : * Other extensions can be cleared.
1310 : : */
1311 : 3 : static bool udp_try_make_stateless(struct sk_buff *skb)
1312 : : {
1313 : 3 : if (!skb_has_extensions(skb))
1314 : : return true;
1315 : :
1316 : 0 : if (!secpath_exists(skb)) {
1317 : : skb_ext_reset(skb);
1318 : : return true;
1319 : : }
1320 : :
1321 : : return false;
1322 : : }
1323 : :
1324 : 3 : static void udp_set_dev_scratch(struct sk_buff *skb)
1325 : : {
1326 : : struct udp_dev_scratch *scratch = udp_skb_scratch(skb);
1327 : :
1328 : : BUILD_BUG_ON(sizeof(struct udp_dev_scratch) > sizeof(long));
1329 : 3 : scratch->_tsize_state = skb->truesize;
1330 : : #if BITS_PER_LONG == 64
1331 : : scratch->len = skb->len;
1332 : : scratch->csum_unnecessary = !!skb_csum_unnecessary(skb);
1333 : : scratch->is_linear = !skb_is_nonlinear(skb);
1334 : : #endif
1335 : 3 : if (udp_try_make_stateless(skb))
1336 : 3 : scratch->_tsize_state |= UDP_SKB_IS_STATELESS;
1337 : 3 : }
1338 : :
1339 : : static void udp_skb_csum_unnecessary_set(struct sk_buff *skb)
1340 : : {
1341 : : /* We come here after udp_lib_checksum_complete() returned 0.
1342 : : * This means that __skb_checksum_complete() might have
1343 : : * set skb->csum_valid to 1.
1344 : : * On 64bit platforms, we can set csum_unnecessary
1345 : : * to true, but only if the skb is not shared.
1346 : : */
1347 : : #if BITS_PER_LONG == 64
1348 : : if (!skb_shared(skb))
1349 : : udp_skb_scratch(skb)->csum_unnecessary = true;
1350 : : #endif
1351 : : }
1352 : :
1353 : : static int udp_skb_truesize(struct sk_buff *skb)
1354 : : {
1355 : 3 : return udp_skb_scratch(skb)->_tsize_state & ~UDP_SKB_IS_STATELESS;
1356 : : }
1357 : :
1358 : : static bool udp_skb_has_head_state(struct sk_buff *skb)
1359 : : {
1360 : 3 : return !(udp_skb_scratch(skb)->_tsize_state & UDP_SKB_IS_STATELESS);
1361 : : }
1362 : :
1363 : : /* fully reclaim rmem/fwd memory allocated for skb */
1364 : 3 : static void udp_rmem_release(struct sock *sk, int size, int partial,
1365 : : bool rx_queue_lock_held)
1366 : : {
1367 : : struct udp_sock *up = udp_sk(sk);
1368 : : struct sk_buff_head *sk_queue;
1369 : : int amt;
1370 : :
1371 : 3 : if (likely(partial)) {
1372 : 3 : up->forward_deficit += size;
1373 : : size = up->forward_deficit;
1374 : 3 : if (size < (sk->sk_rcvbuf >> 2) &&
1375 : 3 : !skb_queue_empty(&up->reader_queue))
1376 : 3 : return;
1377 : : } else {
1378 : 3 : size += up->forward_deficit;
1379 : : }
1380 : 3 : up->forward_deficit = 0;
1381 : :
1382 : : /* acquire the sk_receive_queue for fwd allocated memory scheduling,
1383 : : * if the called don't held it already
1384 : : */
1385 : 3 : sk_queue = &sk->sk_receive_queue;
1386 : 3 : if (!rx_queue_lock_held)
1387 : : spin_lock(&sk_queue->lock);
1388 : :
1389 : :
1390 : 3 : sk->sk_forward_alloc += size;
1391 : 3 : amt = (sk->sk_forward_alloc - partial) & ~(SK_MEM_QUANTUM - 1);
1392 : 3 : sk->sk_forward_alloc -= amt;
1393 : :
1394 : 3 : if (amt)
1395 : 3 : __sk_mem_reduce_allocated(sk, amt >> SK_MEM_QUANTUM_SHIFT);
1396 : :
1397 : 3 : atomic_sub(size, &sk->sk_rmem_alloc);
1398 : :
1399 : : /* this can save us from acquiring the rx queue lock on next receive */
1400 : 3 : skb_queue_splice_tail_init(sk_queue, &up->reader_queue);
1401 : :
1402 : 3 : if (!rx_queue_lock_held)
1403 : : spin_unlock(&sk_queue->lock);
1404 : : }
1405 : :
1406 : : /* Note: called with reader_queue.lock held.
1407 : : * Instead of using skb->truesize here, find a copy of it in skb->dev_scratch
1408 : : * This avoids a cache line miss while receive_queue lock is held.
1409 : : * Look at __udp_enqueue_schedule_skb() to find where this copy is done.
1410 : : */
1411 : 3 : void udp_skb_destructor(struct sock *sk, struct sk_buff *skb)
1412 : : {
1413 : 3 : prefetch(&skb->data);
1414 : 3 : udp_rmem_release(sk, udp_skb_truesize(skb), 1, false);
1415 : 3 : }
1416 : : EXPORT_SYMBOL(udp_skb_destructor);
1417 : :
1418 : : /* as above, but the caller held the rx queue lock, too */
1419 : 1 : static void udp_skb_dtor_locked(struct sock *sk, struct sk_buff *skb)
1420 : : {
1421 : 1 : prefetch(&skb->data);
1422 : 1 : udp_rmem_release(sk, udp_skb_truesize(skb), 1, true);
1423 : 1 : }
1424 : :
1425 : : /* Idea of busylocks is to let producers grab an extra spinlock
1426 : : * to relieve pressure on the receive_queue spinlock shared by consumer.
1427 : : * Under flood, this means that only one producer can be in line
1428 : : * trying to acquire the receive_queue spinlock.
1429 : : * These busylock can be allocated on a per cpu manner, instead of a
1430 : : * per socket one (that would consume a cache line per socket)
1431 : : */
1432 : : static int udp_busylocks_log __read_mostly;
1433 : : static spinlock_t *udp_busylocks __read_mostly;
1434 : :
1435 : 0 : static spinlock_t *busylock_acquire(void *ptr)
1436 : : {
1437 : : spinlock_t *busy;
1438 : :
1439 : 0 : busy = udp_busylocks + hash_ptr(ptr, udp_busylocks_log);
1440 : : spin_lock(busy);
1441 : 0 : return busy;
1442 : : }
1443 : :
1444 : : static void busylock_release(spinlock_t *busy)
1445 : : {
1446 : 3 : if (busy)
1447 : : spin_unlock(busy);
1448 : : }
1449 : :
1450 : 3 : int __udp_enqueue_schedule_skb(struct sock *sk, struct sk_buff *skb)
1451 : : {
1452 : 3 : struct sk_buff_head *list = &sk->sk_receive_queue;
1453 : : int rmem, delta, amt, err = -ENOMEM;
1454 : : spinlock_t *busy = NULL;
1455 : : int size;
1456 : :
1457 : : /* try to avoid the costly atomic add/sub pair when the receive
1458 : : * queue is full; always allow at least a packet
1459 : : */
1460 : 3 : rmem = atomic_read(&sk->sk_rmem_alloc);
1461 : 3 : if (rmem > sk->sk_rcvbuf)
1462 : : goto drop;
1463 : :
1464 : : /* Under mem pressure, it might be helpful to help udp_recvmsg()
1465 : : * having linear skbs :
1466 : : * - Reduce memory overhead and thus increase receive queue capacity
1467 : : * - Less cache line misses at copyout() time
1468 : : * - Less work at consume_skb() (less alien page frag freeing)
1469 : : */
1470 : 3 : if (rmem > (sk->sk_rcvbuf >> 1)) {
1471 : 0 : skb_condense(skb);
1472 : :
1473 : 0 : busy = busylock_acquire(sk);
1474 : : }
1475 : 3 : size = skb->truesize;
1476 : 3 : udp_set_dev_scratch(skb);
1477 : :
1478 : : /* we drop only if the receive buf is full and the receive
1479 : : * queue contains some other skb
1480 : : */
1481 : 3 : rmem = atomic_add_return(size, &sk->sk_rmem_alloc);
1482 : 3 : if (rmem > (size + (unsigned int)sk->sk_rcvbuf))
1483 : : goto uncharge_drop;
1484 : :
1485 : : spin_lock(&list->lock);
1486 : 3 : if (size >= sk->sk_forward_alloc) {
1487 : : amt = sk_mem_pages(size);
1488 : 3 : delta = amt << SK_MEM_QUANTUM_SHIFT;
1489 : 3 : if (!__sk_mem_raise_allocated(sk, delta, amt, SK_MEM_RECV)) {
1490 : : err = -ENOBUFS;
1491 : : spin_unlock(&list->lock);
1492 : : goto uncharge_drop;
1493 : : }
1494 : :
1495 : 3 : sk->sk_forward_alloc += delta;
1496 : : }
1497 : :
1498 : 3 : sk->sk_forward_alloc -= size;
1499 : :
1500 : : /* no need to setup a destructor, we will explicitly release the
1501 : : * forward allocated memory on dequeue
1502 : : */
1503 : : sock_skb_set_dropcount(sk, skb);
1504 : :
1505 : : __skb_queue_tail(list, skb);
1506 : : spin_unlock(&list->lock);
1507 : :
1508 : 3 : if (!sock_flag(sk, SOCK_DEAD))
1509 : 3 : sk->sk_data_ready(sk);
1510 : :
1511 : : busylock_release(busy);
1512 : : return 0;
1513 : :
1514 : : uncharge_drop:
1515 : 0 : atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
1516 : :
1517 : : drop:
1518 : 0 : atomic_inc(&sk->sk_drops);
1519 : : busylock_release(busy);
1520 : 0 : return err;
1521 : : }
1522 : : EXPORT_SYMBOL_GPL(__udp_enqueue_schedule_skb);
1523 : :
1524 : 3 : void udp_destruct_sock(struct sock *sk)
1525 : : {
1526 : : /* reclaim completely the forward allocated memory */
1527 : : struct udp_sock *up = udp_sk(sk);
1528 : : unsigned int total = 0;
1529 : : struct sk_buff *skb;
1530 : :
1531 : 3 : skb_queue_splice_tail_init(&sk->sk_receive_queue, &up->reader_queue);
1532 : 3 : while ((skb = __skb_dequeue(&up->reader_queue)) != NULL) {
1533 : 0 : total += skb->truesize;
1534 : 0 : kfree_skb(skb);
1535 : : }
1536 : 3 : udp_rmem_release(sk, total, 0, true);
1537 : :
1538 : 3 : inet_sock_destruct(sk);
1539 : 3 : }
1540 : : EXPORT_SYMBOL_GPL(udp_destruct_sock);
1541 : :
1542 : 3 : int udp_init_sock(struct sock *sk)
1543 : : {
1544 : 3 : skb_queue_head_init(&udp_sk(sk)->reader_queue);
1545 : 3 : sk->sk_destruct = udp_destruct_sock;
1546 : 3 : return 0;
1547 : : }
1548 : : EXPORT_SYMBOL_GPL(udp_init_sock);
1549 : :
1550 : 3 : void skb_consume_udp(struct sock *sk, struct sk_buff *skb, int len)
1551 : : {
1552 : 3 : if (unlikely(READ_ONCE(sk->sk_peek_off) >= 0)) {
1553 : 0 : bool slow = lock_sock_fast(sk);
1554 : :
1555 : : sk_peek_offset_bwd(sk, len);
1556 : : unlock_sock_fast(sk, slow);
1557 : : }
1558 : :
1559 : 3 : if (!skb_unref(skb))
1560 : 3 : return;
1561 : :
1562 : : /* In the more common cases we cleared the head states previously,
1563 : : * see __udp_queue_rcv_skb().
1564 : : */
1565 : 3 : if (unlikely(udp_skb_has_head_state(skb)))
1566 : 0 : skb_release_head_state(skb);
1567 : 3 : __consume_stateless_skb(skb);
1568 : : }
1569 : : EXPORT_SYMBOL_GPL(skb_consume_udp);
1570 : :
1571 : 3 : static struct sk_buff *__first_packet_length(struct sock *sk,
1572 : : struct sk_buff_head *rcvq,
1573 : : int *total)
1574 : : {
1575 : : struct sk_buff *skb;
1576 : :
1577 : 3 : while ((skb = skb_peek(rcvq)) != NULL) {
1578 : 3 : if (udp_lib_checksum_complete(skb)) {
1579 : 0 : __UDP_INC_STATS(sock_net(sk), UDP_MIB_CSUMERRORS,
1580 : : IS_UDPLITE(sk));
1581 : 0 : __UDP_INC_STATS(sock_net(sk), UDP_MIB_INERRORS,
1582 : : IS_UDPLITE(sk));
1583 : 0 : atomic_inc(&sk->sk_drops);
1584 : : __skb_unlink(skb, rcvq);
1585 : 0 : *total += skb->truesize;
1586 : 0 : kfree_skb(skb);
1587 : : } else {
1588 : : udp_skb_csum_unnecessary_set(skb);
1589 : : break;
1590 : : }
1591 : : }
1592 : 3 : return skb;
1593 : : }
1594 : :
1595 : : /**
1596 : : * first_packet_length - return length of first packet in receive queue
1597 : : * @sk: socket
1598 : : *
1599 : : * Drops all bad checksum frames, until a valid one is found.
1600 : : * Returns the length of found skb, or -1 if none is found.
1601 : : */
1602 : 3 : static int first_packet_length(struct sock *sk)
1603 : : {
1604 : 3 : struct sk_buff_head *rcvq = &udp_sk(sk)->reader_queue;
1605 : 3 : struct sk_buff_head *sk_queue = &sk->sk_receive_queue;
1606 : : struct sk_buff *skb;
1607 : 3 : int total = 0;
1608 : : int res;
1609 : :
1610 : : spin_lock_bh(&rcvq->lock);
1611 : 3 : skb = __first_packet_length(sk, rcvq, &total);
1612 : 3 : if (!skb && !skb_queue_empty_lockless(sk_queue)) {
1613 : : spin_lock(&sk_queue->lock);
1614 : : skb_queue_splice_tail_init(sk_queue, rcvq);
1615 : : spin_unlock(&sk_queue->lock);
1616 : :
1617 : 3 : skb = __first_packet_length(sk, rcvq, &total);
1618 : : }
1619 : 3 : res = skb ? skb->len : -1;
1620 : 3 : if (total)
1621 : 0 : udp_rmem_release(sk, total, 1, false);
1622 : : spin_unlock_bh(&rcvq->lock);
1623 : 3 : return res;
1624 : : }
1625 : :
1626 : : /*
1627 : : * IOCTL requests applicable to the UDP protocol
1628 : : */
1629 : :
1630 : 3 : int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
1631 : : {
1632 : 3 : switch (cmd) {
1633 : : case SIOCOUTQ:
1634 : : {
1635 : : int amount = sk_wmem_alloc_get(sk);
1636 : :
1637 : 0 : return put_user(amount, (int __user *)arg);
1638 : : }
1639 : :
1640 : : case SIOCINQ:
1641 : : {
1642 : 3 : int amount = max_t(int, 0, first_packet_length(sk));
1643 : :
1644 : 3 : return put_user(amount, (int __user *)arg);
1645 : : }
1646 : :
1647 : : default:
1648 : : return -ENOIOCTLCMD;
1649 : : }
1650 : :
1651 : : return 0;
1652 : : }
1653 : : EXPORT_SYMBOL(udp_ioctl);
1654 : :
1655 : 3 : struct sk_buff *__skb_recv_udp(struct sock *sk, unsigned int flags,
1656 : : int noblock, int *off, int *err)
1657 : : {
1658 : 3 : struct sk_buff_head *sk_queue = &sk->sk_receive_queue;
1659 : : struct sk_buff_head *queue;
1660 : : struct sk_buff *last;
1661 : : long timeo;
1662 : : int error;
1663 : :
1664 : 3 : queue = &udp_sk(sk)->reader_queue;
1665 : 3 : flags |= noblock ? MSG_DONTWAIT : 0;
1666 : 3 : timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
1667 : : do {
1668 : : struct sk_buff *skb;
1669 : :
1670 : 3 : error = sock_error(sk);
1671 : 3 : if (error)
1672 : : break;
1673 : :
1674 : 3 : error = -EAGAIN;
1675 : : do {
1676 : : spin_lock_bh(&queue->lock);
1677 : 3 : skb = __skb_try_recv_from_queue(sk, queue, flags,
1678 : : udp_skb_destructor,
1679 : : off, err, &last);
1680 : 3 : if (skb) {
1681 : : spin_unlock_bh(&queue->lock);
1682 : 3 : return skb;
1683 : : }
1684 : :
1685 : 1 : if (skb_queue_empty_lockless(sk_queue)) {
1686 : : spin_unlock_bh(&queue->lock);
1687 : : goto busy_check;
1688 : : }
1689 : :
1690 : : /* refill the reader queue and walk it again
1691 : : * keep both queues locked to avoid re-acquiring
1692 : : * the sk_receive_queue lock if fwd memory scheduling
1693 : : * is needed.
1694 : : */
1695 : : spin_lock(&sk_queue->lock);
1696 : : skb_queue_splice_tail_init(sk_queue, queue);
1697 : :
1698 : 1 : skb = __skb_try_recv_from_queue(sk, queue, flags,
1699 : : udp_skb_dtor_locked,
1700 : : off, err, &last);
1701 : : spin_unlock(&sk_queue->lock);
1702 : : spin_unlock_bh(&queue->lock);
1703 : 1 : if (skb)
1704 : 1 : return skb;
1705 : :
1706 : : busy_check:
1707 : 1 : if (!sk_can_busy_loop(sk))
1708 : : break;
1709 : :
1710 : 0 : sk_busy_loop(sk, flags & MSG_DONTWAIT);
1711 : 0 : } while (!skb_queue_empty_lockless(sk_queue));
1712 : :
1713 : : /* sk_queue is empty, reader_queue may contain peeked packets */
1714 : 1 : } while (timeo &&
1715 : 0 : !__skb_wait_for_more_packets(sk, &error, &timeo,
1716 : 1 : (struct sk_buff *)sk_queue));
1717 : :
1718 : 1 : *err = error;
1719 : 1 : return NULL;
1720 : : }
1721 : : EXPORT_SYMBOL(__skb_recv_udp);
1722 : :
1723 : : /*
1724 : : * This should be easy, if there is something there we
1725 : : * return it, otherwise we block.
1726 : : */
1727 : :
1728 : 3 : int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int noblock,
1729 : : int flags, int *addr_len)
1730 : : {
1731 : : struct inet_sock *inet = inet_sk(sk);
1732 : 3 : DECLARE_SOCKADDR(struct sockaddr_in *, sin, msg->msg_name);
1733 : : struct sk_buff *skb;
1734 : : unsigned int ulen, copied;
1735 : 3 : int off, err, peeking = flags & MSG_PEEK;
1736 : 3 : int is_udplite = IS_UDPLITE(sk);
1737 : : bool checksum_valid = false;
1738 : :
1739 : 3 : if (flags & MSG_ERRQUEUE)
1740 : 0 : return ip_recv_error(sk, msg, len, addr_len);
1741 : :
1742 : : try_again:
1743 : 3 : off = sk_peek_offset(sk, flags);
1744 : 3 : skb = __skb_recv_udp(sk, flags, noblock, &off, &err);
1745 : 3 : if (!skb)
1746 : 1 : return err;
1747 : :
1748 : : ulen = udp_skb_len(skb);
1749 : : copied = len;
1750 : 3 : if (copied > ulen - off)
1751 : : copied = ulen - off;
1752 : 3 : else if (copied < ulen)
1753 : 0 : msg->msg_flags |= MSG_TRUNC;
1754 : :
1755 : : /*
1756 : : * If checksum is needed at all, try to do it while copying the
1757 : : * data. If the data is truncated, or if we only want a partial
1758 : : * coverage checksum (UDP-Lite), do it before the copy.
1759 : : */
1760 : :
1761 : 3 : if (copied < ulen || peeking ||
1762 : 0 : (is_udplite && UDP_SKB_CB(skb)->partial_cov)) {
1763 : 0 : checksum_valid = udp_skb_csum_unnecessary(skb) ||
1764 : 0 : !__udp_lib_checksum_complete(skb);
1765 : 0 : if (!checksum_valid)
1766 : : goto csum_copy_err;
1767 : : }
1768 : :
1769 : 3 : if (checksum_valid || udp_skb_csum_unnecessary(skb)) {
1770 : 3 : if (udp_skb_is_linear(skb))
1771 : 3 : err = copy_linear_skb(skb, copied, off, &msg->msg_iter);
1772 : : else
1773 : 0 : err = skb_copy_datagram_msg(skb, off, msg, copied);
1774 : : } else {
1775 : 0 : err = skb_copy_and_csum_datagram_msg(skb, off, msg);
1776 : :
1777 : 0 : if (err == -EINVAL)
1778 : : goto csum_copy_err;
1779 : : }
1780 : :
1781 : 3 : if (unlikely(err)) {
1782 : 0 : if (!peeking) {
1783 : 0 : atomic_inc(&sk->sk_drops);
1784 : 0 : UDP_INC_STATS(sock_net(sk),
1785 : : UDP_MIB_INERRORS, is_udplite);
1786 : : }
1787 : 0 : kfree_skb(skb);
1788 : 0 : return err;
1789 : : }
1790 : :
1791 : 3 : if (!peeking)
1792 : 3 : UDP_INC_STATS(sock_net(sk),
1793 : : UDP_MIB_INDATAGRAMS, is_udplite);
1794 : :
1795 : 3 : sock_recv_ts_and_drops(msg, sk, skb);
1796 : :
1797 : : /* Copy the address. */
1798 : 3 : if (sin) {
1799 : 3 : sin->sin_family = AF_INET;
1800 : 3 : sin->sin_port = udp_hdr(skb)->source;
1801 : 3 : sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
1802 : 3 : memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
1803 : 3 : *addr_len = sizeof(*sin);
1804 : :
1805 : 3 : if (cgroup_bpf_enabled)
1806 : 3 : BPF_CGROUP_RUN_PROG_UDP4_RECVMSG_LOCK(sk,
1807 : : (struct sockaddr *)sin);
1808 : : }
1809 : :
1810 : 3 : if (udp_sk(sk)->gro_enabled)
1811 : 0 : udp_cmsg_recv(msg, sk, skb);
1812 : :
1813 : 3 : if (inet->cmsg_flags)
1814 : 3 : ip_cmsg_recv_offset(msg, sk, skb, sizeof(struct udphdr), off);
1815 : :
1816 : 3 : err = copied;
1817 : 3 : if (flags & MSG_TRUNC)
1818 : 0 : err = ulen;
1819 : :
1820 : 3 : skb_consume_udp(sk, skb, peeking ? -err : err);
1821 : 3 : return err;
1822 : :
1823 : : csum_copy_err:
1824 : 0 : if (!__sk_queue_drop_skb(sk, &udp_sk(sk)->reader_queue, skb, flags,
1825 : : udp_skb_destructor)) {
1826 : 0 : UDP_INC_STATS(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
1827 : 0 : UDP_INC_STATS(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
1828 : : }
1829 : 0 : kfree_skb(skb);
1830 : :
1831 : : /* starting over for a new packet, but check if we need to yield */
1832 : 0 : cond_resched();
1833 : 0 : msg->msg_flags &= ~MSG_TRUNC;
1834 : 0 : goto try_again;
1835 : : }
1836 : :
1837 : 3 : int udp_pre_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
1838 : : {
1839 : : /* This check is replicated from __ip4_datagram_connect() and
1840 : : * intended to prevent BPF program called below from accessing bytes
1841 : : * that are out of the bound specified by user in addr_len.
1842 : : */
1843 : 3 : if (addr_len < sizeof(struct sockaddr_in))
1844 : : return -EINVAL;
1845 : :
1846 : 3 : return BPF_CGROUP_RUN_PROG_INET4_CONNECT_LOCK(sk, uaddr);
1847 : : }
1848 : : EXPORT_SYMBOL(udp_pre_connect);
1849 : :
1850 : 3 : int __udp_disconnect(struct sock *sk, int flags)
1851 : : {
1852 : : struct inet_sock *inet = inet_sk(sk);
1853 : : /*
1854 : : * 1003.1g - break association.
1855 : : */
1856 : :
1857 : 3 : sk->sk_state = TCP_CLOSE;
1858 : 3 : inet->inet_daddr = 0;
1859 : 3 : inet->inet_dport = 0;
1860 : : sock_rps_reset_rxhash(sk);
1861 : 3 : sk->sk_bound_dev_if = 0;
1862 : 3 : if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK)) {
1863 : 3 : inet_reset_saddr(sk);
1864 : 3 : if (sk->sk_prot->rehash &&
1865 : 3 : (sk->sk_userlocks & SOCK_BINDPORT_LOCK))
1866 : 0 : sk->sk_prot->rehash(sk);
1867 : : }
1868 : :
1869 : 3 : if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
1870 : 3 : sk->sk_prot->unhash(sk);
1871 : 3 : inet->inet_sport = 0;
1872 : : }
1873 : : sk_dst_reset(sk);
1874 : 3 : return 0;
1875 : : }
1876 : : EXPORT_SYMBOL(__udp_disconnect);
1877 : :
1878 : 3 : int udp_disconnect(struct sock *sk, int flags)
1879 : : {
1880 : : lock_sock(sk);
1881 : 3 : __udp_disconnect(sk, flags);
1882 : 3 : release_sock(sk);
1883 : 3 : return 0;
1884 : : }
1885 : : EXPORT_SYMBOL(udp_disconnect);
1886 : :
1887 : 3 : void udp_lib_unhash(struct sock *sk)
1888 : : {
1889 : 3 : if (sk_hashed(sk)) {
1890 : 3 : struct udp_table *udptable = sk->sk_prot->h.udp_table;
1891 : : struct udp_hslot *hslot, *hslot2;
1892 : :
1893 : 3 : hslot = udp_hashslot(udptable, sock_net(sk),
1894 : 3 : udp_sk(sk)->udp_port_hash);
1895 : 3 : hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
1896 : :
1897 : : spin_lock_bh(&hslot->lock);
1898 : 3 : if (rcu_access_pointer(sk->sk_reuseport_cb))
1899 : 1 : reuseport_detach_sock(sk);
1900 : 3 : if (sk_del_node_init_rcu(sk)) {
1901 : 3 : hslot->count--;
1902 : 3 : inet_sk(sk)->inet_num = 0;
1903 : 3 : sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
1904 : :
1905 : : spin_lock(&hslot2->lock);
1906 : : hlist_del_init_rcu(&udp_sk(sk)->udp_portaddr_node);
1907 : 3 : hslot2->count--;
1908 : : spin_unlock(&hslot2->lock);
1909 : : }
1910 : : spin_unlock_bh(&hslot->lock);
1911 : : }
1912 : 3 : }
1913 : : EXPORT_SYMBOL(udp_lib_unhash);
1914 : :
1915 : : /*
1916 : : * inet_rcv_saddr was changed, we must rehash secondary hash
1917 : : */
1918 : 3 : void udp_lib_rehash(struct sock *sk, u16 newhash)
1919 : : {
1920 : 3 : if (sk_hashed(sk)) {
1921 : 3 : struct udp_table *udptable = sk->sk_prot->h.udp_table;
1922 : : struct udp_hslot *hslot, *hslot2, *nhslot2;
1923 : :
1924 : 3 : hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
1925 : 3 : nhslot2 = udp_hashslot2(udptable, newhash);
1926 : 3 : udp_sk(sk)->udp_portaddr_hash = newhash;
1927 : :
1928 : 3 : if (hslot2 != nhslot2 ||
1929 : 3 : rcu_access_pointer(sk->sk_reuseport_cb)) {
1930 : 3 : hslot = udp_hashslot(udptable, sock_net(sk),
1931 : 3 : udp_sk(sk)->udp_port_hash);
1932 : : /* we must lock primary chain too */
1933 : : spin_lock_bh(&hslot->lock);
1934 : 3 : if (rcu_access_pointer(sk->sk_reuseport_cb))
1935 : 0 : reuseport_detach_sock(sk);
1936 : :
1937 : 3 : if (hslot2 != nhslot2) {
1938 : : spin_lock(&hslot2->lock);
1939 : : hlist_del_init_rcu(&udp_sk(sk)->udp_portaddr_node);
1940 : 3 : hslot2->count--;
1941 : : spin_unlock(&hslot2->lock);
1942 : :
1943 : : spin_lock(&nhslot2->lock);
1944 : 3 : hlist_add_head_rcu(&udp_sk(sk)->udp_portaddr_node,
1945 : : &nhslot2->head);
1946 : 3 : nhslot2->count++;
1947 : : spin_unlock(&nhslot2->lock);
1948 : : }
1949 : :
1950 : : spin_unlock_bh(&hslot->lock);
1951 : : }
1952 : : }
1953 : 3 : }
1954 : : EXPORT_SYMBOL(udp_lib_rehash);
1955 : :
1956 : 3 : void udp_v4_rehash(struct sock *sk)
1957 : : {
1958 : 3 : u16 new_hash = ipv4_portaddr_hash(sock_net(sk),
1959 : : inet_sk(sk)->inet_rcv_saddr,
1960 : 3 : inet_sk(sk)->inet_num);
1961 : 3 : udp_lib_rehash(sk, new_hash);
1962 : 3 : }
1963 : :
1964 : 3 : static int __udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
1965 : : {
1966 : : int rc;
1967 : :
1968 : 3 : if (inet_sk(sk)->inet_daddr) {
1969 : : sock_rps_save_rxhash(sk, skb);
1970 : : sk_mark_napi_id(sk, skb);
1971 : : sk_incoming_cpu_update(sk);
1972 : : } else {
1973 : : sk_mark_napi_id_once(sk, skb);
1974 : : }
1975 : :
1976 : 3 : rc = __udp_enqueue_schedule_skb(sk, skb);
1977 : 3 : if (rc < 0) {
1978 : 0 : int is_udplite = IS_UDPLITE(sk);
1979 : :
1980 : : /* Note that an ENOMEM error is charged twice */
1981 : 0 : if (rc == -ENOMEM)
1982 : 0 : UDP_INC_STATS(sock_net(sk), UDP_MIB_RCVBUFERRORS,
1983 : : is_udplite);
1984 : 0 : UDP_INC_STATS(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
1985 : 0 : kfree_skb(skb);
1986 : 0 : trace_udp_fail_queue_rcv_skb(rc, sk);
1987 : 0 : return -1;
1988 : : }
1989 : :
1990 : : return 0;
1991 : : }
1992 : :
1993 : : /* returns:
1994 : : * -1: error
1995 : : * 0: success
1996 : : * >0: "udp encap" protocol resubmission
1997 : : *
1998 : : * Note that in the success and error cases, the skb is assumed to
1999 : : * have either been requeued or freed.
2000 : : */
2001 : 3 : static int udp_queue_rcv_one_skb(struct sock *sk, struct sk_buff *skb)
2002 : : {
2003 : : struct udp_sock *up = udp_sk(sk);
2004 : 3 : int is_udplite = IS_UDPLITE(sk);
2005 : :
2006 : : /*
2007 : : * Charge it to the socket, dropping if the queue is full.
2008 : : */
2009 : 3 : if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
2010 : : goto drop;
2011 : : nf_reset_ct(skb);
2012 : :
2013 : 3 : if (static_branch_unlikely(&udp_encap_needed_key) && up->encap_type) {
2014 : : int (*encap_rcv)(struct sock *sk, struct sk_buff *skb);
2015 : :
2016 : : /*
2017 : : * This is an encapsulation socket so pass the skb to
2018 : : * the socket's udp_encap_rcv() hook. Otherwise, just
2019 : : * fall through and pass this up the UDP socket.
2020 : : * up->encap_rcv() returns the following value:
2021 : : * =0 if skb was successfully passed to the encap
2022 : : * handler or was discarded by it.
2023 : : * >0 if skb should be passed on to UDP.
2024 : : * <0 if skb should be resubmitted as proto -N
2025 : : */
2026 : :
2027 : : /* if we're overly short, let UDP handle it */
2028 : 0 : encap_rcv = READ_ONCE(up->encap_rcv);
2029 : 0 : if (encap_rcv) {
2030 : : int ret;
2031 : :
2032 : : /* Verify checksum before giving to encap */
2033 : 0 : if (udp_lib_checksum_complete(skb))
2034 : : goto csum_error;
2035 : :
2036 : 0 : ret = encap_rcv(sk, skb);
2037 : 0 : if (ret <= 0) {
2038 : 0 : __UDP_INC_STATS(sock_net(sk),
2039 : : UDP_MIB_INDATAGRAMS,
2040 : : is_udplite);
2041 : 0 : return -ret;
2042 : : }
2043 : : }
2044 : :
2045 : : /* FALLTHROUGH -- it's a UDP Packet */
2046 : : }
2047 : :
2048 : : /*
2049 : : * UDP-Lite specific tests, ignored on UDP sockets
2050 : : */
2051 : 3 : if ((up->pcflag & UDPLITE_RECV_CC) && UDP_SKB_CB(skb)->partial_cov) {
2052 : :
2053 : : /*
2054 : : * MIB statistics other than incrementing the error count are
2055 : : * disabled for the following two types of errors: these depend
2056 : : * on the application settings, not on the functioning of the
2057 : : * protocol stack as such.
2058 : : *
2059 : : * RFC 3828 here recommends (sec 3.3): "There should also be a
2060 : : * way ... to ... at least let the receiving application block
2061 : : * delivery of packets with coverage values less than a value
2062 : : * provided by the application."
2063 : : */
2064 : 0 : if (up->pcrlen == 0) { /* full coverage was set */
2065 : : net_dbg_ratelimited("UDPLite: partial coverage %d while full coverage %d requested\n",
2066 : : UDP_SKB_CB(skb)->cscov, skb->len);
2067 : : goto drop;
2068 : : }
2069 : : /* The next case involves violating the min. coverage requested
2070 : : * by the receiver. This is subtle: if receiver wants x and x is
2071 : : * greater than the buffersize/MTU then receiver will complain
2072 : : * that it wants x while sender emits packets of smaller size y.
2073 : : * Therefore the above ...()->partial_cov statement is essential.
2074 : : */
2075 : 0 : if (UDP_SKB_CB(skb)->cscov < up->pcrlen) {
2076 : : net_dbg_ratelimited("UDPLite: coverage %d too small, need min %d\n",
2077 : : UDP_SKB_CB(skb)->cscov, up->pcrlen);
2078 : : goto drop;
2079 : : }
2080 : : }
2081 : :
2082 : 3 : prefetch(&sk->sk_rmem_alloc);
2083 : 3 : if (rcu_access_pointer(sk->sk_filter) &&
2084 : 0 : udp_lib_checksum_complete(skb))
2085 : : goto csum_error;
2086 : :
2087 : 3 : if (sk_filter_trim_cap(sk, skb, sizeof(struct udphdr)))
2088 : : goto drop;
2089 : :
2090 : 3 : udp_csum_pull_header(skb);
2091 : :
2092 : 3 : ipv4_pktinfo_prepare(sk, skb);
2093 : 3 : return __udp_queue_rcv_skb(sk, skb);
2094 : :
2095 : : csum_error:
2096 : 0 : __UDP_INC_STATS(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
2097 : : drop:
2098 : 0 : __UDP_INC_STATS(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
2099 : 0 : atomic_inc(&sk->sk_drops);
2100 : 0 : kfree_skb(skb);
2101 : 0 : return -1;
2102 : : }
2103 : :
2104 : 3 : static int udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
2105 : : {
2106 : : struct sk_buff *next, *segs;
2107 : : int ret;
2108 : :
2109 : 3 : if (likely(!udp_unexpected_gso(sk, skb)))
2110 : 3 : return udp_queue_rcv_one_skb(sk, skb);
2111 : :
2112 : : BUILD_BUG_ON(sizeof(struct udp_skb_cb) > SKB_SGO_CB_OFFSET);
2113 : 0 : __skb_push(skb, -skb_mac_offset(skb));
2114 : 0 : segs = udp_rcv_segment(sk, skb, true);
2115 : 0 : for (skb = segs; skb; skb = next) {
2116 : 0 : next = skb->next;
2117 : 0 : __skb_pull(skb, skb_transport_offset(skb));
2118 : 0 : ret = udp_queue_rcv_one_skb(sk, skb);
2119 : 0 : if (ret > 0)
2120 : 0 : ip_protocol_deliver_rcu(dev_net(skb->dev), skb, -ret);
2121 : : }
2122 : : return 0;
2123 : : }
2124 : :
2125 : : /* For TCP sockets, sk_rx_dst is protected by socket lock
2126 : : * For UDP, we use xchg() to guard against concurrent changes.
2127 : : */
2128 : 3 : bool udp_sk_rx_dst_set(struct sock *sk, struct dst_entry *dst)
2129 : : {
2130 : : struct dst_entry *old;
2131 : :
2132 : 3 : if (dst_hold_safe(dst)) {
2133 : 3 : old = xchg(&sk->sk_rx_dst, dst);
2134 : 3 : dst_release(old);
2135 : 3 : return old != dst;
2136 : : }
2137 : : return false;
2138 : : }
2139 : : EXPORT_SYMBOL(udp_sk_rx_dst_set);
2140 : :
2141 : : /*
2142 : : * Multicasts and broadcasts go to each listener.
2143 : : *
2144 : : * Note: called only from the BH handler context.
2145 : : */
2146 : 3 : static int __udp4_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
2147 : : struct udphdr *uh,
2148 : : __be32 saddr, __be32 daddr,
2149 : : struct udp_table *udptable,
2150 : : int proto)
2151 : : {
2152 : : struct sock *sk, *first = NULL;
2153 : 3 : unsigned short hnum = ntohs(uh->dest);
2154 : 3 : struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum);
2155 : 3 : unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10);
2156 : : unsigned int offset = offsetof(typeof(*sk), sk_node);
2157 : 3 : int dif = skb->dev->ifindex;
2158 : : int sdif = inet_sdif(skb);
2159 : : struct hlist_node *node;
2160 : : struct sk_buff *nskb;
2161 : :
2162 : 3 : if (use_hash2) {
2163 : 0 : hash2_any = ipv4_portaddr_hash(net, htonl(INADDR_ANY), hnum) &
2164 : : udptable->mask;
2165 : 0 : hash2 = ipv4_portaddr_hash(net, daddr, hnum) & udptable->mask;
2166 : : start_lookup:
2167 : 0 : hslot = &udptable->hash2[hash2];
2168 : : offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node);
2169 : : }
2170 : :
2171 : 3 : sk_for_each_entry_offset_rcu(sk, node, &hslot->head, offset) {
2172 : 3 : if (!__udp_is_mcast_sock(net, sk, uh->dest, daddr,
2173 : : uh->source, saddr, dif, sdif, hnum))
2174 : 3 : continue;
2175 : :
2176 : 3 : if (!first) {
2177 : : first = sk;
2178 : 3 : continue;
2179 : : }
2180 : 1 : nskb = skb_clone(skb, GFP_ATOMIC);
2181 : :
2182 : 1 : if (unlikely(!nskb)) {
2183 : 0 : atomic_inc(&sk->sk_drops);
2184 : 0 : __UDP_INC_STATS(net, UDP_MIB_RCVBUFERRORS,
2185 : : IS_UDPLITE(sk));
2186 : 0 : __UDP_INC_STATS(net, UDP_MIB_INERRORS,
2187 : : IS_UDPLITE(sk));
2188 : 0 : continue;
2189 : : }
2190 : 1 : if (udp_queue_rcv_skb(sk, nskb) > 0)
2191 : 0 : consume_skb(nskb);
2192 : : }
2193 : :
2194 : : /* Also lookup *:port if we are using hash2 and haven't done so yet. */
2195 : 3 : if (use_hash2 && hash2 != hash2_any) {
2196 : : hash2 = hash2_any;
2197 : : goto start_lookup;
2198 : : }
2199 : :
2200 : 3 : if (first) {
2201 : 3 : if (udp_queue_rcv_skb(first, skb) > 0)
2202 : 0 : consume_skb(skb);
2203 : : } else {
2204 : 2 : kfree_skb(skb);
2205 : 2 : __UDP_INC_STATS(net, UDP_MIB_IGNOREDMULTI,
2206 : : proto == IPPROTO_UDPLITE);
2207 : : }
2208 : 3 : return 0;
2209 : : }
2210 : :
2211 : : /* Initialize UDP checksum. If exited with zero value (success),
2212 : : * CHECKSUM_UNNECESSARY means, that no more checks are required.
2213 : : * Otherwise, csum completion requires checksumming packet body,
2214 : : * including udp header and folding it to skb->csum.
2215 : : */
2216 : 3 : static inline int udp4_csum_init(struct sk_buff *skb, struct udphdr *uh,
2217 : : int proto)
2218 : : {
2219 : : int err;
2220 : :
2221 : 3 : UDP_SKB_CB(skb)->partial_cov = 0;
2222 : 3 : UDP_SKB_CB(skb)->cscov = skb->len;
2223 : :
2224 : 3 : if (proto == IPPROTO_UDPLITE) {
2225 : 0 : err = udplite_checksum_init(skb, uh);
2226 : 0 : if (err)
2227 : : return err;
2228 : :
2229 : 0 : if (UDP_SKB_CB(skb)->partial_cov) {
2230 : 0 : skb->csum = inet_compute_pseudo(skb, proto);
2231 : 0 : return 0;
2232 : : }
2233 : : }
2234 : :
2235 : : /* Note, we are only interested in != 0 or == 0, thus the
2236 : : * force to int.
2237 : : */
2238 : 3 : err = (__force int)skb_checksum_init_zero_check(skb, proto, uh->check,
2239 : : inet_compute_pseudo);
2240 : 3 : if (err)
2241 : : return err;
2242 : :
2243 : 3 : if (skb->ip_summed == CHECKSUM_COMPLETE && !skb->csum_valid) {
2244 : : /* If SW calculated the value, we know it's bad */
2245 : 0 : if (skb->csum_complete_sw)
2246 : : return 1;
2247 : :
2248 : : /* HW says the value is bad. Let's validate that.
2249 : : * skb->csum is no longer the full packet checksum,
2250 : : * so don't treat it as such.
2251 : : */
2252 : : skb_checksum_complete_unset(skb);
2253 : : }
2254 : :
2255 : : return 0;
2256 : : }
2257 : :
2258 : : /* wrapper for udp_queue_rcv_skb tacking care of csum conversion and
2259 : : * return code conversion for ip layer consumption
2260 : : */
2261 : 3 : static int udp_unicast_rcv_skb(struct sock *sk, struct sk_buff *skb,
2262 : : struct udphdr *uh)
2263 : : {
2264 : : int ret;
2265 : :
2266 : 3 : if (inet_get_convert_csum(sk) && uh->check && !IS_UDPLITE(sk))
2267 : 0 : skb_checksum_try_convert(skb, IPPROTO_UDP, inet_compute_pseudo);
2268 : :
2269 : 3 : ret = udp_queue_rcv_skb(sk, skb);
2270 : :
2271 : : /* a return value > 0 means to resubmit the input, but
2272 : : * it wants the return to be -protocol, or 0
2273 : : */
2274 : 3 : if (ret > 0)
2275 : 0 : return -ret;
2276 : : return 0;
2277 : : }
2278 : :
2279 : : /*
2280 : : * All we need to do is get the socket, and then do a checksum.
2281 : : */
2282 : :
2283 : 3 : int __udp4_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
2284 : : int proto)
2285 : : {
2286 : : struct sock *sk;
2287 : : struct udphdr *uh;
2288 : : unsigned short ulen;
2289 : : struct rtable *rt = skb_rtable(skb);
2290 : : __be32 saddr, daddr;
2291 : 3 : struct net *net = dev_net(skb->dev);
2292 : :
2293 : : /*
2294 : : * Validate the packet.
2295 : : */
2296 : 3 : if (!pskb_may_pull(skb, sizeof(struct udphdr)))
2297 : : goto drop; /* No space for header. */
2298 : :
2299 : : uh = udp_hdr(skb);
2300 : 3 : ulen = ntohs(uh->len);
2301 : 3 : saddr = ip_hdr(skb)->saddr;
2302 : 3 : daddr = ip_hdr(skb)->daddr;
2303 : :
2304 : 3 : if (ulen > skb->len)
2305 : : goto short_packet;
2306 : :
2307 : 3 : if (proto == IPPROTO_UDP) {
2308 : : /* UDP validates ulen. */
2309 : 3 : if (ulen < sizeof(*uh) || pskb_trim_rcsum(skb, ulen))
2310 : : goto short_packet;
2311 : : uh = udp_hdr(skb);
2312 : : }
2313 : :
2314 : 3 : if (udp4_csum_init(skb, uh, proto))
2315 : : goto csum_error;
2316 : :
2317 : : sk = skb_steal_sock(skb);
2318 : 3 : if (sk) {
2319 : : struct dst_entry *dst = skb_dst(skb);
2320 : : int ret;
2321 : :
2322 : 3 : if (unlikely(sk->sk_rx_dst != dst))
2323 : 3 : udp_sk_rx_dst_set(sk, dst);
2324 : :
2325 : 3 : ret = udp_unicast_rcv_skb(sk, skb, uh);
2326 : 3 : sock_put(sk);
2327 : 3 : return ret;
2328 : : }
2329 : :
2330 : 3 : if (rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST))
2331 : 3 : return __udp4_lib_mcast_deliver(net, skb, uh,
2332 : : saddr, daddr, udptable, proto);
2333 : :
2334 : 3 : sk = __udp4_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
2335 : 3 : if (sk)
2336 : 3 : return udp_unicast_rcv_skb(sk, skb, uh);
2337 : :
2338 : 2 : if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
2339 : : goto drop;
2340 : : nf_reset_ct(skb);
2341 : :
2342 : : /* No socket. Drop packet silently, if checksum is wrong */
2343 : 2 : if (udp_lib_checksum_complete(skb))
2344 : : goto csum_error;
2345 : :
2346 : 2 : __UDP_INC_STATS(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
2347 : : icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
2348 : :
2349 : : /*
2350 : : * Hmm. We got an UDP packet to a port to which we
2351 : : * don't wanna listen. Ignore it.
2352 : : */
2353 : 2 : kfree_skb(skb);
2354 : 2 : return 0;
2355 : :
2356 : : short_packet:
2357 : : net_dbg_ratelimited("UDP%s: short packet: From %pI4:%u %d/%d to %pI4:%u\n",
2358 : : proto == IPPROTO_UDPLITE ? "Lite" : "",
2359 : : &saddr, ntohs(uh->source),
2360 : : ulen, skb->len,
2361 : : &daddr, ntohs(uh->dest));
2362 : : goto drop;
2363 : :
2364 : : csum_error:
2365 : : /*
2366 : : * RFC1122: OK. Discards the bad packet silently (as far as
2367 : : * the network is concerned, anyway) as per 4.1.3.4 (MUST).
2368 : : */
2369 : : net_dbg_ratelimited("UDP%s: bad checksum. From %pI4:%u to %pI4:%u ulen %d\n",
2370 : : proto == IPPROTO_UDPLITE ? "Lite" : "",
2371 : : &saddr, ntohs(uh->source), &daddr, ntohs(uh->dest),
2372 : : ulen);
2373 : 0 : __UDP_INC_STATS(net, UDP_MIB_CSUMERRORS, proto == IPPROTO_UDPLITE);
2374 : : drop:
2375 : 0 : __UDP_INC_STATS(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
2376 : 0 : kfree_skb(skb);
2377 : 0 : return 0;
2378 : : }
2379 : :
2380 : : /* We can only early demux multicast if there is a single matching socket.
2381 : : * If more than one socket found returns NULL
2382 : : */
2383 : 2 : static struct sock *__udp4_lib_mcast_demux_lookup(struct net *net,
2384 : : __be16 loc_port, __be32 loc_addr,
2385 : : __be16 rmt_port, __be32 rmt_addr,
2386 : : int dif, int sdif)
2387 : : {
2388 : : struct sock *sk, *result;
2389 : 2 : unsigned short hnum = ntohs(loc_port);
2390 : 2 : unsigned int slot = udp_hashfn(net, hnum, udp_table.mask);
2391 : 2 : struct udp_hslot *hslot = &udp_table.hash[slot];
2392 : :
2393 : : /* Do not bother scanning a too big list */
2394 : 2 : if (hslot->count > 10)
2395 : : return NULL;
2396 : :
2397 : : result = NULL;
2398 : 2 : sk_for_each_rcu(sk, &hslot->head) {
2399 : 2 : if (__udp_is_mcast_sock(net, sk, loc_port, loc_addr,
2400 : : rmt_port, rmt_addr, dif, sdif, hnum)) {
2401 : 2 : if (result)
2402 : : return NULL;
2403 : : result = sk;
2404 : : }
2405 : : }
2406 : :
2407 : 2 : return result;
2408 : : }
2409 : :
2410 : : /* For unicast we should only early demux connected sockets or we can
2411 : : * break forwarding setups. The chains here can be long so only check
2412 : : * if the first socket is an exact match and if not move on.
2413 : : */
2414 : 3 : static struct sock *__udp4_lib_demux_lookup(struct net *net,
2415 : : __be16 loc_port, __be32 loc_addr,
2416 : : __be16 rmt_port, __be32 rmt_addr,
2417 : : int dif, int sdif)
2418 : : {
2419 : 3 : unsigned short hnum = ntohs(loc_port);
2420 : 3 : unsigned int hash2 = ipv4_portaddr_hash(net, loc_addr, hnum);
2421 : 3 : unsigned int slot2 = hash2 & udp_table.mask;
2422 : 3 : struct udp_hslot *hslot2 = &udp_table.hash2[slot2];
2423 : : INET_ADDR_COOKIE(acookie, rmt_addr, loc_addr);
2424 : 3 : const __portpair ports = INET_COMBINED_PORTS(rmt_port, hnum);
2425 : : struct sock *sk;
2426 : :
2427 : 3 : udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) {
2428 : 3 : if (INET_MATCH(sk, net, acookie, rmt_addr,
2429 : : loc_addr, ports, dif, sdif))
2430 : 3 : return sk;
2431 : : /* Only check first socket in chain */
2432 : : break;
2433 : : }
2434 : : return NULL;
2435 : : }
2436 : :
2437 : 3 : int udp_v4_early_demux(struct sk_buff *skb)
2438 : : {
2439 : 3 : struct net *net = dev_net(skb->dev);
2440 : : struct in_device *in_dev = NULL;
2441 : : const struct iphdr *iph;
2442 : : const struct udphdr *uh;
2443 : : struct sock *sk = NULL;
2444 : : struct dst_entry *dst;
2445 : 3 : int dif = skb->dev->ifindex;
2446 : : int sdif = inet_sdif(skb);
2447 : : int ours;
2448 : :
2449 : : /* validate the packet */
2450 : 3 : if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct udphdr)))
2451 : : return 0;
2452 : :
2453 : : iph = ip_hdr(skb);
2454 : : uh = udp_hdr(skb);
2455 : :
2456 : 3 : if (skb->pkt_type == PACKET_MULTICAST) {
2457 : 2 : in_dev = __in_dev_get_rcu(skb->dev);
2458 : :
2459 : 2 : if (!in_dev)
2460 : : return 0;
2461 : :
2462 : 2 : ours = ip_check_mc_rcu(in_dev, iph->daddr, iph->saddr,
2463 : : iph->protocol);
2464 : 2 : if (!ours)
2465 : : return 0;
2466 : :
2467 : 2 : sk = __udp4_lib_mcast_demux_lookup(net, uh->dest, iph->daddr,
2468 : : uh->source, iph->saddr,
2469 : : dif, sdif);
2470 : 3 : } else if (skb->pkt_type == PACKET_HOST) {
2471 : 3 : sk = __udp4_lib_demux_lookup(net, uh->dest, iph->daddr,
2472 : : uh->source, iph->saddr, dif, sdif);
2473 : : }
2474 : :
2475 : 3 : if (!sk || !refcount_inc_not_zero(&sk->sk_refcnt))
2476 : : return 0;
2477 : :
2478 : 3 : skb->sk = sk;
2479 : 3 : skb->destructor = sock_efree;
2480 : 3 : dst = READ_ONCE(sk->sk_rx_dst);
2481 : :
2482 : 3 : if (dst)
2483 : : dst = dst_check(dst, 0);
2484 : 3 : if (dst) {
2485 : 3 : u32 itag = 0;
2486 : :
2487 : : /* set noref for now.
2488 : : * any place which wants to hold dst has to call
2489 : : * dst_hold_safe()
2490 : : */
2491 : : skb_dst_set_noref(skb, dst);
2492 : :
2493 : : /* for unconnected multicast sockets we need to validate
2494 : : * the source on each packet
2495 : : */
2496 : 3 : if (!inet_sk(sk)->inet_daddr && in_dev)
2497 : 2 : return ip_mc_validate_source(skb, iph->daddr,
2498 : : iph->saddr, iph->tos,
2499 : : skb->dev, in_dev, &itag);
2500 : : }
2501 : : return 0;
2502 : : }
2503 : :
2504 : 3 : int udp_rcv(struct sk_buff *skb)
2505 : : {
2506 : 3 : return __udp4_lib_rcv(skb, &udp_table, IPPROTO_UDP);
2507 : : }
2508 : :
2509 : 3 : void udp_destroy_sock(struct sock *sk)
2510 : : {
2511 : : struct udp_sock *up = udp_sk(sk);
2512 : 3 : bool slow = lock_sock_fast(sk);
2513 : : udp_flush_pending_frames(sk);
2514 : : unlock_sock_fast(sk, slow);
2515 : 3 : if (static_branch_unlikely(&udp_encap_needed_key)) {
2516 : 0 : if (up->encap_type) {
2517 : : void (*encap_destroy)(struct sock *sk);
2518 : 0 : encap_destroy = READ_ONCE(up->encap_destroy);
2519 : 0 : if (encap_destroy)
2520 : 0 : encap_destroy(sk);
2521 : : }
2522 : 0 : if (up->encap_enabled)
2523 : 0 : static_branch_dec(&udp_encap_needed_key);
2524 : : }
2525 : 3 : }
2526 : :
2527 : : /*
2528 : : * Socket option code for UDP
2529 : : */
2530 : 0 : int udp_lib_setsockopt(struct sock *sk, int level, int optname,
2531 : : char __user *optval, unsigned int optlen,
2532 : : int (*push_pending_frames)(struct sock *))
2533 : : {
2534 : : struct udp_sock *up = udp_sk(sk);
2535 : : int val, valbool;
2536 : : int err = 0;
2537 : 0 : int is_udplite = IS_UDPLITE(sk);
2538 : :
2539 : 0 : if (optlen < sizeof(int))
2540 : : return -EINVAL;
2541 : :
2542 : 0 : if (get_user(val, (int __user *)optval))
2543 : : return -EFAULT;
2544 : :
2545 : 0 : valbool = val ? 1 : 0;
2546 : :
2547 : 0 : switch (optname) {
2548 : : case UDP_CORK:
2549 : 0 : if (val != 0) {
2550 : 0 : up->corkflag = 1;
2551 : : } else {
2552 : 0 : up->corkflag = 0;
2553 : : lock_sock(sk);
2554 : 0 : push_pending_frames(sk);
2555 : 0 : release_sock(sk);
2556 : : }
2557 : : break;
2558 : :
2559 : : case UDP_ENCAP:
2560 : 0 : switch (val) {
2561 : : case 0:
2562 : : case UDP_ENCAP_ESPINUDP:
2563 : : case UDP_ENCAP_ESPINUDP_NON_IKE:
2564 : 0 : up->encap_rcv = xfrm4_udp_encap_rcv;
2565 : : /* FALLTHROUGH */
2566 : : case UDP_ENCAP_L2TPINUDP:
2567 : 0 : up->encap_type = val;
2568 : : lock_sock(sk);
2569 : 0 : udp_tunnel_encap_enable(sk->sk_socket);
2570 : 0 : release_sock(sk);
2571 : 0 : break;
2572 : : default:
2573 : : err = -ENOPROTOOPT;
2574 : : break;
2575 : : }
2576 : : break;
2577 : :
2578 : : case UDP_NO_CHECK6_TX:
2579 : 0 : up->no_check6_tx = valbool;
2580 : 0 : break;
2581 : :
2582 : : case UDP_NO_CHECK6_RX:
2583 : 0 : up->no_check6_rx = valbool;
2584 : 0 : break;
2585 : :
2586 : : case UDP_SEGMENT:
2587 : 0 : if (val < 0 || val > USHRT_MAX)
2588 : : return -EINVAL;
2589 : 0 : up->gso_size = val;
2590 : 0 : break;
2591 : :
2592 : : case UDP_GRO:
2593 : : lock_sock(sk);
2594 : 0 : if (valbool)
2595 : 0 : udp_tunnel_encap_enable(sk->sk_socket);
2596 : 0 : up->gro_enabled = valbool;
2597 : 0 : release_sock(sk);
2598 : 0 : break;
2599 : :
2600 : : /*
2601 : : * UDP-Lite's partial checksum coverage (RFC 3828).
2602 : : */
2603 : : /* The sender sets actual checksum coverage length via this option.
2604 : : * The case coverage > packet length is handled by send module. */
2605 : : case UDPLITE_SEND_CSCOV:
2606 : 0 : if (!is_udplite) /* Disable the option on UDP sockets */
2607 : : return -ENOPROTOOPT;
2608 : 0 : if (val != 0 && val < 8) /* Illegal coverage: use default (8) */
2609 : : val = 8;
2610 : 0 : else if (val > USHRT_MAX)
2611 : : val = USHRT_MAX;
2612 : 0 : up->pcslen = val;
2613 : 0 : up->pcflag |= UDPLITE_SEND_CC;
2614 : 0 : break;
2615 : :
2616 : : /* The receiver specifies a minimum checksum coverage value. To make
2617 : : * sense, this should be set to at least 8 (as done below). If zero is
2618 : : * used, this again means full checksum coverage. */
2619 : : case UDPLITE_RECV_CSCOV:
2620 : 0 : if (!is_udplite) /* Disable the option on UDP sockets */
2621 : : return -ENOPROTOOPT;
2622 : 0 : if (val != 0 && val < 8) /* Avoid silly minimal values. */
2623 : : val = 8;
2624 : 0 : else if (val > USHRT_MAX)
2625 : : val = USHRT_MAX;
2626 : 0 : up->pcrlen = val;
2627 : 0 : up->pcflag |= UDPLITE_RECV_CC;
2628 : 0 : break;
2629 : :
2630 : : default:
2631 : : err = -ENOPROTOOPT;
2632 : : break;
2633 : : }
2634 : :
2635 : 0 : return err;
2636 : : }
2637 : : EXPORT_SYMBOL(udp_lib_setsockopt);
2638 : :
2639 : 3 : int udp_setsockopt(struct sock *sk, int level, int optname,
2640 : : char __user *optval, unsigned int optlen)
2641 : : {
2642 : 3 : if (level == SOL_UDP || level == SOL_UDPLITE)
2643 : 0 : return udp_lib_setsockopt(sk, level, optname, optval, optlen,
2644 : : udp_push_pending_frames);
2645 : 3 : return ip_setsockopt(sk, level, optname, optval, optlen);
2646 : : }
2647 : :
2648 : : #ifdef CONFIG_COMPAT
2649 : : int compat_udp_setsockopt(struct sock *sk, int level, int optname,
2650 : : char __user *optval, unsigned int optlen)
2651 : : {
2652 : : if (level == SOL_UDP || level == SOL_UDPLITE)
2653 : : return udp_lib_setsockopt(sk, level, optname, optval, optlen,
2654 : : udp_push_pending_frames);
2655 : : return compat_ip_setsockopt(sk, level, optname, optval, optlen);
2656 : : }
2657 : : #endif
2658 : :
2659 : 0 : int udp_lib_getsockopt(struct sock *sk, int level, int optname,
2660 : : char __user *optval, int __user *optlen)
2661 : : {
2662 : : struct udp_sock *up = udp_sk(sk);
2663 : : int val, len;
2664 : :
2665 : 0 : if (get_user(len, optlen))
2666 : : return -EFAULT;
2667 : :
2668 : 0 : len = min_t(unsigned int, len, sizeof(int));
2669 : :
2670 : 0 : if (len < 0)
2671 : : return -EINVAL;
2672 : :
2673 : 0 : switch (optname) {
2674 : : case UDP_CORK:
2675 : 0 : val = up->corkflag;
2676 : 0 : break;
2677 : :
2678 : : case UDP_ENCAP:
2679 : 0 : val = up->encap_type;
2680 : 0 : break;
2681 : :
2682 : : case UDP_NO_CHECK6_TX:
2683 : 0 : val = up->no_check6_tx;
2684 : 0 : break;
2685 : :
2686 : : case UDP_NO_CHECK6_RX:
2687 : 0 : val = up->no_check6_rx;
2688 : 0 : break;
2689 : :
2690 : : case UDP_SEGMENT:
2691 : 0 : val = up->gso_size;
2692 : 0 : break;
2693 : :
2694 : : /* The following two cannot be changed on UDP sockets, the return is
2695 : : * always 0 (which corresponds to the full checksum coverage of UDP). */
2696 : : case UDPLITE_SEND_CSCOV:
2697 : 0 : val = up->pcslen;
2698 : 0 : break;
2699 : :
2700 : : case UDPLITE_RECV_CSCOV:
2701 : 0 : val = up->pcrlen;
2702 : 0 : break;
2703 : :
2704 : : default:
2705 : : return -ENOPROTOOPT;
2706 : : }
2707 : :
2708 : 0 : if (put_user(len, optlen))
2709 : : return -EFAULT;
2710 : 0 : if (copy_to_user(optval, &val, len))
2711 : : return -EFAULT;
2712 : 0 : return 0;
2713 : : }
2714 : : EXPORT_SYMBOL(udp_lib_getsockopt);
2715 : :
2716 : 0 : int udp_getsockopt(struct sock *sk, int level, int optname,
2717 : : char __user *optval, int __user *optlen)
2718 : : {
2719 : 0 : if (level == SOL_UDP || level == SOL_UDPLITE)
2720 : 0 : return udp_lib_getsockopt(sk, level, optname, optval, optlen);
2721 : 0 : return ip_getsockopt(sk, level, optname, optval, optlen);
2722 : : }
2723 : :
2724 : : #ifdef CONFIG_COMPAT
2725 : : int compat_udp_getsockopt(struct sock *sk, int level, int optname,
2726 : : char __user *optval, int __user *optlen)
2727 : : {
2728 : : if (level == SOL_UDP || level == SOL_UDPLITE)
2729 : : return udp_lib_getsockopt(sk, level, optname, optval, optlen);
2730 : : return compat_ip_getsockopt(sk, level, optname, optval, optlen);
2731 : : }
2732 : : #endif
2733 : : /**
2734 : : * udp_poll - wait for a UDP event.
2735 : : * @file - file struct
2736 : : * @sock - socket
2737 : : * @wait - poll table
2738 : : *
2739 : : * This is same as datagram poll, except for the special case of
2740 : : * blocking sockets. If application is using a blocking fd
2741 : : * and a packet with checksum error is in the queue;
2742 : : * then it could get return from select indicating data available
2743 : : * but then block when reading it. Add special case code
2744 : : * to work around these arguably broken applications.
2745 : : */
2746 : 3 : __poll_t udp_poll(struct file *file, struct socket *sock, poll_table *wait)
2747 : : {
2748 : 3 : __poll_t mask = datagram_poll(file, sock, wait);
2749 : 3 : struct sock *sk = sock->sk;
2750 : :
2751 : 3 : if (!skb_queue_empty_lockless(&udp_sk(sk)->reader_queue))
2752 : 3 : mask |= EPOLLIN | EPOLLRDNORM;
2753 : :
2754 : : /* Check for false positives due to checksum errors */
2755 : 3 : if ((mask & EPOLLRDNORM) && !(file->f_flags & O_NONBLOCK) &&
2756 : 3 : !(sk->sk_shutdown & RCV_SHUTDOWN) && first_packet_length(sk) == -1)
2757 : 0 : mask &= ~(EPOLLIN | EPOLLRDNORM);
2758 : :
2759 : 3 : return mask;
2760 : :
2761 : : }
2762 : : EXPORT_SYMBOL(udp_poll);
2763 : :
2764 : 0 : int udp_abort(struct sock *sk, int err)
2765 : : {
2766 : : lock_sock(sk);
2767 : :
2768 : 0 : sk->sk_err = err;
2769 : 0 : sk->sk_error_report(sk);
2770 : 0 : __udp_disconnect(sk, 0);
2771 : :
2772 : 0 : release_sock(sk);
2773 : :
2774 : 0 : return 0;
2775 : : }
2776 : : EXPORT_SYMBOL_GPL(udp_abort);
2777 : :
2778 : : struct proto udp_prot = {
2779 : : .name = "UDP",
2780 : : .owner = THIS_MODULE,
2781 : : .close = udp_lib_close,
2782 : : .pre_connect = udp_pre_connect,
2783 : : .connect = ip4_datagram_connect,
2784 : : .disconnect = udp_disconnect,
2785 : : .ioctl = udp_ioctl,
2786 : : .init = udp_init_sock,
2787 : : .destroy = udp_destroy_sock,
2788 : : .setsockopt = udp_setsockopt,
2789 : : .getsockopt = udp_getsockopt,
2790 : : .sendmsg = udp_sendmsg,
2791 : : .recvmsg = udp_recvmsg,
2792 : : .sendpage = udp_sendpage,
2793 : : .release_cb = ip4_datagram_release_cb,
2794 : : .hash = udp_lib_hash,
2795 : : .unhash = udp_lib_unhash,
2796 : : .rehash = udp_v4_rehash,
2797 : : .get_port = udp_v4_get_port,
2798 : : .memory_allocated = &udp_memory_allocated,
2799 : : .sysctl_mem = sysctl_udp_mem,
2800 : : .sysctl_wmem_offset = offsetof(struct net, ipv4.sysctl_udp_wmem_min),
2801 : : .sysctl_rmem_offset = offsetof(struct net, ipv4.sysctl_udp_rmem_min),
2802 : : .obj_size = sizeof(struct udp_sock),
2803 : : .h.udp_table = &udp_table,
2804 : : #ifdef CONFIG_COMPAT
2805 : : .compat_setsockopt = compat_udp_setsockopt,
2806 : : .compat_getsockopt = compat_udp_getsockopt,
2807 : : #endif
2808 : : .diag_destroy = udp_abort,
2809 : : };
2810 : : EXPORT_SYMBOL(udp_prot);
2811 : :
2812 : : /* ------------------------------------------------------------------------ */
2813 : : #ifdef CONFIG_PROC_FS
2814 : :
2815 : 0 : static struct sock *udp_get_first(struct seq_file *seq, int start)
2816 : : {
2817 : : struct sock *sk;
2818 : 0 : struct udp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
2819 : 0 : struct udp_iter_state *state = seq->private;
2820 : : struct net *net = seq_file_net(seq);
2821 : :
2822 : 0 : for (state->bucket = start; state->bucket <= afinfo->udp_table->mask;
2823 : 0 : ++state->bucket) {
2824 : 0 : struct udp_hslot *hslot = &afinfo->udp_table->hash[state->bucket];
2825 : :
2826 : 0 : if (hlist_empty(&hslot->head))
2827 : 0 : continue;
2828 : :
2829 : : spin_lock_bh(&hslot->lock);
2830 : 0 : sk_for_each(sk, &hslot->head) {
2831 : 0 : if (!net_eq(sock_net(sk), net))
2832 : 0 : continue;
2833 : 0 : if (sk->sk_family == afinfo->family)
2834 : : goto found;
2835 : : }
2836 : : spin_unlock_bh(&hslot->lock);
2837 : : }
2838 : : sk = NULL;
2839 : : found:
2840 : 0 : return sk;
2841 : : }
2842 : :
2843 : 0 : static struct sock *udp_get_next(struct seq_file *seq, struct sock *sk)
2844 : : {
2845 : 0 : struct udp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
2846 : 0 : struct udp_iter_state *state = seq->private;
2847 : : struct net *net = seq_file_net(seq);
2848 : :
2849 : : do {
2850 : : sk = sk_next(sk);
2851 : 0 : } while (sk && (!net_eq(sock_net(sk), net) || sk->sk_family != afinfo->family));
2852 : :
2853 : 0 : if (!sk) {
2854 : 0 : if (state->bucket <= afinfo->udp_table->mask)
2855 : 0 : spin_unlock_bh(&afinfo->udp_table->hash[state->bucket].lock);
2856 : 0 : return udp_get_first(seq, state->bucket + 1);
2857 : : }
2858 : 0 : return sk;
2859 : : }
2860 : :
2861 : 0 : static struct sock *udp_get_idx(struct seq_file *seq, loff_t pos)
2862 : : {
2863 : 0 : struct sock *sk = udp_get_first(seq, 0);
2864 : :
2865 : 0 : if (sk)
2866 : 0 : while (pos && (sk = udp_get_next(seq, sk)) != NULL)
2867 : 0 : --pos;
2868 : 0 : return pos ? NULL : sk;
2869 : : }
2870 : :
2871 : 0 : void *udp_seq_start(struct seq_file *seq, loff_t *pos)
2872 : : {
2873 : 0 : struct udp_iter_state *state = seq->private;
2874 : 0 : state->bucket = MAX_UDP_PORTS;
2875 : :
2876 : 0 : return *pos ? udp_get_idx(seq, *pos-1) : SEQ_START_TOKEN;
2877 : : }
2878 : : EXPORT_SYMBOL(udp_seq_start);
2879 : :
2880 : 0 : void *udp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2881 : : {
2882 : : struct sock *sk;
2883 : :
2884 : 0 : if (v == SEQ_START_TOKEN)
2885 : 0 : sk = udp_get_idx(seq, 0);
2886 : : else
2887 : 0 : sk = udp_get_next(seq, v);
2888 : :
2889 : 0 : ++*pos;
2890 : 0 : return sk;
2891 : : }
2892 : : EXPORT_SYMBOL(udp_seq_next);
2893 : :
2894 : 0 : void udp_seq_stop(struct seq_file *seq, void *v)
2895 : : {
2896 : 0 : struct udp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
2897 : 0 : struct udp_iter_state *state = seq->private;
2898 : :
2899 : 0 : if (state->bucket <= afinfo->udp_table->mask)
2900 : 0 : spin_unlock_bh(&afinfo->udp_table->hash[state->bucket].lock);
2901 : 0 : }
2902 : : EXPORT_SYMBOL(udp_seq_stop);
2903 : :
2904 : : /* ------------------------------------------------------------------------ */
2905 : 0 : static void udp4_format_sock(struct sock *sp, struct seq_file *f,
2906 : : int bucket)
2907 : : {
2908 : : struct inet_sock *inet = inet_sk(sp);
2909 : 0 : __be32 dest = inet->inet_daddr;
2910 : 0 : __be32 src = inet->inet_rcv_saddr;
2911 : 0 : __u16 destp = ntohs(inet->inet_dport);
2912 : 0 : __u16 srcp = ntohs(inet->inet_sport);
2913 : :
2914 : 0 : seq_printf(f, "%5d: %08X:%04X %08X:%04X"
2915 : : " %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %u",
2916 : 0 : bucket, src, srcp, dest, destp, sp->sk_state,
2917 : : sk_wmem_alloc_get(sp),
2918 : : udp_rqueue_get(sp),
2919 : : 0, 0L, 0,
2920 : : from_kuid_munged(seq_user_ns(f), sock_i_uid(sp)),
2921 : : 0, sock_i_ino(sp),
2922 : : refcount_read(&sp->sk_refcnt), sp,
2923 : 0 : atomic_read(&sp->sk_drops));
2924 : 0 : }
2925 : :
2926 : 0 : int udp4_seq_show(struct seq_file *seq, void *v)
2927 : : {
2928 : : seq_setwidth(seq, 127);
2929 : 0 : if (v == SEQ_START_TOKEN)
2930 : 0 : seq_puts(seq, " sl local_address rem_address st tx_queue "
2931 : : "rx_queue tr tm->when retrnsmt uid timeout "
2932 : : "inode ref pointer drops");
2933 : : else {
2934 : 0 : struct udp_iter_state *state = seq->private;
2935 : :
2936 : 0 : udp4_format_sock(v, seq, state->bucket);
2937 : : }
2938 : 0 : seq_pad(seq, '\n');
2939 : 0 : return 0;
2940 : : }
2941 : :
2942 : : const struct seq_operations udp_seq_ops = {
2943 : : .start = udp_seq_start,
2944 : : .next = udp_seq_next,
2945 : : .stop = udp_seq_stop,
2946 : : .show = udp4_seq_show,
2947 : : };
2948 : : EXPORT_SYMBOL(udp_seq_ops);
2949 : :
2950 : : static struct udp_seq_afinfo udp4_seq_afinfo = {
2951 : : .family = AF_INET,
2952 : : .udp_table = &udp_table,
2953 : : };
2954 : :
2955 : 3 : static int __net_init udp4_proc_init_net(struct net *net)
2956 : : {
2957 : 3 : if (!proc_create_net_data("udp", 0444, net->proc_net, &udp_seq_ops,
2958 : : sizeof(struct udp_iter_state), &udp4_seq_afinfo))
2959 : : return -ENOMEM;
2960 : 3 : return 0;
2961 : : }
2962 : :
2963 : 1 : static void __net_exit udp4_proc_exit_net(struct net *net)
2964 : : {
2965 : 1 : remove_proc_entry("udp", net->proc_net);
2966 : 1 : }
2967 : :
2968 : : static struct pernet_operations udp4_net_ops = {
2969 : : .init = udp4_proc_init_net,
2970 : : .exit = udp4_proc_exit_net,
2971 : : };
2972 : :
2973 : 3 : int __init udp4_proc_init(void)
2974 : : {
2975 : 3 : return register_pernet_subsys(&udp4_net_ops);
2976 : : }
2977 : :
2978 : 0 : void udp4_proc_exit(void)
2979 : : {
2980 : 0 : unregister_pernet_subsys(&udp4_net_ops);
2981 : 0 : }
2982 : : #endif /* CONFIG_PROC_FS */
2983 : :
2984 : : static __initdata unsigned long uhash_entries;
2985 : 0 : static int __init set_uhash_entries(char *str)
2986 : : {
2987 : : ssize_t ret;
2988 : :
2989 : 0 : if (!str)
2990 : : return 0;
2991 : :
2992 : : ret = kstrtoul(str, 0, &uhash_entries);
2993 : 0 : if (ret)
2994 : : return 0;
2995 : :
2996 : 0 : if (uhash_entries && uhash_entries < UDP_HTABLE_SIZE_MIN)
2997 : 0 : uhash_entries = UDP_HTABLE_SIZE_MIN;
2998 : : return 1;
2999 : : }
3000 : : __setup("uhash_entries=", set_uhash_entries);
3001 : :
3002 : 3 : void __init udp_table_init(struct udp_table *table, const char *name)
3003 : : {
3004 : : unsigned int i;
3005 : :
3006 : 3 : table->hash = alloc_large_system_hash(name,
3007 : : 2 * sizeof(struct udp_hslot),
3008 : : uhash_entries,
3009 : : 21, /* one slot per 2 MB */
3010 : : 0,
3011 : : &table->log,
3012 : : &table->mask,
3013 : : UDP_HTABLE_SIZE_MIN,
3014 : : 64 * 1024);
3015 : :
3016 : 3 : table->hash2 = table->hash + (table->mask + 1);
3017 : 3 : for (i = 0; i <= table->mask; i++) {
3018 : 3 : INIT_HLIST_HEAD(&table->hash[i].head);
3019 : 3 : table->hash[i].count = 0;
3020 : 3 : spin_lock_init(&table->hash[i].lock);
3021 : : }
3022 : 3 : for (i = 0; i <= table->mask; i++) {
3023 : 3 : INIT_HLIST_HEAD(&table->hash2[i].head);
3024 : 3 : table->hash2[i].count = 0;
3025 : 3 : spin_lock_init(&table->hash2[i].lock);
3026 : : }
3027 : 3 : }
3028 : :
3029 : 0 : u32 udp_flow_hashrnd(void)
3030 : : {
3031 : : static u32 hashrnd __read_mostly;
3032 : :
3033 : 0 : net_get_random_once(&hashrnd, sizeof(hashrnd));
3034 : :
3035 : 0 : return hashrnd;
3036 : : }
3037 : : EXPORT_SYMBOL(udp_flow_hashrnd);
3038 : :
3039 : : static void __udp_sysctl_init(struct net *net)
3040 : : {
3041 : 3 : net->ipv4.sysctl_udp_rmem_min = SK_MEM_QUANTUM;
3042 : 3 : net->ipv4.sysctl_udp_wmem_min = SK_MEM_QUANTUM;
3043 : :
3044 : : #ifdef CONFIG_NET_L3_MASTER_DEV
3045 : 3 : net->ipv4.sysctl_udp_l3mdev_accept = 0;
3046 : : #endif
3047 : : }
3048 : :
3049 : 3 : static int __net_init udp_sysctl_init(struct net *net)
3050 : : {
3051 : : __udp_sysctl_init(net);
3052 : 3 : return 0;
3053 : : }
3054 : :
3055 : : static struct pernet_operations __net_initdata udp_sysctl_ops = {
3056 : : .init = udp_sysctl_init,
3057 : : };
3058 : :
3059 : 3 : void __init udp_init(void)
3060 : : {
3061 : : unsigned long limit;
3062 : : unsigned int i;
3063 : :
3064 : 3 : udp_table_init(&udp_table, "UDP");
3065 : 3 : limit = nr_free_buffer_pages() / 8;
3066 : 3 : limit = max(limit, 128UL);
3067 : 3 : sysctl_udp_mem[0] = limit / 4 * 3;
3068 : 3 : sysctl_udp_mem[1] = limit;
3069 : 3 : sysctl_udp_mem[2] = sysctl_udp_mem[0] * 2;
3070 : :
3071 : : __udp_sysctl_init(&init_net);
3072 : :
3073 : : /* 16 spinlocks per cpu */
3074 : 3 : udp_busylocks_log = ilog2(nr_cpu_ids) + 4;
3075 : 3 : udp_busylocks = kmalloc(sizeof(spinlock_t) << udp_busylocks_log,
3076 : : GFP_KERNEL);
3077 : 3 : if (!udp_busylocks)
3078 : 0 : panic("UDP: failed to alloc udp_busylocks\n");
3079 : 3 : for (i = 0; i < (1U << udp_busylocks_log); i++)
3080 : 3 : spin_lock_init(udp_busylocks + i);
3081 : :
3082 : 3 : if (register_pernet_subsys(&udp_sysctl_ops))
3083 : 0 : panic("UDP: failed to init sysctl parameters.\n");
3084 : 3 : }
|
