udp.c 36.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 *	UDP over IPv6
3
 *	Linux INET6 implementation
Linus Torvalds's avatar
Linus Torvalds committed
4 5
 *
 *	Authors:
6
 *	Pedro Roque		<roque@di.fc.ul.pt>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
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"
Linus Torvalds's avatar
Linus Torvalds committed
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
	__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 &&
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);
Brian Haley's avatar
Brian Haley committed
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)
Linus Torvalds's avatar
Linus Torvalds committed
103
{
Eric Dumazet's avatar
Eric Dumazet committed
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 */
Eric Dumazet's avatar
Eric Dumazet committed
110 111
	udp_sk(sk)->udp_portaddr_hash = hash2_partial;
	return udp_lib_get_port(sk, snum, ipv6_rcv_saddr_equal, hash2_nulladdr);
Linus Torvalds's avatar
Linus Torvalds committed
112 113
}

114 115 116 117 118 119 120 121
static inline int compute_score(struct sock *sk, struct net *net,
				unsigned short hnum,
				struct in6_addr *saddr, __be16 sport,
				struct in6_addr *daddr, __be16 dport,
				int dif)
{
	int score = -1;

122
	if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
123 124 125 126 127
			sk->sk_family == PF_INET6) {
		struct ipv6_pinfo *np = inet6_sk(sk);
		struct inet_sock *inet = inet_sk(sk);

		score = 0;
128 129
		if (inet->inet_dport) {
			if (inet->inet_dport != sport)
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
				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;
}

152 153 154 155 156 157 158 159 160 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 230 231
#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:
		if (unlikely(!atomic_inc_not_zero(&result->sk_refcnt)))
			result = NULL;
		else if (unlikely(compute_score2(result, net, saddr, sport,
				  daddr, hnum, dif) < badness)) {
			sock_put(result);
			goto begin;
		}
	}
	return result;
}

232 233
static struct sock *__udp6_lib_lookup(struct net *net,
				      struct in6_addr *saddr, __be16 sport,
234
				      struct in6_addr *daddr, __be16 dport,
235
				      int dif, struct udp_table *udptable)
Linus Torvalds's avatar
Linus Torvalds committed
236
{
237
	struct sock *sk, *result;
238
	struct hlist_nulls_node *node;
Linus Torvalds's avatar
Linus Torvalds committed
239
	unsigned short hnum = ntohs(dport);
240 241
	unsigned int hash2, slot2, slot = udp_hashfn(net, hnum, udptable->mask);
	struct udp_hslot *hslot2, *hslot = &udptable->hash[slot];
242
	int score, badness;
243

244
	rcu_read_lock();
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
	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;

262 263
			result = udp6_lib_lookup2(net, saddr, sport,
						  &in6addr_any, hnum, dif,
264 265 266 267 268
						  hslot2, slot2);
		}
		rcu_read_unlock();
		return result;
	}
269 270 271
begin:
	result = NULL;
	badness = -1;
272
	sk_nulls_for_each_rcu(sk, node, &hslot->head) {
273 274 275 276
		score = compute_score(sk, net, hnum, saddr, sport, daddr, dport, dif);
		if (score > badness) {
			result = sk;
			badness = score;
Linus Torvalds's avatar
Linus Torvalds committed
277 278
		}
	}
279 280 281 282 283
	/*
	 * 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.
	 */
284
	if (get_nulls_value(node) != slot)
285 286
		goto begin;

287 288 289 290 291 292 293 294 295 296
	if (result) {
		if (unlikely(!atomic_inc_not_zero(&result->sk_refcnt)))
			result = NULL;
		else if (unlikely(compute_score(result, net, hnum, saddr, sport,
					daddr, dport, dif) < badness)) {
			sock_put(result);
			goto begin;
		}
	}
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
297 298 299
	return result;
}

300 301
static struct sock *__udp6_lib_lookup_skb(struct sk_buff *skb,
					  __be16 sport, __be16 dport,
302
					  struct udp_table *udptable)
