udp.c 37.3 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 48 49 50
#include <net/ip6_checksum.h>
#include <net/xfrm.h>

#include <linux/proc_fs.h>
#include <linux/seq_file.h>
51
#include "udp_impl.h"
L
Linus Torvalds 已提交
52

53 54 55 56
int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2)
{
	const struct in6_addr *sk_rcv_saddr6 = &inet6_sk(sk)->rcv_saddr;
	const struct in6_addr *sk2_rcv_saddr6 = inet6_rcv_saddr(sk2);
57 58
	__be32 sk1_rcv_saddr = sk_rcv_saddr(sk);
	__be32 sk2_rcv_saddr = sk_rcv_saddr(sk2);
59 60 61 62 63 64 65
	int sk_ipv6only = ipv6_only_sock(sk);
	int sk2_ipv6only = inet_v6_ipv6only(sk2);
	int addr_type = ipv6_addr_type(sk_rcv_saddr6);
	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)
66
		return (!sk2_ipv6only &&
E
Eric Dumazet 已提交
67 68
			(!sk1_rcv_saddr || !sk2_rcv_saddr ||
			  sk1_rcv_saddr == sk2_rcv_saddr));
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

	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 &&
	    ipv6_addr_equal(sk_rcv_saddr6, sk2_rcv_saddr6))
		return 1;

	return 0;
}

85 86 87 88 89 90 91 92
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 已提交
93
	else if (ipv6_addr_v4mapped(addr6))
94
		hash = jhash_1word((__force u32)addr6->s6_addr32[3], mix);
95
	else
96
		hash = jhash2((__force u32 *)addr6->s6_addr32, 4, mix);
97 98 99 100 101

	return hash ^ port;
}


102
int udp_v6_get_port(struct sock *sk, unsigned short snum)
L
Linus Torvalds 已提交
103
{
E
Eric Dumazet 已提交
104 105 106 107 108
	unsigned int hash2_nulladdr =
		udp6_portaddr_hash(sock_net(sk), &in6addr_any, snum);
	unsigned int hash2_partial = 
		udp6_portaddr_hash(sock_net(sk), &inet6_sk(sk)->rcv_saddr, 0);

109
	/* precompute partial secondary hash */
E
Eric Dumazet 已提交
110 111
	udp_sk(sk)->udp_portaddr_hash = hash2_partial;
	return udp_lib_get_port(sk, snum, ipv6_rcv_saddr_equal, hash2_nulladdr);
L
Linus Torvalds 已提交
112 113
}

E
Eric Dumazet 已提交
114 115 116 117 118 119 120 121 122
static void udp_v6_rehash(struct sock *sk)
{
	u16 new_hash = udp6_portaddr_hash(sock_net(sk),
					  &inet6_sk(sk)->rcv_saddr,
					  inet_sk(sk)->inet_num);

	udp_lib_rehash(sk, new_hash);
}

123 124
static inline int compute_score(struct sock *sk, struct net *net,
				unsigned short hnum,
125 126
				const struct in6_addr *saddr, __be16 sport,
				const struct in6_addr *daddr, __be16 dport,
127 128 129 130
				int dif)
{
	int score = -1;

131
	if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
132 133 134 135 136
			sk->sk_family == PF_INET6) {
		struct ipv6_pinfo *np = inet6_sk(sk);
		struct inet_sock *inet = inet_sk(sk);

		score = 0;
E
Eric Dumazet 已提交
137 138
		if (inet->inet_dport) {
			if (inet->inet_dport != sport)
139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
				return -1;
			score++;
		}
		if (!ipv6_addr_any(&np->rcv_saddr)) {
			if (!ipv6_addr_equal(&np->rcv_saddr, daddr))
				return -1;
			score++;
		}
		if (!ipv6_addr_any(&np->daddr)) {
			if (!ipv6_addr_equal(&np->daddr, saddr))
				return -1;
			score++;
		}
		if (sk->sk_bound_dev_if) {
			if (sk->sk_bound_dev_if != dif)
				return -1;
			score++;
		}
	}
	return score;
}

E
Eric Dumazet 已提交
161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
#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 ipv6_pinfo *np = inet6_sk(sk);
		struct inet_sock *inet = inet_sk(sk);

		if (!ipv6_addr_equal(&np->rcv_saddr, daddr))
			return -1;
		score = 0;
		if (inet->inet_dport) {
			if (inet->inet_dport != sport)
				return -1;
			score++;
		}
		if (!ipv6_addr_any(&np->daddr)) {
			if (!ipv6_addr_equal(&np->daddr, saddr))
				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;
	int score, badness;

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;
			if (score == SCORE2_MAX)
				goto exact_match;
		}
	}
	/*
	 * 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 已提交
230
		if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
E
Eric Dumazet 已提交
231 232 233 234 235 236 237 238 239 240
			result = NULL;
		else if (unlikely(compute_score2(result, net, saddr, sport,
				  daddr, hnum, dif) < badness)) {
			sock_put(result);
			goto begin;
		}
	}
	return result;
}

241
static struct sock *__udp6_lib_lookup(struct net *net,
242 243
				      const struct in6_addr *saddr, __be16 sport,
				      const struct in6_addr *daddr, __be16 dport,
244
				      int dif, struct udp_table *udptable)
L
Linus Torvalds 已提交
245
{
246
	struct sock *sk, *result;
247
	struct hlist_nulls_node *node;
L
Linus Torvalds 已提交
248
	unsigned short hnum = ntohs(dport);
E
Eric Dumazet 已提交
249 250
	unsigned int hash2, slot2, slot = udp_hashfn(net, hnum, udptable->mask);
	struct udp_hslot *hslot2, *hslot = &udptable->hash[slot];
251
	int score, badness;
252

253
	rcu_read_lock();
E
Eric Dumazet 已提交
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
	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;

271 272
			result = udp6_lib_lookup2(net, saddr, sport,
						  &in6addr_any, hnum, dif,
E
Eric Dumazet 已提交
273 274 275 276 277
						  hslot2, slot2);
		}
		rcu_read_unlock();
		return result;
	}
278 279 280
begin:
	result = NULL;
	badness = -1;
281
	sk_nulls_for_each_rcu(sk, node, &hslot->head) {
282 283 284 285
		score = compute_score(sk, net, hnum, saddr, sport, daddr, dport, dif);
		if (score > badness) {
			result = sk;
			badness = score;
L
Linus Torvalds 已提交
286 287
		}
	}
288 289 290 291 292
	/*
	 * 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 已提交
293
	if (get_nulls_value(node) != slot)
294 295
		goto begin;

296
	if (result) {
E
Eric Dumazet 已提交
297
		if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
298 299 300 301 302 303 304 305
			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 已提交
306 307 308
	return result;
}

309 310
static struct sock *__udp6_lib_lookup_skb(struct sk_buff *skb,
					  __be16 sport, __be16 dport,
311
					  struct udp_table *udptable)
312
{
313
	struct sock *sk;
314
	const struct ipv6hdr *iph = ipv6_hdr(skb);
315

316 317
	if (unlikely(sk = skb_steal_sock(skb)))
		return sk;
E
Eric Dumazet 已提交
318 319 320
	return __udp6_lib_lookup(dev_net(skb_dst(skb)->dev), &iph->saddr, sport,
				 &iph->daddr, dport, inet6_iif(skb),
				 udptable);
321 322
}

323 324 325 326 327 328 329 330
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 已提交
331 332 333 334 335
/*
 * 	This should be easy, if there is something there we
 * 	return it, otherwise we block.
 */

