udp.c 37.2 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);
E
Eric Dumazet 已提交
57
	__be32 sk1_rcv_saddr = inet_sk(sk)->inet_rcv_saddr;
58
	__be32 sk2_rcv_saddr = inet_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 315
	struct ipv6hdr *iph = ipv6_hdr(skb);

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 466 467 468 469 470 471 472
{
	struct ipv6_pinfo *np;
	struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
	struct in6_addr *saddr = &hdr->saddr;
	struct in6_addr *daddr = &hdr->daddr;
	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
	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
		goto drop;
L
Linus Torvalds 已提交
510

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

		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 已提交
528 529
	}

530
	if (rcu_dereference_raw(sk->sk_filter)) {
531 532 533
		if (udp_lib_checksum_complete(skb))
			goto drop;
	}
534

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

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

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

561
	sk_nulls_for_each_from(s, node) {
L
Linus Torvalds 已提交
562 563
		struct inet_sock *inet = inet_sk(s);

564
		if (!net_eq(sock_net(s), net))
565 566
			continue;

567 568
		if (udp_sk(s)->udp_port_hash == num &&
		    s->sk_family == PF_INET6) {
L
Linus Torvalds 已提交
569
			struct ipv6_pinfo *np = inet6_sk(s);
E
Eric Dumazet 已提交
570 571
			if (inet->inet_dport) {
				if (inet->inet_dport != rmt_port)
L
Linus Torvalds 已提交
572 573 574 575 576 577 578 579 580 581
					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)) {
582 583
				if (!ipv6_addr_equal(&np->rcv_saddr, loc_addr))
					continue;
L
Linus Torvalds 已提交
584
			}
S
Stephen Hemminger 已提交
585
			if (!inet6_mc_check(s, loc_addr, rmt_addr))
L
Linus Torvalds 已提交
586 587 588 589 590 591 592
				continue;
			return s;
		}
	}
	return NULL;
}

593 594 595 596 597 598 599 600 601 602
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);

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

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

663
	spin_unlock(&hslot->lock);
664 665 666 667 668 669 670 671 672

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

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

676 677
static inline int udp6_csum_init(struct sk_buff *skb, struct udphdr *uh,
				 int proto)
678
{
679 680 681 682 683
	int err;

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

684
	if (proto == IPPROTO_UDPLITE) {
685 686 687 688 689
		err = udplite_checksum_init(skb, uh);
		if (err)
			return err;
	}

690 691 692 693 694 695 696 697
	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 &&
698
	    !csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
699
			     skb->len, proto, skb->csum))
700 701
		skb->ip_summed = CHECKSUM_UNNECESSARY;

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

707
	return 0;
708 709
}

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

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

722 723
	saddr = &ipv6_hdr(skb)->saddr;
	daddr = &ipv6_hdr(skb)->daddr;
724
	uh = udp_hdr(skb);
L
Linus Torvalds 已提交
725 726

	ulen = ntohs(uh->len);
727 728
	if (ulen > skb->len)
		goto short_packet;
L
Linus Torvalds 已提交
729

730 731
	if (proto == IPPROTO_UDP) {
		/* UDP validates ulen. */
L
Linus Torvalds 已提交
732

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

737 738
		if (ulen < sizeof(*uh))
			goto short_packet;
L
Linus Torvalds 已提交
739

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

749 750 751
	if (udp6_csum_init(skb, uh, proto))
		goto discard;

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

	/* Unicast */

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

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

771
		if (udp_lib_checksum_complete(skb))
L
Linus Torvalds 已提交
772
			goto discard;
773 774
		UDP6_INC_STATS_BH(net, UDP_MIB_NOPORTS,
				proto == IPPROTO_UDPLITE);
L
Linus Torvalds 已提交
775

776
		icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
L
Linus Torvalds 已提交
777 778

		kfree_skb(skb);
S
Stephen Hemminger 已提交
779
		return 0;
L
Linus Torvalds 已提交
780
	}
781

L
Linus Torvalds 已提交
782
	/* deliver */
783

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

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

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

817
static __inline__ int udpv6_rcv(struct sk_buff *skb)
818
{
819
	return __udp6_lib_rcv(skb, &udp_table, IPPROTO_UDP);
820 821
}

L
Linus Torvalds 已提交
822 823 824 825 826 827 828
/*
 * 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);

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

838 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
/**
 * 	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 已提交
879 880 881 882
/*
 *	Sending
 */

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

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

	/*
	 * Create a UDP header
	 */
901
	uh = udp_hdr(skb);
L
Linus Torvalds 已提交
902 903 904 905 906
	uh->source = fl->fl_ip_sport;
	uh->dest = fl->fl_ip_dport;
	uh->len = htons(up->len);
	uh->check = 0;

W
Wang Chen 已提交
907
	if (is_udplite)
908
		csum = udplite_csum_outgoing(sk, skb);
