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 [ # # ][ # # ]: 0 : int sk_ipv6only = ipv6_only_sock(sk);
83 : : int sk2_ipv6only = inet_v6_ipv6only(sk2);
84 : 0 : int addr_type = ipv6_addr_type(&sk->sk_v6_rcv_saddr);
85 [ # # ]: 0 : 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 [ # # ]: 0 : 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 [ # # ][ # # ]: 0 : if (addr_type2 == IPV6_ADDR_ANY &&
94 : 0 : !(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 : 0 : 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 [ # # ]: 0 : if (ipv6_addr_any(addr6))
115 : : hash = jhash_1word(0, mix);
116 [ # # ]: 0 : else if (ipv6_addr_v4mapped(addr6))
117 : : hash = jhash_1word((__force u32)addr6->s6_addr32[3], mix);
118 : : else
119 : 0 : 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 : 0 : unsigned int hash2_nulladdr =
128 : 0 : udp6_portaddr_hash(sock_net(sk), &in6addr_any, snum);
129 : 0 : unsigned int hash2_partial =
130 : 0 : udp6_portaddr_hash(sock_net(sk), &sk->sk_v6_rcv_saddr, 0);
131 : :
132 : : /* precompute partial secondary hash */
133 : 0 : udp_sk(sk)->udp_portaddr_hash = hash2_partial;
134 : 0 : 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 : 0 : u16 new_hash = udp6_portaddr_hash(sock_net(sk),
140 : 0 : &sk->sk_v6_rcv_saddr,
141 : 0 : inet_sk(sk)->inet_num);
142 : :
143 : 0 : udp_lib_rehash(sk, new_hash);
144 : 0 : }
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 : : DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name);
464 : 0 : sin6->sin6_family = AF_INET6;
465 : 0 : sin6->sin6_port = udp_hdr(skb)->source;
466 : 0 : sin6->sin6_flowinfo = 0;
467 : :
468 [ # # ]: 0 : if (is_udp4) {
469 : 0 : ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
470 : : &sin6->sin6_addr);
471 : 0 : sin6->sin6_scope_id = 0;
472 : : } else {
473 : 0 : sin6->sin6_addr = ipv6_hdr(skb)->saddr;
474 : 0 : sin6->sin6_scope_id =
475 : 0 : ipv6_iface_scope_id(&sin6->sin6_addr,
476 : : IP6CB(skb)->iif);
477 : : }
478 : 0 : *addr_len = sizeof(*sin6);
479 : : }
480 : :
481 [ # # ]: 0 : if (np->rxopt.all)
482 : 0 : ip6_datagram_recv_common_ctl(sk, msg, skb);
483 : :
484 [ # # ]: 0 : if (is_udp4) {
485 [ # # ]: 0 : if (inet->cmsg_flags)
486 : 0 : ip_cmsg_recv(msg, skb);
487 : : } else {
488 [ # # ]: 0 : if (np->rxopt.all)
489 : 0 : ip6_datagram_recv_specific_ctl(sk, msg, skb);
490 : : }
491 : :
492 : 0 : err = copied;
493 [ # # ]: 0 : if (flags & MSG_TRUNC)
494 : 0 : err = ulen;
495 : :
496 : : out_free:
497 : 0 : skb_free_datagram_locked(sk, skb);
498 : : out:
499 : 0 : return err;
500 : :
501 : : csum_copy_err:
502 : 0 : slow = lock_sock_fast(sk);
503 [ # # ]: 0 : if (!skb_kill_datagram(sk, skb, flags)) {
504 [ # # ]: 0 : if (is_udp4) {
505 [ # # ]: 0 : UDP_INC_STATS_USER(sock_net(sk),
506 : : UDP_MIB_CSUMERRORS, is_udplite);
507 [ # # ]: 0 : UDP_INC_STATS_USER(sock_net(sk),
508 : : UDP_MIB_INERRORS, is_udplite);
509 : : } else {
510 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
511 : : UDP_MIB_CSUMERRORS, is_udplite);
512 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
513 : : UDP_MIB_INERRORS, is_udplite);
514 : : }
515 : : }
516 : : unlock_sock_fast(sk, slow);
517 : :
518 [ # # ]: 0 : if (noblock)
519 : : return -EAGAIN;
520 : :
521 : : /* starting over for a new packet */
522 : 0 : msg->msg_flags &= ~MSG_TRUNC;
523 : 0 : goto try_again;
524 : : }
525 : :
526 : 0 : void __udp6_lib_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
527 : : u8 type, u8 code, int offset, __be32 info,
528 : : struct udp_table *udptable)
529 : : {
530 : : struct ipv6_pinfo *np;
531 : 0 : const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
532 : 0 : const struct in6_addr *saddr = &hdr->saddr;
533 : 0 : const struct in6_addr *daddr = &hdr->daddr;
534 : 0 : struct udphdr *uh = (struct udphdr*)(skb->data+offset);
535 : : struct sock *sk;
536 : : int err;
537 : :
538 : 0 : sk = __udp6_lib_lookup(dev_net(skb->dev), daddr, uh->dest,
539 : : saddr, uh->source, inet6_iif(skb), udptable);
540 [ # # ]: 0 : if (sk == NULL)
541 : 0 : return;
542 : :
543 [ # # ]: 0 : if (type == ICMPV6_PKT_TOOBIG) {
544 [ # # ]: 0 : if (!ip6_sk_accept_pmtu(sk))
545 : : goto out;
546 : 0 : ip6_sk_update_pmtu(skb, sk, info);
547 : : }
548 [ # # ]: 0 : if (type == NDISC_REDIRECT) {
549 : 0 : ip6_sk_redirect(skb, sk);
550 : 0 : goto out;
551 : : }
552 : :
553 : : np = inet6_sk(sk);
554 : :
555 [ # # ][ # # ]: 0 : if (!icmpv6_err_convert(type, code, &err) && !np->recverr)
556 : : goto out;
557 : :
558 [ # # ][ # # ]: 0 : if (sk->sk_state != TCP_ESTABLISHED && !np->recverr)
559 : : goto out;
560 : :
561 [ # # ]: 0 : if (np->recverr)
562 [ # # ]: 0 : ipv6_icmp_error(sk, skb, err, uh->dest, ntohl(info), (u8 *)(uh+1));
563 : :
564 : 0 : sk->sk_err = err;
565 : 0 : sk->sk_error_report(sk);
566 : : out:
567 : : sock_put(sk);
568 : : }
569 : :
570 : 0 : static int __udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
571 : : {
572 : : int rc;
573 : :
574 [ # # ]: 0 : if (!ipv6_addr_any(&sk->sk_v6_daddr)) {
575 : : sock_rps_save_rxhash(sk, skb);
576 : : sk_mark_napi_id(sk, skb);
577 : : }
578 : :
579 : 0 : rc = sock_queue_rcv_skb(sk, skb);
580 [ # # ]: 0 : if (rc < 0) {
581 : 0 : int is_udplite = IS_UDPLITE(sk);
582 : :
583 : : /* Note that an ENOMEM error is charged twice */
584 [ # # ]: 0 : if (rc == -ENOMEM)
585 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk),
586 : : UDP_MIB_RCVBUFERRORS, is_udplite);
587 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
588 : 0 : kfree_skb(skb);
589 : 0 : return -1;
590 : : }
591 : : return 0;
592 : : }
593 : :
594 : 0 : static __inline__ void udpv6_err(struct sk_buff *skb,
595 : : struct inet6_skb_parm *opt, u8 type,
596 : : u8 code, int offset, __be32 info )
597 : : {
598 : 0 : __udp6_lib_err(skb, opt, type, code, offset, info, &udp_table);
599 : 0 : }
600 : :
601 : : static struct static_key udpv6_encap_needed __read_mostly;
602 : 0 : void udpv6_encap_enable(void)
603 : : {
604 [ # # ]: 0 : if (!static_key_enabled(&udpv6_encap_needed))
605 : : static_key_slow_inc(&udpv6_encap_needed);
606 : 0 : }
607 : : EXPORT_SYMBOL(udpv6_encap_enable);
608 : :
609 : 0 : int udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
610 : : {
611 : : struct udp_sock *up = udp_sk(sk);
612 : : int rc;
613 : 0 : int is_udplite = IS_UDPLITE(sk);
614 : :
615 [ # # ]: 0 : if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
616 : : goto drop;
617 : :
618 [ # # ][ # # ]: 0 : if (static_key_false(&udpv6_encap_needed) && up->encap_type) {
619 : : int (*encap_rcv)(struct sock *sk, struct sk_buff *skb);
620 : :
621 : : /*
622 : : * This is an encapsulation socket so pass the skb to
623 : : * the socket's udp_encap_rcv() hook. Otherwise, just
624 : : * fall through and pass this up the UDP socket.
625 : : * up->encap_rcv() returns the following value:
626 : : * =0 if skb was successfully passed to the encap
627 : : * handler or was discarded by it.
628 : : * >0 if skb should be passed on to UDP.
629 : : * <0 if skb should be resubmitted as proto -N
630 : : */
631 : :
632 : : /* if we're overly short, let UDP handle it */
633 : 0 : encap_rcv = ACCESS_ONCE(up->encap_rcv);
634 [ # # ][ # # ]: 0 : if (skb->len > sizeof(struct udphdr) && encap_rcv != NULL) {
635 : : int ret;
636 : :
637 : 0 : ret = encap_rcv(sk, skb);
638 [ # # ]: 0 : if (ret <= 0) {
639 [ # # ]: 0 : UDP_INC_STATS_BH(sock_net(sk),
640 : : UDP_MIB_INDATAGRAMS,
641 : : is_udplite);
642 : 0 : return -ret;
643 : : }
644 : : }
645 : :
646 : : /* FALLTHROUGH -- it's a UDP Packet */
647 : : }
648 : :
649 : : /*
650 : : * UDP-Lite specific tests, ignored on UDP sockets (see net/ipv4/udp.c).
651 : : */
652 [ # # ][ # # ]: 0 : if ((is_udplite & UDPLITE_RECV_CC) && UDP_SKB_CB(skb)->partial_cov) {
653 : :
654 [ # # ]: 0 : if (up->pcrlen == 0) { /* full coverage was set */
655 [ # # ][ # # ]: 0 : LIMIT_NETDEBUG(KERN_WARNING "UDPLITE6: partial coverage"
656 : : " %d while full coverage %d requested\n",
657 : : UDP_SKB_CB(skb)->cscov, skb->len);
658 : : goto drop;
659 : : }
660 [ # # ]: 0 : if (UDP_SKB_CB(skb)->cscov < up->pcrlen) {
661 [ # # ][ # # ]: 0 : LIMIT_NETDEBUG(KERN_WARNING "UDPLITE6: coverage %d "
662 : : "too small, need min %d\n",
663 : : UDP_SKB_CB(skb)->cscov, up->pcrlen);
664 : : goto drop;
665 : : }
666 : : }
667 : :
668 [ # # ]: 0 : if (rcu_access_pointer(sk->sk_filter)) {
669 [ # # ]: 0 : if (udp_lib_checksum_complete(skb))
670 : : goto csum_error;
671 : : }
672 : :
673 [ # # ]: 0 : if (sk_rcvqueues_full(sk, skb, sk->sk_rcvbuf))
674 : : goto drop;
675 : :
676 : : skb_dst_drop(skb);
677 : :
678 : : bh_lock_sock(sk);
679 : : rc = 0;
680 [ # # ]: 0 : if (!sock_owned_by_user(sk))
681 : 0 : rc = __udpv6_queue_rcv_skb(sk, skb);
682 [ # # ]: 0 : else if (sk_add_backlog(sk, skb, sk->sk_rcvbuf)) {
683 : : bh_unlock_sock(sk);
684 : : goto drop;
685 : : }
686 : : bh_unlock_sock(sk);
687 : :
688 : 0 : return rc;
689 : : csum_error:
690 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
691 : : drop:
692 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
693 : 0 : atomic_inc(&sk->sk_drops);
694 : 0 : kfree_skb(skb);
695 : 0 : return -1;
696 : : }
697 : :
698 : 0 : static struct sock *udp_v6_mcast_next(struct net *net, struct sock *sk,
699 : : __be16 loc_port, const struct in6_addr *loc_addr,
700 : : __be16 rmt_port, const struct in6_addr *rmt_addr,
701 : : int dif)
702 : : {
703 : : struct hlist_nulls_node *node;
704 : : struct sock *s = sk;
705 [ # # ]: 0 : unsigned short num = ntohs(loc_port);
706 : :
707 [ # # ][ # # ]: 0 : sk_nulls_for_each_from(s, node) {
708 : : struct inet_sock *inet = inet_sk(s);
709 : :
710 : : if (!net_eq(sock_net(s), net))
711 : : continue;
712 : :
713 [ # # ][ # # ]: 0 : if (udp_sk(s)->udp_port_hash == num &&
714 : 0 : s->sk_family == PF_INET6) {
715 [ # # ]: 0 : if (inet->inet_dport) {
716 [ # # ]: 0 : if (inet->inet_dport != rmt_port)
717 : 0 : continue;
718 : : }
719 [ # # ][ # # ]: 0 : if (!ipv6_addr_any(&sk->sk_v6_daddr) &&
720 : : !ipv6_addr_equal(&sk->sk_v6_daddr, rmt_addr))
721 : 0 : continue;
722 : :
723 [ # # ][ # # ]: 0 : if (s->sk_bound_dev_if && s->sk_bound_dev_if != dif)
724 : 0 : continue;
725 : :
726 [ # # ]: 0 : if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
727 [ # # ]: 0 : if (!ipv6_addr_equal(&sk->sk_v6_rcv_saddr, loc_addr))
728 : 0 : continue;
729 : : }
730 [ # # ]: 0 : if (!inet6_mc_check(s, loc_addr, rmt_addr))
731 : 0 : continue;
732 : : return s;
733 : : }
734 : : }
735 : : return NULL;
736 : : }
737 : :
738 : 0 : static void flush_stack(struct sock **stack, unsigned int count,
739 : : struct sk_buff *skb, unsigned int final)
740 : : {
741 : : struct sk_buff *skb1 = NULL;
742 : : struct sock *sk;
743 : : unsigned int i;
744 : :
745 [ # # ]: 0 : for (i = 0; i < count; i++) {
746 : 0 : sk = stack[i];
747 [ # # ]: 0 : if (likely(skb1 == NULL))
748 [ # # ]: 0 : skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);
749 [ # # ]: 0 : if (!skb1) {
750 : 0 : atomic_inc(&sk->sk_drops);
751 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
752 : : IS_UDPLITE(sk));
753 [ # # ]: 0 : UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS,
754 : : IS_UDPLITE(sk));
755 : : }
756 : :
757 [ # # ][ # # ]: 0 : if (skb1 && udpv6_queue_rcv_skb(sk, skb1) <= 0)
758 : : skb1 = NULL;
759 : : }
760 [ # # ]: 0 : if (unlikely(skb1))
761 : 0 : kfree_skb(skb1);
762 : 0 : }
763 : : /*
764 : : * Note: called only from the BH handler context,
765 : : * so we don't need to lock the hashes.
766 : : */
767 : 0 : static int __udp6_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
768 : : const struct in6_addr *saddr, const struct in6_addr *daddr,
769 : 0 : struct udp_table *udptable)
770 : : {
771 : : struct sock *sk, *stack[256 / sizeof(struct sock *)];
772 : : const struct udphdr *uh = udp_hdr(skb);
773 [ # # ]: 0 : struct udp_hslot *hslot = udp_hashslot(udptable, net, ntohs(uh->dest));
774 : : int dif;
775 : : unsigned int i, count = 0;
776 : :
777 : : spin_lock(&hslot->lock);
778 : : sk = sk_nulls_head(&hslot->head);
779 : : dif = inet6_iif(skb);
780 : 0 : sk = udp_v6_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
781 [ # # ]: 0 : while (sk) {
782 : 0 : stack[count++] = sk;
783 : 0 : sk = udp_v6_mcast_next(net, sk_nulls_next(sk), uh->dest, daddr,
784 : : uh->source, saddr, dif);
785 [ # # ]: 0 : if (unlikely(count == ARRAY_SIZE(stack))) {
786 [ # # ]: 0 : if (!sk)
787 : : break;
788 : 0 : flush_stack(stack, count, skb, ~0);
789 : : count = 0;
790 : : }
791 : : }
792 : : /*
793 : : * before releasing the lock, we must take reference on sockets
794 : : */
795 [ # # ]: 0 : for (i = 0; i < count; i++)
796 : 0 : sock_hold(stack[i]);
797 : :
798 : : spin_unlock(&hslot->lock);
799 : :
800 [ # # ]: 0 : if (count) {
801 : 0 : flush_stack(stack, count, skb, count - 1);
802 : :
803 [ # # ]: 0 : for (i = 0; i < count; i++)
804 : 0 : sock_put(stack[i]);
805 : : } else {
806 : 0 : kfree_skb(skb);
807 : : }
808 : 0 : return 0;
809 : : }
810 : :
811 : 0 : int __udp6_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
812 : : int proto)
813 : : {
814 : : struct net *net = dev_net(skb->dev);
815 : : struct sock *sk;
816 : : struct udphdr *uh;
817 : 0 : const struct in6_addr *saddr, *daddr;
818 : : u32 ulen = 0;
819 : :
820 [ # # ]: 0 : if (!pskb_may_pull(skb, sizeof(struct udphdr)))
821 : : goto discard;
822 : :
823 : 0 : saddr = &ipv6_hdr(skb)->saddr;
824 : 0 : daddr = &ipv6_hdr(skb)->daddr;
825 : : uh = udp_hdr(skb);
826 : :
827 [ # # ]: 0 : ulen = ntohs(uh->len);
828 [ # # ]: 0 : if (ulen > skb->len)
829 : : goto short_packet;
830 : :
831 [ # # ]: 0 : if (proto == IPPROTO_UDP) {
832 : : /* UDP validates ulen. */
833 : :
834 : : /* Check for jumbo payload */
835 [ # # ]: 0 : if (ulen == 0)
836 : : ulen = skb->len;
837 : :
838 [ # # ]: 0 : if (ulen < sizeof(*uh))
839 : : goto short_packet;
840 : :
841 [ # # ]: 0 : if (ulen < skb->len) {
842 [ # # ]: 0 : if (pskb_trim_rcsum(skb, ulen))
843 : : goto short_packet;
844 : 0 : saddr = &ipv6_hdr(skb)->saddr;
845 : 0 : daddr = &ipv6_hdr(skb)->daddr;
846 : : uh = udp_hdr(skb);
847 : : }
848 : : }
849 : :
850 [ # # ]: 0 : if (udp6_csum_init(skb, uh, proto))
851 : : goto csum_error;
852 : :
853 : : /*
854 : : * Multicast receive code
855 : : */
856 [ # # ]: 0 : if (ipv6_addr_is_multicast(daddr))
857 : 0 : return __udp6_lib_mcast_deliver(net, skb,
858 : : saddr, daddr, udptable);
859 : :
860 : : /* Unicast */
861 : :
862 : : /*
863 : : * check socket cache ... must talk to Alan about his plans
864 : : * for sock caches... i'll skip this for now.
865 : : */
866 : 0 : sk = __udp6_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
867 [ # # ]: 0 : if (sk != NULL) {
868 : : int ret;
869 : :
870 : 0 : ret = udpv6_queue_rcv_skb(sk, skb);
871 : : sock_put(sk);
872 : :
873 : : /* a return value > 0 means to resubmit the input, but
874 : : * it wants the return to be -protocol, or 0
875 : : */
876 [ # # ]: 0 : if (ret > 0)
877 : 0 : return -ret;
878 : :
879 : : return 0;
880 : : }
881 : :
882 [ # # ]: 0 : if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
883 : : goto discard;
884 : :
885 [ # # ]: 0 : if (udp_lib_checksum_complete(skb))
886 : : goto csum_error;
887 : :
888 [ # # ]: 0 : UDP6_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
889 : 0 : icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
890 : :
891 : 0 : kfree_skb(skb);
892 : 0 : return 0;
893 : :
894 : : short_packet:
895 [ # # ][ # # ]: 0 : LIMIT_NETDEBUG(KERN_DEBUG "UDP%sv6: short packet: From [%pI6c]:%u %d/%d to [%pI6c]:%u\n",
[ # # ][ # # ]
[ # # ]
896 : : proto == IPPROTO_UDPLITE ? "-Lite" : "",
897 : : saddr,
898 : : ntohs(uh->source),
899 : : ulen,
900 : : skb->len,
901 : : daddr,
902 : : ntohs(uh->dest));
903 : : goto discard;
904 : : csum_error:
905 [ # # ]: 0 : UDP6_INC_STATS_BH(net, UDP_MIB_CSUMERRORS, proto == IPPROTO_UDPLITE);
906 : : discard:
907 [ # # ]: 0 : UDP6_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
908 : 0 : kfree_skb(skb);
909 : 0 : return 0;
910 : : }
911 : :
912 : 0 : static __inline__ int udpv6_rcv(struct sk_buff *skb)
913 : : {
914 : 0 : return __udp6_lib_rcv(skb, &udp_table, IPPROTO_UDP);
915 : : }
916 : :
917 : : /*
918 : : * Throw away all pending data and cancel the corking. Socket is locked.
919 : : */
920 : 0 : static void udp_v6_flush_pending_frames(struct sock *sk)
921 : : {
922 : : struct udp_sock *up = udp_sk(sk);
923 : :
924 [ # # ]: 0 : if (up->pending == AF_INET)
925 : 0 : udp_flush_pending_frames(sk);
926 [ # # ]: 0 : else if (up->pending) {
927 : 0 : up->len = 0;
928 : 0 : up->pending = 0;
929 : 0 : ip6_flush_pending_frames(sk);
930 : : }
931 : 0 : }
932 : :
933 : : /**
934 : : * udp6_hwcsum_outgoing - handle outgoing HW checksumming
935 : : * @sk: socket we are sending on
936 : : * @skb: sk_buff containing the filled-in UDP header
937 : : * (checksum field must be zeroed out)
938 : : */
939 : 0 : static void udp6_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,
940 : : const struct in6_addr *saddr,
941 : : const struct in6_addr *daddr, int len)
942 : : {
943 : : unsigned int offset;
944 : : struct udphdr *uh = udp_hdr(skb);
945 : : __wsum csum = 0;
946 : :
947 [ # # ]: 0 : if (skb_queue_len(&sk->sk_write_queue) == 1) {
948 : : /* Only one fragment on the socket. */
949 : 0 : skb->csum_start = skb_transport_header(skb) - skb->head;
950 : 0 : skb->csum_offset = offsetof(struct udphdr, check);
951 : 0 : uh->check = ~csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP, 0);
952 : : } else {
953 : : /*
954 : : * HW-checksum won't work as there are two or more
955 : : * fragments on the socket so that all csums of sk_buffs
956 : : * should be together
957 : : */
958 : 0 : offset = skb_transport_offset(skb);
959 : 0 : skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
960 : :
961 : 0 : skb->ip_summed = CHECKSUM_NONE;
962 : :
963 [ # # ]: 0 : skb_queue_walk(&sk->sk_write_queue, skb) {
964 : 0 : csum = csum_add(csum, skb->csum);
965 : : }
966 : :
967 : 0 : uh->check = csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP,
968 : : csum);
969 [ # # ]: 0 : if (uh->check == 0)
970 : 0 : uh->check = CSUM_MANGLED_0;
971 : : }
972 : 0 : }
973 : :
974 : : /*
975 : : * Sending
976 : : */
977 : :
978 : 0 : static int udp_v6_push_pending_frames(struct sock *sk)
979 : : {
980 : : struct sk_buff *skb;
981 : : struct udphdr *uh;
982 : : struct udp_sock *up = udp_sk(sk);
983 : : struct inet_sock *inet = inet_sk(sk);
984 : : struct flowi6 *fl6;
985 : : int err = 0;
986 : 0 : int is_udplite = IS_UDPLITE(sk);
987 : : __wsum csum = 0;
988 : :
989 [ # # ]: 0 : if (up->pending == AF_INET)
990 : 0 : return udp_push_pending_frames(sk);
991 : :
992 : : fl6 = &inet->cork.fl.u.ip6;
993 : :
994 : : /* Grab the skbuff where UDP header space exists. */
995 [ # # ]: 0 : if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
996 : : goto out;
997 : :
998 : : /*
999 : : * Create a UDP header
1000 : : */
1001 : : uh = udp_hdr(skb);
1002 : 0 : uh->source = fl6->fl6_sport;
1003 : 0 : uh->dest = fl6->fl6_dport;
1004 [ # # ]: 0 : uh->len = htons(up->len);
1005 : 0 : uh->check = 0;
1006 : :
1007 [ # # ]: 0 : if (is_udplite)
1008 : : csum = udplite_csum_outgoing(sk, skb);
1009 [ # # ]: 0 : else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
1010 : 0 : udp6_hwcsum_outgoing(sk, skb, &fl6->saddr, &fl6->daddr,
1011 : 0 : up->len);
1012 : 0 : goto send;
1013 : : } else
1014 : : csum = udp_csum_outgoing(sk, skb);
1015 : :
1016 : : /* add protocol-dependent pseudo-header */
1017 : 0 : uh->check = csum_ipv6_magic(&fl6->saddr, &fl6->daddr,
1018 : 0 : up->len, fl6->flowi6_proto, csum);
1019 [ # # ]: 0 : if (uh->check == 0)
1020 : 0 : uh->check = CSUM_MANGLED_0;
1021 : :
1022 : : send:
1023 : 0 : err = ip6_push_pending_frames(sk);
1024 [ # # ]: 0 : if (err) {
1025 [ # # ][ # # ]: 0 : if (err == -ENOBUFS && !inet6_sk(sk)->recverr) {
1026 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
1027 : : UDP_MIB_SNDBUFERRORS, is_udplite);
1028 : : err = 0;
1029 : : }
1030 : : } else
1031 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
1032 : : UDP_MIB_OUTDATAGRAMS, is_udplite);
1033 : : out:
1034 : 0 : up->len = 0;
1035 : 0 : up->pending = 0;
1036 : 0 : return err;
1037 : : }
1038 : :
1039 : 0 : int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
1040 : : struct msghdr *msg, size_t len)
1041 : : {
1042 : : struct ipv6_txoptions opt_space;
1043 : : struct udp_sock *up = udp_sk(sk);
1044 : : struct inet_sock *inet = inet_sk(sk);
1045 : : struct ipv6_pinfo *np = inet6_sk(sk);
1046 : 0 : DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name);
1047 : : struct in6_addr *daddr, *final_p, final;
1048 : : struct ipv6_txoptions *opt = NULL;
1049 : : struct ip6_flowlabel *flowlabel = NULL;
1050 : : struct flowi6 fl6;
1051 : : struct dst_entry *dst;
1052 : 0 : int addr_len = msg->msg_namelen;
1053 : 0 : int ulen = len;
1054 : 0 : int hlimit = -1;
1055 : 0 : int tclass = -1;
1056 : 0 : int dontfrag = -1;
1057 [ # # ][ # # ]: 0 : int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
1058 : : int err;
1059 : : int connected = 0;
1060 : 0 : int is_udplite = IS_UDPLITE(sk);
1061 : : int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
1062 : :
1063 : : /* destination address check */
1064 [ # # ]: 0 : if (sin6) {
1065 [ # # ]: 0 : if (addr_len < offsetof(struct sockaddr, sa_data))
1066 : : return -EINVAL;
1067 : :
1068 [ # # # # ]: 0 : switch (sin6->sin6_family) {
1069 : : case AF_INET6:
1070 [ # # ]: 0 : if (addr_len < SIN6_LEN_RFC2133)
1071 : : return -EINVAL;
1072 : 0 : daddr = &sin6->sin6_addr;
1073 : 0 : break;
1074 : : case AF_INET:
1075 : : goto do_udp_sendmsg;
1076 : : case AF_UNSPEC:
1077 : 0 : msg->msg_name = sin6 = NULL;
1078 : 0 : msg->msg_namelen = addr_len = 0;
1079 : : daddr = NULL;
1080 : 0 : break;
1081 : : default:
1082 : : return -EINVAL;
1083 : : }
1084 [ # # ]: 0 : } else if (!up->pending) {
1085 [ # # ]: 0 : if (sk->sk_state != TCP_ESTABLISHED)
1086 : : return -EDESTADDRREQ;
1087 : 0 : daddr = &sk->sk_v6_daddr;
1088 : : } else
1089 : : daddr = NULL;
1090 : :
1091 [ # # ]: 0 : if (daddr) {
1092 [ # # ]: 0 : if (ipv6_addr_v4mapped(daddr)) {
1093 : : struct sockaddr_in sin;
1094 : 0 : sin.sin_family = AF_INET;
1095 [ # # ]: 0 : sin.sin_port = sin6 ? sin6->sin6_port : inet->inet_dport;
1096 : 0 : sin.sin_addr.s_addr = daddr->s6_addr32[3];
1097 : 0 : msg->msg_name = &sin;
1098 : 0 : msg->msg_namelen = sizeof(sin);
1099 : : do_udp_sendmsg:
1100 [ # # ]: 0 : if (__ipv6_only_sock(sk))
1101 : : return -ENETUNREACH;
1102 : 0 : return udp_sendmsg(iocb, sk, msg, len);
1103 : : }
1104 : : }
1105 : :
1106 [ # # ]: 0 : if (up->pending == AF_INET)
1107 : 0 : return udp_sendmsg(iocb, sk, msg, len);
1108 : :
1109 : : /* Rough check on arithmetic overflow,
1110 : : better check is made in ip6_append_data().
1111 : : */
1112 [ # # ]: 0 : if (len > INT_MAX - sizeof(struct udphdr))
1113 : : return -EMSGSIZE;
1114 : :
1115 [ # # ]: 0 : if (up->pending) {
1116 : : /*
1117 : : * There are pending frames.
1118 : : * The socket lock must be held while it's corked.
1119 : : */
1120 : : lock_sock(sk);
1121 [ # # ]: 0 : if (likely(up->pending)) {
1122 [ # # ]: 0 : if (unlikely(up->pending != AF_INET6)) {
1123 : 0 : release_sock(sk);
1124 : 0 : return -EAFNOSUPPORT;
1125 : : }
1126 : : dst = NULL;
1127 : : goto do_append_data;
1128 : : }
1129 : 0 : release_sock(sk);
1130 : : }
1131 : 0 : ulen += sizeof(struct udphdr);
1132 : :
1133 : 0 : memset(&fl6, 0, sizeof(fl6));
1134 : :
1135 [ # # ]: 0 : if (sin6) {
1136 [ # # ]: 0 : if (sin6->sin6_port == 0)
1137 : : return -EINVAL;
1138 : :
1139 : 0 : fl6.fl6_dport = sin6->sin6_port;
1140 : 0 : daddr = &sin6->sin6_addr;
1141 : :
1142 [ # # ]: 0 : if (np->sndflow) {
1143 : 0 : fl6.flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
1144 [ # # ]: 0 : if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
1145 : 0 : flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
1146 [ # # ]: 0 : if (flowlabel == NULL)
1147 : : return -EINVAL;
1148 : : }
1149 : : }
1150 : :
1151 : : /*
1152 : : * Otherwise it will be difficult to maintain
1153 : : * sk->sk_dst_cache.
1154 : : */
1155 [ # # ][ # # ]: 0 : if (sk->sk_state == TCP_ESTABLISHED &&
1156 : : ipv6_addr_equal(daddr, &sk->sk_v6_daddr))
1157 : 0 : daddr = &sk->sk_v6_daddr;
1158 : :
1159 [ # # ][ # # ]: 0 : if (addr_len >= sizeof(struct sockaddr_in6) &&
1160 [ # # ]: 0 : sin6->sin6_scope_id &&
1161 : 0 : __ipv6_addr_needs_scope_id(__ipv6_addr_type(daddr)))
1162 : 0 : fl6.flowi6_oif = sin6->sin6_scope_id;
1163 : : } else {
1164 [ # # ]: 0 : if (sk->sk_state != TCP_ESTABLISHED)
1165 : : return -EDESTADDRREQ;
1166 : :
1167 : 0 : fl6.fl6_dport = inet->inet_dport;
1168 : 0 : daddr = &sk->sk_v6_daddr;
1169 : 0 : fl6.flowlabel = np->flow_label;
1170 : : connected = 1;
1171 : : }
1172 : :
1173 [ # # ]: 0 : if (!fl6.flowi6_oif)
1174 : 0 : fl6.flowi6_oif = sk->sk_bound_dev_if;
1175 : :
1176 [ # # ]: 0 : if (!fl6.flowi6_oif)
1177 : 0 : fl6.flowi6_oif = np->sticky_pktinfo.ipi6_ifindex;
1178 : :
1179 : 0 : fl6.flowi6_mark = sk->sk_mark;
1180 : :
1181 [ # # ]: 0 : if (msg->msg_controllen) {
1182 : : opt = &opt_space;
1183 : 0 : memset(opt, 0, sizeof(struct ipv6_txoptions));
1184 : 0 : opt->tot_len = sizeof(*opt);
1185 : :
1186 : 0 : err = ip6_datagram_send_ctl(sock_net(sk), sk, msg, &fl6, opt,
1187 : : &hlimit, &tclass, &dontfrag);
1188 [ # # ]: 0 : if (err < 0) {
1189 : : fl6_sock_release(flowlabel);
1190 : 0 : return err;
1191 : : }
1192 [ # # ][ # # ]: 0 : if ((fl6.flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) {
1193 : 0 : flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
1194 [ # # ]: 0 : if (flowlabel == NULL)
1195 : : return -EINVAL;
1196 : : }
1197 [ # # ]: 0 : if (!(opt->opt_nflen|opt->opt_flen))
1198 : : opt = NULL;
1199 : : connected = 0;
1200 : : }
1201 [ # # ]: 0 : if (opt == NULL)
1202 : 0 : opt = np->opt;
1203 [ # # ]: 0 : if (flowlabel)
1204 : 0 : opt = fl6_merge_options(&opt_space, flowlabel, opt);
1205 : 0 : opt = ipv6_fixup_options(&opt_space, opt);
1206 : :
1207 : 0 : fl6.flowi6_proto = sk->sk_protocol;
1208 [ # # ]: 0 : if (!ipv6_addr_any(daddr))
1209 : 0 : fl6.daddr = *daddr;
1210 : : else
1211 : 0 : fl6.daddr.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
1212 [ # # ][ # # ]: 0 : if (ipv6_addr_any(&fl6.saddr) && !ipv6_addr_any(&np->saddr))
1213 : 0 : fl6.saddr = np->saddr;
1214 : 0 : fl6.fl6_sport = inet->inet_sport;
1215 : :
1216 : 0 : final_p = fl6_update_dst(&fl6, opt, &final);
1217 [ # # ]: 0 : if (final_p)
1218 : : connected = 0;
1219 : :
1220 [ # # ][ # # ]: 0 : if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr)) {
1221 : 0 : fl6.flowi6_oif = np->mcast_oif;
1222 : 0 : connected = 0;
1223 [ # # ]: 0 : } else if (!fl6.flowi6_oif)
1224 : 0 : fl6.flowi6_oif = np->ucast_oif;
1225 : :
1226 : 0 : security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
1227 : :
1228 : 0 : dst = ip6_sk_dst_lookup_flow(sk, &fl6, final_p);
1229 [ # # ]: 0 : if (IS_ERR(dst)) {
1230 : : err = PTR_ERR(dst);
1231 : : dst = NULL;
1232 : 0 : goto out;
1233 : : }
1234 : :
1235 [ # # ]: 0 : if (hlimit < 0) {
1236 [ # # ]: 0 : if (ipv6_addr_is_multicast(&fl6.daddr))
1237 : 0 : hlimit = np->mcast_hops;
1238 : : else
1239 : 0 : hlimit = np->hop_limit;
1240 [ # # ]: 0 : if (hlimit < 0)
1241 : 0 : hlimit = ip6_dst_hoplimit(dst);
1242 : : }
1243 : :
1244 [ # # ]: 0 : if (tclass < 0)
1245 : 0 : tclass = np->tclass;
1246 : :
1247 [ # # ]: 0 : if (msg->msg_flags&MSG_CONFIRM)
1248 : : goto do_confirm;
1249 : : back_from_confirm:
1250 : :
1251 : : lock_sock(sk);
1252 [ # # ]: 0 : if (unlikely(up->pending)) {
1253 : : /* The socket is already corked while preparing it. */
1254 : : /* ... which is an evident application bug. --ANK */
1255 : 0 : release_sock(sk);
1256 : :
1257 [ # # ][ # # ]: 0 : LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
1258 : : err = -EINVAL;
1259 : : goto out;
1260 : : }
1261 : :
1262 : 0 : up->pending = AF_INET6;
1263 : :
1264 : : do_append_data:
1265 [ # # ]: 0 : if (dontfrag < 0)
1266 : 0 : dontfrag = np->dontfrag;
1267 : 0 : up->len += ulen;
1268 [ # # ]: 0 : getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag;
1269 [ # # ]: 0 : err = ip6_append_data(sk, getfrag, msg->msg_iov, ulen,
1270 : : sizeof(struct udphdr), hlimit, tclass, opt, &fl6,
1271 : : (struct rt6_info*)dst,
1272 : 0 : corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags, dontfrag);
1273 [ # # ]: 0 : if (err)
1274 : 0 : udp_v6_flush_pending_frames(sk);
1275 [ # # ]: 0 : else if (!corkreq)
1276 : 0 : err = udp_v6_push_pending_frames(sk);
1277 [ # # ]: 0 : else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
1278 : 0 : up->pending = 0;
1279 : :
1280 [ # # ]: 0 : if (dst) {
1281 [ # # ]: 0 : if (connected) {
1282 [ # # ]: 0 : ip6_dst_store(sk, dst,
1283 : : ipv6_addr_equal(&fl6.daddr, &sk->sk_v6_daddr) ?
1284 : : &sk->sk_v6_daddr : NULL,
1285 : : #ifdef CONFIG_IPV6_SUBTREES
1286 : : ipv6_addr_equal(&fl6.saddr, &np->saddr) ?
1287 : : &np->saddr :
1288 : : #endif
1289 : : NULL);
1290 : : } else {
1291 : 0 : dst_release(dst);
1292 : : }
1293 : : dst = NULL;
1294 : : }
1295 : :
1296 [ # # ]: 0 : if (err > 0)
1297 [ # # ][ # # ]: 0 : err = np->recverr ? net_xmit_errno(err) : 0;
1298 : 0 : release_sock(sk);
1299 : : out:
1300 : 0 : dst_release(dst);
1301 : : fl6_sock_release(flowlabel);
1302 [ # # ]: 0 : if (!err)
1303 : : return len;
1304 : : /*
1305 : : * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space. Reporting
1306 : : * ENOBUFS might not be good (it's not tunable per se), but otherwise
1307 : : * we don't have a good statistic (IpOutDiscards but it can be too many
1308 : : * things). We could add another new stat but at least for now that
1309 : : * seems like overkill.
1310 : : */
1311 [ # # ][ # # ]: 0 : if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
1312 [ # # ]: 0 : UDP6_INC_STATS_USER(sock_net(sk),
1313 : : UDP_MIB_SNDBUFERRORS, is_udplite);
1314 : : }
1315 : 0 : return err;
1316 : :
1317 : : do_confirm:
1318 : : dst_confirm(dst);
1319 [ # # ][ # # ]: 0 : if (!(msg->msg_flags&MSG_PROBE) || len)
1320 : : goto back_from_confirm;
1321 : : err = 0;
1322 : : goto out;
1323 : : }
1324 : :
1325 : 0 : void udpv6_destroy_sock(struct sock *sk)
1326 : : {
1327 : : struct udp_sock *up = udp_sk(sk);
1328 : : lock_sock(sk);
1329 : 0 : udp_v6_flush_pending_frames(sk);
1330 : 0 : release_sock(sk);
1331 : :
1332 [ # # ][ # # ]: 0 : if (static_key_false(&udpv6_encap_needed) && up->encap_type) {
1333 : : void (*encap_destroy)(struct sock *sk);
1334 : 0 : encap_destroy = ACCESS_ONCE(up->encap_destroy);
1335 [ # # ]: 0 : if (encap_destroy)
1336 : 0 : encap_destroy(sk);
1337 : : }
1338 : :
1339 : 0 : inet6_destroy_sock(sk);
1340 : 0 : }
1341 : :
1342 : : /*
1343 : : * Socket option code for UDP
1344 : : */
1345 : 0 : int udpv6_setsockopt(struct sock *sk, int level, int optname,
1346 : : char __user *optval, unsigned int optlen)
1347 : : {
1348 [ # # ]: 0 : if (level == SOL_UDP || level == SOL_UDPLITE)
1349 : 0 : return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1350 : : udp_v6_push_pending_frames);
1351 : 0 : return ipv6_setsockopt(sk, level, optname, optval, optlen);
1352 : : }
1353 : :
1354 : : #ifdef CONFIG_COMPAT
1355 : : int compat_udpv6_setsockopt(struct sock *sk, int level, int optname,
1356 : : char __user *optval, unsigned int optlen)
1357 : : {
1358 : : if (level == SOL_UDP || level == SOL_UDPLITE)
1359 : : return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1360 : : udp_v6_push_pending_frames);
1361 : : return compat_ipv6_setsockopt(sk, level, optname, optval, optlen);
1362 : : }
1363 : : #endif
1364 : :
1365 : 0 : int udpv6_getsockopt(struct sock *sk, int level, int optname,
1366 : : char __user *optval, int __user *optlen)
1367 : : {
1368 [ # # ]: 0 : if (level == SOL_UDP || level == SOL_UDPLITE)
1369 : 0 : return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1370 : 0 : return ipv6_getsockopt(sk, level, optname, optval, optlen);
1371 : : }
1372 : :
1373 : : #ifdef CONFIG_COMPAT
1374 : : int compat_udpv6_getsockopt(struct sock *sk, int level, int optname,
1375 : : char __user *optval, int __user *optlen)
1376 : : {
1377 : : if (level == SOL_UDP || level == SOL_UDPLITE)
1378 : : return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1379 : : return compat_ipv6_getsockopt(sk, level, optname, optval, optlen);
1380 : : }
1381 : : #endif
1382 : :
1383 : : static const struct inet6_protocol udpv6_protocol = {
1384 : : .handler = udpv6_rcv,
1385 : : .err_handler = udpv6_err,
1386 : : .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1387 : : };
1388 : :
1389 : : /* ------------------------------------------------------------------------ */
1390 : : #ifdef CONFIG_PROC_FS
1391 : 0 : int udp6_seq_show(struct seq_file *seq, void *v)
1392 : : {
1393 [ + + ]: 15 : if (v == SEQ_START_TOKEN) {
1394 : 10 : seq_puts(seq, IPV6_SEQ_DGRAM_HEADER);
1395 : : } else {
1396 : 5 : int bucket = ((struct udp_iter_state *)seq->private)->bucket;
1397 : : struct inet_sock *inet = inet_sk(v);
1398 [ - + ]: 5 : __u16 srcp = ntohs(inet->inet_sport);
1399 [ - + ]: 5 : __u16 destp = ntohs(inet->inet_dport);
1400 : 5 : ip6_dgram_sock_seq_show(seq, v, srcp, destp, bucket);
1401 : : }
1402 : 15 : return 0;
1403 : : }
1404 : :
1405 : : static const struct file_operations udp6_afinfo_seq_fops = {
1406 : : .owner = THIS_MODULE,
1407 : : .open = udp_seq_open,
1408 : : .read = seq_read,
1409 : : .llseek = seq_lseek,
1410 : : .release = seq_release_net
1411 : : };
1412 : :
1413 : : static struct udp_seq_afinfo udp6_seq_afinfo = {
1414 : : .name = "udp6",
1415 : : .family = AF_INET6,
1416 : : .udp_table = &udp_table,
1417 : : .seq_fops = &udp6_afinfo_seq_fops,
1418 : : .seq_ops = {
1419 : : .show = udp6_seq_show,
1420 : : },
1421 : : };
1422 : :
1423 : 0 : int __net_init udp6_proc_init(struct net *net)
1424 : : {
1425 : 0 : return udp_proc_register(net, &udp6_seq_afinfo);
1426 : : }
1427 : :
1428 : 0 : void udp6_proc_exit(struct net *net) {
1429 : 0 : udp_proc_unregister(net, &udp6_seq_afinfo);
1430 : 0 : }
1431 : : #endif /* CONFIG_PROC_FS */
1432 : :
1433 : 0 : void udp_v6_clear_sk(struct sock *sk, int size)
1434 : : {
1435 : : struct inet_sock *inet = inet_sk(sk);
1436 : :
1437 : : /* we do not want to clear pinet6 field, because of RCU lookups */
1438 : 0 : sk_prot_clear_portaddr_nulls(sk, offsetof(struct inet_sock, pinet6));
1439 : :
1440 : 0 : size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1441 [ # # ]: 0 : memset(&inet->pinet6 + 1, 0, size);
1442 : 0 : }
1443 : :
1444 : : /* ------------------------------------------------------------------------ */
1445 : :
1446 : : struct proto udpv6_prot = {
1447 : : .name = "UDPv6",
1448 : : .owner = THIS_MODULE,
1449 : : .close = udp_lib_close,
1450 : : .connect = ip6_datagram_connect,
1451 : : .disconnect = udp_disconnect,
1452 : : .ioctl = udp_ioctl,
1453 : : .destroy = udpv6_destroy_sock,
1454 : : .setsockopt = udpv6_setsockopt,
1455 : : .getsockopt = udpv6_getsockopt,
1456 : : .sendmsg = udpv6_sendmsg,
1457 : : .recvmsg = udpv6_recvmsg,
1458 : : .backlog_rcv = __udpv6_queue_rcv_skb,
1459 : : .hash = udp_lib_hash,
1460 : : .unhash = udp_lib_unhash,
1461 : : .rehash = udp_v6_rehash,
1462 : : .get_port = udp_v6_get_port,
1463 : : .memory_allocated = &udp_memory_allocated,
1464 : : .sysctl_mem = sysctl_udp_mem,
1465 : : .sysctl_wmem = &sysctl_udp_wmem_min,
1466 : : .sysctl_rmem = &sysctl_udp_rmem_min,
1467 : : .obj_size = sizeof(struct udp6_sock),
1468 : : .slab_flags = SLAB_DESTROY_BY_RCU,
1469 : : .h.udp_table = &udp_table,
1470 : : #ifdef CONFIG_COMPAT
1471 : : .compat_setsockopt = compat_udpv6_setsockopt,
1472 : : .compat_getsockopt = compat_udpv6_getsockopt,
1473 : : #endif
1474 : : .clear_sk = udp_v6_clear_sk,
1475 : : };
1476 : :
1477 : : static struct inet_protosw udpv6_protosw = {
1478 : : .type = SOCK_DGRAM,
1479 : : .protocol = IPPROTO_UDP,
1480 : : .prot = &udpv6_prot,
1481 : : .ops = &inet6_dgram_ops,
1482 : : .no_check = UDP_CSUM_DEFAULT,
1483 : : .flags = INET_PROTOSW_PERMANENT,
1484 : : };
1485 : :
1486 : :
1487 : 0 : int __init udpv6_init(void)
1488 : : {
1489 : : int ret;
1490 : :
1491 : 0 : ret = inet6_add_protocol(&udpv6_protocol, IPPROTO_UDP);
1492 [ # # ]: 0 : if (ret)
1493 : : goto out;
1494 : :
1495 : 0 : ret = inet6_register_protosw(&udpv6_protosw);
1496 [ # # ]: 0 : if (ret)
1497 : : goto out_udpv6_protocol;
1498 : : out:
1499 : 0 : return ret;
1500 : :
1501 : : out_udpv6_protocol:
1502 : 0 : inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
1503 : 0 : goto out;
1504 : : }
1505 : :
1506 : 0 : void udpv6_exit(void)
1507 : : {
1508 : 0 : inet6_unregister_protosw(&udpv6_protosw);
1509 : 0 : inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
1510 : 0 : }
|