336
int udpv6_recvmsg(struct kiocb *iocb, struct sock *sk,
L
Linus Torvalds 已提交
337 338 339 340 341
		  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);
342
	struct sk_buff *skb;
G
Gerrit Renker 已提交
343
	unsigned int ulen;
344
	int peeked;
345 346
	int err;
	int is_udplite = IS_UDPLITE(sk);
347
	int is_udp4;
348
	bool slow;
L
Linus Torvalds 已提交
349

350 351 352
	if (addr_len)
		*addr_len=sizeof(struct sockaddr_in6);

L
Linus Torvalds 已提交
353 354 355
	if (flags & MSG_ERRQUEUE)
		return ipv6_recv_error(sk, msg, len);

356 357 358
	if (np->rxpmtu && np->rxopt.bits.rxpmtu)
		return ipv6_recv_rxpmtu(sk, msg, len);

L
Linus Torvalds 已提交
359
try_again:
360 361
	skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
				  &peeked, &err);
L
Linus Torvalds 已提交
362 363 364
	if (!skb)
		goto out;

365
	ulen = skb->len - sizeof(struct udphdr);
G
Gerrit Renker 已提交
366 367 368
	if (len > ulen)
		len = ulen;
	else if (len < ulen)
369
		msg->msg_flags |= MSG_TRUNC;
L
Linus Torvalds 已提交
370

371 372
	is_udp4 = (skb->protocol == htons(ETH_P_IP));

373
	/*
374 375 376
	 * 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.
377 378
	 */

G
Gerrit Renker 已提交
379
	if (len < ulen || UDP_SKB_CB(skb)->partial_cov) {
380
		if (udp_lib_checksum_complete(skb))
L
Linus Torvalds 已提交
381
			goto csum_copy_err;
382 383
	}

384
	if (skb_csum_unnecessary(skb))
385
		err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
G
Gerrit Renker 已提交
386
					      msg->msg_iov,len);
387
	else {
L
Linus Torvalds 已提交
388 389 390 391 392 393 394
		err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);
		if (err == -EINVAL)
			goto csum_copy_err;
	}
	if (err)
		goto out_free;

395 396 397 398 399 400 401 402
	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);
	}
403

404
	sock_recv_ts_and_drops(msg, sk, skb);
L
Linus Torvalds 已提交
405 406 407 408

	/* Copy the address. */
	if (msg->msg_name) {
		struct sockaddr_in6 *sin6;
409

L
Linus Torvalds 已提交
410 411
		sin6 = (struct sockaddr_in6 *) msg->msg_name;
		sin6->sin6_family = AF_INET6;
412
		sin6->sin6_port = udp_hdr(skb)->source;
L
Linus Torvalds 已提交
413 414 415
		sin6->sin6_flowinfo = 0;
		sin6->sin6_scope_id = 0;

416
		if (is_udp4)
B
Brian Haley 已提交
417 418
			ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
					       &sin6->sin6_addr);
L
Linus Torvalds 已提交
419
		else {
420 421
			ipv6_addr_copy(&sin6->sin6_addr,
				       &ipv6_hdr(skb)->saddr);
L
Linus Torvalds 已提交
422 423 424 425 426
			if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)
				sin6->sin6_scope_id = IP6CB(skb)->iif;
		}

	}
427
	if (is_udp4) {
L
Linus Torvalds 已提交
428 429 430 431 432
		if (inet->cmsg_flags)
			ip_cmsg_recv(msg, skb);
	} else {
		if (np->rxopt.all)
			datagram_recv_ctl(sk, msg, skb);
433
	}
L
Linus Torvalds 已提交
434

G
Gerrit Renker 已提交
435
	err = len;
L
Linus Torvalds 已提交
436
	if (flags & MSG_TRUNC)
437
		err = ulen;
L
Linus Torvalds 已提交
438 439

out_free:
440
	skb_free_datagram_locked(sk, skb);
L
Linus Torvalds 已提交
441 442 443 444
out:
	return err;

csum_copy_err:
445
	slow = lock_sock_fast(sk);
446 447 448 449 450 451 452 453
	if (!skb_kill_datagram(sk, skb, flags)) {
		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);
	}
454
	unlock_sock_fast(sk, slow);
L
Linus Torvalds 已提交
455

456
	if (flags & MSG_DONTWAIT)
L
Linus Torvalds 已提交
457 458 459 460
		return -EAGAIN;
	goto try_again;
}