909 910 911 912 913
	else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
		udp6_hwcsum_outgoing(sk, skb, &fl->fl6_src, &fl->fl6_dst,
				     up->len);
		goto send;
	} else
914
		csum = udp_csum_outgoing(sk, skb);
L
Linus Torvalds 已提交
915

916 917 918
	/* add protocol-dependent pseudo-header */
	uh->check = csum_ipv6_magic(&fl->fl6_src, &fl->fl6_dst,
				    up->len, fl->proto, csum   );
L
Linus Torvalds 已提交
919
	if (uh->check == 0)
920
		uh->check = CSUM_MANGLED_0;
L
Linus Torvalds 已提交
921

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

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

	/* 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;
988
	} else
L
Linus Torvalds 已提交
989 990 991
		daddr = NULL;

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

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

H
Herbert Xu 已提交
1033
	memset(&fl, 0, sizeof(fl));
L
Linus Torvalds 已提交
1034 1035 1036 1037 1038

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

H
Herbert Xu 已提交
1039
		fl.fl_ip_dport = sin6->sin6_port;
L
Linus Torvalds 已提交
1040 1041 1042
		daddr = &sin6->sin6_addr;

		if (np->sndflow) {
H
Herbert Xu 已提交
1043 1044 1045
			fl.fl6_flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
			if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
				flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
L
Linus Torvalds 已提交
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
				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)
H
Herbert Xu 已提交
1063
			fl.oif = sin6->sin6_scope_id;
L
Linus Torvalds 已提交
1064 1065 1066 1067
	} else {
		if (sk->sk_state != TCP_ESTABLISHED)
			return -EDESTADDRREQ;

E
Eric Dumazet 已提交
1068
		fl.fl_ip_dport = inet->inet_dport;
L
Linus Torvalds 已提交
1069
		daddr = &np->daddr;
H
Herbert Xu 已提交
1070
		fl.fl6_flowlabel = np->flow_label;
1071
		connected = 1;
L
Linus Torvalds 已提交
1072 1073
	}

H
Herbert Xu 已提交
1074 1075
	if (!fl.oif)
		fl.oif = sk->sk_bound_dev_if;
L
Linus Torvalds 已提交
1076

1077 1078 1079
	if (!fl.oif)
		fl.oif = np->sticky_pktinfo.ipi6_ifindex;

B
Brian Haley 已提交
1080 1081
	fl.mark = sk->sk_mark;

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

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

1108
	fl.proto = sk->sk_protocol;
1109 1110 1111 1112
	if (!ipv6_addr_any(daddr))
		ipv6_addr_copy(&fl.fl6_dst, daddr);
	else
		fl.fl6_dst.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
H
Herbert Xu 已提交
1113 1114
	if (ipv6_addr_any(&fl.fl6_src) && !ipv6_addr_any(&np->saddr))
		ipv6_addr_copy(&fl.fl6_src, &np->saddr);
E
Eric Dumazet 已提交
1115
	fl.fl_ip_sport = inet->inet_sport;
1116

1117 1118
	final_p = fl6_update_dst(&fl, opt, &final);
	if (final_p)
1119
		connected = 0;
L
Linus Torvalds 已提交
1120

H
Herbert Xu 已提交
1121 1122
	if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst)) {
		fl.oif = np->mcast_oif;
1123 1124
		connected = 0;
	}
L
Linus Torvalds 已提交
1125

H
Herbert Xu 已提交
1126
	security_sk_classify_flow(sk, &fl);
V
Venkat Yekkirala 已提交
1127

H
Herbert Xu 已提交
1128
	err = ip6_sk_dst_lookup(sk, &dst, &fl);
L
Linus Torvalds 已提交
1129 1130 1131
	if (err)
		goto out;
	if (final_p)
H
Herbert Xu 已提交
1132
		ipv6_addr_copy(&fl.fl6_dst, final_p);
L
Linus Torvalds 已提交
1133

A
Alexey Dobriyan 已提交
1134 1135
	err = __xfrm_lookup(sock_net(sk), &dst, &fl, sk, XFRM_LOOKUP_WAIT);
	if (err < 0) {
1136 1137 1138 1139 1140
		if (err == -EREMOTE)
			err = ip6_dst_blackhole(sk, &dst, &fl);
		if (err < 0)
			goto out;
	}
L
Linus Torvalds 已提交
1141 1142

	if (hlimit < 0) {
H
Herbert Xu 已提交
1143
		if (ipv6_addr_is_multicast(&fl.fl6_dst))
L
Linus Torvalds 已提交
1144 1145 1146 1147
			hlimit = np->mcast_hops;
		else
			hlimit = np->hop_limit;
		if (hlimit < 0)
1148
			hlimit = ip6_dst_hoplimit(dst);
L
Linus Torvalds 已提交
1149 1150
	}

G
Gerrit Renker 已提交
1151
	if (tclass < 0)
1152 1153
		tclass = np->tclass;

1154 1155 1156
	if (dontfrag < 0)
		dontfrag = np->dontfrag;

L
Linus Torvalds 已提交
1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
	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);

1167
		LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
L
Linus Torvalds 已提交
1168 1169 1170 1171 1172 1173 1174 1175
		err = -EINVAL;
		goto out;
	}

	up->pending = AF_INET6;

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

1188 1189 1190
	if (dst) {
		if (connected) {
			ip6_dst_store(sk, dst,
H
Herbert Xu 已提交
1191
				      ipv6_addr_equal(&fl.fl6_dst, &np->daddr) ?
1192 1193
				      &np->daddr : NULL,
#ifdef CONFIG_IPV6_SUBTREES
H
Herbert Xu 已提交
1194
				      ipv6_addr_equal(&fl.fl6_src, &np->saddr) ?
1195 1196 1197
				      &np->saddr :
#endif
				      NULL);
1198 1199 1200
		} else {
			dst_release(dst);
		}
1201
		dst = NULL;
1202 1203
	}

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

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

1233
void udpv6_destroy_sock(struct sock *sk)
L
Linus Torvalds 已提交
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
{
	lock_sock(sk);
	udp_v6_flush_pending_frames(sk);
	release_sock(sk);

	inet6_destroy_sock(sk);
}

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

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

1265 1266
int udpv6_getsockopt(struct sock *sk, int level, int optname,
		     char __user *optval, int __user *optlen)
1267
{
1268
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1269
		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1270
	return ipv6_getsockopt(sk, level, optname, optval, optlen);
1271 1272 1273
}

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

1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 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 1331 1332 1333 1334 1335 1336 1337 1338 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 1370 1371 1372 1373
static int udp6_ufo_send_check(struct sk_buff *skb)
{
	struct ipv6hdr *ipv6h;
	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;
}

static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb, int features)
{
	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.
	 */
	offset = skb->csum_start - skb_headroom(skb);
	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. */
	if ((skb_headroom(skb) < frag_hdr_sz) &&
	    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;
}

