udp.c 38.1 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 83
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 sk_ipv6only = ipv6_only_sock(sk);
	int sk2_ipv6only = inet_v6_ipv6only(sk2);
84
	int addr_type = ipv6_addr_type(&sk->sk_v6_rcv_saddr);
85 86 87 88
	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)
89
		return (!sk2_ipv6only &&
E
Eric Dumazet 已提交
90 91
			(!sk->sk_rcv_saddr || !sk2->sk_rcv_saddr ||
			  sk->sk_rcv_saddr == sk2->sk_rcv_saddr));
92 93 94 95 96 97 98 99 100 101

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

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

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

	return 0;
}

108 109 110 111 112 113 114 115
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 已提交
116
	else if (ipv6_addr_v4mapped(addr6))
117
		hash = jhash_1word((__force u32)addr6->s6_addr32[3], mix);
118
	else
119
		hash = jhash2((__force u32 *)addr6->s6_addr32, 4, mix);
120 121 122 123 124

	return hash ^ port;
}


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

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

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

	udp_lib_rehash(sk, new_hash);
}

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

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

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

E
Eric Dumazet 已提交
183 184 185 186 187 188 189 190 191 192 193 194
#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);

195
		if (!ipv6_addr_equal(&sk->sk_v6_rcv_saddr, daddr))
E
Eric Dumazet 已提交
196 197 198 199 200 201 202
			return -1;
		score = 0;
		if (inet->inet_dport) {
			if (inet->inet_dport != sport)
				return -1;
			score++;
		}
203 204
		if (!ipv6_addr_any(&sk->sk_v6_daddr)) {
			if (!ipv6_addr_equal(&sk->sk_v6_daddr, saddr))
E
Eric Dumazet 已提交
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
				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;
226 227
	int score, badness, matches = 0, reuseport = 0;
	u32 hash = 0;
E
Eric Dumazet 已提交
228 229 230 231 232 233 234 235 236 237

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;
238 239
			reuseport = sk->sk_reuseport;
			if (reuseport) {
240 241
				hash = udp6_ehashfn(net, daddr, hnum,
						    saddr, sport);
242 243
				matches = 1;
			} else if (score == SCORE2_MAX)
E
Eric Dumazet 已提交
244
				goto exact_match;
245 246 247 248 249
		} else if (score == badness && reuseport) {
			matches++;
			if (((u64)hash * matches) >> 32 == 0)
				result = sk;
			hash = next_pseudo_random32(hash);
E
Eric Dumazet 已提交
250 251 252 253 254 255 256 257 258 259 260 261
		}
	}
	/*
	 * 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 已提交
262
		if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
E
Eric Dumazet 已提交
263 264 265 266 267 268 269 270 271 272
			result = NULL;
		else if (unlikely(compute_score2(result, net, saddr, sport,
				  daddr, hnum, dif) < badness)) {
			sock_put(result);
			goto begin;
		}
	}
	return result;
}

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

286
	rcu_read_lock();
E
Eric Dumazet 已提交
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
	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;

304 305
			result = udp6_lib_lookup2(net, saddr, sport,
						  &in6addr_any, hnum, dif,
E
Eric Dumazet 已提交
306 307 308 309 310
						  hslot2, slot2);
		}
		rcu_read_unlock();
		return result;
	}
311 312 313
begin:
	result = NULL;
	badness = -1;
314
	sk_nulls_for_each_rcu(sk, node, &hslot->head) {
315 316 317 318
		score = compute_score(sk, net, hnum, saddr, sport, daddr, dport, dif);
		if (score > badness) {
			result = sk;
			badness = score;
319 320
			reuseport = sk->sk_reuseport;
			if (reuseport) {
321 322
				hash = udp6_ehashfn(net, daddr, hnum,
						    saddr, sport);
323 324 325 326 327 328 329
				matches = 1;
			}
		} else if (score == badness && reuseport) {
			matches++;
			if (((u64)hash * matches) >> 32 == 0)
				result = sk;
			hash = next_pseudo_random32(hash);
L
Linus Torvalds 已提交
330 331
		}
	}
332 333 334 335 336
	/*
	 * 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 已提交
337
	if (get_nulls_value(node) != slot)
338 339
		goto begin;

340
	if (result) {
E
Eric Dumazet 已提交
341
		if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
342 343 344 345 346 347 348 349
			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 已提交
350 351
	return result;
}
352
EXPORT_SYMBOL_GPL(__udp6_lib_lookup);
L
Linus Torvalds 已提交
353

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

361 362
	if (unlikely(sk = skb_steal_sock(skb)))
		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 379 380
/*
 * 	This should be easy, if there is something there we
 * 	return it, otherwise we block.
 */

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
		err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