461
void __udp6_lib_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
462
		    u8 type, u8 code, int offset, __be32 info,
463
		    struct udp_table *udptable)
L
Linus Torvalds 已提交
464 465
{
	struct ipv6_pinfo *np;
466 467 468
	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 已提交
469 470 471 472
	struct udphdr *uh = (struct udphdr*)(skb->data+offset);
	struct sock *sk;
	int err;

473
	sk = __udp6_lib_lookup(dev_net(skb->dev), daddr, uh->dest,
474
			       saddr, uh->source, inet6_iif(skb), udptable);
L
Linus Torvalds 已提交
475 476 477 478 479 480 481 482 483 484 485
	if (sk == NULL)
		return;

	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;

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

L
Linus Torvalds 已提交
489 490 491 492 493 494
	sk->sk_err = err;
	sk->sk_error_report(sk);
out:
	sock_put(sk);
}

495
static __inline__ void udpv6_err(struct sk_buff *skb,
496 497
				 struct inet6_skb_parm *opt, u8 type,
				 u8 code, int offset, __be32 info     )
498
{
499
	__udp6_lib_err(skb, opt, type, code, offset, info, &udp_table);
500 501 502
}

int udpv6_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
503
{
504
	struct udp_sock *up = udp_sk(sk);
505
	int rc;
W
Wang Chen 已提交
506
	int is_udplite = IS_UDPLITE(sk);
507

508 509 510
	if (!ipv6_addr_any(&inet6_sk(sk)->daddr))
		sock_rps_save_rxhash(sk, skb->rxhash);

511 512
	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
		goto drop;
L
Linus Torvalds 已提交
513

514 515 516
	/*
	 * UDP-Lite specific tests, ignored on UDP sockets (see net/ipv4/udp.c).
	 */
W
Wang Chen 已提交
517
	if ((is_udplite & UDPLITE_RECV_CC)  &&  UDP_SKB_CB(skb)->partial_cov) {
518 519 520 521 522 523 524 525 526 527 528 529 530

		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 已提交
531 532
	}

533
	if (rcu_dereference_raw(sk->sk_filter)) {
534 535 536
		if (udp_lib_checksum_complete(skb))
			goto drop;
	}
537

E
Eric Dumazet 已提交
538
	if ((rc = ip_queue_rcv_skb(sk, skb)) < 0) {
539
		/* Note that an ENOMEM error is charged twice */
E
Eric Dumazet 已提交
540
		if (rc == -ENOMEM)
541 542
			UDP6_INC_STATS_BH(sock_net(sk),
					UDP_MIB_RCVBUFERRORS, is_udplite);
E
Eric Dumazet 已提交
543
		goto drop_no_sk_drops_inc;
L
Linus Torvalds 已提交
544
	}
545

L
Linus Torvalds 已提交
546
	return 0;
547
drop:
E
Eric Dumazet 已提交
548 549
	atomic_inc(&sk->sk_drops);
drop_no_sk_drops_inc:
550
	UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
551 552
	kfree_skb(skb);
	return -1;
L
Linus Torvalds 已提交
553 554
}

555
static struct sock *udp_v6_mcast_next(struct net *net, struct sock *sk,
556 557
				      __be16 loc_port, const struct in6_addr *loc_addr,
				      __be16 rmt_port, const struct in6_addr *rmt_addr,
L
Linus Torvalds 已提交
558 559
				      int dif)
{
560
	struct hlist_nulls_node *node;
L
Linus Torvalds 已提交
561 562 563
	struct sock *s = sk;
	unsigned short num = ntohs(loc_port);

564
	sk_nulls_for_each_from(s, node) {
L
Linus Torvalds 已提交
565 566
		struct inet_sock *inet = inet_sk(s);

567
		if (!net_eq(sock_net(s), net))
568 569
			continue;

570 571
		if (udp_sk(s)->udp_port_hash == num &&
		    s->sk_family == PF_INET6) {
L
Linus Torvalds 已提交
572
			struct ipv6_pinfo *np = inet6_sk(s);
E
Eric Dumazet 已提交
573 574
			if (inet->inet_dport) {
				if (inet->inet_dport != rmt_port)
L
Linus Torvalds 已提交
575 576 577 578 579 580 581 582 583 584
					continue;
			}
			if (!ipv6_addr_any(&np->daddr) &&
			    !ipv6_addr_equal(&np->daddr, rmt_addr))
				continue;

			if (s->sk_bound_dev_if && s->sk_bound_dev_if != dif)
				continue;

			if (!ipv6_addr_any(&np->rcv_saddr)) {
585 586
				if (!ipv6_addr_equal(&np->rcv_saddr, loc_addr))
					continue;
L
Linus Torvalds 已提交
587
			}
S
Stephen Hemminger 已提交
588
			if (!inet6_mc_check(s, loc_addr, rmt_addr))
L
Linus Torvalds 已提交
589 590 591 592 593 594 595
				continue;
			return s;
		}
	}
	return NULL;
}

596 597 598 599 600 601 602 603 604 605
static void flush_stack(struct sock **stack, unsigned int count,
			struct sk_buff *skb, unsigned int final)
{
	unsigned int i;
	struct sock *sk;
	struct sk_buff *skb1;

	for (i = 0; i < count; i++) {
		skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);

606
		sk = stack[i];
607
		if (skb1) {
608
			if (sk_rcvqueues_full(sk, skb1)) {
609 610 611
				kfree_skb(skb1);
				goto drop;
			}
612 613 614
			bh_lock_sock(sk);
			if (!sock_owned_by_user(sk))
				udpv6_queue_rcv_skb(sk, skb1);
Z
Zhu Yi 已提交
615
			else if (sk_add_backlog(sk, skb1)) {
Z
Zhu Yi 已提交
616 617 618 619
				kfree_skb(skb1);
				bh_unlock_sock(sk);
				goto drop;
			}
620
			bh_unlock_sock(sk);
Z
Zhu Yi 已提交
621
			continue;
622
		}
Z
Zhu Yi 已提交
623 624 625 626 627 628
drop:
		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));
