udp.c 38.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 *	UDP over IPv6
3
 *	Linux INET6 implementation
L
Linus Torvalds 已提交
4 5
 *
 *	Authors:
6
 *	Pedro Roque		<roque@di.fc.ul.pt>
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
 *
 *	Based on linux/ipv4/udp.c
 *
 *	Fixes:
 *	Hideaki YOSHIFUJI	:	sin6_scope_id support
 *	YOSHIFUJI Hideaki @USAGI and:	Support IPV6_V6ONLY socket option, which
 *	Alexey Kuznetsov		allow both IPv4 and IPv6 sockets to bind
 *					a single port at the same time.
 *      Kazunori MIYAZAWA @USAGI:       change process style to use ip6_append_data
 *      YOSHIFUJI Hideaki @USAGI:	convert /proc/net/udp6 to seq_file.
 *
 *	This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/in6.h>
#include <linux/netdevice.h>
#include <linux/if_arp.h>
#include <linux/ipv6.h>
#include <linux/icmpv6.h>
#include <linux/init.h>
35
#include <linux/module.h>
36
#include <linux/skbuff.h>
37
#include <linux/slab.h>
L
Linus Torvalds 已提交
38 39 40 41 42 43 44
#include <asm/uaccess.h>

#include <net/ndisc.h>
#include <net/protocol.h>
#include <net/transp_v6.h>
#include <net/ip6_route.h>
#include <net/raw.h>
45
#include <net/tcp_states.h>
L
Linus Torvalds 已提交
46 47
#include <net/ip6_checksum.h>
#include <net/xfrm.h>
48
#include <net/inet6_hashtables.h>
49
#include <net/busy_poll.h>
L
Linus Torvalds 已提交
50 51 52

#include <linux/proc_fs.h>
#include <linux/seq_file.h>
53
#include <trace/events/skb.h>
54
#include "udp_impl.h"
L
Linus Torvalds 已提交
55

56 57 58 59 60 61
static unsigned int udp6_ehashfn(struct net *net,
				  const struct in6_addr *laddr,
				  const u16 lport,
				  const struct in6_addr *faddr,
				  const __be16 fport)
{
62 63 64 65 66 67 68 69 70 71 72 73 74
	static u32 udp6_ehash_secret __read_mostly;
	static u32 udp_ipv6_hash_secret __read_mostly;

	u32 lhash, fhash;

	net_get_random_once(&udp6_ehash_secret,
			    sizeof(udp6_ehash_secret));
	net_get_random_once(&udp_ipv6_hash_secret,
			    sizeof(udp_ipv6_hash_secret));

	lhash = (__force u32)laddr->s6_addr32[3];
	fhash = __ipv6_addr_jhash(faddr, udp_ipv6_hash_secret);

75
	return __inet6_ehashfn(lhash, lport, fhash, fport,
76
			       udp_ipv6_hash_secret + net_hash_mix(net));
77 78
}

79 80 81 82
int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2)
{
	const struct in6_addr *sk2_rcv_saddr6 = inet6_rcv_saddr(sk2);
	int sk2_ipv6only = inet_v6_ipv6only(sk2);
83
	int addr_type = ipv6_addr_type(&sk->sk_v6_rcv_saddr);
84 85 86 87
	int addr_type2 = sk2_rcv_saddr6 ? ipv6_addr_type(sk2_rcv_saddr6) : IPV6_ADDR_MAPPED;

	/* if both are mapped, treat as IPv4 */
	if (addr_type == IPV6_ADDR_MAPPED && addr_type2 == IPV6_ADDR_MAPPED)
88
		return (!sk2_ipv6only &&
E
Eric Dumazet 已提交
89 90
			(!sk->sk_rcv_saddr || !sk2->sk_rcv_saddr ||
			  sk->sk_rcv_saddr == sk2->sk_rcv_saddr));
91 92 93 94 95 96

	if (addr_type2 == IPV6_ADDR_ANY &&
	    !(sk2_ipv6only && addr_type == IPV6_ADDR_MAPPED))
		return 1;

	if (addr_type == IPV6_ADDR_ANY &&
97
	    !(ipv6_only_sock(sk) && addr_type2 == IPV6_ADDR_MAPPED))
98 99 100
		return 1;

	if (sk2_rcv_saddr6 &&
101
	    ipv6_addr_equal(&sk->sk_v6_rcv_saddr, sk2_rcv_saddr6))
102 103 104 105 106
		return 1;

	return 0;
}

107 108 109 110 111 112 113 114
static unsigned int udp6_portaddr_hash(struct net *net,
				       const struct in6_addr *addr6,
				       unsigned int port)
{
	unsigned int hash, mix = net_hash_mix(net);

	if (ipv6_addr_any(addr6))
		hash = jhash_1word(0, mix);
B
Brian Haley 已提交
115
	else if (ipv6_addr_v4mapped(addr6))
116
		hash = jhash_1word((__force u32)addr6->s6_addr32[3], mix);
117
	else
118
		hash = jhash2((__force u32 *)addr6->s6_addr32, 4, mix);
119 120 121 122 123

	return hash ^ port;
}


124
int udp_v6_get_port(struct sock *sk, unsigned short snum)
L
Linus Torvalds 已提交
125
{
E
Eric Dumazet 已提交
126 127
	unsigned int hash2_nulladdr =
		udp6_portaddr_hash(sock_net(sk), &in6addr_any, snum);
128
	unsigned int hash2_partial =
129
		udp6_portaddr_hash(sock_net(sk), &sk->sk_v6_rcv_saddr, 0);
E
Eric Dumazet 已提交
130

131
	/* precompute partial secondary hash */
E
Eric Dumazet 已提交
132 133
	udp_sk(sk)->udp_portaddr_hash = hash2_partial;
	return udp_lib_get_port(sk, snum, ipv6_rcv_saddr_equal, hash2_nulladdr);
L
Linus Torvalds 已提交
134 135
}

E
Eric Dumazet 已提交
136 137 138
static void udp_v6_rehash(struct sock *sk)
{
	u16 new_hash = udp6_portaddr_hash(sock_net(sk),
139
					  &sk->sk_v6_rcv_saddr,
E
Eric Dumazet 已提交
140 141 142 143 144
					  inet_sk(sk)->inet_num);

	udp_lib_rehash(sk, new_hash);
}

145 146
static inline int compute_score(struct sock *sk, struct net *net,
				unsigned short hnum,
147 148
				const struct in6_addr *saddr, __be16 sport,
				const struct in6_addr *daddr, __be16 dport,
149 150 151 152
				int dif)
{
	int score = -1;

153
	if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
154 155 156 157
			sk->sk_family == PF_INET6) {
		struct inet_sock *inet = inet_sk(sk);

		score = 0;
E
Eric Dumazet 已提交
158 159
		if (inet->inet_dport) {
			if (inet->inet_dport != sport)
160 161 162
				return -1;
			score++;
		}
163 164
		if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
			if (!ipv6_addr_equal(&sk->sk_v6_rcv_saddr, daddr))
165 166 167
				return -1;
			score++;
		}
168 169
		if (!ipv6_addr_any(&sk->sk_v6_daddr)) {
			if (!ipv6_addr_equal(&sk->sk_v6_daddr, saddr))
170 171 172 173 174 175 176 177 178 179 180 181
				return -1;
			score++;
		}
		if (sk->sk_bound_dev_if) {
			if (sk->sk_bound_dev_if != dif)
				return -1;
			score++;
		}
	}
	return score;
}