429
					      msg->msg_iov, 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 476
			sin6->sin6_scope_id =
				ipv6_iface_scope_id(&sin6->sin6_addr,
						    IP6CB(skb)->iif);
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;
L
Linus Torvalds 已提交
534 535 536 537
	struct udphdr *uh = (struct udphdr*)(skb->data+offset);
	struct sock *sk;
	int err;

538
	sk = __udp6_lib_lookup(dev_net(skb->dev), daddr, uh->dest,
539
			       saddr, uh->source, inet6_iif(skb), udptable);
L
Linus Torvalds 已提交
540 541 542
	if (sk == NULL)
		return;

543 544 545
	if (type == ICMPV6_PKT_TOOBIG) {
		if (!ip6_sk_accept_pmtu(sk))
			goto out;
546
		ip6_sk_update_pmtu(skb, sk, info);
547
	}
548
	if (type == NDISC_REDIRECT) {
549
		ip6_sk_redirect(skb, sk);
550 551
		goto out;
	}
552

L
Linus Torvalds 已提交
553 554 555 556 557 558 559 560
	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;

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

L
Linus Torvalds 已提交
564 565 566 567 568 569
	sk->sk_err = err;
	sk->sk_error_report(sk);
out:
	sock_put(sk);
}

570 571 572 573
static int __udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
{
	int rc;

574
	if (!ipv6_addr_any(&sk->sk_v6_daddr)) {
575
		sock_rps_save_rxhash(sk, skb);
576 577
		sk_mark_napi_id(sk, skb);
	}
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593

	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;
}

594
static __inline__ void udpv6_err(struct sk_buff *skb,
595 596
				 struct inet6_skb_parm *opt, u8 type,
				 u8 code, int offset, __be32 info     )
597
{
598
	__udp6_lib_err(skb, opt, type, code, offset, info, &udp_table);
599 600
}

601 602 603 604 605 606 607 608
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);

609
int udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
610
{
611
	struct udp_sock *up = udp_sk(sk);
612
	int rc;
W
Wang Chen 已提交
613
	int is_udplite = IS_UDPLITE(sk);
614

615 616
	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
		goto drop;
L
Linus Torvalds 已提交
617

618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
	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;

637 638 639 640
			/* Verify checksum before giving to encap */
			if (udp_lib_checksum_complete(skb))
				goto csum_error;

641 642 643 644 645 646 647 648 649 650 651 652
			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 */
	}

653 654 655
	/*
	 * UDP-Lite specific tests, ignored on UDP sockets (see net/ipv4/udp.c).
	 */
W
Wang Chen 已提交
656
	if ((is_udplite & UDPLITE_RECV_CC)  &&  UDP_SKB_CB(skb)->partial_cov) {
657 658 659 660 661 662 663 664 665 666 667 668 669

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

672
	if (rcu_access_pointer(sk->sk_filter)) {
673
		if (udp_lib_checksum_complete(skb))
674
			goto csum_error;
675
	}
676

677 678 679
	if (sk_rcvqueues_full(sk, skb, sk->sk_rcvbuf))
		goto drop;

680
	skb_dst_drop(skb);
681

682 683 684 685 686 687 688 689 690
	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);
691 692

	return rc;
693 694
csum_error:
	UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
695
drop:
696
	UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
697
	atomic_inc(&sk->sk_drops);
698 699
	kfree_skb(skb);
	return -1;
L
Linus Torvalds 已提交
700 701
}