629 630
	}
}
L
Linus Torvalds 已提交
631 632 633 634
/*
 * Note: called only from the BH handler context,
 * so we don't need to lock the hashes.
 */
635
static int __udp6_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
636
		const struct in6_addr *saddr, const struct in6_addr *daddr,
637
		struct udp_table *udptable)
L
Linus Torvalds 已提交
638
{
639
	struct sock *sk, *stack[256 / sizeof(struct sock *)];
640
	const struct udphdr *uh = udp_hdr(skb);
641
	struct udp_hslot *hslot = udp_hashslot(udptable, net, ntohs(uh->dest));
L
Linus Torvalds 已提交
642
	int dif;
643
	unsigned int i, count = 0;
L
Linus Torvalds 已提交
644

645
	spin_lock(&hslot->lock);
646
	sk = sk_nulls_head(&hslot->head);
647
	dif = inet6_iif(skb);
648
	sk = udp_v6_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
649 650 651 652 653 654 655 656 657
	while (sk) {
		stack[count++] = sk;
		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 已提交
658
		}
L
Linus Torvalds 已提交
659
	}
660 661 662 663 664 665
	/*
	 * before releasing the lock, we must take reference on sockets
	 */
	for (i = 0; i < count; i++)
		sock_hold(stack[i]);

666
	spin_unlock(&hslot->lock);
667 668 669 670 671 672 673 674 675

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

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

679 680
static inline int udp6_csum_init(struct sk_buff *skb, struct udphdr *uh,
				 int proto)
681
{
682 683 684 685 686
	int err;

	UDP_SKB_CB(skb)->partial_cov = 0;
	UDP_SKB_CB(skb)->cscov = skb->len;

687
	if (proto == IPPROTO_UDPLITE) {
688 689 690 691 692
		err = udplite_checksum_init(skb, uh);
		if (err)
			return err;
	}

693 694 695 696 697 698 699 700
	if (uh->check == 0) {
		/* 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\n");
		return 1;
	}
	if (skb->ip_summed == CHECKSUM_COMPLETE &&
701
	    !csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
702
			     skb->len, proto, skb->csum))
703 704
		skb->ip_summed = CHECKSUM_UNNECESSARY;

705
	if (!skb_csum_unnecessary(skb))
706 707
		skb->csum = ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
							 &ipv6_hdr(skb)->daddr,
708
							 skb->len, proto, 0));
709

710
	return 0;
711 712
}

713
int __udp6_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
714
		   int proto)
L
Linus Torvalds 已提交
715
{
716
	struct net *net = dev_net(skb->dev);
L
Linus Torvalds 已提交
717
	struct sock *sk;
718
	struct udphdr *uh;
719
	const struct in6_addr *saddr, *daddr;
L
Linus Torvalds 已提交
720 721 722
	u32 ulen = 0;

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

725 726
	saddr = &ipv6_hdr(skb)->saddr;
	daddr = &ipv6_hdr(skb)->daddr;
727
	uh = udp_hdr(skb);
L
Linus Torvalds 已提交
728 729

	ulen = ntohs(uh->len);
730 731
	if (ulen > skb->len)
		goto short_packet;
L
Linus Torvalds 已提交
732

733 734
	if (proto == IPPROTO_UDP) {
		/* UDP validates ulen. */
L
Linus Torvalds 已提交
735

736 737 738
		/* Check for jumbo payload */
		if (ulen == 0)
			ulen = skb->len;
L
Linus Torvalds 已提交
739

740 741
		if (ulen < sizeof(*uh))
			goto short_packet;
L
Linus Torvalds 已提交
742

743 744 745
		if (ulen < skb->len) {
			if (pskb_trim_rcsum(skb, ulen))
				goto short_packet;
746 747
			saddr = &ipv6_hdr(skb)->saddr;
			daddr = &ipv6_hdr(skb)->daddr;
748
			uh = udp_hdr(skb);
749 750
		}
	}
L
Linus Torvalds 已提交
751

752 753 754
	if (udp6_csum_init(skb, uh, proto))
		goto discard;

755 756
	/*
	 *	Multicast receive code
L
Linus Torvalds 已提交
757
	 */
758
	if (ipv6_addr_is_multicast(daddr))
759 760
		return __udp6_lib_mcast_deliver(net, skb,
				saddr, daddr, udptable);
L
Linus Torvalds 已提交
761 762 763

	/* Unicast */

764
	/*
L
Linus Torvalds 已提交
765 766 767
	 * check socket cache ... must talk to Alan about his plans
	 * for sock caches... i'll skip this for now.
	 */
768
	sk = __udp6_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
L
Linus Torvalds 已提交
769 770 771 772 773

	if (sk == NULL) {
		if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
			goto discard;

774
		if (udp_lib_checksum_complete(skb))
L
Linus Torvalds 已提交
775
			goto discard;
776 777
		UDP6_INC_STATS_BH(net, UDP_MIB_NOPORTS,
				proto == IPPROTO_UDPLITE);
L
Linus Torvalds 已提交
778

779
		icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
L
Linus Torvalds 已提交
780 781

		kfree_skb(skb);
S
Stephen Hemminger 已提交
782
		return 0;
L
Linus Torvalds 已提交
783
	}
784

L
Linus Torvalds 已提交
785
	/* deliver */
786

787 788 789 790
	if (sk_rcvqueues_full(sk, skb)) {
		sock_put(sk);
		goto discard;
	}
791
	bh_lock_sock(sk);
H
Hideo Aoki 已提交
792 793
	if (!sock_owned_by_user(sk))
		udpv6_queue_rcv_skb(sk, skb);
Z
Zhu Yi 已提交
794
	else if (sk_add_backlog(sk, skb)) {
Z
Zhu Yi 已提交
795 796 797 798 799
		atomic_inc(&sk->sk_drops);
		bh_unlock_sock(sk);
		sock_put(sk);
		goto discard;
	}
H
Hideo Aoki 已提交
800
	bh_unlock_sock(sk);
L
Linus Torvalds 已提交
801
	sock_put(sk);
S
Stephen Hemminger 已提交
802
	return 0;
L
Linus Torvalds 已提交
803

804
short_packet:
805
	LIMIT_NETDEBUG(KERN_DEBUG "UDP%sv6: short packet: From [%pI6c]:%u %d/%d to [%pI6c]:%u\n",
806
		       proto == IPPROTO_UDPLITE ? "-Lite" : "",
807 808 809 810 811 812
		       saddr,
		       ntohs(uh->source),
		       ulen,
		       skb->len,
		       daddr,
		       ntohs(uh->dest));
L
Linus Torvalds 已提交
813 814

discard:
815
	UDP6_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
L
Linus Torvalds 已提交
816
	kfree_skb(skb);
S
Stephen Hemminger 已提交
817
	return 0;
L
Linus Torvalds 已提交
818
}
819

