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

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

#include <net/ndisc.h>
#include <net/protocol.h>
#include <net/transp_v6.h>
#include <net/ip6_route.h>
#include <net/raw.h>
45
#include <net/tcp_states.h>
L
Linus Torvalds 已提交
46 47 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 (noblock)
L
Linus Torvalds 已提交
457
		return -EAGAIN;
458 459 460

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

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

476
	sk = __udp6_lib_lookup(dev_net(skb->dev), daddr, uh->dest,
477
			       saddr, uh->source, inet6_iif(skb), udptable);
L
Linus Torvalds 已提交
478 479 480 481 482 483 484 485 486 487 488
	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;

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

L
Linus Torvalds 已提交
492 493 494 495 496 497
	sk->sk_err = err;
	sk->sk_error_report(sk);
out:
	sock_put(sk);
}

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

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

511
	if (!ipv6_addr_any(&inet6_sk(sk)->daddr))
512
		sock_rps_save_rxhash(sk, skb);
513

514 515
	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
		goto drop;
L
Linus Torvalds 已提交
516

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

		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 已提交
534 535
	}

536
	if (rcu_access_pointer(sk->sk_filter)) {
537 538 539
		if (udp_lib_checksum_complete(skb))
			goto drop;
	}
540

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

L
Linus Torvalds 已提交
551
	return 0;
552
drop:
E
Eric Dumazet 已提交
553 554
	atomic_inc(&sk->sk_drops);
drop_no_sk_drops_inc:
555
	UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
556 557
	kfree_skb(skb);
	return -1;
L
Linus Torvalds 已提交
558 559
}

560
static struct sock *udp_v6_mcast_next(struct net *net, struct sock *sk,
561 562
				      __be16 loc_port, const struct in6_addr *loc_addr,
				      __be16 rmt_port, const struct in6_addr *rmt_addr,
L
Linus Torvalds 已提交
563 564
				      int dif)
{
565
	struct hlist_nulls_node *node;
L
Linus Torvalds 已提交
566 567 568
	struct sock *s = sk;
	unsigned short num = ntohs(loc_port);

569
	sk_nulls_for_each_from(s, node) {
L
Linus Torvalds 已提交
570 571
		struct inet_sock *inet = inet_sk(s);

572
		if (!net_eq(sock_net(s), net))
573 574
			continue;

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

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

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

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

671
	spin_unlock(&hslot->lock);
672 673 674 675 676 677 678 679 680

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

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

684 685
static inline int udp6_csum_init(struct sk_buff *skb, struct udphdr *uh,
				 int proto)
686
{
687 688 689 690 691
	int err;

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

692
	if (proto == IPPROTO_UDPLITE) {
693 694 695 696 697
		err = udplite_checksum_init(skb, uh);
		if (err)
			return err;
	}

698 699 700 701 702 703 704 705
	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 &&
706
	    !csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
707
			     skb->len, proto, skb->csum))
708 709
		skb->ip_summed = CHECKSUM_UNNECESSARY;

710
	if (!skb_csum_unnecessary(skb))
711 712
		skb->csum = ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
							 &ipv6_hdr(skb)->daddr,
713
							 skb->len, proto, 0));
714

715
	return 0;
716 717
}

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

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

730 731
	saddr = &ipv6_hdr(skb)->saddr;
	daddr = &ipv6_hdr(skb)->daddr;
732
	uh = udp_hdr(skb);
L
Linus Torvalds 已提交
733 734

	ulen = ntohs(uh->len);
735 736
	if (ulen > skb->len)
		goto short_packet;
L
Linus Torvalds 已提交
737

738 739
	if (proto == IPPROTO_UDP) {
		/* UDP validates ulen. */
L
Linus Torvalds 已提交
740

741 742 743
		/* Check for jumbo payload */
		if (ulen == 0)
			ulen = skb->len;
L
Linus Torvalds 已提交
744

745 746
		if (ulen < sizeof(*uh))
			goto short_packet;
L
Linus Torvalds 已提交
747

748 749 750
		if (ulen < skb->len) {
			if (pskb_trim_rcsum(skb, ulen))
				goto short_packet;
751 752
			saddr = &ipv6_hdr(skb)->saddr;
			daddr = &ipv6_hdr(skb)->daddr;
753
			uh = udp_hdr(skb);
754 755
		}
	}
L
Linus Torvalds 已提交
756

757 758 759
	if (udp6_csum_init(skb, uh, proto))
		goto discard;

760 761
	/*
	 *	Multicast receive code
L
Linus Torvalds 已提交
762
	 */