E
Eric Dumazet 已提交
182 183 184 185 186 187 188 189 190 191 192 193
#define SCORE2_MAX (1 + 1 + 1)
static inline int compute_score2(struct sock *sk, struct net *net,
				const struct in6_addr *saddr, __be16 sport,
				const struct in6_addr *daddr, unsigned short hnum,
				int dif)
{
	int score = -1;

	if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
			sk->sk_family == PF_INET6) {
		struct inet_sock *inet = inet_sk(sk);

194
		if (!ipv6_addr_equal(&sk->sk_v6_rcv_saddr, daddr))
E
Eric Dumazet 已提交
195 196 197 198 199 200 201
			return -1;
		score = 0;
		if (inet->inet_dport) {
			if (inet->inet_dport != sport)
				return -1;
			score++;
		}
202 203
		if (!ipv6_addr_any(&sk->sk_v6_daddr)) {
			if (!ipv6_addr_equal(&sk->sk_v6_daddr, saddr))
E
Eric Dumazet 已提交
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
				return -1;
			score++;
		}
		if (sk->sk_bound_dev_if) {
			if (sk->sk_bound_dev_if != dif)
				return -1;
			score++;
		}
	}
	return score;
}


/* called with read_rcu_lock() */
static struct sock *udp6_lib_lookup2(struct net *net,
		const struct in6_addr *saddr, __be16 sport,
		const struct in6_addr *daddr, unsigned int hnum, int dif,
		struct udp_hslot *hslot2, unsigned int slot2)
{
	struct sock *sk, *result;
	struct hlist_nulls_node *node;
225 226
	int score, badness, matches = 0, reuseport = 0;
	u32 hash = 0;
E
Eric Dumazet 已提交
227 228 229 230 231 232 233 234 235 236

begin:
	result = NULL;
	badness = -1;
	udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
		score = compute_score2(sk, net, saddr, sport,
				      daddr, hnum, dif);
		if (score > badness) {
			result = sk;
			badness = score;
237 238
			reuseport = sk->sk_reuseport;
			if (reuseport) {
239 240
				hash = udp6_ehashfn(net, daddr, hnum,
						    saddr, sport);
241 242
				matches = 1;
			} else if (score == SCORE2_MAX)
E
Eric Dumazet 已提交
243
				goto exact_match;
244 245
		} else if (score == badness && reuseport) {
			matches++;
246
			if (reciprocal_scale(hash, matches) == 0)
247 248
				result = sk;
			hash = next_pseudo_random32(hash);
E
Eric Dumazet 已提交
249 250 251 252 253 254 255 256 257 258 259 260
		}
	}
	/*
	 * if the nulls value we got at the end of this lookup is
	 * not the expected one, we must restart lookup.
	 * We probably met an item that was moved to another chain.
	 */
	if (get_nulls_value(node) != slot2)
		goto begin;

	if (result) {
exact_match:
E
Eric Dumazet 已提交
261
		if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
E
Eric Dumazet 已提交
262 263 264 265 266 267 268 269 270 271
			result = NULL;
		else if (unlikely(compute_score2(result, net, saddr, sport,
				  daddr, hnum, dif) < badness)) {
			sock_put(result);
			goto begin;
		}
	}
	return result;
}

272
struct sock *__udp6_lib_lookup(struct net *net,
273 274
				      const struct in6_addr *saddr, __be16 sport,
				      const struct in6_addr *daddr, __be16 dport,
275
				      int dif, struct udp_table *udptable)
L
Linus Torvalds 已提交
276
{
277
	struct sock *sk, *result;
278
	struct hlist_nulls_node *node;
L
Linus Torvalds 已提交
279
	unsigned short hnum = ntohs(dport);
E
Eric Dumazet 已提交
280 281
	unsigned int hash2, slot2, slot = udp_hashfn(net, hnum, udptable->mask);
	struct udp_hslot *hslot2, *hslot = &udptable->hash[slot];
282 283
	int score, badness, matches = 0, reuseport = 0;
	u32 hash = 0;
284

285
	rcu_read_lock();
E
Eric Dumazet 已提交
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
	if (hslot->count > 10) {
		hash2 = udp6_portaddr_hash(net, daddr, hnum);
		slot2 = hash2 & udptable->mask;
		hslot2 = &udptable->hash2[slot2];
		if (hslot->count < hslot2->count)
			goto begin;

		result = udp6_lib_lookup2(net, saddr, sport,
					  daddr, hnum, dif,
					  hslot2, slot2);
		if (!result) {
			hash2 = udp6_portaddr_hash(net, &in6addr_any, hnum);
			slot2 = hash2 & udptable->mask;
			hslot2 = &udptable->hash2[slot2];
			if (hslot->count < hslot2->count)
				goto begin;

303 304
			result = udp6_lib_lookup2(net, saddr, sport,
						  &in6addr_any, hnum, dif,
E
Eric Dumazet 已提交
305 306 307 308 309
						  hslot2, slot2);
		}
		rcu_read_unlock();
		return result;
	}
310 311 312
begin:
	result = NULL;
	badness = -1;
313
	sk_nulls_for_each_rcu(sk, node, &hslot->head) {
314 315 316 317
		score = compute_score(sk, net, hnum, saddr, sport, daddr, dport, dif);
		if (score > badness) {
			result = sk;
			badness = score;
318 319
			reuseport = sk->sk_reuseport;
			if (reuseport) {
320 321
				hash = udp6_ehashfn(net, daddr, hnum,
						    saddr, sport);
322 323 324 325
				matches = 1;
			}
		} else if (score == badness && reuseport) {
			matches++;
326
			if (reciprocal_scale(hash, matches) == 0)
327 328
				result = sk;
			hash = next_pseudo_random32(hash);
L
Linus Torvalds 已提交
329 330
		}
	}
331 332 333 334 335
	/*
	 * if the nulls value we got at the end of this lookup is
	 * not the expected one, we must restart lookup.
	 * We probably met an item that was moved to another chain.
	 */
E
Eric Dumazet 已提交
336
	if (get_nulls_value(node) != slot)
337 338
		goto begin;

339
	if (result) {
E
Eric Dumazet 已提交
340
		if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
341 342 343 344 345 346 347 348
			result = NULL;
		else if (unlikely(compute_score(result, net, hnum, saddr, sport,
					daddr, dport, dif) < badness)) {
			sock_put(result);
			goto begin;
		}
	}
	rcu_read_unlock();
L
Linus Torvalds 已提交
349 350
	return result;
}
351
EXPORT_SYMBOL_GPL(__udp6_lib_lookup);
L
Linus Torvalds 已提交
352

353 354
static struct sock *__udp6_lib_lookup_skb(struct sk_buff *skb,
					  __be16 sport, __be16 dport,
355
					  struct udp_table *udptable)
356
{
357
	struct sock *sk;
358
	const struct ipv6hdr *iph = ipv6_hdr(skb);
359

360 361
	sk = skb_steal_sock(skb);
	if (unlikely(sk))
362
		return sk;
E
Eric Dumazet 已提交
363 364 365
	return __udp6_lib_lookup(dev_net(skb_dst(skb)->dev), &iph->saddr, sport,
				 &iph->daddr, dport, inet6_iif(skb),
				 udptable);
366 367
}

368 369 370 371 372 373 374 375
struct sock *udp6_lib_lookup(struct net *net, const struct in6_addr *saddr, __be16 sport,
			     const struct in6_addr *daddr, __be16 dport, int dif)
{
	return __udp6_lib_lookup(net, saddr, sport, daddr, dport, dif, &udp_table);
}
EXPORT_SYMBOL_GPL(udp6_lib_lookup);


L
Linus Torvalds 已提交
376
/*
377 378
 *	This should be easy, if there is something there we
 *	return it, otherwise we block.
L
Linus Torvalds 已提交
379 380
 */

381
int udpv6_recvmsg(struct kiocb *iocb, struct sock *sk,
L
Linus Torvalds 已提交
382 383 384 385 386
		  struct msghdr *msg, size_t len,
		  int noblock, int flags, int *addr_len)
{
	struct ipv6_pinfo *np = inet6_sk(sk);
	struct inet_sock *inet = inet_sk(sk);
387
	struct sk_buff *skb;
388
	unsigned int ulen, copied;
389
	int peeked, off = 0;
390 391
	int err;
	int is_udplite = IS_UDPLITE(sk);
392
	int is_udp4;
393
	bool slow;
L
Linus Torvalds 已提交
394 395

	if (flags & MSG_ERRQUEUE)
396
		return ipv6_recv_error(sk, msg, len, addr_len);
L
Linus Torvalds 已提交
397

398
	if (np->rxpmtu && np->rxopt.bits.rxpmtu)
399
		return ipv6_recv_rxpmtu(sk, msg, len, addr_len);
400

L
Linus Torvalds 已提交
401
try_again:
402
	skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
403
				  &peeked, &off, &err);