820
static __inline__ int udpv6_rcv(struct sk_buff *skb)
821
{
822
	return __udp6_lib_rcv(skb, &udp_table, IPPROTO_UDP);
823 824
}

L
Linus Torvalds 已提交
825 826 827 828 829 830 831
/*
 * 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);

832 833 834
	if (up->pending == AF_INET)
		udp_flush_pending_frames(sk);
	else if (up->pending) {
L
Linus Torvalds 已提交
835 836 837
		up->len = 0;
		up->pending = 0;
		ip6_flush_pending_frames(sk);
838
	}
L
Linus Torvalds 已提交
839 840
}

841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881
/**
 * 	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 已提交
882 883 884 885
/*
 *	Sending
 */

886
static int udp_v6_push_pending_frames(struct sock *sk)
L
Linus Torvalds 已提交
887 888 889
{
	struct sk_buff *skb;
	struct udphdr *uh;
890
	struct udp_sock  *up = udp_sk(sk);
L
Linus Torvalds 已提交
891
	struct inet_sock *inet = inet_sk(sk);
892
	struct flowi6 *fl6 = &inet->cork.fl.u.ip6;
L
Linus Torvalds 已提交
893
	int err = 0;
W
Wang Chen 已提交
894
	int is_udplite = IS_UDPLITE(sk);
895
	__wsum csum = 0;
L
Linus Torvalds 已提交
896 897 898 899 900 901 902 903

	/* Grab the skbuff where UDP header space exists. */
	if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
		goto out;

	/*
	 * Create a UDP header
	 */
904
	uh = udp_hdr(skb);
905 906
	uh->source = fl6->fl6_sport;
	uh->dest = fl6->fl6_dport;
L
Linus Torvalds 已提交
907 908 909
	uh->len = htons(up->len);
	uh->check = 0;

W
Wang Chen 已提交
910
	if (is_udplite)
911
		csum = udplite_csum_outgoing(sk, skb);
912
	else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
913
		udp6_hwcsum_outgoing(sk, skb, &fl6->saddr, &fl6->daddr,
914 915 916
				     up->len);
		goto send;
	} else
917
		csum = udp_csum_outgoing(sk, skb);
L
Linus Torvalds 已提交
918

919
	/* add protocol-dependent pseudo-header */
920 921
	uh->check = csum_ipv6_magic(&fl6->saddr, &fl6->daddr,
				    up->len, fl6->flowi6_proto, csum);
L
Linus Torvalds 已提交
922
	if (uh->check == 0)
923
		uh->check = CSUM_MANGLED_0;
L
Linus Torvalds 已提交
924

925
send:
L
Linus Torvalds 已提交
926
	err = ip6_push_pending_frames(sk);
E
Eric Dumazet 已提交
927 928 929 930 931 932 933 934 935
	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 已提交
936 937 938 939 940 941
out:
	up->len = 0;
	up->pending = 0;
	return err;
}

942
int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
L
Linus Torvalds 已提交
943 944 945 946 947 948 949
		  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);
	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) msg->msg_name;
950
	struct in6_addr *daddr, *final_p, final;
L
Linus Torvalds 已提交
951 952
	struct ipv6_txoptions *opt = NULL;
	struct ip6_flowlabel *flowlabel = NULL;
953
	struct flowi6 fl6;
L
Linus Torvalds 已提交
954 955 956 957
	struct dst_entry *dst;
	int addr_len = msg->msg_namelen;
	int ulen = len;
	int hlimit = -1;
958
	int tclass = -1;
959
	int dontfrag = -1;
L
Linus Torvalds 已提交
960 961
	int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
	int err;
962
	int connected = 0;
W
Wang Chen 已提交
963
	int is_udplite = IS_UDPLITE(sk);
964
	int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
L
Linus Torvalds 已提交
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

	/* 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;
		daddr = &np->daddr;
991
	} else
L
Linus Torvalds 已提交
992 993 994
		daddr = NULL;

	if (daddr) {
B
Brian Haley 已提交
995
		if (ipv6_addr_v4mapped(daddr)) {
L
Linus Torvalds 已提交
996 997
			struct sockaddr_in sin;
			sin.sin_family = AF_INET;
E
Eric Dumazet 已提交
998
			sin.sin_port = sin6 ? sin6->sin6_port : inet->inet_dport;
L
Linus Torvalds 已提交
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
			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,
1013
	   better check is made in ip6_append_data().
L
Linus Torvalds 已提交
1014 1015 1016
	   */
	if (len > INT_MAX - sizeof(struct udphdr))
		return -EMSGSIZE;
1017

L
Linus Torvalds 已提交
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
	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);

1036
	memset(&fl6, 0, sizeof(fl6));
L
Linus Torvalds 已提交
1037 1038 1039 1040 1041

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

1042
		fl6.fl6_dport = sin6->sin6_port;