303
{
304
	struct sock *sk;
305 306
	struct ipv6hdr *iph = ipv6_hdr(skb);

307 308
	if (unlikely(sk = skb_steal_sock(skb)))
		return sk;
Eric Dumazet's avatar
Eric Dumazet committed
309 310 311
	return __udp6_lib_lookup(dev_net(skb_dst(skb)->dev), &iph->saddr, sport,
				 &iph->daddr, dport, inet6_iif(skb),
				 udptable);
312 313
}

Linus Torvalds's avatar
Linus Torvalds committed
314 315 316 317 318
/*
 * 	This should be easy, if there is something there we
 * 	return it, otherwise we block.
 */

319
int udpv6_recvmsg(struct kiocb *iocb, struct sock *sk,
Linus Torvalds's avatar
Linus Torvalds committed
320 321 322 323 324
		  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);
325
	struct sk_buff *skb;
Gerrit Renker's avatar
Gerrit Renker committed
326
	unsigned int ulen;
327
	int peeked;
328 329
	int err;
	int is_udplite = IS_UDPLITE(sk);
330
	int is_udp4;
Linus Torvalds's avatar
Linus Torvalds committed
331

332 333 334
	if (addr_len)
		*addr_len=sizeof(struct sockaddr_in6);

Linus Torvalds's avatar
Linus Torvalds committed
335 336 337
	if (flags & MSG_ERRQUEUE)
		return ipv6_recv_error(sk, msg, len);

338 339 340
	if (np->rxpmtu && np->rxopt.bits.rxpmtu)
		return ipv6_recv_rxpmtu(sk, msg, len);

Linus Torvalds's avatar
Linus Torvalds committed
341
try_again:
342 343
	skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
				  &peeked, &err);
Linus Torvalds's avatar
Linus Torvalds committed
344 345 346
	if (!skb)
		goto out;

347
	ulen = skb->len - sizeof(struct udphdr);
Gerrit Renker's avatar
Gerrit Renker committed
348 349 350
	if (len > ulen)
		len = ulen;
	else if (len < ulen)
351
		msg->msg_flags |= MSG_TRUNC;
Linus Torvalds's avatar
Linus Torvalds committed
352

353 354
	is_udp4 = (skb->protocol == htons(ETH_P_IP));

355
	/*
356 357 358
	 * 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.
359 360
	 */

Gerrit Renker's avatar
Gerrit Renker committed
361
	if (len < ulen || UDP_SKB_CB(skb)->partial_cov) {
362
		if (udp_lib_checksum_complete(skb))
Linus Torvalds's avatar
Linus Torvalds committed
363
			goto csum_copy_err;
364 365
	}

366
	if (skb_csum_unnecessary(skb))
367
		err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
Gerrit Renker's avatar
Gerrit Renker committed
368
					      msg->msg_iov,len);
369
	else {
Linus Torvalds's avatar
Linus Torvalds committed
370 371 372 373 374 375 376
		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;

377 378 379 380 381 382 383 384
	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);
	}
385

386
	sock_recv_ts_and_drops(msg, sk, skb);
Linus Torvalds's avatar
Linus Torvalds committed
387 388 389 390

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

Linus Torvalds's avatar
Linus Torvalds committed
392 393
		sin6 = (struct sockaddr_in6 *) msg->msg_name;
		sin6->sin6_family = AF_INET6;
394
		sin6->sin6_port = udp_hdr(skb)->source;
Linus Torvalds's avatar
Linus Torvalds committed
395 396 397
		sin6->sin6_flowinfo = 0;
		sin6->sin6_scope_id = 0;

398
		if (is_udp4)
399 400
			ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
					       &sin6->sin6_addr);
Linus Torvalds's avatar
Linus Torvalds committed
401
		else {
402 403
			ipv6_addr_copy(&sin6->sin6_addr,
				       &ipv6_hdr(skb)->saddr);
Linus Torvalds's avatar
Linus Torvalds committed
404 405 406 407 408
			if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)
				sin6->sin6_scope_id = IP6CB(skb)->iif;
		}

	}