L
Linus Torvalds 已提交
404 405 406
	if (!skb)
		goto out;

407
	ulen = skb->len - sizeof(struct udphdr);
408 409 410 411
	copied = len;
	if (copied > ulen)
		copied = ulen;
	else if (copied < ulen)
412
		msg->msg_flags |= MSG_TRUNC;
L
Linus Torvalds 已提交
413

414 415
	is_udp4 = (skb->protocol == htons(ETH_P_IP));

416
	/*
417 418 419
	 * If checksum is needed at all, try to do it while copying the
	 * data.  If the data is truncated, or if we only want a partial
	 * coverage checksum (UDP-Lite), do it before the copy.
420 421
	 */

422
	if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) {
423
		if (udp_lib_checksum_complete(skb))
L
Linus Torvalds 已提交
424
			goto csum_copy_err;
425 426
	}

427
	if (skb_csum_unnecessary(skb))
428 429
		err = skb_copy_datagram_msg(skb, sizeof(struct udphdr),
					    msg, copied);
430
	else {
L
Linus Torvalds 已提交
431 432 433 434
		err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);
		if (err == -EINVAL)
			goto csum_copy_err;
	}
435 436
	if (unlikely(err)) {
		trace_kfree_skb(skb, udpv6_recvmsg);
437 438 439 440 441 442 443 444 445 446 447
		if (!peeked) {
			atomic_inc(&sk->sk_drops);
			if (is_udp4)
				UDP_INC_STATS_USER(sock_net(sk),
						   UDP_MIB_INERRORS,
						   is_udplite);
			else
				UDP6_INC_STATS_USER(sock_net(sk),
						    UDP_MIB_INERRORS,
						    is_udplite);
		}
L
Linus Torvalds 已提交
448
		goto out_free;
449
	}
450 451 452 453 454 455 456 457
	if (!peeked) {
		if (is_udp4)
			UDP_INC_STATS_USER(sock_net(sk),
					UDP_MIB_INDATAGRAMS, is_udplite);
		else
			UDP6_INC_STATS_USER(sock_net(sk),
					UDP_MIB_INDATAGRAMS, is_udplite);
	}
458

459
	sock_recv_ts_and_drops(msg, sk, skb);
L
Linus Torvalds 已提交
460 461 462

	/* Copy the address. */
	if (msg->msg_name) {
463
		DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name);
L
Linus Torvalds 已提交
464
		sin6->sin6_family = AF_INET6;
465
		sin6->sin6_port = udp_hdr(skb)->source;
L
Linus Torvalds 已提交
466 467
		sin6->sin6_flowinfo = 0;

468
		if (is_udp4) {
B
Brian Haley 已提交
469 470
			ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
					       &sin6->sin6_addr);
471 472
			sin6->sin6_scope_id = 0;
		} else {
A
Alexey Dobriyan 已提交
473
			sin6->sin6_addr = ipv6_hdr(skb)->saddr;
474 475
			sin6->sin6_scope_id =
				ipv6_iface_scope_id(&sin6->sin6_addr,
476
						    inet6_iif(skb));
L
Linus Torvalds 已提交
477
		}
478
		*addr_len = sizeof(*sin6);
L
Linus Torvalds 已提交
479
	}
480 481 482 483

	if (np->rxopt.all)
		ip6_datagram_recv_common_ctl(sk, msg, skb);

484
	if (is_udp4) {
L
Linus Torvalds 已提交
485 486 487 488
		if (inet->cmsg_flags)
			ip_cmsg_recv(msg, skb);
	} else {
		if (np->rxopt.all)
489
			ip6_datagram_recv_specific_ctl(sk, msg, skb);
490
	}
L
Linus Torvalds 已提交
491

492
	err = copied;
L
Linus Torvalds 已提交
493
	if (flags & MSG_TRUNC)
494
		err = ulen;
L
Linus Torvalds 已提交
495 496

out_free:
497
	skb_free_datagram_locked(sk, skb);
L
Linus Torvalds 已提交
498 499 500 501
out:
	return err;

csum_copy_err:
502
	slow = lock_sock_fast(sk);
503
	if (!skb_kill_datagram(sk, skb, flags)) {
504 505 506
		if (is_udp4) {
			UDP_INC_STATS_USER(sock_net(sk),
					UDP_MIB_CSUMERRORS, is_udplite);
507 508
			UDP_INC_STATS_USER(sock_net(sk),
					UDP_MIB_INERRORS, is_udplite);
509 510 511
		} else {
			UDP6_INC_STATS_USER(sock_net(sk),
					UDP_MIB_CSUMERRORS, is_udplite);
512 513
			UDP6_INC_STATS_USER(sock_net(sk),
					UDP_MIB_INERRORS, is_udplite);
514
		}
515
	}
516
	unlock_sock_fast(sk, slow);
L
Linus Torvalds 已提交
517

518
	if (noblock)
L
Linus Torvalds 已提交
519
		return -EAGAIN;
520 521 522

	/* starting over for a new packet */
	msg->msg_flags &= ~MSG_TRUNC;
L
Linus Torvalds 已提交
523 524 525
	goto try_again;
}

526
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)
L
Linus Torvalds 已提交
529 530
{
	struct ipv6_pinfo *np;
531 532 533
	const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
	const struct in6_addr *saddr = &hdr->saddr;
	const struct in6_addr *daddr = &hdr->daddr;
534
	struct udphdr *uh = (struct udphdr *)(skb->data+offset);
L
Linus Torvalds 已提交
535 536
	struct sock *sk;
	int err;
537
	struct net *net = dev_net(skb->dev);
L
Linus Torvalds 已提交
538

539
	sk = __udp6_lib_lookup(net, daddr, uh->dest,
540
			       saddr, uh->source, inet6_iif(skb), udptable);
541 542 543
	if (sk == NULL) {
		ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
				   ICMP6_MIB_INERRORS);
L
Linus Torvalds 已提交
544
		return;
545
	}
L
Linus Torvalds 已提交
546

547 548 549
	if (type == ICMPV6_PKT_TOOBIG) {
		if (!ip6_sk_accept_pmtu(sk))
			goto out;
550
		ip6_sk_update_pmtu(skb, sk, info);
551
	}
552
	if (type == NDISC_REDIRECT) {
553
		ip6_sk_redirect(skb, sk);
554 555
		goto out;
	}
556

L
Linus Torvalds 已提交
557 558 559 560 561 562 563 564
	np = inet6_sk(sk);

	if (!icmpv6_err_convert(type, code, &err) && !np->recverr)
		goto out;

	if (sk->sk_state != TCP_ESTABLISHED && !np->recverr)
		goto out;

565
	if (np->recverr)
L
Linus Torvalds 已提交
566
		ipv6_icmp_error(sk, skb, err, uh->dest, ntohl(info), (u8 *)(uh+1));
567

L
Linus Torvalds 已提交
568 569 570 571 572 573
	sk->sk_err = err;
	sk->sk_error_report(sk);
out:
	sock_put(sk);
}

574 575 576 577
static int __udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
{
	int rc;

578
	if (!ipv6_addr_any(&sk->sk_v6_daddr)) {
579
		sock_rps_save_rxhash(sk, skb);
580
		sk_mark_napi_id(sk, skb);
E
Eric Dumazet 已提交
581
		sk_incoming_cpu_update(sk);
582
	}
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598

	rc = sock_queue_rcv_skb(sk, skb);
	if (rc < 0) {
		int is_udplite = IS_UDPLITE(sk);

		/* Note that an ENOMEM error is charged twice */
		if (rc == -ENOMEM)
			UDP6_INC_STATS_BH(sock_net(sk),
					UDP_MIB_RCVBUFERRORS, is_udplite);
		UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
		kfree_skb(skb);
		return -1;
	}
	return 0;
}