L
Linus Torvalds 已提交
1043 1044 1045
		daddr = &sin6->sin6_addr;

		if (np->sndflow) {
1046 1047 1048
			fl6.flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
			if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
				flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
L
Linus Torvalds 已提交
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
				if (flowlabel == NULL)
					return -EINVAL;
				daddr = &flowlabel->dst;
			}
		}

		/*
		 * Otherwise it will be difficult to maintain
		 * sk->sk_dst_cache.
		 */
		if (sk->sk_state == TCP_ESTABLISHED &&
		    ipv6_addr_equal(daddr, &np->daddr))
			daddr = &np->daddr;

		if (addr_len >= sizeof(struct sockaddr_in6) &&
		    sin6->sin6_scope_id &&
		    ipv6_addr_type(daddr)&IPV6_ADDR_LINKLOCAL)
1066
			fl6.flowi6_oif = sin6->sin6_scope_id;
L
Linus Torvalds 已提交
1067 1068 1069 1070
	} else {
		if (sk->sk_state != TCP_ESTABLISHED)
			return -EDESTADDRREQ;

1071
		fl6.fl6_dport = inet->inet_dport;
L
Linus Torvalds 已提交
1072
		daddr = &np->daddr;
1073
		fl6.flowlabel = np->flow_label;
1074
		connected = 1;
L
Linus Torvalds 已提交
1075 1076
	}

1077 1078
	if (!fl6.flowi6_oif)
		fl6.flowi6_oif = sk->sk_bound_dev_if;
L
Linus Torvalds 已提交
1079

1080 1081
	if (!fl6.flowi6_oif)
		fl6.flowi6_oif = np->sticky_pktinfo.ipi6_ifindex;
1082

1083
	fl6.flowi6_mark = sk->sk_mark;
B
Brian Haley 已提交
1084

L
Linus Torvalds 已提交
1085 1086 1087 1088 1089
	if (msg->msg_controllen) {
		opt = &opt_space;
		memset(opt, 0, sizeof(struct ipv6_txoptions));
		opt->tot_len = sizeof(*opt);

1090
		err = datagram_send_ctl(sock_net(sk), msg, &fl6, opt, &hlimit,
1091
					&tclass, &dontfrag);
L
Linus Torvalds 已提交
1092 1093 1094 1095
		if (err < 0) {
			fl6_sock_release(flowlabel);
			return err;
		}
1096 1097
		if ((fl6.flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) {
			flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
L
Linus Torvalds 已提交
1098 1099 1100 1101 1102
			if (flowlabel == NULL)
				return -EINVAL;
		}
		if (!(opt->opt_nflen|opt->opt_flen))
			opt = NULL;
1103
		connected = 0;
L
Linus Torvalds 已提交
1104 1105 1106
	}
	if (opt == NULL)
		opt = np->opt;
1107 1108 1109
	if (flowlabel)
		opt = fl6_merge_options(&opt_space, flowlabel, opt);
	opt = ipv6_fixup_options(&opt_space, opt);
L
Linus Torvalds 已提交
1110

1111
	fl6.flowi6_proto = sk->sk_protocol;
1112
	if (!ipv6_addr_any(daddr))
1113
		ipv6_addr_copy(&fl6.daddr, daddr);
1114
	else
1115 1116 1117
		fl6.daddr.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
	if (ipv6_addr_any(&fl6.saddr) && !ipv6_addr_any(&np->saddr))
		ipv6_addr_copy(&fl6.saddr, &np->saddr);
1118
	fl6.fl6_sport = inet->inet_sport;
1119

1120
	final_p = fl6_update_dst(&fl6, opt, &final);
1121
	if (final_p)
1122
		connected = 0;
L
Linus Torvalds 已提交
1123

1124 1125
	if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr)) {
		fl6.flowi6_oif = np->mcast_oif;
1126 1127
		connected = 0;
	}
L
Linus Torvalds 已提交
1128

1129
	security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
V
Venkat Yekkirala 已提交
1130

1131
	dst = ip6_sk_dst_lookup_flow(sk, &fl6, final_p, true);
1132 1133 1134
	if (IS_ERR(dst)) {
		err = PTR_ERR(dst);
		dst = NULL;
L
Linus Torvalds 已提交
1135
		goto out;
1136
	}
L
Linus Torvalds 已提交
1137 1138

	if (hlimit < 0) {
1139
		if (ipv6_addr_is_multicast(&fl6.daddr))
L
Linus Torvalds 已提交
1140 1141 1142 1143
			hlimit = np->mcast_hops;
		else
			hlimit = np->hop_limit;
		if (hlimit < 0)
1144
			hlimit = ip6_dst_hoplimit(dst);
L
Linus Torvalds 已提交
1145 1146
	}

G
Gerrit Renker 已提交
1147
	if (tclass < 0)
1148 1149
		tclass = np->tclass;

1150 1151 1152
	if (dontfrag < 0)
		dontfrag = np->dontfrag;

L
Linus Torvalds 已提交
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
	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);

1163
		LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
L
Linus Torvalds 已提交
1164 1165 1166 1167 1168 1169 1170 1171
		err = -EINVAL;
		goto out;
	}

	up->pending = AF_INET6;

do_append_data:
	up->len += ulen;
1172 1173
	getfrag  =  is_udplite ?  udplite_getfrag : ip_generic_getfrag;
	err = ip6_append_data(sk, getfrag, msg->msg_iov, ulen,
1174
		sizeof(struct udphdr), hlimit, tclass, opt, &fl6,
1175
		(struct rt6_info*)dst,
1176
		corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags, dontfrag);
L
Linus Torvalds 已提交
1177 1178 1179
	if (err)
		udp_v6_flush_pending_frames(sk);
	else if (!corkreq)
1180
		err = udp_v6_push_pending_frames(sk);
H
Herbert Xu 已提交
1181 1182
	else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
		up->pending = 0;
L
Linus Torvalds 已提交
1183