763
	if (ipv6_addr_is_multicast(daddr))
764 765
		return __udp6_lib_mcast_deliver(net, skb,
				saddr, daddr, udptable);
L
Linus Torvalds 已提交
766 767 768

	/* Unicast */

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

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

779
		if (udp_lib_checksum_complete(skb))
L
Linus Torvalds 已提交
780
			goto discard;
781 782
		UDP6_INC_STATS_BH(net, UDP_MIB_NOPORTS,
				proto == IPPROTO_UDPLITE);
L
Linus Torvalds 已提交
783

784
		icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
L
Linus Torvalds 已提交
785 786

		kfree_skb(skb);
S
Stephen Hemminger 已提交
787
		return 0;
L
Linus Torvalds 已提交
788
	}
789

L
Linus Torvalds 已提交
790
	/* deliver */
791

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

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

discard:
820
	UDP6_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
L
Linus Torvalds 已提交
821
	kfree_skb(skb);
S
Stephen Hemminger 已提交
822
	return 0;
L
Linus Torvalds 已提交
823
}
824

825
static __inline__ int udpv6_rcv(struct sk_buff *skb)
826
{
827
	return __udp6_lib_rcv(skb, &udp_table, IPPROTO_UDP);
828 829
}

L
Linus Torvalds 已提交
830 831 832 833 834 835 836
/*
 * 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);

837 838 839
	if (up->pending == AF_INET)
		udp_flush_pending_frames(sk);
	else if (up->pending) {
L
Linus Torvalds 已提交
840 841 842
		up->len = 0;
		up->pending = 0;
		ip6_flush_pending_frames(sk);
843
	}
L
Linus Torvalds 已提交
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 882 883 884 885 886
/**
 * 	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 已提交
887 888 889 890
/*
 *	Sending
 */

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

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

	/*
	 * Create a UDP header
	 */
909
	uh = udp_hdr(skb);
910 911
	uh->source = fl6->fl6_sport;
	uh->dest = fl6->fl6_dport;
L
Linus Torvalds 已提交
912 913 914
	uh->len = htons(up->len);
	uh->check = 0;

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

924
	/* add protocol-dependent pseudo-header */
925 926
	uh->check = csum_ipv6_magic(&fl6->saddr, &fl6->daddr,
				    up->len, fl6->flowi6_proto, csum);
L
Linus Torvalds 已提交
927
	if (uh->check == 0)
928
		uh->check = CSUM_MANGLED_0;
L
Linus Torvalds 已提交
929

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

947
int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
L
Linus Torvalds 已提交
948 949 950 951 952 953 954
		  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;
955
	struct in6_addr *daddr, *final_p, final;
L
Linus Torvalds 已提交
956 957
	struct ipv6_txoptions *opt = NULL;
	struct ip6_flowlabel *flowlabel = NULL;
958
	struct flowi6 fl6;
L
Linus Torvalds 已提交
959 960 961 962
	struct dst_entry *dst;
	int addr_len = msg->msg_namelen;
	int ulen = len;
	int hlimit = -1;
963
	int tclass = -1;
964
	int dontfrag = -1;
L
Linus Torvalds 已提交
965 966
	int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
	int err;
967
	int connected = 0;
W
Wang Chen 已提交
968
	int is_udplite = IS_UDPLITE(sk);
969
	int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