599
static __inline__ void udpv6_err(struct sk_buff *skb,
600
				 struct inet6_skb_parm *opt, u8 type,
601
				 u8 code, int offset, __be32 info)
602
{
603
	__udp6_lib_err(skb, opt, type, code, offset, info, &udp_table);
604 605
}

606 607 608 609 610 611 612 613
static struct static_key udpv6_encap_needed __read_mostly;
void udpv6_encap_enable(void)
{
	if (!static_key_enabled(&udpv6_encap_needed))
		static_key_slow_inc(&udpv6_encap_needed);
}
EXPORT_SYMBOL(udpv6_encap_enable);

614
int udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
615
{
616
	struct udp_sock *up = udp_sk(sk);
617
	int rc;
W
Wang Chen 已提交
618
	int is_udplite = IS_UDPLITE(sk);
619

620 621
	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
		goto drop;
L
Linus Torvalds 已提交
622

623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
	if (static_key_false(&udpv6_encap_needed) && up->encap_type) {
		int (*encap_rcv)(struct sock *sk, struct sk_buff *skb);

		/*
		 * This is an encapsulation socket so pass the skb to
		 * the socket's udp_encap_rcv() hook. Otherwise, just
		 * fall through and pass this up the UDP socket.
		 * up->encap_rcv() returns the following value:
		 * =0 if skb was successfully passed to the encap
		 *    handler or was discarded by it.
		 * >0 if skb should be passed on to UDP.
		 * <0 if skb should be resubmitted as proto -N
		 */

		/* if we're overly short, let UDP handle it */
		encap_rcv = ACCESS_ONCE(up->encap_rcv);
		if (skb->len > sizeof(struct udphdr) && encap_rcv != NULL) {
			int ret;

642 643 644 645
			/* Verify checksum before giving to encap */
			if (udp_lib_checksum_complete(skb))
				goto csum_error;

646 647 648 649 650 651 652 653 654 655 656 657
			ret = encap_rcv(sk, skb);
			if (ret <= 0) {
				UDP_INC_STATS_BH(sock_net(sk),
						 UDP_MIB_INDATAGRAMS,
						 is_udplite);
				return -ret;
			}
		}

		/* FALLTHROUGH -- it's a UDP Packet */
	}

658 659 660
	/*
	 * UDP-Lite specific tests, ignored on UDP sockets (see net/ipv4/udp.c).
	 */
W
Wang Chen 已提交
661
	if ((is_udplite & UDPLITE_RECV_CC)  &&  UDP_SKB_CB(skb)->partial_cov) {
662 663

		if (up->pcrlen == 0) {          /* full coverage was set  */
664 665
			net_dbg_ratelimited("UDPLITE6: partial coverage %d while full coverage %d requested\n",
					    UDP_SKB_CB(skb)->cscov, skb->len);
666 667 668
			goto drop;
		}
		if (UDP_SKB_CB(skb)->cscov  <  up->pcrlen) {
669 670
			net_dbg_ratelimited("UDPLITE6: coverage %d too small, need min %d\n",
					    UDP_SKB_CB(skb)->cscov, up->pcrlen);
671 672
			goto drop;
		}
L
Linus Torvalds 已提交
673 674
	}

675
	if (rcu_access_pointer(sk->sk_filter)) {
676
		if (udp_lib_checksum_complete(skb))
677
			goto csum_error;
678
	}
679

680
	if (sk_rcvqueues_full(sk, sk->sk_rcvbuf)) {
681 682
		UDP6_INC_STATS_BH(sock_net(sk),
				  UDP_MIB_RCVBUFERRORS, is_udplite);
683
		goto drop;
684
	}
685

686
	skb_dst_drop(skb);
687

688 689 690 691 692 693 694 695 696
	bh_lock_sock(sk);
	rc = 0;
	if (!sock_owned_by_user(sk))
		rc = __udpv6_queue_rcv_skb(sk, skb);
	else if (sk_add_backlog(sk, skb, sk->sk_rcvbuf)) {
		bh_unlock_sock(sk);
		goto drop;
	}
	bh_unlock_sock(sk);
697 698

	return rc;
699

700 701
csum_error:
	UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
702
drop:
703
	UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
704
	atomic_inc(&sk->sk_drops);
705 706
	kfree_skb(skb);
	return -1;
L
Linus Torvalds 已提交
707 708
}

709 710 711 712
static bool __udp_v6_is_mcast_sock(struct net *net, struct sock *sk,
				   __be16 loc_port, const struct in6_addr *loc_addr,
				   __be16 rmt_port, const struct in6_addr *rmt_addr,
				   int dif, unsigned short hnum)
L
Linus Torvalds 已提交
713
{
714
	struct inet_sock *inet = inet_sk(sk);
L
Linus Torvalds 已提交
715

716 717 718 719 720 721 722 723 724 725 726 727 728
	if (!net_eq(sock_net(sk), net))
		return false;

	if (udp_sk(sk)->udp_port_hash != hnum ||
	    sk->sk_family != PF_INET6 ||
	    (inet->inet_dport && inet->inet_dport != rmt_port) ||
	    (!ipv6_addr_any(&sk->sk_v6_daddr) &&
		    !ipv6_addr_equal(&sk->sk_v6_daddr, rmt_addr)) ||
	    (sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif))
		return false;
	if (!inet6_mc_check(sk, loc_addr, rmt_addr))
		return false;
	return true;
L
Linus Torvalds 已提交
729 730
}

731 732 733
static void flush_stack(struct sock **stack, unsigned int count,
			struct sk_buff *skb, unsigned int final)
{
734
	struct sk_buff *skb1 = NULL;
735
	struct sock *sk;
736
	unsigned int i;
737 738

	for (i = 0; i < count; i++) {
739
		sk = stack[i];
740 741 742 743 744 745 746 747
		if (likely(skb1 == NULL))
			skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);
		if (!skb1) {
			atomic_inc(&sk->sk_drops);
			UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
					  IS_UDPLITE(sk));
			UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS,
					  IS_UDPLITE(sk));
748
		}
749 750 751

		if (skb1 && udpv6_queue_rcv_skb(sk, skb1) <= 0)
			skb1 = NULL;
752
		sock_put(sk);
753
	}
754 755
	if (unlikely(skb1))
		kfree_skb(skb1);
756
}
757 758 759 760 761 762

static void udp6_csum_zero_error(struct sk_buff *skb)
{
	/* RFC 2460 section 8.1 says that we SHOULD log
	 * this error. Well, it is reasonable.
	 */
763 764 765
	net_dbg_ratelimited("IPv6: udp checksum is 0 for [%pI6c]:%u->[%pI6c]:%u\n",
			    &ipv6_hdr(skb)->saddr, ntohs(udp_hdr(skb)->source),
			    &ipv6_hdr(skb)->daddr, ntohs(udp_hdr(skb)->dest));
766 767
}

L
Linus Torvalds 已提交
768 769 770 771
/*
 * Note: called only from the BH handler context,
 * so we don't need to lock the hashes.
 */
772
static int __udp6_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
773
		const struct in6_addr *saddr, const struct in6_addr *daddr,
774
		struct udp_table *udptable, int proto)
L
Linus Torvalds 已提交
775
{
776
	struct sock *sk, *stack[256 / sizeof(struct sock *)];
777
	const struct udphdr *uh = udp_hdr(skb);
778 779 780 781
	struct hlist_nulls_node *node;
	unsigned short hnum = ntohs(uh->dest);
	struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum);
	int dif = inet6_iif(skb);
782 783
	unsigned int count = 0, offset = offsetof(typeof(*sk), sk_nulls_node);
	unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10);