1184 1185 1186
	if (dst) {
		if (connected) {
			ip6_dst_store(sk, dst,
1187
				      ipv6_addr_equal(&fl6.daddr, &np->daddr) ?
1188 1189
				      &np->daddr : NULL,
#ifdef CONFIG_IPV6_SUBTREES
1190
				      ipv6_addr_equal(&fl6.saddr, &np->saddr) ?
1191 1192 1193
				      &np->saddr :
#endif
				      NULL);
1194 1195 1196
		} else {
			dst_release(dst);
		}
1197
		dst = NULL;
1198 1199
	}

L
Linus Torvalds 已提交
1200 1201 1202 1203
	if (err > 0)
		err = np->recverr ? net_xmit_errno(err) : 0;
	release_sock(sk);
out:
1204
	dst_release(dst);
L
Linus Torvalds 已提交
1205
	fl6_sock_release(flowlabel);
1206
	if (!err)
L
Linus Torvalds 已提交
1207
		return len;
1208 1209 1210 1211 1212 1213 1214 1215
	/*
	 * 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)) {
1216 1217
		UDP6_INC_STATS_USER(sock_net(sk),
				UDP_MIB_SNDBUFERRORS, is_udplite);
1218
	}
L
Linus Torvalds 已提交
1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
	return err;

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

1229
void udpv6_destroy_sock(struct sock *sk)
L
Linus Torvalds 已提交
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240
{
	lock_sock(sk);
	udp_v6_flush_pending_frames(sk);
	release_sock(sk);

	inet6_destroy_sock(sk);
}

/*
 *	Socket option code for UDP
 */
1241
int udpv6_setsockopt(struct sock *sk, int level, int optname,
1242
		     char __user *optval, unsigned int optlen)
1243
{
1244
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1245 1246
		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
					  udp_v6_push_pending_frames);
1247
	return ipv6_setsockopt(sk, level, optname, optval, optlen);
1248 1249 1250
}

#ifdef CONFIG_COMPAT
1251
int compat_udpv6_setsockopt(struct sock *sk, int level, int optname,
1252
			    char __user *optval, unsigned int optlen)
1253
{
1254
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1255 1256
		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
					  udp_v6_push_pending_frames);
1257
	return compat_ipv6_setsockopt(sk, level, optname, optval, optlen);
1258 1259 1260
}
#endif

1261 1262
int udpv6_getsockopt(struct sock *sk, int level, int optname,
		     char __user *optval, int __user *optlen)
1263
{
1264
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1265
		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1266
	return ipv6_getsockopt(sk, level, optname, optval, optlen);
1267 1268 1269
}

#ifdef CONFIG_COMPAT
1270 1271
int compat_udpv6_getsockopt(struct sock *sk, int level, int optname,
			    char __user *optval, int __user *optlen)
1272
{
1273
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1274
		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1275
	return compat_ipv6_getsockopt(sk, level, optname, optval, optlen);
1276 1277 1278
}
#endif

1279 1280
static int udp6_ufo_send_check(struct sk_buff *skb)
{
1281
	const struct ipv6hdr *ipv6h;
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297
	struct udphdr *uh;

	if (!pskb_may_pull(skb, sizeof(*uh)))
		return -EINVAL;

	ipv6h = ipv6_hdr(skb);
	uh = udp_hdr(skb);

	uh->check = ~csum_ipv6_magic(&ipv6h->saddr, &ipv6h->daddr, skb->len,
				     IPPROTO_UDP, 0);
	skb->csum_start = skb_transport_header(skb) - skb->head;
	skb->csum_offset = offsetof(struct udphdr, check);
	skb->ip_summed = CHECKSUM_PARTIAL;
	return 0;
}

1298
static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb, u32 features)
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
{
	struct sk_buff *segs = ERR_PTR(-EINVAL);
	unsigned int mss;
	unsigned int unfrag_ip6hlen, unfrag_len;
	struct frag_hdr *fptr;
	u8 *mac_start, *prevhdr;
	u8 nexthdr;
	u8 frag_hdr_sz = sizeof(struct frag_hdr);
	int offset;
	__wsum csum;

	mss = skb_shinfo(skb)->gso_size;
	if (unlikely(skb->len <= mss))
		goto out;

	if (skb_gso_ok(skb, features | NETIF_F_GSO_ROBUST)) {
		/* Packet is from an untrusted source, reset gso_segs. */
		int type = skb_shinfo(skb)->gso_type;

		if (unlikely(type & ~(SKB_GSO_UDP | SKB_GSO_DODGY) ||
			     !(type & (SKB_GSO_UDP))))
			goto out;

		skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss);

		segs = NULL;
		goto out;
	}

	/* Do software UFO. Complete and fill in the UDP checksum as HW cannot
	 * do checksum of UDP packets sent as multiple IP fragments.
	 */
1331
	offset = skb_checksum_start_offset(skb);
1332 1333 1334 1335 1336 1337
	csum = skb_checksum(skb, offset, skb->len- offset, 0);
	offset += skb->csum_offset;
	*(__sum16 *)(skb->data + offset) = csum_fold(csum);
	skb->ip_summed = CHECKSUM_NONE;

	/* Check if there is enough headroom to insert fragment header. */
1338
	if ((skb_mac_header(skb) < skb->head + frag_hdr_sz) &&
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
	    pskb_expand_head(skb, frag_hdr_sz, 0, GFP_ATOMIC))
		goto out;

	/* Find the unfragmentable header and shift it left by frag_hdr_sz
	 * bytes to insert fragment header.
	 */
	unfrag_ip6hlen = ip6_find_1stfragopt(skb, &prevhdr);
	nexthdr = *prevhdr;
	*prevhdr = NEXTHDR_FRAGMENT;
	unfrag_len = skb_network_header(skb) - skb_mac_header(skb) +
		     unfrag_ip6hlen;
	mac_start = skb_mac_header(skb);
	memmove(mac_start-frag_hdr_sz, mac_start, unfrag_len);

	skb->mac_header -= frag_hdr_sz;
	skb->network_header -= frag_hdr_sz;

	fptr = (struct frag_hdr *)(skb_network_header(skb) + unfrag_ip6hlen);
	fptr->nexthdr = nexthdr;
	fptr->reserved = 0;
	ipv6_select_ident(fptr);

	/* Fragment the skb. ipv6 header and the remaining fields of the
	 * fragment header are updated in ipv6_gso_segment()
	 */
	segs = skb_segment(skb, features);