409
	if (is_udp4) {
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412 413 414
		if (inet->cmsg_flags)
			ip_cmsg_recv(msg, skb);
	} else {
		if (np->rxopt.all)
			datagram_recv_ctl(sk, msg, skb);
415
	}
Linus Torvalds's avatar
Linus Torvalds committed
416

Gerrit Renker's avatar
Gerrit Renker committed
417
	err = len;
Linus Torvalds's avatar
Linus Torvalds committed
418
	if (flags & MSG_TRUNC)
419
		err = ulen;
Linus Torvalds's avatar
Linus Torvalds committed
420 421

out_free:
422
	skb_free_datagram_locked(sk, skb);
Linus Torvalds's avatar
Linus Torvalds committed
423 424 425 426
out:
	return err;

csum_copy_err:
Hideo Aoki's avatar
Hideo Aoki committed
427
	lock_sock(sk);
428 429 430 431 432 433 434 435
	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);
	}
Hideo Aoki's avatar
Hideo Aoki committed
436
	release_sock(sk);
Linus Torvalds's avatar
Linus Torvalds committed
437

438
	if (flags & MSG_DONTWAIT)
Linus Torvalds's avatar
Linus Torvalds committed
439 440 441 442
		return -EAGAIN;
	goto try_again;
}

443
void __udp6_lib_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
444
		    u8 type, u8 code, int offset, __be32 info,
445
		    struct udp_table *udptable)
Linus Torvalds's avatar
Linus Torvalds committed
446 447 448 449 450 451 452 453 454
{
	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;

455
	sk = __udp6_lib_lookup(dev_net(skb->dev), daddr, uh->dest,
456
			       saddr, uh->source, inet6_iif(skb), udptable);
Linus Torvalds's avatar
Linus Torvalds committed
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
	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;

	if (np->recverr)
		ipv6_icmp_error(sk, skb, err, uh->dest, ntohl(info), (u8 *)(uh+1));

	sk->sk_err = err;
	sk->sk_error_report(sk);
out:
	sock_put(sk);
}

477
static __inline__ void udpv6_err(struct sk_buff *skb,
478 479
				 struct inet6_skb_parm *opt, u8 type,
				 u8 code, int offset, __be32 info     )
480
{
481
	__udp6_lib_err(skb, opt, type, code, offset, info, &udp_table);
482 483 484
}

int udpv6_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
485
{
486
	struct udp_sock *up = udp_sk(sk);
487
	int rc;
488
	int is_udplite = IS_UDPLITE(sk);
489

490 491
	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
		goto drop;
Linus Torvalds's avatar
Linus Torvalds committed
492

493 494 495
	/*
	 * UDP-Lite specific tests, ignored on UDP sockets (see net/ipv4/udp.c).
	 */
496
	if ((is_udplite & UDPLITE_RECV_CC)  &&  UDP_SKB_CB(skb)->partial_cov) {
497 498 499 500 501 502 503 504 505 506 507 508 509

		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;
		}
Linus Torvalds's avatar
Linus Torvalds committed
510 511
	}

512 513 514 515
	if (sk->sk_filter) {
		if (udp_lib_checksum_complete(skb))
			goto drop;
	}
516

Eric Dumazet's avatar
Eric Dumazet committed
517
	if ((rc = sock_queue_rcv_skb(sk, skb)) < 0) {
518
		/* Note that an ENOMEM error is charged twice */
Eric Dumazet's avatar
Eric Dumazet committed
519
		if (rc == -ENOMEM)
520 521
			UDP6_INC_STATS_BH(sock_net(sk),
					UDP_MIB_RCVBUFERRORS, is_udplite);
522
		goto drop_no_sk_drops_inc;
Linus Torvalds's avatar
Linus Torvalds committed
523
	}
524

Linus Torvalds's avatar
Linus Torvalds committed
525
	return 0;