784
	bool inner_flushed = false;
785 786 787 788 789 790 791 792 793

	if (use_hash2) {
		hash2_any = udp6_portaddr_hash(net, &in6addr_any, hnum) &
			    udp_table.mask;
		hash2 = udp6_portaddr_hash(net, daddr, hnum) & udp_table.mask;
start_lookup:
		hslot = &udp_table.hash2[hash2];
		offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node);
	}
L
Linus Torvalds 已提交
794

795
	spin_lock(&hslot->lock);
796
	sk_nulls_for_each_entry_offset(sk, node, &hslot->head, offset) {
797 798 799 800 801 802 803 804 805 806
		if (__udp_v6_is_mcast_sock(net, sk,
					   uh->dest, daddr,
					   uh->source, saddr,
					   dif, hnum) &&
		    /* If zero checksum and no_check is not on for
		     * the socket then skip it.
		     */
		    (uh->check || udp_sk(sk)->no_check6_rx)) {
			if (unlikely(count == ARRAY_SIZE(stack))) {
				flush_stack(stack, count, skb, ~0);
807
				inner_flushed = true;
808 809
				count = 0;
			}
810
			stack[count++] = sk;
811
			sock_hold(sk);
H
Hideo Aoki 已提交
812
		}
L
Linus Torvalds 已提交
813
	}
814

815
	spin_unlock(&hslot->lock);
816

817 818 819 820 821 822
	/* Also lookup *:port if we are using hash2 and haven't done so yet. */
	if (use_hash2 && hash2 != hash2_any) {
		hash2 = hash2_any;
		goto start_lookup;
	}

823 824 825
	if (count) {
		flush_stack(stack, count, skb, count - 1);
	} else {
826 827 828 829
		if (!inner_flushed)
			UDP_INC_STATS_BH(net, UDP_MIB_IGNOREDMULTI,
					 proto == IPPROTO_UDPLITE);
		consume_skb(skb);
830
	}
831
	return 0;
L
Linus Torvalds 已提交
832 833
}

834
int __udp6_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
835
		   int proto)
L
Linus Torvalds 已提交
836
{
837
	struct net *net = dev_net(skb->dev);
L
Linus Torvalds 已提交
838
	struct sock *sk;
839
	struct udphdr *uh;
840
	const struct in6_addr *saddr, *daddr;
L
Linus Torvalds 已提交
841 842 843
	u32 ulen = 0;

	if (!pskb_may_pull(skb, sizeof(struct udphdr)))
844
		goto discard;
L
Linus Torvalds 已提交
845

846 847
	saddr = &ipv6_hdr(skb)->saddr;
	daddr = &ipv6_hdr(skb)->daddr;
848
	uh = udp_hdr(skb);
L
Linus Torvalds 已提交
849 850

	ulen = ntohs(uh->len);
851 852
	if (ulen > skb->len)
		goto short_packet;
L
Linus Torvalds 已提交
853

854 855
	if (proto == IPPROTO_UDP) {
		/* UDP validates ulen. */
L
Linus Torvalds 已提交
856

857 858 859
		/* Check for jumbo payload */
		if (ulen == 0)
			ulen = skb->len;
L
Linus Torvalds 已提交
860

861 862
		if (ulen < sizeof(*uh))
			goto short_packet;
L
Linus Torvalds 已提交
863

864 865 866
		if (ulen < skb->len) {
			if (pskb_trim_rcsum(skb, ulen))
				goto short_packet;
867 868
			saddr = &ipv6_hdr(skb)->saddr;
			daddr = &ipv6_hdr(skb)->daddr;
869
			uh = udp_hdr(skb);
870 871
		}
	}
L
Linus Torvalds 已提交
872

873
	if (udp6_csum_init(skb, uh, proto))
874
		goto csum_error;
875

876 877
	/*
	 *	Multicast receive code
L
Linus Torvalds 已提交
878
	 */
879
	if (ipv6_addr_is_multicast(daddr))
880
		return __udp6_lib_mcast_deliver(net, skb,
881
				saddr, daddr, udptable, proto);
L
Linus Torvalds 已提交
882 883 884

	/* Unicast */

885
	/*
L
Linus Torvalds 已提交
886 887 888
	 * check socket cache ... must talk to Alan about his plans
	 * for sock caches... i'll skip this for now.
	 */
889
	sk = __udp6_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
890
	if (sk != NULL) {
891 892
		int ret;

893
		if (!uh->check && !udp_sk(sk)->no_check6_rx) {
894
			sock_put(sk);
895 896 897 898
			udp6_csum_zero_error(skb);
			goto csum_error;
		}

899 900 901 902
		if (udp_sk(sk)->convert_csum && uh->check && !IS_UDPLITE(sk))
			skb_checksum_try_convert(skb, IPPROTO_UDP, uh->check,
						 ip6_compute_pseudo);

903
		ret = udpv6_queue_rcv_skb(sk, skb);
904
		sock_put(sk);
L
Linus Torvalds 已提交
905

906 907 908 909 910
		/* a return value > 0 means to resubmit the input, but
		 * it wants the return to be -protocol, or 0
		 */
		if (ret > 0)
			return -ret;
L
Linus Torvalds 已提交
911

S
Stephen Hemminger 已提交
912
		return 0;
L
Linus Torvalds 已提交
913
	}
914

915 916 917 918 919
	if (!uh->check) {
		udp6_csum_zero_error(skb);
		goto csum_error;
	}

920
	if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
921
		goto discard;
922 923

	if (udp_lib_checksum_complete(skb))
924
		goto csum_error;
925 926 927 928 929

	UDP6_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
	icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);

	kfree_skb(skb);
S
Stephen Hemminger 已提交
930
	return 0;
L
Linus Torvalds 已提交
931

932
short_packet:
933 934 935 936 937
	net_dbg_ratelimited("UDP%sv6: short packet: From [%pI6c]:%u %d/%d to [%pI6c]:%u\n",
			    proto == IPPROTO_UDPLITE ? "-Lite" : "",
			    saddr, ntohs(uh->source),
			    ulen, skb->len,
			    daddr, ntohs(uh->dest));
938 939 940
	goto discard;
csum_error:
	UDP6_INC_STATS_BH(net, UDP_MIB_CSUMERRORS, proto == IPPROTO_UDPLITE);
L
Linus Torvalds 已提交
941
discard:
942
	UDP6_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
L
Linus Torvalds 已提交
943
	kfree_skb(skb);
S
Stephen Hemminger 已提交
944
	return 0;
L
Linus Torvalds 已提交
945
}
946

947
static __inline__ int udpv6_rcv(struct sk_buff *skb)
948
{
949
	return __udp6_lib_rcv(skb, &udp_table, IPPROTO_UDP);
950 951
}

L
Linus Torvalds 已提交
952 953 954 955 956 957 958
/*
 * Throw away all pending data and cancel the corking. Socket is locked.
 */
static void udp_v6_flush_pending_frames(struct sock *sk)
{
	struct udp_sock *up = udp_sk(sk);

959 960 961
	if (up->pending == AF_INET)
		udp_flush_pending_frames(sk);
	else if (up->pending) {
L
Linus Torvalds 已提交
962 963 964
		up->len = 0;
		up->pending = 0;
		ip6_flush_pending_frames(sk);
965
	}
L
Linus Torvalds 已提交
966 967
}

968
/**
969 970 971 972
 *	udp6_hwcsum_outgoing  -  handle outgoing HW checksumming
 *	@sk:	socket we are sending on
 *	@skb:	sk_buff containing the filled-in UDP header
 *		(checksum field must be zeroed out)
973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
 */