out:
	return segs;
}

1370
static const struct inet6_protocol udpv6_protocol = {
L
Linus Torvalds 已提交
1371 1372
	.handler	=	udpv6_rcv,
	.err_handler	=	udpv6_err,
1373 1374
	.gso_send_check =	udp6_ufo_send_check,
	.gso_segment	=	udp6_ufo_fragment,
L
Linus Torvalds 已提交
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384
	.flags		=	INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
};

/* ------------------------------------------------------------------------ */
#ifdef CONFIG_PROC_FS

static void udp6_sock_seq_show(struct seq_file *seq, struct sock *sp, int bucket)
{
	struct inet_sock *inet = inet_sk(sp);
	struct ipv6_pinfo *np = inet6_sk(sp);
1385
	const struct in6_addr *dest, *src;
L
Linus Torvalds 已提交
1386 1387 1388 1389
	__u16 destp, srcp;

	dest  = &np->daddr;
	src   = &np->rcv_saddr;
E
Eric Dumazet 已提交
1390 1391
	destp = ntohs(inet->inet_dport);
	srcp  = ntohs(inet->inet_sport);
L
Linus Torvalds 已提交
1392
	seq_printf(seq,
1393
		   "%5d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
E
Eric Dumazet 已提交
1394
		   "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d\n",
L
Linus Torvalds 已提交
1395 1396 1397 1398 1399
		   bucket,
		   src->s6_addr32[0], src->s6_addr32[1],
		   src->s6_addr32[2], src->s6_addr32[3], srcp,
		   dest->s6_addr32[0], dest->s6_addr32[1],
		   dest->s6_addr32[2], dest->s6_addr32[3], destp,
1400
		   sp->sk_state,
1401 1402
		   sk_wmem_alloc_get(sp),
		   sk_rmem_alloc_get(sp),
L
Linus Torvalds 已提交
1403 1404 1405
		   0, 0L, 0,
		   sock_i_uid(sp), 0,
		   sock_i_ino(sp),
E
Eric Dumazet 已提交
1406 1407
		   atomic_read(&sp->sk_refcnt), sp,
		   atomic_read(&sp->sk_drops));
L
Linus Torvalds 已提交
1408 1409
}

1410
int udp6_seq_show(struct seq_file *seq, void *v)
L
Linus Torvalds 已提交
1411 1412 1413 1414 1415 1416 1417
{
	if (v == SEQ_START_TOKEN)
		seq_printf(seq,
			   "  sl  "
			   "local_address                         "
			   "remote_address                        "
			   "st tx_queue rx_queue tr tm->when retrnsmt"
E
Eric Dumazet 已提交
1418
			   "   uid  timeout inode ref pointer drops\n");
L
Linus Torvalds 已提交
1419 1420 1421 1422 1423 1424 1425 1426
	else
		udp6_sock_seq_show(seq, v, ((struct udp_iter_state *)seq->private)->bucket);
	return 0;
}

static struct udp_seq_afinfo udp6_seq_afinfo = {
	.name		= "udp6",
	.family		= AF_INET6,
1427
	.udp_table	= &udp_table,
1428 1429 1430
	.seq_fops	= {
		.owner	=	THIS_MODULE,
	},
1431 1432 1433
	.seq_ops	= {
		.show		= udp6_seq_show,
	},
L
Linus Torvalds 已提交
1434 1435
};

1436
int __net_init udp6_proc_init(struct net *net)
L
Linus Torvalds 已提交
1437
{
1438
	return udp_proc_register(net, &udp6_seq_afinfo);
L
Linus Torvalds 已提交
1439 1440
}

1441 1442
void udp6_proc_exit(struct net *net) {
	udp_proc_unregister(net, &udp6_seq_afinfo);
L
Linus Torvalds 已提交
1443 1444 1445 1446 1447 1448
}
#endif /* CONFIG_PROC_FS */

/* ------------------------------------------------------------------------ */

struct proto udpv6_prot = {
1449 1450
	.name		   = "UDPv6",
	.owner		   = THIS_MODULE,
1451
	.close		   = udp_lib_close,
1452 1453 1454 1455 1456 1457 1458 1459 1460
	.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,
	.backlog_rcv	   = udpv6_queue_rcv_skb,
1461 1462
	.hash		   = udp_lib_hash,
	.unhash		   = udp_lib_unhash,
E
Eric Dumazet 已提交
1463
	.rehash		   = udp_v6_rehash,
1464
	.get_port	   = udp_v6_get_port,
H
Hideo Aoki 已提交
1465 1466 1467 1468
	.memory_allocated  = &udp_memory_allocated,
	.sysctl_mem	   = sysctl_udp_mem,
	.sysctl_wmem	   = &sysctl_udp_wmem_min,
	.sysctl_rmem	   = &sysctl_udp_rmem_min,
1469
	.obj_size	   = sizeof(struct udp6_sock),
1470
	.slab_flags	   = SLAB_DESTROY_BY_RCU,
1471
	.h.udp_table	   = &udp_table,
1472
#ifdef CONFIG_COMPAT
1473 1474
	.compat_setsockopt = compat_udpv6_setsockopt,
	.compat_getsockopt = compat_udpv6_getsockopt,
1475
#endif
1476
	.clear_sk	   = sk_prot_clear_portaddr_nulls,
L
Linus Torvalds 已提交
1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
};

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


1489
int __init udpv6_init(void)
L
Linus Torvalds 已提交
1490
{
1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
	int ret;

	ret = inet6_add_protocol(&udpv6_protocol, IPPROTO_UDP);
	if (ret)
		goto out;

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

1508
void udpv6_exit(void)
1509 1510 1511
{
	inet6_unregister_protosw(&udpv6_protosw);
	inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
L
Linus Torvalds 已提交
1512
}