526
drop:
527 528
	atomic_inc(&sk->sk_drops);
drop_no_sk_drops_inc:
529
	UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
530 531
	kfree_skb(skb);
	return -1;
Linus Torvalds's avatar
Linus Torvalds committed
532 533
}

534
static struct sock *udp_v6_mcast_next(struct net *net, struct sock *sk,
Al Viro's avatar
Al Viro committed
535 536
				      __be16 loc_port, struct in6_addr *loc_addr,
				      __be16 rmt_port, struct in6_addr *rmt_addr,
Linus Torvalds's avatar
Linus Torvalds committed
537 538
				      int dif)
{
539
	struct hlist_nulls_node *node;
Linus Torvalds's avatar
Linus Torvalds committed
540 541 542
	struct sock *s = sk;
	unsigned short num = ntohs(loc_port);

543
	sk_nulls_for_each_from(s, node) {
Linus Torvalds's avatar
Linus Torvalds committed
544 545
		struct inet_sock *inet = inet_sk(s);

546
		if (!net_eq(sock_net(s), net))
547 548
			continue;

549 550
		if (udp_sk(s)->udp_port_hash == num &&
		    s->sk_family == PF_INET6) {
Linus Torvalds's avatar
Linus Torvalds committed
551
			struct ipv6_pinfo *np = inet6_sk(s);
552 553
			if (inet->inet_dport) {
				if (inet->inet_dport != rmt_port)
Linus Torvalds's avatar
Linus Torvalds committed
554 555 556 557 558 559 560 561 562 563
					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)) {
564 565
				if (!ipv6_addr_equal(&np->rcv_saddr, loc_addr))
					continue;
Linus Torvalds's avatar
Linus Torvalds committed
566
			}
Stephen Hemminger's avatar
Stephen Hemminger committed
567
			if (!inet6_mc_check(s, loc_addr, rmt_addr))
Linus Torvalds's avatar
Linus Torvalds committed
568 569 570 571 572 573 574
				continue;
			return s;
		}
	}
	return NULL;
}

575 576 577 578 579 580 581 582 583 584
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);

585
		sk = stack[i];
586
		if (skb1) {
587 588 589 590
			if (sk_rcvqueues_full(sk, skb)) {
				kfree_skb(skb1);
				goto drop;
			}
591 592 593
			bh_lock_sock(sk);
			if (!sock_owned_by_user(sk))
				udpv6_queue_rcv_skb(sk, skb1);
Zhu Yi's avatar
Zhu Yi committed
594
			else if (sk_add_backlog(sk, skb1)) {
Zhu Yi's avatar
Zhu Yi committed
595 596 597 598
				kfree_skb(skb1);
				bh_unlock_sock(sk);
				goto drop;
			}
599
			bh_unlock_sock(sk);
Zhu Yi's avatar
Zhu Yi committed
600
			continue;
601
		}
Zhu Yi's avatar
Zhu Yi committed
602 603 604 605 606 607
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));
608 609
	}
}
Linus Torvalds's avatar
Linus Torvalds committed
610 611 612 613
/*
 * Note: called only from the BH handler context,
 * so we don't need to lock the hashes.
 */
614 615
static int __udp6_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
		struct in6_addr *saddr, struct in6_addr *daddr,
616
		struct udp_table *udptable)
Linus Torvalds's avatar
Linus Torvalds committed
617
{
618
	struct sock *sk, *stack[256 / sizeof(struct sock *)];
619
	const struct udphdr *uh = udp_hdr(skb);
620
	struct udp_hslot *hslot = udp_hashslot(udptable, net, ntohs(uh->dest));
Linus Torvalds's avatar
Linus Torvalds committed
621
	int dif;
622
	unsigned int i, count = 0;
Linus Torvalds's avatar
Linus Torvalds committed
623

624
	spin_lock(&hslot->lock);
625
	sk = sk_nulls_head(&hslot->head);
626
	dif = inet6_iif(skb);
627
	sk = udp_v6_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
628 629 630 631 632 633 634 635 636
	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;
Hideo Aoki's avatar
Hideo Aoki committed
637
		}