1374
static const struct inet6_protocol udpv6_protocol = {
L
Linus Torvalds 已提交
1375 1376
	.handler	=	udpv6_rcv,
	.err_handler	=	udpv6_err,
1377 1378
	.gso_send_check =	udp6_ufo_send_check,
	.gso_segment	=	udp6_ufo_fragment,
L
Linus Torvalds 已提交
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393
	.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);
	struct in6_addr *dest, *src;
	__u16 destp, srcp;

	dest  = &np->daddr;
	src   = &np->rcv_saddr;
E
Eric Dumazet 已提交
1394 1395
	destp = ntohs(inet->inet_dport);
	srcp  = ntohs(inet->inet_sport);
L
Linus Torvalds 已提交
1396
	seq_printf(seq,
1397
		   "%5d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
E
Eric Dumazet 已提交
1398
		   "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d\n",
L
Linus Torvalds 已提交
1399 1400 1401 1402 1403
		   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,
1404
		   sp->sk_state,
1405 1406
		   sk_wmem_alloc_get(sp),
		   sk_rmem_alloc_get(sp),
L
Linus Torvalds 已提交
1407 1408 1409
		   0, 0L, 0,
		   sock_i_uid(sp), 0,
		   sock_i_ino(sp),
E
Eric Dumazet 已提交
1410 1411
		   atomic_read(&sp->sk_refcnt), sp,
		   atomic_read(&sp->sk_drops));
L
Linus Torvalds 已提交
1412 1413
}

1414
int udp6_seq_show(struct seq_file *seq, void *v)
L
Linus Torvalds 已提交
1415 1416 1417 1418 1419 1420 1421
{
	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 已提交
1422
			   "   uid  timeout inode ref pointer drops\n");
L
Linus Torvalds 已提交
1423 1424 1425 1426 1427 1428 1429 1430
	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,
1431
	.udp_table	= &udp_table,
1432 1433 1434
	.seq_fops	= {
		.owner	=	THIS_MODULE,
	},
1435 1436 1437
	.seq_ops	= {
		.show		= udp6_seq_show,
	},
L
Linus Torvalds 已提交
1438 1439
};

1440
int __net_init udp6_proc_init(struct net *net)
L
Linus Torvalds 已提交
1441
{
1442
	return udp_proc_register(net, &udp6_seq_afinfo);
L
Linus Torvalds 已提交
1443 1444
}

1445 1446
void udp6_proc_exit(struct net *net) {
	udp_proc_unregister(net, &udp6_seq_afinfo);
L
Linus Torvalds 已提交
1447 1448 1449 1450 1451 1452
}
#endif /* CONFIG_PROC_FS */

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

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

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


1492
int __init udpv6_init(void)
L
Linus Torvalds 已提交
1493
{
1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
	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;
}

1511
void udpv6_exit(void)
1512 1513 1514
{
	inet6_unregister_protosw(&udpv6_protosw);
	inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
L
Linus Torvalds 已提交
1515
}