static void udp6_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,
				 const struct in6_addr *saddr,
				 const struct in6_addr *daddr, int len)
{
	unsigned int offset;
	struct udphdr *uh = udp_hdr(skb);
	__wsum csum = 0;

	if (skb_queue_len(&sk->sk_write_queue) == 1) {
		/* Only one fragment on the socket.  */
		skb->csum_start = skb_transport_header(skb) - skb->head;
		skb->csum_offset = offsetof(struct udphdr, check);
		uh->check = ~csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP, 0);
	} else {
		/*
		 * HW-checksum won't work as there are two or more
		 * fragments on the socket so that all csums of sk_buffs
		 * should be together
		 */
		offset = skb_transport_offset(skb);
		skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);

		skb->ip_summed = CHECKSUM_NONE;

		skb_queue_walk(&sk->sk_write_queue, skb) {
			csum = csum_add(csum, skb->csum);
		}

		uh->check = csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP,
					    csum);
		if (uh->check == 0)
			uh->check = CSUM_MANGLED_0;
	}
}

L
Linus Torvalds 已提交
1009 1010 1011 1012
/*
 *	Sending
 */

1013
static int udp_v6_push_pending_frames(struct sock *sk)
L
Linus Torvalds 已提交
1014 1015 1016
{
	struct sk_buff *skb;
	struct udphdr *uh;
1017
	struct udp_sock  *up = udp_sk(sk);
L
Linus Torvalds 已提交
1018
	struct inet_sock *inet = inet_sk(sk);
1019
	struct flowi6 *fl6;
L
Linus Torvalds 已提交
1020
	int err = 0;
W
Wang Chen 已提交
1021
	int is_udplite = IS_UDPLITE(sk);
1022
	__wsum csum = 0;
L
Linus Torvalds 已提交
1023

1024 1025 1026 1027 1028
	if (up->pending == AF_INET)
		return udp_push_pending_frames(sk);

	fl6 = &inet->cork.fl.u.ip6;

L
Linus Torvalds 已提交
1029
	/* Grab the skbuff where UDP header space exists. */
1030 1031
	skb = skb_peek(&sk->sk_write_queue);
	if (skb == NULL)
L
Linus Torvalds 已提交
1032 1033 1034 1035 1036
		goto out;

	/*
	 * Create a UDP header
	 */
1037
	uh = udp_hdr(skb);
1038 1039
	uh->source = fl6->fl6_sport;
	uh->dest = fl6->fl6_dport;
L
Linus Torvalds 已提交
1040 1041 1042
	uh->len = htons(up->len);
	uh->check = 0;

W
Wang Chen 已提交
1043
	if (is_udplite)
1044
		csum = udplite_csum_outgoing(sk, skb);
1045
	else if (up->no_check6_tx) {   /* UDP csum disabled */
1046 1047 1048
		skb->ip_summed = CHECKSUM_NONE;
		goto send;
	} else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
1049
		udp6_hwcsum_outgoing(sk, skb, &fl6->saddr, &fl6->daddr,
1050 1051 1052
				     up->len);
		goto send;
	} else
1053
		csum = udp_csum_outgoing(sk, skb);
L
Linus Torvalds 已提交
1054

1055
	/* add protocol-dependent pseudo-header */
1056 1057
	uh->check = csum_ipv6_magic(&fl6->saddr, &fl6->daddr,
				    up->len, fl6->flowi6_proto, csum);
L
Linus Torvalds 已提交
1058
	if (uh->check == 0)
1059
		uh->check = CSUM_MANGLED_0;
L
Linus Torvalds 已提交
1060

1061
send:
L
Linus Torvalds 已提交
1062
	err = ip6_push_pending_frames(sk);
E
Eric Dumazet 已提交
1063 1064 1065 1066 1067 1068 1069 1070 1071
	if (err) {
		if (err == -ENOBUFS && !inet6_sk(sk)->recverr) {
			UDP6_INC_STATS_USER(sock_net(sk),
					    UDP_MIB_SNDBUFERRORS, is_udplite);
			err = 0;
		}
	} else
		UDP6_INC_STATS_USER(sock_net(sk),
				    UDP_MIB_OUTDATAGRAMS, is_udplite);
L
Linus Torvalds 已提交
1072 1073 1074 1075 1076 1077
out:
	up->len = 0;
	up->pending = 0;
	return err;
}

1078
int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
L
Linus Torvalds 已提交
1079 1080 1081 1082 1083 1084
		  struct msghdr *msg, size_t len)
{
	struct ipv6_txoptions opt_space;
	struct udp_sock *up = udp_sk(sk);
	struct inet_sock *inet = inet_sk(sk);
	struct ipv6_pinfo *np = inet6_sk(sk);
1085
	DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name);
1086
	struct in6_addr *daddr, *final_p, final;
L
Linus Torvalds 已提交
1087 1088
	struct ipv6_txoptions *opt = NULL;
	struct ip6_flowlabel *flowlabel = NULL;
1089
	struct flowi6 fl6;
L
Linus Torvalds 已提交
1090 1091 1092 1093
	struct dst_entry *dst;
	int addr_len = msg->msg_namelen;
	int ulen = len;
	int hlimit = -1;
1094
	int tclass = -1;
1095
	int dontfrag = -1;
L
Linus Torvalds 已提交
1096 1097
	int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
	int err;
1098
	int connected = 0;
W
Wang Chen 已提交
1099
	int is_udplite = IS_UDPLITE(sk);
1100
	int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
L
Linus Torvalds 已提交
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125

	/* destination address check */
	if (sin6) {
		if (addr_len < offsetof(struct sockaddr, sa_data))
			return -EINVAL;

		switch (sin6->sin6_family) {
		case AF_INET6:
			if (addr_len < SIN6_LEN_RFC2133)
				return -EINVAL;
			daddr = &sin6->sin6_addr;
			break;
		case AF_INET:
			goto do_udp_sendmsg;
		case AF_UNSPEC:
			msg->msg_name = sin6 = NULL;
			msg->msg_namelen = addr_len = 0;
			daddr = NULL;
			break;
		default:
			return -EINVAL;
		}
	} else if (!up->pending) {
		if (sk->sk_state != TCP_ESTABLISHED)
			return -EDESTADDRREQ;
1126
		daddr = &sk->sk_v6_daddr;
1127
	} else
L
Linus Torvalds 已提交
1128 1129 1130
		daddr = NULL;

	if (daddr) {
B
Brian Haley 已提交
1131
		if (ipv6_addr_v4mapped(daddr)) {
L
Linus Torvalds 已提交
1132 1133
			struct sockaddr_in sin;
			sin.sin_family = AF_INET;
E
Eric Dumazet 已提交
1134
			sin.sin_port = sin6 ? sin6->sin6_port : inet->inet_dport;
L
Linus Torvalds 已提交
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148
			sin.sin_addr.s_addr = daddr->s6_addr32[3];
			msg->msg_name = &sin;
			msg->msg_namelen = sizeof(sin);
do_udp_sendmsg:
			if (__ipv6_only_sock(sk))
				return -ENETUNREACH;
			return udp_sendmsg(iocb, sk, msg, len);
		}
	}

	if (up->pending == AF_INET)
		return udp_sendmsg(iocb, sk, msg, len);

	/* Rough check on arithmetic overflow,
1149
	   better check is made in ip6_append_data().
L
Linus Torvalds 已提交
1150 1151 1152
	   */
	if (len > INT_MAX - sizeof(struct udphdr))
		return -EMSGSIZE;
1153

L
Linus Torvalds 已提交
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
	if (up->pending) {
		/*
		 * There are pending frames.
		 * The socket lock must be held while it's corked.
		 */
		lock_sock(sk);
		if (likely(up->pending)) {
			if (unlikely(up->pending != AF_INET6)) {
				release_sock(sk);
				return -EAFNOSUPPORT;
			}
			dst = NULL;
			goto do_append_data;
		}
		release_sock(sk);
	}
	ulen += sizeof(struct udphdr);

1172
	memset(&fl6, 0, sizeof(fl6));