Linus Torvalds's avatar
Linus Torvalds committed
638
	}
639 640 641 642 643 644
	/*
	 * before releasing the lock, we must take reference on sockets
	 */
	for (i = 0; i < count; i++)
		sock_hold(stack[i]);

645
	spin_unlock(&hslot->lock);
646 647 648 649 650 651 652 653 654

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

		for (i = 0; i < count; i++)
			sock_put(stack[i]);
	} else {
		kfree_skb(skb);
	}
655
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
656 657
}

658 659
static inline int udp6_csum_init(struct sk_buff *skb, struct udphdr *uh,
				 int proto)
660
{
661 662 663 664 665
	int err;

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

666
	if (proto == IPPROTO_UDPLITE) {
667 668 669 670 671
		err = udplite_checksum_init(skb, uh);
		if (err)
			return err;
	}

672 673 674 675 676 677 678 679
	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 &&
680
	    !csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
681
			     skb->len, proto, skb->csum))
682 683
		skb->ip_summed = CHECKSUM_UNNECESSARY;

684
	if (!skb_csum_unnecessary(skb))
685 686
		skb->csum = ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
							 &ipv6_hdr(skb)->daddr,
687
							 skb->len, proto, 0));
688

689
	return 0;
690 691
}

692
int __udp6_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
693
		   int proto)
