Branch data Line data Source code
1 : : /*
2 : : * UDP over IPv6
3 : : * Linux INET6 implementation
4 : : *
5 : : * Authors:
6 : : * Pedro Roque <roque@di.fc.ul.pt>
7 : : *
8 : : * Based on linux/ipv4/udp.c
9 : : *
10 : : * Fixes:
11 : : * Hideaki YOSHIFUJI : sin6_scope_id support
12 : : * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
13 : : * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
14 : : * a single port at the same time.
15 : : * Kazunori MIYAZAWA @USAGI: change process style to use ip6_append_data
16 : : * YOSHIFUJI Hideaki @USAGI: convert /proc/net/udp6 to seq_file.
17 : : *
18 : : * This program is free software; you can redistribute it and/or
19 : : * modify it under the terms of the GNU General Public License
20 : : * as published by the Free Software Foundation; either version
21 : : * 2 of the License, or (at your option) any later version.
22 : : */
23 : :
24 : : #include <linux/errno.h>
25 : : #include <linux/types.h>
26 : : #include <linux/socket.h>
27 : : #include <linux/sockios.h>
28 : : #include <linux/net.h>
29 : : #include <linux/in6.h>
30 : : #include <linux/netdevice.h>
31 : : #include <linux/if_arp.h>
32 : : #include <linux/ipv6.h>
33 : : #include <linux/icmpv6.h>
34 : : #include <linux/init.h>
35 : : #include <linux/module.h>
36 : : #include <linux/skbuff.h>
37 : : #include <linux/slab.h>
38 : : #include <asm/uaccess.h>
39 : :
40 : : #include <net/ndisc.h>
41 : : #include <net/protocol.h>
42 : : #include <net/transp_v6.h>
43 : : #include <net/ip6_route.h>
44 : : #include <net/raw.h>
45 : : #include <net/tcp_states.h>
46 : : #include <net/ip6_checksum.h>
47 : : #include <net/xfrm.h>
48 : : #include <net/inet6_hashtables.h>
49 : : #include <net/busy_poll.h>
50 : :
51 : : #include <linux/proc_fs.h>
52 : : #include <linux/seq_file.h>
53 : : #include <trace/events/skb.h>
54 : : #include "udp_impl.h"
55 : :
56 : 0 : static unsigned int udp6_ehashfn(struct net *net,
57 : : const struct in6_addr *laddr,
58 : : const u16 lport,
59 : : const struct in6_addr *faddr,
60 : : const __be16 fport)
61 : : {
62 : : static u32 udp6_ehash_secret __read_mostly;
63 : : static u32 udp_ipv6_hash_secret __read_mostly;
64 : :
65 : : u32 lhash, fhash;
66 : :
67 [ # # ]: 0 : net_get_random_once(&udp6_ehash_secret,
68 : : sizeof(udp6_ehash_secret));
69 [ # # ]: 0 : net_get_random_once(&udp_ipv6_hash_secret,
70 : : sizeof(udp_ipv6_hash_secret));
71 : :
72 : 0 : lhash = (__force u32)laddr->s6_addr32[3];
73 : 0 : fhash = __ipv6_addr_jhash(faddr, udp_ipv6_hash_secret);
74 : :
75 : 0 : return __inet6_ehashfn(lhash, lport, fhash, fport,
76 : : udp_ipv6_hash_secret + net_hash_mix(net));
77 : : }
78 : :
79 : 0 : int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2)
80 : : {
81 : : const struct in6_addr *sk2_rcv_saddr6 = inet6_rcv_saddr(sk2);
82 [ + - ][ - + ]: 1 : int sk_ipv6only = ipv6_only_sock(sk);
83 : : int sk2_ipv6only = inet_v6_ipv6only(sk2);
84 : 1 : int addr_type = ipv6_addr_type(&sk->sk_v6_rcv_saddr);
85 [ + - ]: 1 : int addr_type2 = sk2_rcv_saddr6 ? ipv6_addr_type(sk2_rcv_saddr6) : IPV6_ADDR_MAPPED;
86 : :
87 : : /* if both are mapped, treat as IPv4 */
88 [ - + ]: 1 : if (addr_type == IPV6_ADDR_MAPPED && addr_type2 == IPV6_ADDR_MAPPED)
89 [ # # ][ # # ]: 0 : return (!sk2_ipv6only &&
90 [ # # ][ # # ]: 0 : (!sk->sk_rcv_saddr || !sk2->sk_rcv_saddr ||
91 : : sk->sk_rcv_saddr == sk2->sk_rcv_saddr));
92 : :
93 [ + - ][ - + ]: 1 : if (addr_type2 == IPV6_ADDR_ANY &&
94 : 1 : !(sk2_ipv6only && addr_type == IPV6_ADDR_MAPPED))
95 : : return 1;
96 : :
97 [ # # ][ # # ]: 0 : if (addr_type == IPV6_ADDR_ANY &&
98 : 0 : !(sk_ipv6only && addr_type2 == IPV6_ADDR_MAPPED))
99 : : return 1;
100 : :
101 [ # # ][ # # ]: 0 : if (sk2_rcv_saddr6 &&
102 : : ipv6_addr_equal(&sk->sk_v6_rcv_saddr, sk2_rcv_saddr6))
103 : : return 1;
104 : :
105 : 0 : return 0;
106 : : }
107 : :
108 : 27 : static unsigned int udp6_portaddr_hash(struct net *net,
109 : : const struct in6_addr *addr6,
110 : : unsigned int port)
111 : : {
112 : : unsigned int hash, mix = net_hash_mix(net);
113 : :
114 [ + ]: 27 : if (ipv6_addr_any(addr6))
115 : : hash = jhash_1word(0, mix);
116 [ + + ]: 34 : else if (ipv6_addr_v4mapped(addr6))
117 : : hash = jhash_1word((__force u32)addr6->s6_addr32[3], mix);
118 : : else
119 : 30 : hash = jhash2((__force u32 *)addr6->s6_addr32, 4, mix);
120 : :
121 : 0 : return hash ^ port;
122 : : }
123 : :
124 : :
125 : 0 : int udp_v6_get_port(struct sock *sk, unsigned short snum)
126 : : {
127 : 8 : unsigned int hash2_nulladdr =
128 : 8 : udp6_portaddr_hash(sock_net(sk), &in6addr_any, snum);
129 : 8 : unsigned int hash2_partial =
130 : 8 : udp6_portaddr_hash(sock_net(sk), &sk->sk_v6_rcv_saddr, 0);
131 : :
132 : : /* precompute partial secondary hash */
133 : 8 : udp_sk(sk)->udp_portaddr_hash = hash2_partial;
134 : 8 : return udp_lib_get_port(sk, snum, ipv6_rcv_saddr_equal, hash2_nulladdr);
135 : : }
136 : :
137 : 0 : static void udp_v6_rehash(struct sock *sk)
138 : : {
139 : 11 : u16 new_hash = udp6_portaddr_hash(sock_net(sk),
140 : 11 : &sk->sk_v6_rcv_saddr,
141 : 11 : inet_sk(sk)->inet_num);
142 : :
143 : 11 : udp_lib_rehash(sk, new_hash);
144 : 11 : }
145 : :
146 : : static inline int compute_score(struct sock *sk, struct net *net,
147 : : unsigned short hnum,
148 : : const struct in6_addr *saddr, __be16 sport,
149 : : const struct in6_addr *daddr, __be16 dport,
150 : : int dif)
151 : : {
152 : : int score = -1;
153 : :
154 [ # # ][ # # ]: 0 : if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
[ # # ][ # # ]
155 : 0 : sk->sk_family == PF_INET6) {
156 : : struct inet_sock *inet = inet_sk(sk);
157 : :
158 : : score = 0;
159 [ # # ][ # # ]: 0 : if (inet->inet_dport) {
160 [ # # ][ # # ]: 0 : if (inet->inet_dport != sport)
161 : : return -1;
162 : : score++;
163 : : }
164 [ # # ][ # # ]: 0 : if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
165 [ # # ][ # # ]: 0 : if (!ipv6_addr_equal(&sk->sk_v6_rcv_saddr, daddr))
166 : : return -1;
167 : 0 : score++;
168 : : }
169 [ # # ][ # # ]: 0 : if (!ipv6_addr_any(&sk->sk_v6_daddr)) {
170 [ # # ][ # # ]: 0 : if (!ipv6_addr_equal(&sk->sk_v6_daddr, saddr))
171 : : return -1;
172 : 0 : score++;
173 : : }
174 [ # # ][ # # ]: 0 : if (sk->sk_bound_dev_if) {
175 [ # # ][ # # ]: 0 : if (sk->sk_bound_dev_if != dif)
176 : : return -1;
177 : 0 : score++;
178 : : }
179 : : }
180 : : return score;
181 : : }
182 : :
183 : : #define SCORE2_MAX (1 + 1 + 1)
184 : : static inline int compute_score2(struct sock *sk, struct net *net,
185 : : const struct in6_addr *saddr, __be16 sport,
186 : : const struct in6_addr *daddr, unsigned short hnum,
187 : : int dif)
188 : : {
189 : : int score = -1;
190 : :
191 [ # # ][ # # ]: 0 : if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
[ # # ][ # # ]
192 : 0 : sk->sk_family == PF_INET6) {
193 : : struct inet_sock *inet = inet_sk(sk);
194 : :
195 [ # # ][ # # ]: 0 : if (!ipv6_addr_equal(&sk->sk_v6_rcv_saddr, daddr))
196 : : return -1;
197 : : score = 0;
198 [ # # ][ # # ]: 0 : if (inet->inet_dport) {
199 [ # # ][ # # ]: 0 : if (inet->inet_dport != sport)
200 : : return -1;
201 : : score++;
202 : : }
203 [ # # ][ # # ]: 0 : if (!ipv6_addr_any(&sk->sk_v6_daddr)) {
204 [ # # ][ # # ]: 0 : if (!ipv6_addr_equal(&sk->sk_v6_daddr, saddr))
205 : : return -1;
206 : 0 : score++;
207 : : }
208 [ # # ][ # # ]: 0 : if (sk->sk_bound_dev_if) {
209 [ # # ][ # # ]: 0 : if (sk->sk_bound_dev_if != dif)
210 : : return -1;
211 : 0 : score++;
212 : : }
213 : : }
214 : : return score;
215 : : }
216 : :
217 : :
218 : : /* called with read_rcu_lock() */
219 : 0 : static struct sock *udp6_lib_lookup2(struct net *net,
220 : : const struct in6_addr *saddr, __be16 sport,
221 : : const struct in6_addr *daddr, unsigned int hnum, int dif,
222 : : struct udp_hslot *hslot2, unsigned int slot2)
223 : : {
224 : : struct sock *sk, *result;
225 : : struct hlist_nulls_node *node;
226 : : int score, badness, matches = 0, reuseport = 0;
227 : : u32 hash = 0;
228 : :
229 : : begin:
230 : : result = NULL;
231 : : badness = -1;
232 [ # # ]: 0 : udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
233 : 0 : score = compute_score2(sk, net, saddr, sport,
234 : : daddr, hnum, dif);
235 [ # # ]: 0 : if (score > badness) {
236 : : result = sk;
237 : : badness = score;
238 : 0 : reuseport = sk->sk_reuseport;
239 [ # # ]: 0 : if (reuseport) {
240 : 0 : hash = udp6_ehashfn(net, daddr, hnum,
241 : : saddr, sport);
242 : : matches = 1;
243 [ # # ]: 0 : } else if (score == SCORE2_MAX)
244 : : goto exact_match;
245 [ # # ]: 0 : } else if (score == badness && reuseport) {
246 : 0 : matches++;
247 [ # # ]: 0 : if (((u64)hash * matches) >> 32 == 0)
248 : : result = sk;
249 : : hash = next_pseudo_random32(hash);
250 : : }
251 : : }
252 : : /*
253 : : * if the nulls value we got at the end of this lookup is
254 : : * not the expected one, we must restart lookup.
255 : : * We probably met an item that was moved to another chain.
256 : : */
257 [ # # ]: 0 : if (get_nulls_value(node) != slot2)
258 : : goto begin;
259 : :
260 [ # # ]: 0 : if (result) {
261 : : exact_match:
262 [ # # ]: 0 : if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
263 : : result = NULL;
264 [ # # ]: 0 : else if (unlikely(compute_score2(result, net, saddr, sport,
265 : : daddr, hnum, dif) < badness)) {
266 : : sock_put(result);
267 : : goto begin;
268 : : }
269 : : }
270 : 0 : return result;
271 : : }
272 : :
273 : 0 : struct sock *__udp6_lib_lookup(struct net *net,
274 : : const struct in6_addr *saddr, __be16 sport,
275 : : const struct in6_addr *daddr, __be16 dport,
276 : : int dif, struct udp_table *udptable)
277 : : {
278 : : struct sock *sk, *result;
279 : : struct hlist_nulls_node *node;
280 [ # # ]: 0 : unsigned short hnum = ntohs(dport);
281 : 0 : unsigned int hash2, slot2, slot = udp_hashfn(net, hnum, udptable->mask);
282 : 0 : struct udp_hslot *hslot2, *hslot = &udptable->hash[slot];
283 : : int score, badness, matches = 0, reuseport = 0;
284 : : u32 hash = 0;
285 : :
286 : : rcu_read_lock();
287 [ # # ]: 0 : if (hslot->count > 10) {
288 : 0 : hash2 = udp6_portaddr_hash(net, daddr, hnum);
289 : 0 : slot2 = hash2 & udptable->mask;
290 : 0 : hslot2 = &udptable->hash2[slot2];
291 [ # # ]: 0 : if (hslot->count < hslot2->count)
292 : : goto begin;
293 : :
294 : 0 : result = udp6_lib_lookup2(net, saddr, sport,
295 : : daddr, hnum, dif,
296 : : hslot2, slot2);
297 [ # # ]: 0 : if (!result) {
298 : 0 : hash2 = udp6_portaddr_hash(net, &in6addr_any, hnum);
299 : 0 : slot2 = hash2 & udptable->mask;
300 : 0 : hslot2 = &udptable->hash2[slot2];
301 [ # # ]: 0 : if (hslot->count < hslot2->count)
302 : : goto begin;
303 : :
304 : 0 : result = udp6_lib_lookup2(net, saddr, sport,
305 : : &in6addr_any, hnum, dif,
306 : : hslot2, slot2);
307 : : }
308 : : rcu_read_unlock();
309 : 0 : return result;
310 : : }
311 : : begin:
312 : : result = NULL;
313 : : badness = -1;
314 [ # # ]: 0 : sk_nulls_for_each_rcu(sk, node, &hslot->head) {
315 : : score = compute_score(sk, net, hnum, saddr, sport, daddr, dport, dif);
316 [ # # ]: 0 : if (score > badness) {
317 : : result = sk;
318 : : badness = score;
319 : 0 : reuseport = sk->sk_reuseport;
320 [ # # ]: 0 : if (reuseport) {
321 : 0 : hash = udp6_ehashfn(net, daddr, hnum,
322 : : saddr, sport);
323 : : matches = 1;
324 : : }
325 [ # # ]: 0 : } else if (score == badness && reuseport) {
326 : 0 : matches++;
327 [ # # ]: 0 : if (((u64)hash * matches) >> 32 == 0)
328 : : result = sk;
329 : : hash = next_pseudo_random32(hash);
330 : : }
331 : : }
332 : : /*
333 : : * if the nulls value we got at the end of this lookup is
334 : : * not the expected one, we must restart lookup.
335 : : * We probably met an item that was moved to another chain.
336 : : */
337 [ # # ]: 0 : if (get_nulls_value(node) != slot)
338 : : goto begin;
339 : :
340 [ # # ]: 0 : if (result) {
341 [ # # ]: 0 : if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
342 : : result = NULL;
343 [ # # ]: 0 : else if (unlikely(compute_score(result, net, hnum, saddr, sport,
344 : : daddr, dport, dif) < badness)) {
345 : : sock_put(result);
346 : : goto begin;
347 : : }
348 : : }
349 : : rcu_read_unlock();
350 : 0 : return result;
351 : : }
352 : : EXPORT_SYMBOL_GPL(__udp6_lib_lookup);
353 : :
354 : 0 : static struct sock *__udp6_lib_lookup_skb(struct sk_buff *skb,
355 : : __be16 sport, __be16 dport,
356 : : struct udp_table *udptable)
357 : : {
358 : : struct sock *sk;
359 : : const struct ipv6hdr *iph = ipv6_hdr(skb);
360 : :
361 [ # # ]: 0 : if (unlikely(sk = skb_steal_sock(skb)))
362 : : return sk;
363 : 0 : return __udp6_lib_lookup(dev_net(skb_dst(skb)->dev), &iph->saddr, sport,
364 : : &iph->daddr, dport, inet6_iif(skb),
365 : : udptable);
366 : : }
367 : :
368 : 0 : struct sock *udp6_lib_lookup(struct net *net, const struct in6_addr *saddr, __be16 sport,
369 : : const struct in6_addr *daddr, __be16 dport, int dif)
370 : : {
371 : 0 : return __udp6_lib_lookup(net, saddr, sport, daddr, dport, dif, &udp_table);
372 : : }
373 : : EXPORT_SYMBOL_GPL(udp6_lib_lookup);
374 : :
375 : :
376 : : /*
377 : : * This should be easy, if there is something there we
378 : : * return it, otherwise we block.
379 : : */
380 : :
381 : 0 : int udpv6_recvmsg(struct kiocb *iocb, struct sock *sk,
382 : : struct msghdr *msg, size_t len,
383 : : int noblock, int flags, int *addr_len)
384 : : {
385 : : struct ipv6_pinfo *np = inet6_sk(sk);
386 : : struct inet_sock *inet = inet_sk(sk);
387 : : struct sk_buff *skb;
388 : : unsigned int ulen, copied;
389 : 0 : int peeked, off = 0;
390 : : int err;
391 : 0 : int is_udplite = IS_UDPLITE(sk);
392 : : int is_udp4;
393 : : bool slow;
394 : :
395 [ # # ]: 0 : if (flags & MSG_ERRQUEUE)
396 : 0 : return ipv6_recv_error(sk, msg, len, addr_len);
397 : :
398 [ # # ][ # # ]: 0 : if (np->rxpmtu && np->rxopt.bits.rxpmtu)
399 : 0 : return ipv6_recv_rxpmtu(sk, msg, len, addr_len);
400 : :
401 : : try_again:
402 [ # # ]: 0 : skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
403 : : &peeked, &off, &err);
404 [ # # ]: 0 : if (!skb)
405 : : goto out;
406 : :
407 : 0 : ulen = skb->len - sizeof(struct udphdr);
408 : : copied = len;
409 [ # # ]: 0 : if (copied > ulen)
410 : : copied = ulen;
411 [ # # ]: 0 : else if (copied < ulen)
412 : 0 : msg->msg_flags |= MSG_TRUNC;
413 : :
414 : 0 : is_udp4 = (skb->protocol == htons(ETH_P_IP));
415 : :
416 : : /*
417 : : * If checksum is needed at all, try to do it while copying the
418 : : * data. If the data is truncated, or if we only want a partial
419 : : * coverage checksum (UDP-Lite), do it before the copy.
420 : : */
421 : :
422 [ # # ][ # # ]: 0 : if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) {
423 [ # # ]: 0 : if (udp_lib_checksum_complete(skb))
424 : : goto csum_copy_err;
425 : : }
426 : :
427 [ # # ]: 0 : if (skb_csum_unnecessary(skb))
428 : 0 : err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
429 : : msg->msg_iov, copied);
430 : : else {
431 : 0 : err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);
432 [ # # ]: 0 : if (err == -EINVAL)
433 : : goto csum_copy_err;
434 : : }
435 [ # # ]: 0 : if (unlikely(err)) {
436 : : trace_kfree_skb(skb, udpv6_recvmsg);
437 [ # # ]: 0 : if (!peeked) {
438 : 0 : atomic_inc(&sk->sk_drops);
439 [ # # ]: 0 : if (is_udp4)
440 [ # # ]: 0 : UDP_INC_STATS_USER(sock_net(sk),
441 : : UDP_MIB_INERRORS,
442 : : is_udplite);
443 : : else
444 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
445 : : UDP_MIB_INERRORS,
446 : : is_udplite);
447 : : }
448 : : goto out_free;
449 : : }
450 [ # # ]: 0 : if (!peeked) {
451 [ # # ]: 0 : if (is_udp4)
452 [ # # ]: 0 : UDP_INC_STATS_USER(sock_net(sk),
453 : : UDP_MIB_INDATAGRAMS, is_udplite);
454 : : else
455 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
456 : : UDP_MIB_INDATAGRAMS, is_udplite);
457 : : }
458 : :
459 : : sock_recv_ts_and_drops(msg, sk, skb);
460 : :
461 : : /* Copy the address. */
462 [ # # ]: 0 : if (msg->msg_name) {
463 : : struct sockaddr_in6 *sin6;
464 : :
465 : : sin6 = (struct sockaddr_in6 *) msg->msg_name;
466 : 0 : sin6->sin6_family = AF_INET6;
467 : 0 : sin6->sin6_port = udp_hdr(skb)->source;
468 : 0 : sin6->sin6_flowinfo = 0;
469 : :
470 [ # # ]: 0 : if (is_udp4) {
471 : 0 : ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
472 : : &sin6->sin6_addr);
473 : 0 : sin6->sin6_scope_id = 0;
474 : : } else {
475 : 0 : sin6->sin6_addr = ipv6_hdr(skb)->saddr;
476 : 0 : sin6->sin6_scope_id =
477 : 0 : ipv6_iface_scope_id(&sin6->sin6_addr,
478 : : IP6CB(skb)->iif);
479 : : }
480 : 0 : *addr_len = sizeof(*sin6);
481 : : }
482 [ # # ]: 0 : if (is_udp4) {
483 [ # # ]: 0 : if (inet->cmsg_flags)
484 : 0 : ip_cmsg_recv(msg, skb);
485 : : } else {
486 [ # # ]: 0 : if (np->rxopt.all)
487 : 0 : ip6_datagram_recv_ctl(sk, msg, skb);
488 : : }
489 : :
490 : 0 : err = copied;
491 [ # # ]: 0 : if (flags & MSG_TRUNC)
492 : 0 : err = ulen;
493 : :
494 : : out_free:
495 : 0 : skb_free_datagram_locked(sk, skb);
496 : : out:
497 : 0 : return err;
498 : :
499 : : csum_copy_err:
500 : 0 : slow = lock_sock_fast(sk);
501 [ # # ]: 0 : if (!skb_kill_datagram(sk, skb, flags)) {
502 [ # # ]: 0 : if (is_udp4) {
503 [ # # ]: 0 : UDP_INC_STATS_USER(sock_net(sk),
504 : : UDP_MIB_CSUMERRORS, is_udplite);
505 [ # # ]: 0 : UDP_INC_STATS_USER(sock_net(sk),
506 : : UDP_MIB_INERRORS, is_udplite);
507 : : } else {
508 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
509 : : UDP_MIB_CSUMERRORS, is_udplite);
510 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
511 : : UDP_MIB_INERRORS, is_udplite);
512 : : }
513 : : }
514 : : unlock_sock_fast(sk, slow);
515 : :
516 [ # # ]: 0 : if (noblock)
517 : : return -EAGAIN;
518 : :
519 : : /* starting over for a new packet */
520 : 0 : msg->msg_flags &= ~MSG_TRUNC;
521 : 0 : goto try_again;
522 : : }
523 : :
524 : 0 : void __udp6_lib_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
525 : : u8 type, u8 code, int offset, __be32 info,
526 : : struct udp_table *udptable)
527 : : {
528 : : struct ipv6_pinfo *np;
529 : 0 : const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
530 : 0 : const struct in6_addr *saddr = &hdr->saddr;
531 : 0 : const struct in6_addr *daddr = &hdr->daddr;
532 : 0 : struct udphdr *uh = (struct udphdr*)(skb->data+offset);
533 : : struct sock *sk;
534 : : int err;
535 : :
536 : 0 : sk = __udp6_lib_lookup(dev_net(skb->dev), daddr, uh->dest,
537 : : saddr, uh->source, inet6_iif(skb), udptable);
538 [ # # ]: 0 : if (sk == NULL)
539 : 0 : return;
540 : :
541 [ # # ]: 0 : if (type == ICMPV6_PKT_TOOBIG)
542 : 0 : ip6_sk_update_pmtu(skb, sk, info);
543 [ # # ]: 0 : if (type == NDISC_REDIRECT) {
544 : 0 : ip6_sk_redirect(skb, sk);
545 : 0 : goto out;
546 : : }
547 : :
548 : : np = inet6_sk(sk);
549 : :
550 [ # # ][ # # ]: 0 : if (!icmpv6_err_convert(type, code, &err) && !np->recverr)
551 : : goto out;
552 : :
553 [ # # ][ # # ]: 0 : if (sk->sk_state != TCP_ESTABLISHED && !np->recverr)
554 : : goto out;
555 : :
556 [ # # ]: 0 : if (np->recverr)
557 [ # # ]: 0 : ipv6_icmp_error(sk, skb, err, uh->dest, ntohl(info), (u8 *)(uh+1));
558 : :
559 : 0 : sk->sk_err = err;
560 : 0 : sk->sk_error_report(sk);
561 : : out:
562 : : sock_put(sk);
563 : : }
564 : :
565 : 0 : static int __udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
566 : : {
567 : : int rc;
568 : :
569 [ # # ]: 0 : if (!ipv6_addr_any(&sk->sk_v6_daddr)) {
570 : : sock_rps_save_rxhash(sk, skb);
571 : : sk_mark_napi_id(sk, skb);
572 : : }
573 : :
574 : 0 : rc = sock_queue_rcv_skb(sk, skb);
575 [ # # ]: 0 : if (rc < 0) {
576 : 0 : int is_udplite = IS_UDPLITE(sk);
577 : :
578 : : /* Note that an ENOMEM error is charged twice */
579 [ # # ]: 0 : if (rc == -ENOMEM)
580 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk),
581 : : UDP_MIB_RCVBUFERRORS, is_udplite);
582 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
583 : 0 : kfree_skb(skb);
584 : 0 : return -1;
585 : : }
586 : : return 0;
587 : : }
588 : :
589 : 0 : static __inline__ void udpv6_err(struct sk_buff *skb,
590 : : struct inet6_skb_parm *opt, u8 type,
591 : : u8 code, int offset, __be32 info )
592 : : {
593 : 0 : __udp6_lib_err(skb, opt, type, code, offset, info, &udp_table);
594 : 0 : }
595 : :
596 : : static struct static_key udpv6_encap_needed __read_mostly;
597 : 0 : void udpv6_encap_enable(void)
598 : : {
599 [ # # ]: 0 : if (!static_key_enabled(&udpv6_encap_needed))
600 : : static_key_slow_inc(&udpv6_encap_needed);
601 : 0 : }
602 : : EXPORT_SYMBOL(udpv6_encap_enable);
603 : :
604 : 0 : int udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
605 : : {
606 : : struct udp_sock *up = udp_sk(sk);
607 : : int rc;
608 : 0 : int is_udplite = IS_UDPLITE(sk);
609 : :
610 [ # # ]: 0 : if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
611 : : goto drop;
612 : :
613 [ # # ][ # # ]: 0 : if (static_key_false(&udpv6_encap_needed) && up->encap_type) {
614 : : int (*encap_rcv)(struct sock *sk, struct sk_buff *skb);
615 : :
616 : : /*
617 : : * This is an encapsulation socket so pass the skb to
618 : : * the socket's udp_encap_rcv() hook. Otherwise, just
619 : : * fall through and pass this up the UDP socket.
620 : : * up->encap_rcv() returns the following value:
621 : : * =0 if skb was successfully passed to the encap
622 : : * handler or was discarded by it.
623 : : * >0 if skb should be passed on to UDP.
624 : : * <0 if skb should be resubmitted as proto -N
625 : : */
626 : :
627 : : /* if we're overly short, let UDP handle it */
628 : 0 : encap_rcv = ACCESS_ONCE(up->encap_rcv);
629 [ # # ][ # # ]: 0 : if (skb->len > sizeof(struct udphdr) && encap_rcv != NULL) {
630 : : int ret;
631 : :
632 : 0 : ret = encap_rcv(sk, skb);
633 [ # # ]: 0 : if (ret <= 0) {
634 [ # # ]: 0 : UDP_INC_STATS_BH(sock_net(sk),
635 : : UDP_MIB_INDATAGRAMS,
636 : : is_udplite);
637 : 0 : return -ret;
638 : : }
639 : : }
640 : :
641 : : /* FALLTHROUGH -- it's a UDP Packet */
642 : : }
643 : :
644 : : /*
645 : : * UDP-Lite specific tests, ignored on UDP sockets (see net/ipv4/udp.c).
646 : : */
647 [ # # ][ # # ]: 0 : if ((is_udplite & UDPLITE_RECV_CC) && UDP_SKB_CB(skb)->partial_cov) {
648 : :
649 [ # # ]: 0 : if (up->pcrlen == 0) { /* full coverage was set */
650 [ # # ][ # # ]: 0 : LIMIT_NETDEBUG(KERN_WARNING "UDPLITE6: partial coverage"
651 : : " %d while full coverage %d requested\n",
652 : : UDP_SKB_CB(skb)->cscov, skb->len);
653 : : goto drop;
654 : : }
655 [ # # ]: 0 : if (UDP_SKB_CB(skb)->cscov < up->pcrlen) {
656 [ # # ][ # # ]: 0 : LIMIT_NETDEBUG(KERN_WARNING "UDPLITE6: coverage %d "
657 : : "too small, need min %d\n",
658 : : UDP_SKB_CB(skb)->cscov, up->pcrlen);
659 : : goto drop;
660 : : }
661 : : }
662 : :
663 [ # # ]: 0 : if (rcu_access_pointer(sk->sk_filter)) {
664 [ # # ]: 0 : if (udp_lib_checksum_complete(skb))
665 : : goto csum_error;
666 : : }
667 : :
668 [ # # ]: 0 : if (sk_rcvqueues_full(sk, skb, sk->sk_rcvbuf))
669 : : goto drop;
670 : :
671 : : skb_dst_drop(skb);
672 : :
673 : : bh_lock_sock(sk);
674 : : rc = 0;
675 [ # # ]: 0 : if (!sock_owned_by_user(sk))
676 : 0 : rc = __udpv6_queue_rcv_skb(sk, skb);
677 [ # # ]: 0 : else if (sk_add_backlog(sk, skb, sk->sk_rcvbuf)) {
678 : : bh_unlock_sock(sk);
679 : : goto drop;
680 : : }
681 : : bh_unlock_sock(sk);
682 : :
683 : 0 : return rc;
684 : : csum_error:
685 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
686 : : drop:
687 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
688 : 0 : atomic_inc(&sk->sk_drops);
689 : 0 : kfree_skb(skb);
690 : 0 : return -1;
691 : : }
692 : :
693 : 0 : static struct sock *udp_v6_mcast_next(struct net *net, struct sock *sk,
694 : : __be16 loc_port, const struct in6_addr *loc_addr,
695 : : __be16 rmt_port, const struct in6_addr *rmt_addr,
696 : : int dif)
697 : : {
698 : : struct hlist_nulls_node *node;
699 : : struct sock *s = sk;
700 [ # # ]: 0 : unsigned short num = ntohs(loc_port);
701 : :
702 [ # # ][ # # ]: 0 : sk_nulls_for_each_from(s, node) {
703 : : struct inet_sock *inet = inet_sk(s);
704 : :
705 : : if (!net_eq(sock_net(s), net))
706 : : continue;
707 : :
708 [ # # ][ # # ]: 0 : if (udp_sk(s)->udp_port_hash == num &&
709 : 0 : s->sk_family == PF_INET6) {
710 [ # # ]: 0 : if (inet->inet_dport) {
711 [ # # ]: 0 : if (inet->inet_dport != rmt_port)
712 : 0 : continue;
713 : : }
714 [ # # ][ # # ]: 0 : if (!ipv6_addr_any(&sk->sk_v6_daddr) &&
715 : : !ipv6_addr_equal(&sk->sk_v6_daddr, rmt_addr))
716 : 0 : continue;
717 : :
718 [ # # ][ # # ]: 0 : if (s->sk_bound_dev_if && s->sk_bound_dev_if != dif)
719 : 0 : continue;
720 : :
721 [ # # ]: 0 : if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
722 [ # # ]: 0 : if (!ipv6_addr_equal(&sk->sk_v6_rcv_saddr, loc_addr))
723 : 0 : continue;
724 : : }
725 [ # # ]: 0 : if (!inet6_mc_check(s, loc_addr, rmt_addr))
726 : 0 : continue;
727 : : return s;
728 : : }
729 : : }
730 : : return NULL;
731 : : }
732 : :
733 : 0 : static void flush_stack(struct sock **stack, unsigned int count,
734 : : struct sk_buff *skb, unsigned int final)
735 : : {
736 : : struct sk_buff *skb1 = NULL;
737 : : struct sock *sk;
738 : : unsigned int i;
739 : :
740 [ # # ]: 0 : for (i = 0; i < count; i++) {
741 : 0 : sk = stack[i];
742 [ # # ]: 0 : if (likely(skb1 == NULL))
743 [ # # ]: 0 : skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);
744 [ # # ]: 0 : if (!skb1) {
745 : 0 : atomic_inc(&sk->sk_drops);
746 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
747 : : IS_UDPLITE(sk));
748 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS,
749 : : IS_UDPLITE(sk));
750 : : }
751 : :
752 [ # # ][ # # ]: 0 : if (skb1 && udpv6_queue_rcv_skb(sk, skb1) <= 0)
753 : : skb1 = NULL;
754 : : }
755 [ # # ]: 0 : if (unlikely(skb1))
756 : 0 : kfree_skb(skb1);
757 : 0 : }
758 : : /*
759 : : * Note: called only from the BH handler context,
760 : : * so we don't need to lock the hashes.
761 : : */
762 : 0 : static int __udp6_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
763 : : const struct in6_addr *saddr, const struct in6_addr *daddr,
764 : 0 : struct udp_table *udptable)
765 : : {
766 : : struct sock *sk, *stack[256 / sizeof(struct sock *)];
767 : : const struct udphdr *uh = udp_hdr(skb);
768 [ # # ]: 0 : struct udp_hslot *hslot = udp_hashslot(udptable, net, ntohs(uh->dest));
769 : : int dif;
770 : : unsigned int i, count = 0;
771 : :
772 : : spin_lock(&hslot->lock);
773 : : sk = sk_nulls_head(&hslot->head);
774 : : dif = inet6_iif(skb);
775 : 0 : sk = udp_v6_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
776 [ # # ]: 0 : while (sk) {
777 : 0 : stack[count++] = sk;
778 : 0 : sk = udp_v6_mcast_next(net, sk_nulls_next(sk), uh->dest, daddr,
779 : : uh->source, saddr, dif);
780 [ # # ]: 0 : if (unlikely(count == ARRAY_SIZE(stack))) {
781 [ # # ]: 0 : if (!sk)
782 : : break;
783 : 0 : flush_stack(stack, count, skb, ~0);
784 : : count = 0;
785 : : }
786 : : }
787 : : /*
788 : : * before releasing the lock, we must take reference on sockets
789 : : */
790 [ # # ]: 0 : for (i = 0; i < count; i++)
791 : 0 : sock_hold(stack[i]);
792 : :
793 : : spin_unlock(&hslot->lock);
794 : :
795 [ # # ]: 0 : if (count) {
796 : 0 : flush_stack(stack, count, skb, count - 1);
797 : :
798 [ # # ]: 0 : for (i = 0; i < count; i++)
799 : 0 : sock_put(stack[i]);
800 : : } else {
801 : 0 : kfree_skb(skb);
802 : : }
803 : 0 : return 0;
804 : : }
805 : :
806 : 0 : int __udp6_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
807 : : int proto)
808 : : {
809 : : struct net *net = dev_net(skb->dev);
810 : : struct sock *sk;
811 : : struct udphdr *uh;
812 : 0 : const struct in6_addr *saddr, *daddr;
813 : : u32 ulen = 0;
814 : :
815 [ # # ]: 0 : if (!pskb_may_pull(skb, sizeof(struct udphdr)))
816 : : goto discard;
817 : :
818 : 0 : saddr = &ipv6_hdr(skb)->saddr;
819 : 0 : daddr = &ipv6_hdr(skb)->daddr;
820 : : uh = udp_hdr(skb);
821 : :
822 [ # # ]: 0 : ulen = ntohs(uh->len);
823 [ # # ]: 0 : if (ulen > skb->len)
824 : : goto short_packet;
825 : :
826 [ # # ]: 0 : if (proto == IPPROTO_UDP) {
827 : : /* UDP validates ulen. */
828 : :
829 : : /* Check for jumbo payload */
830 [ # # ]: 0 : if (ulen == 0)
831 : : ulen = skb->len;
832 : :
833 [ # # ]: 0 : if (ulen < sizeof(*uh))
834 : : goto short_packet;
835 : :
836 [ # # ]: 0 : if (ulen < skb->len) {
837 [ # # ]: 0 : if (pskb_trim_rcsum(skb, ulen))
838 : : goto short_packet;
839 : 0 : saddr = &ipv6_hdr(skb)->saddr;
840 : 0 : daddr = &ipv6_hdr(skb)->daddr;
841 : : uh = udp_hdr(skb);
842 : : }
843 : : }
844 : :
845 [ # # ]: 0 : if (udp6_csum_init(skb, uh, proto))
846 : : goto csum_error;
847 : :
848 : : /*
849 : : * Multicast receive code
850 : : */
851 [ # # ]: 0 : if (ipv6_addr_is_multicast(daddr))
852 : 0 : return __udp6_lib_mcast_deliver(net, skb,
853 : : saddr, daddr, udptable);
854 : :
855 : : /* Unicast */
856 : :
857 : : /*
858 : : * check socket cache ... must talk to Alan about his plans
859 : : * for sock caches... i'll skip this for now.
860 : : */
861 : 0 : sk = __udp6_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
862 [ # # ]: 0 : if (sk != NULL) {
863 : : int ret;
864 : :
865 : 0 : ret = udpv6_queue_rcv_skb(sk, skb);
866 : : sock_put(sk);
867 : :
868 : : /* a return value > 0 means to resubmit the input, but
869 : : * it wants the return to be -protocol, or 0
870 : : */
871 [ # # ]: 0 : if (ret > 0)
872 : 0 : return -ret;
873 : :
874 : : return 0;
875 : : }
876 : :
877 [ # # ]: 0 : if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
878 : : goto discard;
879 : :
880 [ # # ]: 0 : if (udp_lib_checksum_complete(skb))
881 : : goto csum_error;
882 : :
883 [ # # ]: 0 : UDP6_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
884 : 0 : icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
885 : :
886 : 0 : kfree_skb(skb);
887 : 0 : return 0;
888 : :
889 : : short_packet:
890 [ # # ][ # # ]: 0 : LIMIT_NETDEBUG(KERN_DEBUG "UDP%sv6: short packet: From [%pI6c]:%u %d/%d to [%pI6c]:%u\n",
[ # # ][ # # ]
[ # # ]
891 : : proto == IPPROTO_UDPLITE ? "-Lite" : "",
892 : : saddr,
893 : : ntohs(uh->source),
894 : : ulen,
895 : : skb->len,
896 : : daddr,
897 : : ntohs(uh->dest));
898 : : goto discard;
899 : : csum_error:
900 [ # # ]: 0 : UDP6_INC_STATS_BH(net, UDP_MIB_CSUMERRORS, proto == IPPROTO_UDPLITE);
901 : : discard:
902 [ # # ]: 0 : UDP6_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
903 : 0 : kfree_skb(skb);
904 : 0 : return 0;
905 : : }
906 : :
907 : 0 : static __inline__ int udpv6_rcv(struct sk_buff *skb)
908 : : {
909 : 0 : return __udp6_lib_rcv(skb, &udp_table, IPPROTO_UDP);
910 : : }
911 : :
912 : : /*
913 : : * Throw away all pending data and cancel the corking. Socket is locked.
914 : : */
915 : 0 : static void udp_v6_flush_pending_frames(struct sock *sk)
916 : : {
917 : : struct udp_sock *up = udp_sk(sk);
918 : :
919 [ - + ]: 5 : if (up->pending == AF_INET)
920 : 0 : udp_flush_pending_frames(sk);
921 [ - + ]: 5 : else if (up->pending) {
922 : 0 : up->len = 0;
923 : 0 : up->pending = 0;
924 : 0 : ip6_flush_pending_frames(sk);
925 : : }
926 : 0 : }
927 : :
928 : : /**
929 : : * udp6_hwcsum_outgoing - handle outgoing HW checksumming
930 : : * @sk: socket we are sending on
931 : : * @skb: sk_buff containing the filled-in UDP header
932 : : * (checksum field must be zeroed out)
933 : : */
934 : 0 : static void udp6_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,
935 : : const struct in6_addr *saddr,
936 : : const struct in6_addr *daddr, int len)
937 : : {
938 : : unsigned int offset;
939 : : struct udphdr *uh = udp_hdr(skb);
940 : : __wsum csum = 0;
941 : :
942 [ # # ]: 0 : if (skb_queue_len(&sk->sk_write_queue) == 1) {
943 : : /* Only one fragment on the socket. */
944 : 0 : skb->csum_start = skb_transport_header(skb) - skb->head;
945 : 0 : skb->csum_offset = offsetof(struct udphdr, check);
946 : 0 : uh->check = ~csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP, 0);
947 : : } else {
948 : : /*
949 : : * HW-checksum won't work as there are two or more
950 : : * fragments on the socket so that all csums of sk_buffs
951 : : * should be together
952 : : */
953 : 0 : offset = skb_transport_offset(skb);
954 : 0 : skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
955 : :
956 : 0 : skb->ip_summed = CHECKSUM_NONE;
957 : :
958 [ # # ]: 0 : skb_queue_walk(&sk->sk_write_queue, skb) {
959 : 0 : csum = csum_add(csum, skb->csum);
960 : : }
961 : :
962 : 0 : uh->check = csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP,
963 : : csum);
964 [ # # ]: 0 : if (uh->check == 0)
965 : 0 : uh->check = CSUM_MANGLED_0;
966 : : }
967 : 0 : }
968 : :
969 : : /*
970 : : * Sending
971 : : */
972 : :
973 : 0 : static int udp_v6_push_pending_frames(struct sock *sk)
974 : : {
975 : : struct sk_buff *skb;
976 : : struct udphdr *uh;
977 : : struct udp_sock *up = udp_sk(sk);
978 : : struct inet_sock *inet = inet_sk(sk);
979 : : struct flowi6 *fl6;
980 : : int err = 0;
981 : 0 : int is_udplite = IS_UDPLITE(sk);
982 : : __wsum csum = 0;
983 : :
984 [ # # ]: 0 : if (up->pending == AF_INET)
985 : 0 : return udp_push_pending_frames(sk);
986 : :
987 : : fl6 = &inet->cork.fl.u.ip6;
988 : :
989 : : /* Grab the skbuff where UDP header space exists. */
990 [ # # ]: 0 : if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
991 : : goto out;
992 : :
993 : : /*
994 : : * Create a UDP header
995 : : */
996 : : uh = udp_hdr(skb);
997 : 0 : uh->source = fl6->fl6_sport;
998 : 0 : uh->dest = fl6->fl6_dport;
999 [ # # ]: 0 : uh->len = htons(up->len);
1000 : 0 : uh->check = 0;
1001 : :
1002 [ # # ]: 0 : if (is_udplite)
1003 : : csum = udplite_csum_outgoing(sk, skb);
1004 [ # # ]: 0 : else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
1005 : 0 : udp6_hwcsum_outgoing(sk, skb, &fl6->saddr, &fl6->daddr,
1006 : 0 : up->len);
1007 : 0 : goto send;
1008 : : } else
1009 : : csum = udp_csum_outgoing(sk, skb);
1010 : :
1011 : : /* add protocol-dependent pseudo-header */
1012 : 0 : uh->check = csum_ipv6_magic(&fl6->saddr, &fl6->daddr,
1013 : 0 : up->len, fl6->flowi6_proto, csum);
1014 [ # # ]: 0 : if (uh->check == 0)
1015 : 0 : uh->check = CSUM_MANGLED_0;
1016 : :
1017 : : send:
1018 : 0 : err = ip6_push_pending_frames(sk);
1019 [ # # ]: 0 : if (err) {
1020 [ # # ][ # # ]: 0 : if (err == -ENOBUFS && !inet6_sk(sk)->recverr) {
1021 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
1022 : : UDP_MIB_SNDBUFERRORS, is_udplite);
1023 : : err = 0;
1024 : : }
1025 : : } else
1026 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
1027 : : UDP_MIB_OUTDATAGRAMS, is_udplite);
1028 : : out:
1029 : 0 : up->len = 0;
1030 : 0 : up->pending = 0;
1031 : 0 : return err;
1032 : : }
1033 : :
1034 : 0 : int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
1035 : : struct msghdr *msg, size_t len)
1036 : : {
1037 : : struct ipv6_txoptions opt_space;
1038 : : struct udp_sock *up = udp_sk(sk);
1039 : : struct inet_sock *inet = inet_sk(sk);
1040 : : struct ipv6_pinfo *np = inet6_sk(sk);
1041 : 0 : struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) msg->msg_name;
1042 : : struct in6_addr *daddr, *final_p, final;
1043 : : struct ipv6_txoptions *opt = NULL;
1044 : : struct ip6_flowlabel *flowlabel = NULL;
1045 : : struct flowi6 fl6;
1046 : : struct dst_entry *dst;
1047 : 0 : int addr_len = msg->msg_namelen;
1048 : 0 : int ulen = len;
1049 : 0 : int hlimit = -1;
1050 : 0 : int tclass = -1;
1051 : 0 : int dontfrag = -1;
1052 [ # # ][ # # ]: 0 : int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
1053 : : int err;
1054 : : int connected = 0;
1055 : 0 : int is_udplite = IS_UDPLITE(sk);
1056 : : int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
1057 : :
1058 : : /* destination address check */
1059 [ # # ]: 0 : if (sin6) {
1060 [ # # ]: 0 : if (addr_len < offsetof(struct sockaddr, sa_data))
1061 : : return -EINVAL;
1062 : :
1063 [ # # # # ]: 0 : switch (sin6->sin6_family) {
1064 : : case AF_INET6:
1065 [ # # ]: 0 : if (addr_len < SIN6_LEN_RFC2133)
1066 : : return -EINVAL;
1067 : 0 : daddr = &sin6->sin6_addr;
1068 : 0 : break;
1069 : : case AF_INET:
1070 : : goto do_udp_sendmsg;
1071 : : case AF_UNSPEC:
1072 : 0 : msg->msg_name = sin6 = NULL;
1073 : 0 : msg->msg_namelen = addr_len = 0;
1074 : : daddr = NULL;
1075 : 0 : break;
1076 : : default:
1077 : : return -EINVAL;
1078 : : }
1079 [ # # ]: 0 : } else if (!up->pending) {
1080 [ # # ]: 0 : if (sk->sk_state != TCP_ESTABLISHED)
1081 : : return -EDESTADDRREQ;
1082 : 0 : daddr = &sk->sk_v6_daddr;
1083 : : } else
1084 : : daddr = NULL;
1085 : :
1086 [ # # ]: 0 : if (daddr) {
1087 [ # # ]: 0 : if (ipv6_addr_v4mapped(daddr)) {
1088 : : struct sockaddr_in sin;
1089 : 0 : sin.sin_family = AF_INET;
1090 [ # # ]: 0 : sin.sin_port = sin6 ? sin6->sin6_port : inet->inet_dport;
1091 : 0 : sin.sin_addr.s_addr = daddr->s6_addr32[3];
1092 : 0 : msg->msg_name = &sin;
1093 : 0 : msg->msg_namelen = sizeof(sin);
1094 : : do_udp_sendmsg:
1095 [ # # ]: 0 : if (__ipv6_only_sock(sk))
1096 : : return -ENETUNREACH;
1097 : 0 : return udp_sendmsg(iocb, sk, msg, len);
1098 : : }
1099 : : }
1100 : :
1101 [ # # ]: 0 : if (up->pending == AF_INET)
1102 : 0 : return udp_sendmsg(iocb, sk, msg, len);
1103 : :
1104 : : /* Rough check on arithmetic overflow,
1105 : : better check is made in ip6_append_data().
1106 : : */
1107 [ # # ]: 0 : if (len > INT_MAX - sizeof(struct udphdr))
1108 : : return -EMSGSIZE;
1109 : :
1110 [ # # ]: 0 : if (up->pending) {
1111 : : /*
1112 : : * There are pending frames.
1113 : : * The socket lock must be held while it's corked.
1114 : : */
1115 : : lock_sock(sk);
1116 [ # # ]: 0 : if (likely(up->pending)) {
1117 [ # # ]: 0 : if (unlikely(up->pending != AF_INET6)) {
1118 : 0 : release_sock(sk);
1119 : 0 : return -EAFNOSUPPORT;
1120 : : }
1121 : : dst = NULL;
1122 : : goto do_append_data;
1123 : : }
1124 : 0 : release_sock(sk);
1125 : : }
1126 : 0 : ulen += sizeof(struct udphdr);
1127 : :
1128 : 0 : memset(&fl6, 0, sizeof(fl6));
1129 : :
1130 [ # # ]: 0 : if (sin6) {
1131 [ # # ]: 0 : if (sin6->sin6_port == 0)
1132 : : return -EINVAL;
1133 : :
1134 : 0 : fl6.fl6_dport = sin6->sin6_port;
1135 : 0 : daddr = &sin6->sin6_addr;
1136 : :
1137 [ # # ]: 0 : if (np->sndflow) {
1138 : 0 : fl6.flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
1139 [ # # ]: 0 : if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
1140 : 0 : flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
1141 [ # # ]: 0 : if (flowlabel == NULL)
1142 : : return -EINVAL;
1143 : : }
1144 : : }
1145 : :
1146 : : /*
1147 : : * Otherwise it will be difficult to maintain
1148 : : * sk->sk_dst_cache.
1149 : : */
1150 [ # # ][ # # ]: 0 : if (sk->sk_state == TCP_ESTABLISHED &&
1151 : : ipv6_addr_equal(daddr, &sk->sk_v6_daddr))
1152 : 0 : daddr = &sk->sk_v6_daddr;
1153 : :
1154 [ # # ][ # # ]: 0 : if (addr_len >= sizeof(struct sockaddr_in6) &&
1155 [ # # ]: 0 : sin6->sin6_scope_id &&
1156 : 0 : __ipv6_addr_needs_scope_id(__ipv6_addr_type(daddr)))
1157 : 0 : fl6.flowi6_oif = sin6->sin6_scope_id;
1158 : : } else {
1159 [ # # ]: 0 : if (sk->sk_state != TCP_ESTABLISHED)
1160 : : return -EDESTADDRREQ;
1161 : :
1162 : 0 : fl6.fl6_dport = inet->inet_dport;
1163 : 0 : daddr = &sk->sk_v6_daddr;
1164 : 0 : fl6.flowlabel = np->flow_label;
1165 : : connected = 1;
1166 : : }
1167 : :
1168 [ # # ]: 0 : if (!fl6.flowi6_oif)
1169 : 0 : fl6.flowi6_oif = sk->sk_bound_dev_if;
1170 : :
1171 [ # # ]: 0 : if (!fl6.flowi6_oif)
1172 : 0 : fl6.flowi6_oif = np->sticky_pktinfo.ipi6_ifindex;
1173 : :
1174 : 0 : fl6.flowi6_mark = sk->sk_mark;
1175 : :
1176 [ # # ]: 0 : if (msg->msg_controllen) {
1177 : : opt = &opt_space;
1178 : 0 : memset(opt, 0, sizeof(struct ipv6_txoptions));
1179 : 0 : opt->tot_len = sizeof(*opt);
1180 : :
1181 : 0 : err = ip6_datagram_send_ctl(sock_net(sk), sk, msg, &fl6, opt,
1182 : : &hlimit, &tclass, &dontfrag);
1183 [ # # ]: 0 : if (err < 0) {
1184 : : fl6_sock_release(flowlabel);
1185 : 0 : return err;
1186 : : }
1187 [ # # ][ # # ]: 0 : if ((fl6.flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) {
1188 : 0 : flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
1189 [ # # ]: 0 : if (flowlabel == NULL)
1190 : : return -EINVAL;
1191 : : }
1192 [ # # ]: 0 : if (!(opt->opt_nflen|opt->opt_flen))
1193 : : opt = NULL;
1194 : : connected = 0;
1195 : : }
1196 [ # # ]: 0 : if (opt == NULL)
1197 : 0 : opt = np->opt;
1198 [ # # ]: 0 : if (flowlabel)
1199 : 0 : opt = fl6_merge_options(&opt_space, flowlabel, opt);
1200 : 0 : opt = ipv6_fixup_options(&opt_space, opt);
1201 : :
1202 : 0 : fl6.flowi6_proto = sk->sk_protocol;
1203 [ # # ]: 0 : if (!ipv6_addr_any(daddr))
1204 : 0 : fl6.daddr = *daddr;
1205 : : else
1206 : 0 : fl6.daddr.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
1207 [ # # ][ # # ]: 0 : if (ipv6_addr_any(&fl6.saddr) && !ipv6_addr_any(&np->saddr))
1208 : 0 : fl6.saddr = np->saddr;
1209 : 0 : fl6.fl6_sport = inet->inet_sport;
1210 : :
1211 : 0 : final_p = fl6_update_dst(&fl6, opt, &final);
1212 [ # # ]: 0 : if (final_p)
1213 : : connected = 0;
1214 : :
1215 [ # # ][ # # ]: 0 : if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr)) {
1216 : 0 : fl6.flowi6_oif = np->mcast_oif;
1217 : 0 : connected = 0;
1218 [ # # ]: 0 : } else if (!fl6.flowi6_oif)
1219 : 0 : fl6.flowi6_oif = np->ucast_oif;
1220 : :
1221 : 0 : security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
1222 : :
1223 : 0 : dst = ip6_sk_dst_lookup_flow(sk, &fl6, final_p, true);
1224 [ # # ]: 0 : if (IS_ERR(dst)) {
1225 : : err = PTR_ERR(dst);
1226 : : dst = NULL;
1227 : 0 : goto out;
1228 : : }
1229 : :
1230 [ # # ]: 0 : if (hlimit < 0) {
1231 [ # # ]: 0 : if (ipv6_addr_is_multicast(&fl6.daddr))
1232 : 0 : hlimit = np->mcast_hops;
1233 : : else
1234 : 0 : hlimit = np->hop_limit;
1235 [ # # ]: 0 : if (hlimit < 0)
1236 : 0 : hlimit = ip6_dst_hoplimit(dst);
1237 : : }
1238 : :
1239 [ # # ]: 0 : if (tclass < 0)
1240 : 0 : tclass = np->tclass;
1241 : :
1242 [ # # ]: 0 : if (msg->msg_flags&MSG_CONFIRM)
1243 : : goto do_confirm;
1244 : : back_from_confirm:
1245 : :
1246 : : lock_sock(sk);
1247 [ # # ]: 0 : if (unlikely(up->pending)) {
1248 : : /* The socket is already corked while preparing it. */
1249 : : /* ... which is an evident application bug. --ANK */
1250 : 0 : release_sock(sk);
1251 : :
1252 [ # # ][ # # ]: 0 : LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
1253 : : err = -EINVAL;
1254 : : goto out;
1255 : : }
1256 : :
1257 : 0 : up->pending = AF_INET6;
1258 : :
1259 : : do_append_data:
1260 [ # # ]: 0 : if (dontfrag < 0)
1261 : 0 : dontfrag = np->dontfrag;
1262 : 0 : up->len += ulen;
1263 [ # # ]: 0 : getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag;
1264 [ # # ]: 0 : err = ip6_append_data(sk, getfrag, msg->msg_iov, ulen,
1265 : : sizeof(struct udphdr), hlimit, tclass, opt, &fl6,
1266 : : (struct rt6_info*)dst,
1267 : 0 : corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags, dontfrag);
1268 [ # # ]: 0 : if (err)
1269 : 0 : udp_v6_flush_pending_frames(sk);
1270 [ # # ]: 0 : else if (!corkreq)
1271 : 0 : err = udp_v6_push_pending_frames(sk);
1272 [ # # ]: 0 : else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
1273 : 0 : up->pending = 0;
1274 : :
1275 [ # # ]: 0 : if (dst) {
1276 [ # # ]: 0 : if (connected) {
1277 [ # # ]: 0 : ip6_dst_store(sk, dst,
1278 : : ipv6_addr_equal(&fl6.daddr, &sk->sk_v6_daddr) ?
1279 : : &sk->sk_v6_daddr : NULL,
1280 : : #ifdef CONFIG_IPV6_SUBTREES
1281 : : ipv6_addr_equal(&fl6.saddr, &np->saddr) ?
1282 : : &np->saddr :
1283 : : #endif
1284 : : NULL);
1285 : : } else {
1286 : 0 : dst_release(dst);
1287 : : }
1288 : : dst = NULL;
1289 : : }
1290 : :
1291 [ # # ]: 0 : if (err > 0)
1292 [ # # ][ # # ]: 0 : err = np->recverr ? net_xmit_errno(err) : 0;
1293 : 0 : release_sock(sk);
1294 : : out:
1295 : 0 : dst_release(dst);
1296 : : fl6_sock_release(flowlabel);
1297 [ # # ]: 0 : if (!err)
1298 : : return len;
1299 : : /*
1300 : : * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space. Reporting
1301 : : * ENOBUFS might not be good (it's not tunable per se), but otherwise
1302 : : * we don't have a good statistic (IpOutDiscards but it can be too many
1303 : : * things). We could add another new stat but at least for now that
1304 : : * seems like overkill.
1305 : : */
1306 [ # # ][ # # ]: 0 : if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
1307 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
1308 : : UDP_MIB_SNDBUFERRORS, is_udplite);
1309 : : }
1310 : 0 : return err;
1311 : :
1312 : : do_confirm:
1313 : : dst_confirm(dst);
1314 [ # # ][ # # ]: 0 : if (!(msg->msg_flags&MSG_PROBE) || len)
1315 : : goto back_from_confirm;
1316 : : err = 0;
1317 : : goto out;
1318 : : }
1319 : :
1320 : 0 : void udpv6_destroy_sock(struct sock *sk)
1321 : : {
1322 : : struct udp_sock *up = udp_sk(sk);
1323 : : lock_sock(sk);
1324 : 5 : udp_v6_flush_pending_frames(sk);
1325 : 5 : release_sock(sk);
1326 : :
1327 [ - + ][ # # ]: 5 : if (static_key_false(&udpv6_encap_needed) && up->encap_type) {
1328 : : void (*encap_destroy)(struct sock *sk);
1329 : 0 : encap_destroy = ACCESS_ONCE(up->encap_destroy);
1330 [ # # ]: 0 : if (encap_destroy)
1331 : 0 : encap_destroy(sk);
1332 : : }
1333 : :
1334 : 5 : inet6_destroy_sock(sk);
1335 : 5 : }
1336 : :
1337 : : /*
1338 : : * Socket option code for UDP
1339 : : */
1340 : 0 : int udpv6_setsockopt(struct sock *sk, int level, int optname,
1341 : : char __user *optval, unsigned int optlen)
1342 : : {
1343 [ # # ]: 0 : if (level == SOL_UDP || level == SOL_UDPLITE)
1344 : 0 : return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1345 : : udp_v6_push_pending_frames);
1346 : 0 : return ipv6_setsockopt(sk, level, optname, optval, optlen);
1347 : : }
1348 : :
1349 : : #ifdef CONFIG_COMPAT
1350 : : int compat_udpv6_setsockopt(struct sock *sk, int level, int optname,
1351 : : char __user *optval, unsigned int optlen)
1352 : : {
1353 : : if (level == SOL_UDP || level == SOL_UDPLITE)
1354 : : return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1355 : : udp_v6_push_pending_frames);
1356 : : return compat_ipv6_setsockopt(sk, level, optname, optval, optlen);
1357 : : }
1358 : : #endif
1359 : :
1360 : 0 : int udpv6_getsockopt(struct sock *sk, int level, int optname,
1361 : : char __user *optval, int __user *optlen)
1362 : : {
1363 [ # # ]: 0 : if (level == SOL_UDP || level == SOL_UDPLITE)
1364 : 0 : return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1365 : 0 : return ipv6_getsockopt(sk, level, optname, optval, optlen);
1366 : : }
1367 : :
1368 : : #ifdef CONFIG_COMPAT
1369 : : int compat_udpv6_getsockopt(struct sock *sk, int level, int optname,
1370 : : char __user *optval, int __user *optlen)
1371 : : {
1372 : : if (level == SOL_UDP || level == SOL_UDPLITE)
1373 : : return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1374 : : return compat_ipv6_getsockopt(sk, level, optname, optval, optlen);
1375 : : }
1376 : : #endif
1377 : :
1378 : : static const struct inet6_protocol udpv6_protocol = {
1379 : : .handler = udpv6_rcv,
1380 : : .err_handler = udpv6_err,
1381 : : .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1382 : : };
1383 : :
1384 : : /* ------------------------------------------------------------------------ */
1385 : : #ifdef CONFIG_PROC_FS
1386 : 0 : int udp6_seq_show(struct seq_file *seq, void *v)
1387 : : {
1388 [ + + ]: 3 : if (v == SEQ_START_TOKEN) {
1389 : 2 : seq_puts(seq, IPV6_SEQ_DGRAM_HEADER);
1390 : : } else {
1391 : 1 : int bucket = ((struct udp_iter_state *)seq->private)->bucket;
1392 : : struct inet_sock *inet = inet_sk(v);
1393 [ - + ]: 1 : __u16 srcp = ntohs(inet->inet_sport);
1394 [ - + ]: 1 : __u16 destp = ntohs(inet->inet_dport);
1395 : 1 : ip6_dgram_sock_seq_show(seq, v, srcp, destp, bucket);
1396 : : }
1397 : 3 : return 0;
1398 : : }
1399 : :
1400 : : static const struct file_operations udp6_afinfo_seq_fops = {
1401 : : .owner = THIS_MODULE,
1402 : : .open = udp_seq_open,
1403 : : .read = seq_read,
1404 : : .llseek = seq_lseek,
1405 : : .release = seq_release_net
1406 : : };
1407 : :
1408 : : static struct udp_seq_afinfo udp6_seq_afinfo = {
1409 : : .name = "udp6",
1410 : : .family = AF_INET6,
1411 : : .udp_table = &udp_table,
1412 : : .seq_fops = &udp6_afinfo_seq_fops,
1413 : : .seq_ops = {
1414 : : .show = udp6_seq_show,
1415 : : },
1416 : : };
1417 : :
1418 : 0 : int __net_init udp6_proc_init(struct net *net)
1419 : : {
1420 : 0 : return udp_proc_register(net, &udp6_seq_afinfo);
1421 : : }
1422 : :
1423 : 0 : void udp6_proc_exit(struct net *net) {
1424 : 0 : udp_proc_unregister(net, &udp6_seq_afinfo);
1425 : 0 : }
1426 : : #endif /* CONFIG_PROC_FS */
1427 : :
1428 : 0 : void udp_v6_clear_sk(struct sock *sk, int size)
1429 : : {
1430 : : struct inet_sock *inet = inet_sk(sk);
1431 : :
1432 : : /* we do not want to clear pinet6 field, because of RCU lookups */
1433 : 5 : sk_prot_clear_portaddr_nulls(sk, offsetof(struct inet_sock, pinet6));
1434 : :
1435 : 5 : size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1436 [ + - ]: 5 : memset(&inet->pinet6 + 1, 0, size);
1437 : 0 : }
1438 : :
1439 : : /* ------------------------------------------------------------------------ */
1440 : :
1441 : : struct proto udpv6_prot = {
1442 : : .name = "UDPv6",
1443 : : .owner = THIS_MODULE,
1444 : : .close = udp_lib_close,
1445 : : .connect = ip6_datagram_connect,
1446 : : .disconnect = udp_disconnect,
1447 : : .ioctl = udp_ioctl,
1448 : : .destroy = udpv6_destroy_sock,
1449 : : .setsockopt = udpv6_setsockopt,
1450 : : .getsockopt = udpv6_getsockopt,
1451 : : .sendmsg = udpv6_sendmsg,
1452 : : .recvmsg = udpv6_recvmsg,
1453 : : .backlog_rcv = __udpv6_queue_rcv_skb,
1454 : : .hash = udp_lib_hash,
1455 : : .unhash = udp_lib_unhash,
1456 : : .rehash = udp_v6_rehash,
1457 : : .get_port = udp_v6_get_port,
1458 : : .memory_allocated = &udp_memory_allocated,
1459 : : .sysctl_mem = sysctl_udp_mem,
1460 : : .sysctl_wmem = &sysctl_udp_wmem_min,
1461 : : .sysctl_rmem = &sysctl_udp_rmem_min,
1462 : : .obj_size = sizeof(struct udp6_sock),
1463 : : .slab_flags = SLAB_DESTROY_BY_RCU,
1464 : : .h.udp_table = &udp_table,
1465 : : #ifdef CONFIG_COMPAT
1466 : : .compat_setsockopt = compat_udpv6_setsockopt,
1467 : : .compat_getsockopt = compat_udpv6_getsockopt,
1468 : : #endif
1469 : : .clear_sk = udp_v6_clear_sk,
1470 : : };
1471 : :
1472 : : static struct inet_protosw udpv6_protosw = {
1473 : : .type = SOCK_DGRAM,
1474 : : .protocol = IPPROTO_UDP,
1475 : : .prot = &udpv6_prot,
1476 : : .ops = &inet6_dgram_ops,
1477 : : .no_check = UDP_CSUM_DEFAULT,
1478 : : .flags = INET_PROTOSW_PERMANENT,
1479 : : };
1480 : :
1481 : :
1482 : 0 : int __init udpv6_init(void)
1483 : : {
1484 : : int ret;
1485 : :
1486 : 0 : ret = inet6_add_protocol(&udpv6_protocol, IPPROTO_UDP);
1487 [ # # ]: 0 : if (ret)
1488 : : goto out;
1489 : :
1490 : 0 : ret = inet6_register_protosw(&udpv6_protosw);
1491 [ # # ]: 0 : if (ret)
1492 : : goto out_udpv6_protocol;
1493 : : out:
1494 : 0 : return ret;
1495 : :
1496 : : out_udpv6_protocol:
1497 : 0 : inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
1498 : 0 : goto out;
1499 : : }
1500 : :
1501 : 0 : void udpv6_exit(void)
1502 : : {
1503 : 0 : inet6_unregister_protosw(&udpv6_protosw);
1504 : 0 : inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
1505 : 0 : }
|