L
Linus Torvalds 已提交
1173 1174 1175 1176 1177

	if (sin6) {
		if (sin6->sin6_port == 0)
			return -EINVAL;

1178
		fl6.fl6_dport = sin6->sin6_port;
L
Linus Torvalds 已提交
1179 1180 1181
		daddr = &sin6->sin6_addr;

		if (np->sndflow) {
1182 1183 1184
			fl6.flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
			if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
				flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
L
Linus Torvalds 已提交
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
				if (flowlabel == NULL)
					return -EINVAL;
			}
		}

		/*
		 * Otherwise it will be difficult to maintain
		 * sk->sk_dst_cache.
		 */
		if (sk->sk_state == TCP_ESTABLISHED &&
1195 1196
		    ipv6_addr_equal(daddr, &sk->sk_v6_daddr))
			daddr = &sk->sk_v6_daddr;
L
Linus Torvalds 已提交
1197 1198 1199

		if (addr_len >= sizeof(struct sockaddr_in6) &&
		    sin6->sin6_scope_id &&
1200
		    __ipv6_addr_needs_scope_id(__ipv6_addr_type(daddr)))
1201
			fl6.flowi6_oif = sin6->sin6_scope_id;
L
Linus Torvalds 已提交
1202 1203 1204 1205
	} else {
		if (sk->sk_state != TCP_ESTABLISHED)
			return -EDESTADDRREQ;

1206
		fl6.fl6_dport = inet->inet_dport;
1207
		daddr = &sk->sk_v6_daddr;
1208
		fl6.flowlabel = np->flow_label;
1209
		connected = 1;
L
Linus Torvalds 已提交
1210 1211
	}

1212 1213
	if (!fl6.flowi6_oif)
		fl6.flowi6_oif = sk->sk_bound_dev_if;
L
Linus Torvalds 已提交
1214

1215 1216
	if (!fl6.flowi6_oif)
		fl6.flowi6_oif = np->sticky_pktinfo.ipi6_ifindex;
1217

1218
	fl6.flowi6_mark = sk->sk_mark;
B
Brian Haley 已提交
1219

L
Linus Torvalds 已提交
1220 1221 1222 1223 1224
	if (msg->msg_controllen) {
		opt = &opt_space;
		memset(opt, 0, sizeof(struct ipv6_txoptions));
		opt->tot_len = sizeof(*opt);

1225 1226
		err = ip6_datagram_send_ctl(sock_net(sk), sk, msg, &fl6, opt,
					    &hlimit, &tclass, &dontfrag);
L
Linus Torvalds 已提交
1227 1228 1229 1230
		if (err < 0) {
			fl6_sock_release(flowlabel);
			return err;
		}
1231 1232
		if ((fl6.flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) {
			flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
L
Linus Torvalds 已提交
1233 1234 1235 1236 1237
			if (flowlabel == NULL)
				return -EINVAL;
		}
		if (!(opt->opt_nflen|opt->opt_flen))
			opt = NULL;
1238
		connected = 0;
L
Linus Torvalds 已提交
1239 1240 1241
	}
	if (opt == NULL)
		opt = np->opt;
1242 1243 1244
	if (flowlabel)
		opt = fl6_merge_options(&opt_space, flowlabel, opt);
	opt = ipv6_fixup_options(&opt_space, opt);
L
Linus Torvalds 已提交
1245

1246
	fl6.flowi6_proto = sk->sk_protocol;
1247
	if (!ipv6_addr_any(daddr))
A
Alexey Dobriyan 已提交
1248
		fl6.daddr = *daddr;
1249
	else
1250 1251
		fl6.daddr.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
	if (ipv6_addr_any(&fl6.saddr) && !ipv6_addr_any(&np->saddr))
A
Alexey Dobriyan 已提交
1252
		fl6.saddr = np->saddr;
1253
	fl6.fl6_sport = inet->inet_sport;
1254

1255
	final_p = fl6_update_dst(&fl6, opt, &final);
1256
	if (final_p)
1257
		connected = 0;
L
Linus Torvalds 已提交
1258

1259 1260
	if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr)) {
		fl6.flowi6_oif = np->mcast_oif;
1261
		connected = 0;
1262 1263
	} else if (!fl6.flowi6_oif)
		fl6.flowi6_oif = np->ucast_oif;
L
Linus Torvalds 已提交
1264

1265
	security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
V
Venkat Yekkirala 已提交
1266

1267
	dst = ip6_sk_dst_lookup_flow(sk, &fl6, final_p);
1268 1269 1270
	if (IS_ERR(dst)) {
		err = PTR_ERR(dst);
		dst = NULL;
L
Linus Torvalds 已提交
1271
		goto out;
1272
	}
L
Linus Torvalds 已提交
1273

1274 1275
	if (hlimit < 0)
		hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
L
Linus Torvalds 已提交
1276

G
Gerrit Renker 已提交
1277
	if (tclass < 0)
1278 1279
		tclass = np->tclass;

L
Linus Torvalds 已提交
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
	if (msg->msg_flags&MSG_CONFIRM)
		goto do_confirm;
back_from_confirm:

	lock_sock(sk);
	if (unlikely(up->pending)) {
		/* The socket is already corked while preparing it. */
		/* ... which is an evident application bug. --ANK */
		release_sock(sk);

1290
		net_dbg_ratelimited("udp cork app bug 2\n");
L
Linus Torvalds 已提交
1291 1292 1293 1294 1295 1296 1297
		err = -EINVAL;
		goto out;
	}

	up->pending = AF_INET6;

do_append_data:
1298 1299
	if (dontfrag < 0)
		dontfrag = np->dontfrag;
L
Linus Torvalds 已提交
1300
	up->len += ulen;
1301 1302
	getfrag  =  is_udplite ?  udplite_getfrag : ip_generic_getfrag;
	err = ip6_append_data(sk, getfrag, msg->msg_iov, ulen,
1303
		sizeof(struct udphdr), hlimit, tclass, opt, &fl6,
1304
		(struct rt6_info *)dst,
1305
		corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags, dontfrag);
L
Linus Torvalds 已提交
1306 1307 1308
	if (err)
		udp_v6_flush_pending_frames(sk);
	else if (!corkreq)
1309
		err = udp_v6_push_pending_frames(sk);
H
Herbert Xu 已提交
1310 1311
	else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
		up->pending = 0;
L
Linus Torvalds 已提交
1312

1313 1314 1315
	if (dst) {
		if (connected) {
			ip6_dst_store(sk, dst,
1316 1317
				      ipv6_addr_equal(&fl6.daddr, &sk->sk_v6_daddr) ?
				      &sk->sk_v6_daddr : NULL,
1318
#ifdef CONFIG_IPV6_SUBTREES
1319
				      ipv6_addr_equal(&fl6.saddr, &np->saddr) ?
1320 1321 1322
				      &np->saddr :
#endif
				      NULL);
1323 1324 1325
		} else {
			dst_release(dst);
		}
1326
		dst = NULL;
1327 1328
	}

L
Linus Torvalds 已提交
1329 1330 1331 1332
	if (err > 0)
		err = np->recverr ? net_xmit_errno(err) : 0;
	release_sock(sk);
out:
1333
	dst_release(dst);
L
Linus Torvalds 已提交
1334
	fl6_sock_release(flowlabel);
1335
	if (!err)
L
Linus Torvalds 已提交
1336
		return len;
1337 1338 1339 1340 1341 1342 1343 1344
	/*
	 * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space.  Reporting
	 * ENOBUFS might not be good (it's not tunable per se), but otherwise
	 * we don't have a good statistic (IpOutDiscards but it can be too many
	 * things).  We could add another new stat but at least for now that
	 * seems like overkill.
	 */
	if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
1345 1346
		UDP6_INC_STATS_USER(sock_net(sk),
				UDP_MIB_SNDBUFERRORS, is_udplite);
1347
	}
L
Linus Torvalds 已提交
1348 1349 1350 1351 1352 1353 1354 1355 1356 1357
	return err;

do_confirm:
	dst_confirm(dst);
	if (!(msg->msg_flags&MSG_PROBE) || len)
		goto back_from_confirm;
	err = 0;
	goto out;
}