Linus Torvalds's avatar
Linus Torvalds committed
694
{
695
	struct net *net = dev_net(skb->dev);
Linus Torvalds's avatar
Linus Torvalds committed
696
	struct sock *sk;
697
	struct udphdr *uh;
Linus Torvalds's avatar
Linus Torvalds committed
698 699 700 701 702 703
	struct in6_addr *saddr, *daddr;
	u32 ulen = 0;

	if (!pskb_may_pull(skb, sizeof(struct udphdr)))
		goto short_packet;

704 705
	saddr = &ipv6_hdr(skb)->saddr;
	daddr = &ipv6_hdr(skb)->daddr;
706
	uh = udp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
707 708

	ulen = ntohs(uh->len);
709 710
	if (ulen > skb->len)
		goto short_packet;
Linus Torvalds's avatar
Linus Torvalds committed
711

712 713
	if (proto == IPPROTO_UDP) {
		/* UDP validates ulen. */
Linus Torvalds's avatar
Linus Torvalds committed
714

715 716 717
		/* Check for jumbo payload */
		if (ulen == 0)
			ulen = skb->len;
Linus Torvalds's avatar
Linus Torvalds committed
718

719 720
		if (ulen < sizeof(*uh))
			goto short_packet;
Linus Torvalds's avatar
Linus Torvalds committed
721

722 723 724
		if (ulen < skb->len) {
			if (pskb_trim_rcsum(skb, ulen))
				goto short_packet;
725 726
			saddr = &ipv6_hdr(skb)->saddr;
			daddr = &ipv6_hdr(skb)->daddr;
727
			uh = udp_hdr(skb);
728 729
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
730

731 732 733
	if (udp6_csum_init(skb, uh, proto))
		goto discard;

734 735
	/*
	 *	Multicast receive code
Linus Torvalds's avatar
Linus Torvalds committed
736
	 */
737
	if (ipv6_addr_is_multicast(daddr))
738 739
		return __udp6_lib_mcast_deliver(net, skb,
				saddr, daddr, udptable);
Linus Torvalds's avatar
Linus Torvalds committed
740 741 742

	/* Unicast */

743
	/*
Linus Torvalds's avatar
Linus Torvalds committed
744 745 746
	 * check socket cache ... must talk to Alan about his plans
	 * for sock caches... i'll skip this for now.
	 */
747
	sk = __udp6_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
Linus Torvalds's avatar
Linus Torvalds committed
748 749 750 751 752

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

753
		if (udp_lib_checksum_complete(skb))
Linus Torvalds's avatar
Linus Torvalds committed
754
			goto discard;
755 756
		UDP6_INC_STATS_BH(net, UDP_MIB_NOPORTS,
				proto == IPPROTO_UDPLITE);
Linus Torvalds's avatar
Linus Torvalds committed
757

758
		icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
Linus Torvalds's avatar
Linus Torvalds committed
759 760

		kfree_skb(skb);
Stephen Hemminger's avatar
Stephen Hemminger committed
761
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
762
	}
763

Linus Torvalds's avatar
Linus Torvalds committed
764
	/* deliver */
765

766 767 768 769
	if (sk_rcvqueues_full(sk, skb)) {
		sock_put(sk);
		goto discard;
	}
770
	bh_lock_sock(sk);
Hideo Aoki's avatar
Hideo Aoki committed
771 772
	if (!sock_owned_by_user(sk))
		udpv6_queue_rcv_skb(sk, skb);
Zhu Yi's avatar
Zhu Yi committed
773
	else if (sk_add_backlog(sk, skb)) {
Zhu Yi's avatar
Zhu Yi committed
774 775 776 777 778
		atomic_inc(&sk->sk_drops);
		bh_unlock_sock(sk);
		sock_put(sk);
		goto discard;
	}
Hideo Aoki's avatar
Hideo Aoki committed
779
	bh_unlock_sock(sk);
Linus Torvalds's avatar
Linus Torvalds committed
780
	sock_put(sk);
Stephen Hemminger's avatar
Stephen Hemminger committed
781
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
782

783
short_packet:
784
	LIMIT_NETDEBUG(KERN_DEBUG "UDP%sv6: short packet: %d/%u\n",
785
		       proto == IPPROTO_UDPLITE ? "-Lite" : "",
786
		       ulen, skb->len);
Linus Torvalds's avatar
Linus Torvalds committed
787 788

discard:
789
	UDP6_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
Linus Torvalds's avatar
Linus Torvalds committed
790
	kfree_skb(skb);
Stephen Hemminger's avatar
Stephen Hemminger committed
791
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
792
}
793

794
static __inline__ int udpv6_rcv(struct sk_buff *skb)
795
{
796
	return __udp6_lib_rcv(skb, &udp_table, IPPROTO_UDP);
797 798
}

Linus Torvalds's avatar
Linus Torvalds committed
799 800 801 802 803 804 805
/*
 * 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);

806 807 808
	if (up->pending == AF_INET)
		udp_flush_pending_frames(sk);
	else if (up->pending) {
Linus Torvalds's avatar
Linus Torvalds committed
809 810 811
		up->len = 0;
		up->pending = 0;
		ip6_flush_pending_frames(sk);
812
	}
Linus Torvalds's avatar
Linus Torvalds committed
813 814
}

815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855
/**
 * 	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;
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
856 857 858 859
/*
 *	Sending
 */

860
static int udp_v6_push_pending_frames(struct sock *sk)
Linus Torvalds's avatar
Linus Torvalds committed
861 862 863
{
	struct sk_buff *skb;
	struct udphdr *uh;
864
	struct udp_sock  *up = udp_sk(sk);
Linus Torvalds's avatar
Linus Torvalds committed
865 866 867
	struct inet_sock *inet = inet_sk(sk);
	struct flowi *fl = &inet->cork.fl;
	int err = 0;
868
	int is_udplite = IS_UDPLITE(sk);
869
	__wsum csum = 0;
Linus Torvalds's avatar
Linus Torvalds committed
870 871 872 873 874 875 876 877

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

	/*
	 * Create a UDP header
	 */
878
	uh = udp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
879 880 881 882 883
	uh->source = fl->fl_ip_sport;
	uh->dest = fl->fl_ip_dport;
	uh->len = htons(up->len);
	uh->check = 0;

884
	if (is_udplite)
885
		csum = udplite_csum_outgoing(sk, skb);
886 887 888 889 890
	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
891
		csum = udp_csum_outgoing(sk, skb);
Linus Torvalds's avatar
Linus Torvalds committed
892

893 894 895
	/* add protocol-dependent pseudo-header */
	uh->check = csum_ipv6_magic(&fl->fl6_src, &fl->fl6_dst,
				    up->len, fl->proto, csum   );
Linus Torvalds's avatar
Linus Torvalds committed
896
	if (uh->check == 0)
897
		uh->check = CSUM_MANGLED_0;
Linus Torvalds's avatar
Linus Torvalds committed
898

899
send:
Linus Torvalds's avatar
Linus Torvalds committed
900
	err = ip6_push_pending_frames(sk);
Eric Dumazet's avatar
Eric Dumazet committed
901 902 903 904 905 906 907 908 909
	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);
Linus Torvalds's avatar
Linus Torvalds committed
910 911 912 913 914 915
out:
	up->len = 0;
	up->pending = 0;
	return err;
}