702
static struct sock *udp_v6_mcast_next(struct net *net, struct sock *sk,
703 704
				      __be16 loc_port, const struct in6_addr *loc_addr,
				      __be16 rmt_port, const struct in6_addr *rmt_addr,
L
Linus Torvalds 已提交
705 706
				      int dif)
{
707
	struct hlist_nulls_node *node;
L
Linus Torvalds 已提交
708 709
	unsigned short num = ntohs(loc_port);

710 711
	sk_nulls_for_each_from(sk, node) {
		struct inet_sock *inet = inet_sk(sk);
L
Linus Torvalds 已提交
712

713
		if (!net_eq(sock_net(sk), net))
714 715
			continue;

716 717
		if (udp_sk(sk)->udp_port_hash == num &&
		    sk->sk_family == PF_INET6) {
E
Eric Dumazet 已提交
718 719
			if (inet->inet_dport) {
				if (inet->inet_dport != rmt_port)
L
Linus Torvalds 已提交
720 721
					continue;
			}
722 723
			if (!ipv6_addr_any(&sk->sk_v6_daddr) &&
			    !ipv6_addr_equal(&sk->sk_v6_daddr, rmt_addr))
L
Linus Torvalds 已提交
724 725
				continue;

726
			if (sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif)
L
Linus Torvalds 已提交
727 728
				continue;

729 730
			if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
				if (!ipv6_addr_equal(&sk->sk_v6_rcv_saddr, loc_addr))
731
					continue;
L
Linus Torvalds 已提交
732
			}
733
			if (!inet6_mc_check(sk, loc_addr, rmt_addr))
L
Linus Torvalds 已提交
734
				continue;
735
			return sk;
L
Linus Torvalds 已提交
736 737 738 739 740
		}
	}
	return NULL;
}

741 742 743
static void flush_stack(struct sock **stack, unsigned int count,
			struct sk_buff *skb, unsigned int final)
{
744
	struct sk_buff *skb1 = NULL;
745
	struct sock *sk;
746
	unsigned int i;
747 748

	for (i = 0; i < count; i++) {
749
		sk = stack[i];
750 751 752 753 754 755 756 757
		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));
758
		}
759 760 761

		if (skb1 && udpv6_queue_rcv_skb(sk, skb1) <= 0)
			skb1 = NULL;
762
	}
763 764
	if (unlikely(skb1))
		kfree_skb(skb1);
765
}
766 767 768 769 770 771 772 773 774 775 776

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.
	 */
	LIMIT_NETDEBUG(KERN_INFO "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));
}

L
Linus Torvalds 已提交
777 778 779 780
/*
 * Note: called only from the BH handler context,
 * so we don't need to lock the hashes.
 */
781
static int __udp6_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
782
		const struct in6_addr *saddr, const struct in6_addr *daddr,
783
		struct udp_table *udptable)
L
Linus Torvalds 已提交
784
{
785
	struct sock *sk, *stack[256 / sizeof(struct sock *)];
786
	const struct udphdr *uh = udp_hdr(skb);
787
	struct udp_hslot *hslot = udp_hashslot(udptable, net, ntohs(uh->dest));
L
Linus Torvalds 已提交
788
	int dif;
789
	unsigned int i, count = 0;
L
Linus Torvalds 已提交
790

791
	spin_lock(&hslot->lock);
792
	sk = sk_nulls_head(&hslot->head);
793
	dif = inet6_iif(skb);
794
	sk = udp_v6_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
795
	while (sk) {
796
		/* If zero checksum and no_check is not on for
797 798
		 * the socket then skip it.
		 */
799
		if (uh->check || udp_sk(sk)->no_check6_rx)
800 801
			stack[count++] = sk;

802 803 804 805 806 807 808
		sk = udp_v6_mcast_next(net, sk_nulls_next(sk), uh->dest, daddr,
				       uh->source, saddr, dif);
		if (unlikely(count == ARRAY_SIZE(stack))) {
			if (!sk)
				break;
			flush_stack(stack, count, skb, ~0);
			count = 0;
H
Hideo Aoki 已提交
809
		}
L
Linus Torvalds 已提交
810
	}
811 812 813 814 815 816
	/*
	 * before releasing the lock, we must take reference on sockets
	 */
	for (i = 0; i < count; i++)
		sock_hold(stack[i]);

817
	spin_unlock(&hslot->lock);
818 819 820 821 822 823 824 825 826

	if (count) {
		flush_stack(stack, count, skb, count - 1);

		for (i = 0; i < count; i++)
			sock_put(stack[i]);
	} else {
		kfree_skb(skb);
	}
827
	return 0;
L
Linus Torvalds 已提交
828 829
}

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

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

842 843
	saddr = &ipv6_hdr(skb)->saddr;
	daddr = &ipv6_hdr(skb)->daddr;