L
Linus Torvalds 已提交
970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995

	/* 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;
996
	} else
L
Linus Torvalds 已提交
997 998 999
		daddr = NULL;

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

L
Linus Torvalds 已提交
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
	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);

1041
	memset(&fl6, 0, sizeof(fl6));
L
Linus Torvalds 已提交
1042 1043 1044 1045 1046

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

1047
		fl6.fl6_dport = sin6->sin6_port;
L
Linus Torvalds 已提交
1048 1049 1050
		daddr = &sin6->sin6_addr;

		if (np->sndflow) {
1051 1052 1053
			fl6.flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
			if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
				flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
L
Linus Torvalds 已提交
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
				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)
1071
			fl6.flowi6_oif = sin6->sin6_scope_id;
L
Linus Torvalds 已提交
1072 1073 1074 1075
	} else {
		if (sk->sk_state != TCP_ESTABLISHED)
			return -EDESTADDRREQ;

1076
		fl6.fl6_dport = inet->inet_dport;
L
Linus Torvalds 已提交
1077
		daddr = &np->daddr;
1078
		fl6.flowlabel = np->flow_label;
1079
		connected = 1;
L
Linus Torvalds 已提交
1080 1081
	}

1082 1083
	if (!fl6.flowi6_oif)
		fl6.flowi6_oif = sk->sk_bound_dev_if;
L
Linus Torvalds 已提交
1084

1085 1086
	if (!fl6.flowi6_oif)
		fl6.flowi6_oif = np->sticky_pktinfo.ipi6_ifindex;
1087

1088
	fl6.flowi6_mark = sk->sk_mark;
B
Brian Haley 已提交
1089

L
Linus Torvalds 已提交
1090 1091 1092 1093 1094
	if (msg->msg_controllen) {
		opt = &opt_space;
		memset(opt, 0, sizeof(struct ipv6_txoptions));
		opt->tot_len = sizeof(*opt);

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

1116
	fl6.flowi6_proto = sk->sk_protocol;
1117
	if (!ipv6_addr_any(daddr))
1118
		ipv6_addr_copy(&fl6.daddr, daddr);
1119
	else
1120 1121 1122
		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);
1123
	fl6.fl6_sport = inet->inet_sport;
1124

1125
	final_p = fl6_update_dst(&fl6, opt, &final);
1126
	if (final_p)
1127
		connected = 0;
L
Linus Torvalds 已提交
1128

1129 1130
	if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr)) {
		fl6.flowi6_oif = np->mcast_oif;
1131 1132
		connected = 0;
	}
L
Linus Torvalds 已提交
1133

1134
	security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
V
Venkat Yekkirala 已提交
1135

1136
	dst = ip6_sk_dst_lookup_flow(sk, &fl6, final_p, true);
1137 1138 1139
	if (IS_ERR(dst)) {
		err = PTR_ERR(dst);
		dst = NULL;
L
Linus Torvalds 已提交
1140
		goto out;
1141
	}
L
Linus Torvalds 已提交
1142 1143

	if (hlimit < 0) {
1144
		if (ipv6_addr_is_multicast(&fl6.daddr))
L
Linus Torvalds 已提交
1145 1146 1147 1148
			hlimit = np->mcast_hops;
		else
			hlimit = np->hop_limit;
		if (hlimit < 0)
1149
			hlimit = ip6_dst_hoplimit(dst);
L
Linus Torvalds 已提交
1150 1151
	}

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

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

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

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

	up->pending = AF_INET6;

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

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

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

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

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

	inet6_destroy_sock(sk);
}

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

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

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

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

1284 1285
static int udp6_ufo_send_check(struct sk_buff *skb)
{
1286
	const struct ipv6hdr *ipv6h;
1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
	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;
}

1303
static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb, u32 features)
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
{
	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.
	 */
1336
	offset = skb_checksum_start_offset(skb);
1337 1338 1339 1340 1341 1342
	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. */
1343
	if ((skb_mac_header(skb) < skb->head + frag_hdr_sz) &&
1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363
	    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;
1364
	ipv6_select_ident(fptr, (struct rt6_info *)skb_dst(skb));
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374

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

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

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

1415
int udp6_seq_show(struct seq_file *seq, void *v)
L
Linus Torvalds 已提交
1416 1417 1418 1419 1420 1421 1422
{
	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 已提交
1423
			   "   uid  timeout inode ref pointer drops\n");
L
Linus Torvalds 已提交
1424 1425 1426 1427 1428
	else
		udp6_sock_seq_show(seq, v, ((struct udp_iter_state *)seq->private)->bucket);
	return 0;
}

1429 1430 1431 1432 1433 1434 1435 1436
static const struct file_operations udp6_afinfo_seq_fops = {
	.owner    = THIS_MODULE,
	.open     = udp_seq_open,
	.read     = seq_read,
	.llseek   = seq_lseek,
	.release  = seq_release_net
};

L
Linus Torvalds 已提交
1437 1438 1439
static struct udp_seq_afinfo udp6_seq_afinfo = {
	.name		= "udp6",
	.family		= AF_INET6,
1440
	.udp_table	= &udp_table,
1441
	.seq_fops	= &udp6_afinfo_seq_fops,
1442 1443 1444
	.seq_ops	= {
		.show		= udp6_seq_show,
	},
L
Linus Torvalds 已提交
1445 1446
};

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

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

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

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

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


1500
int __init udpv6_init(void)
L
Linus Torvalds 已提交
1501
{
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
	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;
}

1519
void udpv6_exit(void)
1520 1521 1522
{
	inet6_unregister_protosw(&udpv6_protosw);
	inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
L
Linus Torvalds 已提交
1523
}