1358
void udpv6_destroy_sock(struct sock *sk)
L
Linus Torvalds 已提交
1359
{
T
Tom Parkin 已提交
1360
	struct udp_sock *up = udp_sk(sk);
L
Linus Torvalds 已提交
1361 1362 1363 1364
	lock_sock(sk);
	udp_v6_flush_pending_frames(sk);
	release_sock(sk);

T
Tom Parkin 已提交
1365 1366 1367 1368 1369 1370 1371
	if (static_key_false(&udpv6_encap_needed) && up->encap_type) {
		void (*encap_destroy)(struct sock *sk);
		encap_destroy = ACCESS_ONCE(up->encap_destroy);
		if (encap_destroy)
			encap_destroy(sk);
	}

L
Linus Torvalds 已提交
1372 1373 1374 1375 1376 1377
	inet6_destroy_sock(sk);
}

/*
 *	Socket option code for UDP
 */
1378
int udpv6_setsockopt(struct sock *sk, int level, int optname,
1379
		     char __user *optval, unsigned int optlen)
1380
{
1381
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1382 1383
		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
					  udp_v6_push_pending_frames);
1384
	return ipv6_setsockopt(sk, level, optname, optval, optlen);
1385 1386 1387
}

#ifdef CONFIG_COMPAT
1388
int compat_udpv6_setsockopt(struct sock *sk, int level, int optname,
1389
			    char __user *optval, unsigned int optlen)
1390
{
1391
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1392 1393
		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
					  udp_v6_push_pending_frames);
1394
	return compat_ipv6_setsockopt(sk, level, optname, optval, optlen);
1395 1396 1397
}
#endif

1398 1399
int udpv6_getsockopt(struct sock *sk, int level, int optname,
		     char __user *optval, int __user *optlen)
1400
{
1401
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1402
		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1403
	return ipv6_getsockopt(sk, level, optname, optval, optlen);
1404 1405 1406
}

#ifdef CONFIG_COMPAT
1407 1408
int compat_udpv6_getsockopt(struct sock *sk, int level, int optname,
			    char __user *optval, int __user *optlen)
1409
{
1410
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1411
		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1412
	return compat_ipv6_getsockopt(sk, level, optname, optval, optlen);
1413 1414 1415
}
#endif

1416
static const struct inet6_protocol udpv6_protocol = {
L
Linus Torvalds 已提交
1417 1418 1419 1420 1421 1422 1423
	.handler	=	udpv6_rcv,
	.err_handler	=	udpv6_err,
	.flags		=	INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
};

/* ------------------------------------------------------------------------ */
#ifdef CONFIG_PROC_FS
1424
int udp6_seq_show(struct seq_file *seq, void *v)
L
Linus Torvalds 已提交
1425
{
1426 1427 1428 1429 1430 1431 1432 1433 1434
	if (v == SEQ_START_TOKEN) {
		seq_puts(seq, IPV6_SEQ_DGRAM_HEADER);
	} else {
		int bucket = ((struct udp_iter_state *)seq->private)->bucket;
		struct inet_sock *inet = inet_sk(v);
		__u16 srcp = ntohs(inet->inet_sport);
		__u16 destp = ntohs(inet->inet_dport);
		ip6_dgram_sock_seq_show(seq, v, srcp, destp, bucket);
	}
L
Linus Torvalds 已提交
1435 1436 1437
	return 0;
}

1438 1439 1440 1441 1442 1443 1444 1445
static const struct file_operations udp6_afinfo_seq_fops = {
	.owner    = THIS_MODULE,
	.open     = udp_seq_open,
	.read     = seq_read,
	.llseek   = seq_lseek,
	.release  = seq_release_net
};

L
Linus Torvalds 已提交
1446 1447 1448
static struct udp_seq_afinfo udp6_seq_afinfo = {
	.name		= "udp6",
	.family		= AF_INET6,
1449
	.udp_table	= &udp_table,
1450
	.seq_fops	= &udp6_afinfo_seq_fops,
1451 1452 1453
	.seq_ops	= {
		.show		= udp6_seq_show,
	},
L
Linus Torvalds 已提交
1454 1455
};

1456
int __net_init udp6_proc_init(struct net *net)
L
Linus Torvalds 已提交
1457
{
1458
	return udp_proc_register(net, &udp6_seq_afinfo);
L
Linus Torvalds 已提交
1459 1460
}

1461 1462
void udp6_proc_exit(struct net *net) {
	udp_proc_unregister(net, &udp6_seq_afinfo);
L
Linus Torvalds 已提交
1463 1464 1465
}
#endif /* CONFIG_PROC_FS */

E
Eric Dumazet 已提交
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476
void udp_v6_clear_sk(struct sock *sk, int size)
{
	struct inet_sock *inet = inet_sk(sk);

	/* we do not want to clear pinet6 field, because of RCU lookups */
	sk_prot_clear_portaddr_nulls(sk, offsetof(struct inet_sock, pinet6));

	size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
	memset(&inet->pinet6 + 1, 0, size);
}

L
Linus Torvalds 已提交
1477 1478 1479
/* ------------------------------------------------------------------------ */

struct proto udpv6_prot = {
1480 1481
	.name		   = "UDPv6",
	.owner		   = THIS_MODULE,
1482
	.close		   = udp_lib_close,
1483 1484 1485 1486 1487 1488 1489 1490
	.connect	   = ip6_datagram_connect,
	.disconnect	   = udp_disconnect,
	.ioctl		   = udp_ioctl,
	.destroy	   = udpv6_destroy_sock,
	.setsockopt	   = udpv6_setsockopt,
	.getsockopt	   = udpv6_getsockopt,
	.sendmsg	   = udpv6_sendmsg,
	.recvmsg	   = udpv6_recvmsg,
1491
	.backlog_rcv	   = __udpv6_queue_rcv_skb,
1492 1493
	.hash		   = udp_lib_hash,
	.unhash		   = udp_lib_unhash,
E
Eric Dumazet 已提交
1494
	.rehash		   = udp_v6_rehash,
1495
	.get_port	   = udp_v6_get_port,
H
Hideo Aoki 已提交
1496 1497 1498 1499
	.memory_allocated  = &udp_memory_allocated,
	.sysctl_mem	   = sysctl_udp_mem,
	.sysctl_wmem	   = &sysctl_udp_wmem_min,
	.sysctl_rmem	   = &sysctl_udp_rmem_min,
1500
	.obj_size	   = sizeof(struct udp6_sock),
1501
	.slab_flags	   = SLAB_DESTROY_BY_RCU,
1502
	.h.udp_table	   = &udp_table,
1503
#ifdef CONFIG_COMPAT
1504 1505
	.compat_setsockopt = compat_udpv6_setsockopt,
	.compat_getsockopt = compat_udpv6_getsockopt,
1506
#endif
E
Eric Dumazet 已提交
1507
	.clear_sk	   = udp_v6_clear_sk,
L
Linus Torvalds 已提交
1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
};

static struct inet_protosw udpv6_protosw = {
	.type =      SOCK_DGRAM,
	.protocol =  IPPROTO_UDP,
	.prot =      &udpv6_prot,
	.ops =       &inet6_dgram_ops,
	.flags =     INET_PROTOSW_PERMANENT,
};


1519
int __init udpv6_init(void)
L
Linus Torvalds 已提交
1520
{
1521 1522
	int ret;

1523 1524
	ret = inet6_add_protocol(&udpv6_protocol, IPPROTO_UDP);
	if (ret)
1525
		goto out;
1526

1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
	ret = inet6_register_protosw(&udpv6_protosw);
	if (ret)
		goto out_udpv6_protocol;
out:
	return ret;

out_udpv6_protocol:
	inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
	goto out;
}

1538
void udpv6_exit(void)
1539 1540 1541
{
	inet6_unregister_protosw(&udpv6_protosw);
	inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
L
Linus Torvalds 已提交
1542
}