844
	uh = udp_hdr(skb);
L
Linus Torvalds 已提交
845 846

	ulen = ntohs(uh->len);
847 848
	if (ulen > skb->len)
		goto short_packet;
L
Linus Torvalds 已提交
849

850 851
	if (proto == IPPROTO_UDP) {
		/* UDP validates ulen. */
L
Linus Torvalds 已提交
852

853 854 855
		/* Check for jumbo payload */
		if (ulen == 0)
			ulen = skb->len;
L
Linus Torvalds 已提交
856

857 858
		if (ulen < sizeof(*uh))
			goto short_packet;
L
Linus Torvalds 已提交
859

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

869
	if (udp6_csum_init(skb, uh, proto))
870
		goto csum_error;
871

872 873
	/*
	 *	Multicast receive code
L
Linus Torvalds 已提交
874
	 */
875
	if (ipv6_addr_is_multicast(daddr))
876 877
		return __udp6_lib_mcast_deliver(net, skb,
				saddr, daddr, udptable);
L
Linus Torvalds 已提交
878 879 880

	/* Unicast */

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

889
		if (!uh->check && !udp_sk(sk)->no_check6_rx) {
890
			sock_put(sk);
891 892 893 894
			udp6_csum_zero_error(skb);
			goto csum_error;
		}

895
		ret = udpv6_queue_rcv_skb(sk, skb);
896
		sock_put(sk);
L
Linus Torvalds 已提交
897

898 899 900 901 902
		/* 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 已提交
903

S
Stephen Hemminger 已提交
904
		return 0;
L
Linus Torvalds 已提交
905
	}
906

907 908 909 910 911
	if (!uh->check) {
		udp6_csum_zero_error(skb);
		goto csum_error;
	}

912
	if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
913
		goto discard;
914 915

	if (udp_lib_checksum_complete(skb))
916
		goto csum_error;
917 918 919 920 921

	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 已提交
922
	return 0;
L
Linus Torvalds 已提交
923

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

942
static __inline__ int udpv6_rcv(struct sk_buff *skb)
943
{
944
	return __udp6_lib_rcv(skb, &udp_table, IPPROTO_UDP);
945 946
}

L
Linus Torvalds 已提交
947 948 949 950 951 952 953
/*
 * 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);

954 955 956
	if (up->pending == AF_INET)
		udp_flush_pending_frames(sk);
	else if (up->pending) {
L
Linus Torvalds 已提交
957 958 959
		up->len = 0;
		up->pending = 0;
		ip6_flush_pending_frames(sk);
960
	}
L
Linus Torvalds 已提交
961 962
}

963 964 965 966 967 968 969 970 971 972 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
/**
 * 	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)
 */
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 已提交
1004 1005 1006 1007
/*
 *	Sending
 */

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

1019 1020 1021 1022 1023
	if (up->pending == AF_INET)
		return udp_push_pending_frames(sk);

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

L
Linus Torvalds 已提交
1024 1025 1026 1027 1028 1029 1030
	/* Grab the skbuff where UDP header space exists. */
	if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
		goto out;

	/*
	 * Create a UDP header
	 */
1031
	uh = udp_hdr(skb);
1032 1033
	uh->source = fl6->fl6_sport;
	uh->dest = fl6->fl6_dport;
L
Linus Torvalds 已提交
1034 1035 1036
	uh->len = htons(up->len);
	uh->check = 0;

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

1049
	/* add protocol-dependent pseudo-header */
1050 1051
	uh->check = csum_ipv6_magic(&fl6->saddr, &fl6->daddr,
				    up->len, fl6->flowi6_proto, csum);
L
Linus Torvalds 已提交
1052
	if (uh->check == 0)
1053
		uh->check = CSUM_MANGLED_0;
L
Linus Torvalds 已提交
1054

1055
send:
L
Linus Torvalds 已提交
1056
	err = ip6_push_pending_frames(sk);
E
Eric Dumazet 已提交
1057 1058 1059 1060 1061 1062 1063 1064 1065
	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 已提交
1066 1067 1068 1069 1070 1071
out:
	up->len = 0;
	up->pending = 0;
	return err;
}

1072
int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
L
Linus Torvalds 已提交
1073 1074 1075 1076 1077 1078
		  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);