916
int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
Linus Torvalds's avatar
Linus Torvalds committed
917 918 919 920 921 922 923 924 925 926
		  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;
	struct in6_addr *daddr, *final_p = NULL, final;
	struct ipv6_txoptions *opt = NULL;
	struct ip6_flowlabel *flowlabel = NULL;
Herbert Xu's avatar
Herbert Xu committed
927
	struct flowi fl;
Linus Torvalds's avatar
Linus Torvalds committed
928 929 930 931
	struct dst_entry *dst;
	int addr_len = msg->msg_namelen;
	int ulen = len;
	int hlimit = -1;
932
	int tclass = -1;
933
	int dontfrag = -1;
Linus Torvalds's avatar
Linus Torvalds committed
934 935
	int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
	int err;
936
	int connected = 0;
937
	int is_udplite = IS_UDPLITE(sk);
938
	int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
Linus Torvalds's avatar
Linus Torvalds committed
939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964

	/* 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;
965
	} else
Linus Torvalds's avatar
Linus Torvalds committed
966 967 968
		daddr = NULL;

	if (daddr) {
969
		if (ipv6_addr_v4mapped(daddr)) {
Linus Torvalds's avatar
Linus Torvalds committed
970 971
			struct sockaddr_in sin;
			sin.sin_family = AF_INET;
972
			sin.sin_port = sin6 ? sin6->sin6_port : inet->inet_dport;
Linus Torvalds's avatar
Linus Torvalds committed
973 974 975 976 977 978 979 980 981 982 983 984 985 986
			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,
987
	   better check is made in ip6_append_data().
Linus Torvalds's avatar
Linus Torvalds committed
988 989 990
	   */
	if (len > INT_MAX - sizeof(struct udphdr))
		return -EMSGSIZE;
991

Linus Torvalds's avatar
Linus Torvalds committed
992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
	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);

Herbert Xu's avatar
Herbert Xu committed
1010
	memset(&fl, 0, sizeof(fl));
Linus Torvalds's avatar
Linus Torvalds committed
1011 1012 1013 1014 1015

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

Herbert Xu's avatar
Herbert Xu committed
1016
		fl.fl_ip_dport = sin6->sin6_port;
Linus Torvalds's avatar
Linus Torvalds committed
1017 1018 1019
		daddr = &sin6->sin6_addr;

		if (np->sndflow) {
Herbert Xu's avatar
Herbert Xu committed
1020 1021 1022
			fl.fl6_flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
			if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
				flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
Linus Torvalds's avatar
Linus Torvalds committed
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
				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)
Herbert Xu's avatar
Herbert Xu committed
1040
			fl.oif = sin6->sin6_scope_id;
Linus Torvalds's avatar
Linus Torvalds committed
1041 1042 1043 1044
	} else {
		if (sk->sk_state != TCP_ESTABLISHED)
			return -EDESTADDRREQ;

1045
		fl.fl_ip_dport = inet->inet_dport;