1079
	DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name);
1080
	struct in6_addr *daddr, *final_p, final;
L
Linus Torvalds 已提交
1081 1082
	struct ipv6_txoptions *opt = NULL;
	struct ip6_flowlabel *flowlabel = NULL;
1083
	struct flowi6 fl6;
L
Linus Torvalds 已提交
1084 1085 1086 1087
	struct dst_entry *dst;
	int addr_len = msg->msg_namelen;
	int ulen = len;
	int hlimit = -1;
1088
	int tclass = -1;
1089
	int dontfrag = -1;
L
Linus Torvalds 已提交
1090 1091
	int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
	int err;
1092
	int connected = 0;
W
Wang Chen 已提交
1093
	int is_udplite = IS_UDPLITE(sk);
1094
	int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
L
Linus Torvalds 已提交
1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119

	/* 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;
1120
		daddr = &sk->sk_v6_daddr;
1121
	} else
L
Linus Torvalds 已提交
1122 1123 1124
		daddr = NULL;

	if (daddr) {
B
Brian Haley 已提交
1125
		if (ipv6_addr_v4mapped(daddr)) {
L
Linus Torvalds 已提交
1126 1127
			struct sockaddr_in sin;
			sin.sin_family = AF_INET;
E
Eric Dumazet 已提交
1128
			sin.sin_port = sin6 ? sin6->sin6_port : inet->inet_dport;
L
Linus Torvalds 已提交
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
			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,
1143
	   better check is made in ip6_append_data().
L
Linus Torvalds 已提交
1144 1145 1146
	   */
	if (len > INT_MAX - sizeof(struct udphdr))
		return -EMSGSIZE;
1147

L
Linus Torvalds 已提交
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
	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);

1166
	memset(&fl6, 0, sizeof(fl6));
L
Linus Torvalds 已提交
1167 1168 1169 1170 1171

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

1172
		fl6.fl6_dport = sin6->sin6_port;
L
Linus Torvalds 已提交
1173 1174 1175
		daddr = &sin6->sin6_addr;

		if (np->sndflow) {
1176 1177 1178
			fl6.flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
			if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
				flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
L
Linus Torvalds 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
				if (flowlabel == NULL)
					return -EINVAL;
			}
		}

		/*
		 * Otherwise it will be difficult to maintain
		 * sk->sk_dst_cache.
		 */
		if (sk->sk_state == TCP_ESTABLISHED &&
1189 1190
		    ipv6_addr_equal(daddr, &sk->sk_v6_daddr))
			daddr = &sk->sk_v6_daddr;
L
Linus Torvalds 已提交
1191 1192 1193

		if (addr_len >= sizeof(struct sockaddr_in6) &&
		    sin6->sin6_scope_id &&
1194
		    __ipv6_addr_needs_scope_id(__ipv6_addr_type(daddr)))
1195
			fl6.flowi6_oif = sin6->sin6_scope_id;
L
Linus Torvalds 已提交
1196 1197 1198 1199
	} else {
		if (sk->sk_state != TCP_ESTABLISHED)
			return -EDESTADDRREQ;

1200
		fl6.fl6_dport = inet->inet_dport;
1201
		daddr = &sk->sk_v6_daddr;
1202
		fl6.flowlabel = np->flow_label;
1203
		connected = 1;
L
Linus Torvalds 已提交
1204 1205
	}

1206 1207
	if (!fl6.flowi6_oif)
		fl6.flowi6_oif = sk->sk_bound_dev_if;
L
Linus Torvalds 已提交
1208

1209 1210
	if (!fl6.flowi6_oif)
		fl6.flowi6_oif = np->sticky_pktinfo.ipi6_ifindex;
1211

1212
	fl6.flowi6_mark = sk->sk_mark;
B
Brian Haley 已提交
1213

L
Linus Torvalds 已提交
1214 1215 1216 1217 1218
	if (msg->msg_controllen) {
		opt = &opt_space;
		memset(opt, 0, sizeof(struct ipv6_txoptions));
		opt->tot_len = sizeof(*opt);

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

1240
	fl6.flowi6_proto = sk->sk_protocol;
1241
	if (!ipv6_addr_any(daddr))
A
Alexey Dobriyan 已提交
1242
		fl6.daddr = *daddr;
1243
	else
1244 1245
		fl6.daddr.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
	if (ipv6_addr_any(&fl6.saddr) && !ipv6_addr_any(&np->saddr))
A
Alexey Dobriyan 已提交
1246
		fl6.saddr = np->saddr;
1247
	fl6.fl6_sport = inet->inet_sport;
1248

1249
	final_p = fl6_update_dst(&fl6, opt, &final);
1250
	if (final_p)
1251
		connected = 0;
L
Linus Torvalds 已提交
1252

1253 1254
	if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr)) {
		fl6.flowi6_oif = np->mcast_oif;
1255
		connected = 0;
1256 1257
	} else if (!fl6.flowi6_oif)
		fl6.flowi6_oif = np->ucast_oif;
L
Linus Torvalds 已提交
1258

1259
	security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
V
Venkat Yekkirala 已提交
1260

1261
	dst = ip6_sk_dst_lookup_flow(sk, &fl6, final_p);
1262 1263 1264
	if (IS_ERR(dst)) {
		err = PTR_ERR(dst);
		dst = NULL;
L
Linus Torvalds 已提交
1265
		goto out;
1266
	}
L
Linus Torvalds 已提交
1267

1268 1269
	if (hlimit < 0)
		hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
L
Linus Torvalds 已提交
1270

G
Gerrit Renker 已提交
1271
	if (tclass < 0)
1272 1273
		tclass = np->tclass;

L
Linus Torvalds 已提交
1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
	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);

1284
		LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
L
Linus Torvalds 已提交
1285 1286 1287 1288 1289 1290 1291
		err = -EINVAL;
		goto out;
	}

	up->pending = AF_INET6;

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

1307 1308 1309
	if (dst) {
		if (connected) {
			ip6_dst_store(sk, dst,
1310 1311
				      ipv6_addr_equal(&fl6.daddr, &sk->sk_v6_daddr) ?
				      &sk->sk_v6_daddr : NULL,
1312
#ifdef CONFIG_IPV6_SUBTREES
1313
				      ipv6_addr_equal(&fl6.saddr, &np->saddr) ?
1314 1315 1316
				      &np->saddr :
#endif
				      NULL);
1317 1318 1319
		} else {
			dst_release(dst);
		}
1320
		dst = NULL;
1321 1322
	}

L
Linus Torvalds 已提交
1323 1324 1325 1326
	if (err > 0)
		err = np->recverr ? net_xmit_errno(err) : 0;
	release_sock(sk);
out:
1327
	dst_release(dst);
L
Linus Torvalds 已提交
1328
	fl6_sock_release(flowlabel);
1329
	if (!err)
L
Linus Torvalds 已提交
1330
		return len;
1331 1332 1333 1334 1335 1336 1337 1338
	/*
	 * 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)) {
1339 1340
		UDP6_INC_STATS_USER(sock_net(sk),
				UDP_MIB_SNDBUFERRORS, is_udplite);
1341
	}
L
Linus Torvalds 已提交
1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
	return err;

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

1352
void udpv6_destroy_sock(struct sock *sk)
L
Linus Torvalds 已提交
1353
{
T
Tom Parkin 已提交
1354
	struct udp_sock *up = udp_sk(sk);
L
Linus Torvalds 已提交
1355 1356 1357 1358
	lock_sock(sk);
	udp_v6_flush_pending_frames(sk);
	release_sock(sk);

T
Tom Parkin 已提交
1359 1360 1361 1362 1363 1364 1365
	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 已提交
1366 1367 1368 1369 1370 1371
	inet6_destroy_sock(sk);
}

/*
 *	Socket option code for UDP
 */
1372
int udpv6_setsockopt(struct sock *sk, int level, int optname,
1373
		     char __user *optval, unsigned int optlen)
1374
{
1375
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1376 1377
		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
					  udp_v6_push_pending_frames);
1378
	return ipv6_setsockopt(sk, level, optname, optval, optlen);
1379 1380 1381
}

#ifdef CONFIG_COMPAT
1382
int compat_udpv6_setsockopt(struct sock *sk, int level, int optname,
1383
			    char __user *optval, unsigned int optlen)
1384
{
1385
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1386 1387
		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
					  udp_v6_push_pending_frames);
1388
	return compat_ipv6_setsockopt(sk, level, optname, optval, optlen);
1389 1390 1391
}
#endif

1392 1393
int udpv6_getsockopt(struct sock *sk, int level, int optname,
		     char __user *optval, int __user *optlen)
1394
{
1395
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1396
		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1397
	return ipv6_getsockopt(sk, level, optname, optval, optlen);
1398 1399 1400
}

#ifdef CONFIG_COMPAT
1401 1402
int compat_udpv6_getsockopt(struct sock *sk, int level, int optname,
			    char __user *optval, int __user *optlen)
1403
{
1404
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1405
		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1406
	return compat_ipv6_getsockopt(sk, level, optname, optval, optlen);
1407 1408 1409
}
#endif

1410
static const struct inet6_protocol udpv6_protocol = {
L
Linus Torvalds 已提交
1411 1412 1413 1414 1415 1416 1417
	.handler	=	udpv6_rcv,
	.err_handler	=	udpv6_err,
	.flags		=	INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
};

/* ------------------------------------------------------------------------ */
#ifdef CONFIG_PROC_FS
1418
int udp6_seq_show(struct seq_file *seq, void *v)
L
Linus Torvalds 已提交
1419
{
1420 1421 1422 1423 1424 1425 1426 1427 1428
	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 已提交
1429 1430 1431
	return 0;
}

1432 1433 1434 1435 1436 1437 1438 1439
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 已提交
1440 1441 1442
static struct udp_seq_afinfo udp6_seq_afinfo = {
	.name		= "udp6",
	.family		= AF_INET6,
1443
	.udp_table	= &udp_table,
1444
	.seq_fops	= &udp6_afinfo_seq_fops,
1445 1446 1447
	.seq_ops	= {
		.show		= udp6_seq_show,
	},
L
Linus Torvalds 已提交
1448 1449
};

1450
int __net_init udp6_proc_init(struct net *net)
L
Linus Torvalds 已提交
1451
{
1452
	return udp_proc_register(net, &udp6_seq_afinfo);
L
Linus Torvalds 已提交
1453 1454
}

1455 1456
void udp6_proc_exit(struct net *net) {
	udp_proc_unregister(net, &udp6_seq_afinfo);
L
Linus Torvalds 已提交
1457 1458 1459
}
#endif /* CONFIG_PROC_FS */

E
Eric Dumazet 已提交
1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470
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 已提交
1471 1472 1473
/* ------------------------------------------------------------------------ */

struct proto udpv6_prot = {
1474 1475
	.name		   = "UDPv6",
	.owner		   = THIS_MODULE,
1476
	.close		   = udp_lib_close,
1477 1478 1479 1480 1481 1482 1483 1484
	.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,
1485
	.backlog_rcv	   = __udpv6_queue_rcv_skb,
1486 1487
	.hash		   = udp_lib_hash,
	.unhash		   = udp_lib_unhash,
E
Eric Dumazet 已提交
1488
	.rehash		   = udp_v6_rehash,
1489
	.get_port	   = udp_v6_get_port,
H
Hideo Aoki 已提交
1490 1491 1492 1493
	.memory_allocated  = &udp_memory_allocated,
	.sysctl_mem	   = sysctl_udp_mem,
	.sysctl_wmem	   = &sysctl_udp_wmem_min,
	.sysctl_rmem	   = &sysctl_udp_rmem_min,
1494
	.obj_size	   = sizeof(struct udp6_sock),
1495
	.slab_flags	   = SLAB_DESTROY_BY_RCU,
1496
	.h.udp_table	   = &udp_table,
1497
#ifdef CONFIG_COMPAT
1498 1499
	.compat_setsockopt = compat_udpv6_setsockopt,
	.compat_getsockopt = compat_udpv6_getsockopt,
1500
#endif
E
Eric Dumazet 已提交
1501
	.clear_sk	   = udp_v6_clear_sk,
L
Linus Torvalds 已提交
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
};

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


1513
int __init udpv6_init(void)
L
Linus Torvalds 已提交
1514
{
1515 1516
	int ret;

1517 1518
	ret = inet6_add_protocol(&udpv6_protocol, IPPROTO_UDP);
	if (ret)
1519
		goto out;
1520

1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531
	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;
}

1532
void udpv6_exit(void)
1533 1534 1535
{
	inet6_unregister_protosw(&udpv6_protosw);
	inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
L
Linus Torvalds 已提交
1536
}