udp.c 25.5 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>
Linus Torvalds's avatar
Linus Torvalds committed
37 38 39 40 41 42 43
#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>
44
#include <net/tcp_states.h>
Linus Torvalds's avatar
Linus Torvalds committed
45 46 47 48 49
#include <net/ip6_checksum.h>
#include <net/xfrm.h>

#include <linux/proc_fs.h>
#include <linux/seq_file.h>
50
#include "udp_impl.h"
Linus Torvalds's avatar
Linus Torvalds committed
51

52
int udp_v6_get_port(struct sock *sk, unsigned short snum)
Linus Torvalds's avatar
Linus Torvalds committed
53
{
54
	return udp_lib_get_port(sk, snum, ipv6_rcv_saddr_equal);
Linus Torvalds's avatar
Linus Torvalds committed
55 56
}

57 58
static struct sock *__udp6_lib_lookup(struct net *net,
				      struct in6_addr *saddr, __be16 sport,
59 60
				      struct in6_addr *daddr, __be16 dport,
				      int dif, struct hlist_head udptable[])
Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64 65 66
{
	struct sock *sk, *result = NULL;
	struct hlist_node *node;
	unsigned short hnum = ntohs(dport);
	int badness = -1;

67
	read_lock(&udp_hash_lock);
68
	sk_for_each(sk, node, &udptable[hnum & (UDP_HTABLE_SIZE - 1)]) {
Linus Torvalds's avatar
Linus Torvalds committed
69 70
		struct inet_sock *inet = inet_sk(sk);

71
		if (net_eq(sock_net(sk), net) && sk->sk_hash == hnum &&
72
				sk->sk_family == PF_INET6) {
Linus Torvalds's avatar
Linus Torvalds committed
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
			struct ipv6_pinfo *np = inet6_sk(sk);
			int score = 0;
			if (inet->dport) {
				if (inet->dport != sport)
					continue;
				score++;
			}
			if (!ipv6_addr_any(&np->rcv_saddr)) {
				if (!ipv6_addr_equal(&np->rcv_saddr, daddr))
					continue;
				score++;
			}
			if (!ipv6_addr_any(&np->daddr)) {
				if (!ipv6_addr_equal(&np->daddr, saddr))
					continue;
				score++;
			}
			if (sk->sk_bound_dev_if) {
				if (sk->sk_bound_dev_if != dif)
					continue;
				score++;
			}
Stephen Hemminger's avatar
Stephen Hemminger committed
95
			if (score == 4) {
Linus Torvalds's avatar
Linus Torvalds committed
96 97
				result = sk;
				break;
Stephen Hemminger's avatar
Stephen Hemminger committed
98
			} else if (score > badness) {
Linus Torvalds's avatar
Linus Torvalds committed
99 100 101 102 103 104 105
				result = sk;
				badness = score;
			}
		}
	}
	if (result)
		sock_hold(result);
106
	read_unlock(&udp_hash_lock);
Linus Torvalds's avatar
Linus Torvalds committed
107 108 109 110 111 112 113 114
	return result;
}

/*
 * 	This should be easy, if there is something there we
 * 	return it, otherwise we block.
 */

115
int udpv6_recvmsg(struct kiocb *iocb, struct sock *sk,
Linus Torvalds's avatar
Linus Torvalds committed
116 117 118 119 120
		  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);
121
	struct sk_buff *skb;
122
	unsigned int ulen, copied;
123
	int peeked;
124 125
	int err;
	int is_udplite = IS_UDPLITE(sk);
Linus Torvalds's avatar
Linus Torvalds committed
126

127 128 129
	if (addr_len)
		*addr_len=sizeof(struct sockaddr_in6);

Linus Torvalds's avatar
Linus Torvalds committed
130 131 132 133
	if (flags & MSG_ERRQUEUE)
		return ipv6_recv_error(sk, msg, len);

try_again:
134 135
	skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
				  &peeked, &err);
Linus Torvalds's avatar
Linus Torvalds committed
136 137 138
	if (!skb)
		goto out;

139 140 141 142 143
	ulen = skb->len - sizeof(struct udphdr);
	copied = len;
	if (copied > ulen)
		copied = ulen;
	else if (copied < ulen)
144
		msg->msg_flags |= MSG_TRUNC;
Linus Torvalds's avatar
Linus Torvalds committed
145

146
	/*
147 148 149
	 * 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.
150 151
	 */

152 153
	if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) {
		if (udp_lib_checksum_complete(skb))
Linus Torvalds's avatar
Linus Torvalds committed
154
			goto csum_copy_err;
155 156
	}

157
	if (skb_csum_unnecessary(skb))
158 159 160
		err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
					      msg->msg_iov, copied       );
	else {
Linus Torvalds's avatar
Linus Torvalds committed
161 162 163 164 165 166 167
		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;

168 169
	if (!peeked)
		UDP6_INC_STATS_USER(UDP_MIB_INDATAGRAMS, is_udplite);
170

Linus Torvalds's avatar
Linus Torvalds committed
171 172 173 174 175
	sock_recv_timestamp(msg, sk, skb);

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

Linus Torvalds's avatar
Linus Torvalds committed
177 178
		sin6 = (struct sockaddr_in6 *) msg->msg_name;
		sin6->sin6_family = AF_INET6;
179
		sin6->sin6_port = udp_hdr(skb)->source;
Linus Torvalds's avatar
Linus Torvalds committed
180 181 182 183 184
		sin6->sin6_flowinfo = 0;
		sin6->sin6_scope_id = 0;

		if (skb->protocol == htons(ETH_P_IP))
			ipv6_addr_set(&sin6->sin6_addr, 0, 0,
185
				      htonl(0xffff), ip_hdr(skb)->saddr);
Linus Torvalds's avatar
Linus Torvalds committed
186
		else {
187 188
			ipv6_addr_copy(&sin6->sin6_addr,
				       &ipv6_hdr(skb)->saddr);
Linus Torvalds's avatar
Linus Torvalds committed
189 190 191 192 193 194 195 196 197 198 199
			if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)
				sin6->sin6_scope_id = IP6CB(skb)->iif;
		}

	}
	if (skb->protocol == htons(ETH_P_IP)) {
		if (inet->cmsg_flags)
			ip_cmsg_recv(msg, skb);
	} else {
		if (np->rxopt.all)
			datagram_recv_ctl(sk, msg, skb);
200
	}
Linus Torvalds's avatar
Linus Torvalds committed
201 202 203

	err = copied;
	if (flags & MSG_TRUNC)
204
		err = ulen;
Linus Torvalds's avatar
Linus Torvalds committed
205 206

out_free:
Hideo Aoki's avatar
Hideo Aoki committed
207
	lock_sock(sk);
Linus Torvalds's avatar
Linus Torvalds committed
208
	skb_free_datagram(sk, skb);
Hideo Aoki's avatar
Hideo Aoki committed
209
	release_sock(sk);
Linus Torvalds's avatar
Linus Torvalds committed
210 211 212 213
out:
	return err;

csum_copy_err:
Hideo Aoki's avatar
Hideo Aoki committed
214
	lock_sock(sk);
215 216
	if (!skb_kill_datagram(sk, skb, flags))
		UDP6_INC_STATS_USER(UDP_MIB_INERRORS, is_udplite);
Hideo Aoki's avatar
Hideo Aoki committed
217
	release_sock(sk);
Linus Torvalds's avatar
Linus Torvalds committed
218

219
	if (flags & MSG_DONTWAIT)
Linus Torvalds's avatar
Linus Torvalds committed
220 221 222 223
		return -EAGAIN;
	goto try_again;
}

224 225 226
void __udp6_lib_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
		    int type, int code, int offset, __be32 info,
		    struct hlist_head udptable[]                    )
Linus Torvalds's avatar
Linus Torvalds committed
227 228 229 230 231 232 233 234 235
{
	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;

236
	sk = __udp6_lib_lookup(dev_net(skb->dev), daddr, uh->dest,
237
			       saddr, uh->source, inet6_iif(skb), udptable);
Linus Torvalds's avatar
Linus Torvalds committed
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
	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);
}

258 259
static __inline__ void udpv6_err(struct sk_buff *skb,
				 struct inet6_skb_parm *opt, int type,
260
				 int code, int offset, __be32 info     )
261
{
262
	__udp6_lib_err(skb, opt, type, code, offset, info, udp_hash);
263 264 265
}

int udpv6_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
266
{
267
	struct udp_sock *up = udp_sk(sk);
268
	int rc;
269
	int is_udplite = IS_UDPLITE(sk);
270

271 272
	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
		goto drop;
Linus Torvalds's avatar
Linus Torvalds committed
273

274 275 276
	/*
	 * UDP-Lite specific tests, ignored on UDP sockets (see net/ipv4/udp.c).
	 */
277
	if ((is_udplite & UDPLITE_RECV_CC)  &&  UDP_SKB_CB(skb)->partial_cov) {
278 279 280 281 282 283 284 285 286 287 288 289 290

		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
291 292
	}

293 294 295 296
	if (sk->sk_filter) {
		if (udp_lib_checksum_complete(skb))
			goto drop;
	}
297

298 299 300
	if ((rc = sock_queue_rcv_skb(sk,skb)) < 0) {
		/* Note that an ENOMEM error is charged twice */
		if (rc == -ENOMEM)
301
			UDP6_INC_STATS_BH(UDP_MIB_RCVBUFERRORS, is_udplite);
302
		goto drop;
Linus Torvalds's avatar
Linus Torvalds committed
303
	}
304

Linus Torvalds's avatar
Linus Torvalds committed
305
	return 0;
306
drop:
307
	UDP6_INC_STATS_BH(UDP_MIB_INERRORS, is_udplite);
308 309
	kfree_skb(skb);
	return -1;
Linus Torvalds's avatar
Linus Torvalds committed
310 311 312
}

static struct sock *udp_v6_mcast_next(struct sock *sk,
Al Viro's avatar
Al Viro committed
313 314
				      __be16 loc_port, struct in6_addr *loc_addr,
				      __be16 rmt_port, struct in6_addr *rmt_addr,
Linus Torvalds's avatar
Linus Torvalds committed
315 316 317 318 319 320 321 322 323
				      int dif)
{
	struct hlist_node *node;
	struct sock *s = sk;
	unsigned short num = ntohs(loc_port);

	sk_for_each_from(s, node) {
		struct inet_sock *inet = inet_sk(s);

324
		if (sock_net(s) != sock_net(sk))
325 326
			continue;

327
		if (s->sk_hash == num && s->sk_family == PF_INET6) {
Linus Torvalds's avatar
Linus Torvalds committed
328 329 330 331 332 333 334 335 336 337 338 339 340
			struct ipv6_pinfo *np = inet6_sk(s);
			if (inet->dport) {
				if (inet->dport != rmt_port)
					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)) {
341 342
				if (!ipv6_addr_equal(&np->rcv_saddr, loc_addr))
					continue;
Linus Torvalds's avatar
Linus Torvalds committed
343
			}
Stephen Hemminger's avatar
Stephen Hemminger committed
344
			if (!inet6_mc_check(s, loc_addr, rmt_addr))
Linus Torvalds's avatar
Linus Torvalds committed
345 346 347 348 349 350 351 352 353 354 355
				continue;
			return s;
		}
	}
	return NULL;
}

/*
 * Note: called only from the BH handler context,
 * so we don't need to lock the hashes.
 */
356
static int __udp6_lib_mcast_deliver(struct sk_buff *skb, struct in6_addr *saddr,
357
			   struct in6_addr *daddr, struct hlist_head udptable[])
Linus Torvalds's avatar
Linus Torvalds committed
358 359
{
	struct sock *sk, *sk2;
360
	const struct udphdr *uh = udp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
361 362 363
	int dif;

	read_lock(&udp_hash_lock);
364
	sk = sk_head(&udptable[ntohs(uh->dest) & (UDP_HTABLE_SIZE - 1)]);
365
	dif = inet6_iif(skb);
Linus Torvalds's avatar
Linus Torvalds committed
366 367 368 369 370 371 372 373 374 375
	sk = udp_v6_mcast_next(sk, uh->dest, daddr, uh->source, saddr, dif);
	if (!sk) {
		kfree_skb(skb);
		goto out;
	}

	sk2 = sk;
	while ((sk2 = udp_v6_mcast_next(sk_next(sk2), uh->dest, daddr,
					uh->source, saddr, dif))) {
		struct sk_buff *buff = skb_clone(skb, GFP_ATOMIC);
Hideo Aoki's avatar
Hideo Aoki committed
376 377 378 379 380 381 382 383
		if (buff) {
			bh_lock_sock_nested(sk2);
			if (!sock_owned_by_user(sk2))
				udpv6_queue_rcv_skb(sk2, buff);
			else
				sk_add_backlog(sk2, buff);
			bh_unlock_sock(sk2);
		}
Linus Torvalds's avatar
Linus Torvalds committed
384
	}
Hideo Aoki's avatar
Hideo Aoki committed
385 386 387 388 389 390
	bh_lock_sock_nested(sk);
	if (!sock_owned_by_user(sk))
		udpv6_queue_rcv_skb(sk, skb);
	else
		sk_add_backlog(sk, skb);
	bh_unlock_sock(sk);
Linus Torvalds's avatar
Linus Torvalds committed
391 392
out:
	read_unlock(&udp_hash_lock);
393
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
394 395
}

396 397
static inline int udp6_csum_init(struct sk_buff *skb, struct udphdr *uh,
				 int proto)
398
{
399 400 401 402 403
	int err;

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

404
	if (proto == IPPROTO_UDPLITE) {
405 406 407 408 409
		err = udplite_checksum_init(skb, uh);
		if (err)
			return err;
	}

410 411 412 413 414 415 416 417
	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 &&
418
	    !csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
419
			     skb->len, proto, skb->csum))
420 421
		skb->ip_summed = CHECKSUM_UNNECESSARY;

422
	if (!skb_csum_unnecessary(skb))
423 424
		skb->csum = ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
							 &ipv6_hdr(skb)->daddr,
425
							 skb->len, proto, 0));
426

427
	return 0;
428 429
}

430
int __udp6_lib_rcv(struct sk_buff *skb, struct hlist_head udptable[],
431
		   int proto)
Linus Torvalds's avatar
Linus Torvalds committed
432 433
{
	struct sock *sk;
434
	struct udphdr *uh;
Linus Torvalds's avatar
Linus Torvalds committed
435 436 437 438 439 440 441
	struct net_device *dev = skb->dev;
	struct in6_addr *saddr, *daddr;
	u32 ulen = 0;

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

442 443
	saddr = &ipv6_hdr(skb)->saddr;
	daddr = &ipv6_hdr(skb)->daddr;
444
	uh = udp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
445 446

	ulen = ntohs(uh->len);
447 448
	if (ulen > skb->len)
		goto short_packet;
Linus Torvalds's avatar
Linus Torvalds committed
449

450 451
	if (proto == IPPROTO_UDP) {
		/* UDP validates ulen. */
Linus Torvalds's avatar
Linus Torvalds committed
452

453 454 455
		/* Check for jumbo payload */
		if (ulen == 0)
			ulen = skb->len;
Linus Torvalds's avatar
Linus Torvalds committed
456

457 458
		if (ulen < sizeof(*uh))
			goto short_packet;
Linus Torvalds's avatar
Linus Torvalds committed
459

460 461 462
		if (ulen < skb->len) {
			if (pskb_trim_rcsum(skb, ulen))
				goto short_packet;
463 464
			saddr = &ipv6_hdr(skb)->saddr;
			daddr = &ipv6_hdr(skb)->daddr;
465
			uh = udp_hdr(skb);
466 467
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
468

469 470 471
	if (udp6_csum_init(skb, uh, proto))
		goto discard;

472 473
	/*
	 *	Multicast receive code
Linus Torvalds's avatar
Linus Torvalds committed
474
	 */
475 476
	if (ipv6_addr_is_multicast(daddr))
		return __udp6_lib_mcast_deliver(skb, saddr, daddr, udptable);
Linus Torvalds's avatar
Linus Torvalds committed
477 478 479

	/* Unicast */

480
	/*
Linus Torvalds's avatar
Linus Torvalds committed
481 482 483
	 * check socket cache ... must talk to Alan about his plans
	 * for sock caches... i'll skip this for now.
	 */
484
	sk = __udp6_lib_lookup(dev_net(skb->dev), saddr, uh->source,
485
			       daddr, uh->dest, inet6_iif(skb), udptable);
Linus Torvalds's avatar
Linus Torvalds committed
486 487 488 489 490

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

491
		if (udp_lib_checksum_complete(skb))
Linus Torvalds's avatar
Linus Torvalds committed
492
			goto discard;
493
		UDP6_INC_STATS_BH(UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
Linus Torvalds's avatar
Linus Torvalds committed
494 495 496 497

		icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0, dev);

		kfree_skb(skb);
Stephen Hemminger's avatar
Stephen Hemminger committed
498
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
499
	}
500

Linus Torvalds's avatar
Linus Torvalds committed
501
	/* deliver */
502

Hideo Aoki's avatar
Hideo Aoki committed
503 504 505 506 507 508
	bh_lock_sock_nested(sk);
	if (!sock_owned_by_user(sk))
		udpv6_queue_rcv_skb(sk, skb);
	else
		sk_add_backlog(sk, skb);
	bh_unlock_sock(sk);
Linus Torvalds's avatar
Linus Torvalds committed
509
	sock_put(sk);
Stephen Hemminger's avatar
Stephen Hemminger committed
510
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
511

512
short_packet:
513
	LIMIT_NETDEBUG(KERN_DEBUG "UDP%sv6: short packet: %d/%u\n",
514
		       proto == IPPROTO_UDPLITE ? "-Lite" : "",
515
		       ulen, skb->len);
Linus Torvalds's avatar
Linus Torvalds committed
516 517

discard:
518
	UDP6_INC_STATS_BH(UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
Linus Torvalds's avatar
Linus Torvalds committed
519
	kfree_skb(skb);
Stephen Hemminger's avatar
Stephen Hemminger committed
520
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
521
}
522

523
static __inline__ int udpv6_rcv(struct sk_buff *skb)
524
{
525
	return __udp6_lib_rcv(skb, udp_hash, IPPROTO_UDP);
526 527
}

Linus Torvalds's avatar
Linus Torvalds committed
528 529 530 531 532 533 534
/*
 * 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);

535 536 537
	if (up->pending == AF_INET)
		udp_flush_pending_frames(sk);
	else if (up->pending) {
Linus Torvalds's avatar
Linus Torvalds committed
538 539 540
		up->len = 0;
		up->pending = 0;
		ip6_flush_pending_frames(sk);
541
	}
Linus Torvalds's avatar
Linus Torvalds committed
542 543 544 545 546 547
}

/*
 *	Sending
 */

548
static int udp_v6_push_pending_frames(struct sock *sk)
Linus Torvalds's avatar
Linus Torvalds committed
549 550 551
{
	struct sk_buff *skb;
	struct udphdr *uh;
552
	struct udp_sock  *up = udp_sk(sk);
Linus Torvalds's avatar
Linus Torvalds committed
553 554 555
	struct inet_sock *inet = inet_sk(sk);
	struct flowi *fl = &inet->cork.fl;
	int err = 0;
556
	int is_udplite = IS_UDPLITE(sk);
557
	__wsum csum = 0;
Linus Torvalds's avatar
Linus Torvalds committed
558 559 560 561 562 563 564 565

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

	/*
	 * Create a UDP header
	 */
566
	uh = udp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
567 568 569 570 571
	uh->source = fl->fl_ip_sport;
	uh->dest = fl->fl_ip_dport;
	uh->len = htons(up->len);
	uh->check = 0;

572
	if (is_udplite)
573 574 575
		csum = udplite_csum_outgoing(sk, skb);
	 else
		csum = udp_csum_outgoing(sk, skb);
Linus Torvalds's avatar
Linus Torvalds committed
576

577 578 579
	/* 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
580
	if (uh->check == 0)
581
		uh->check = CSUM_MANGLED_0;
Linus Torvalds's avatar
Linus Torvalds committed
582 583 584 585 586

	err = ip6_push_pending_frames(sk);
out:
	up->len = 0;
	up->pending = 0;
587
	if (!err)
588
		UDP6_INC_STATS_USER(UDP_MIB_OUTDATAGRAMS, is_udplite);
Linus Torvalds's avatar
Linus Torvalds committed
589 590 591
	return err;
}

592
int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
Linus Torvalds's avatar
Linus Torvalds committed
593 594 595 596 597 598 599 600 601 602
		  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
603
	struct flowi fl;
Linus Torvalds's avatar
Linus Torvalds committed
604 605 606 607
	struct dst_entry *dst;
	int addr_len = msg->msg_namelen;
	int ulen = len;
	int hlimit = -1;
608
	int tclass = -1;
Linus Torvalds's avatar
Linus Torvalds committed
609 610
	int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
	int err;
611
	int connected = 0;
612
	int is_udplite = IS_UDPLITE(sk);
613
	int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
Linus Torvalds's avatar
Linus Torvalds committed
614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639

	/* 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;
640
	} else
Linus Torvalds's avatar
Linus Torvalds committed
641 642 643
		daddr = NULL;

	if (daddr) {
644
		if (ipv6_addr_v4mapped(daddr)) {
Linus Torvalds's avatar
Linus Torvalds committed
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
			struct sockaddr_in sin;
			sin.sin_family = AF_INET;
			sin.sin_port = sin6 ? sin6->sin6_port : inet->dport;
			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,
662
	   better check is made in ip6_append_data().
Linus Torvalds's avatar
Linus Torvalds committed
663 664 665
	   */
	if (len > INT_MAX - sizeof(struct udphdr))
		return -EMSGSIZE;
666

Linus Torvalds's avatar
Linus Torvalds committed
667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
	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
685
	memset(&fl, 0, sizeof(fl));
Linus Torvalds's avatar
Linus Torvalds committed
686 687 688 689 690

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

Herbert Xu's avatar
Herbert Xu committed
691
		fl.fl_ip_dport = sin6->sin6_port;
Linus Torvalds's avatar
Linus Torvalds committed
692 693 694
		daddr = &sin6->sin6_addr;

		if (np->sndflow) {
Herbert Xu's avatar
Herbert Xu committed
695 696 697
			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
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
				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
715
			fl.oif = sin6->sin6_scope_id;
Linus Torvalds's avatar
Linus Torvalds committed
716 717 718 719
	} else {
		if (sk->sk_state != TCP_ESTABLISHED)
			return -EDESTADDRREQ;

Herbert Xu's avatar
Herbert Xu committed
720
		fl.fl_ip_dport = inet->dport;
Linus Torvalds's avatar
Linus Torvalds committed
721
		daddr = &np->daddr;
Herbert Xu's avatar
Herbert Xu committed
722
		fl.fl6_flowlabel = np->flow_label;
723
		connected = 1;
Linus Torvalds's avatar
Linus Torvalds committed
724 725
	}

Herbert Xu's avatar
Herbert Xu committed
726 727
	if (!fl.oif)
		fl.oif = sk->sk_bound_dev_if;
Linus Torvalds's avatar
Linus Torvalds committed
728 729 730 731 732 733

	if (msg->msg_controllen) {
		opt = &opt_space;
		memset(opt, 0, sizeof(struct ipv6_txoptions));
		opt->tot_len = sizeof(*opt);

734
		err = datagram_send_ctl(sock_net(sk), msg, &fl, opt, &hlimit, &tclass);
Linus Torvalds's avatar
Linus Torvalds committed
735 736 737 738
		if (err < 0) {
			fl6_sock_release(flowlabel);
			return err;
		}
Herbert Xu's avatar
Herbert Xu committed
739 740
		if ((fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) {
			flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
Linus Torvalds's avatar
Linus Torvalds committed
741 742 743 744 745
			if (flowlabel == NULL)
				return -EINVAL;
		}
		if (!(opt->opt_nflen|opt->opt_flen))
			opt = NULL;
746
		connected = 0;
Linus Torvalds's avatar
Linus Torvalds committed
747 748 749
	}
	if (opt == NULL)
		opt = np->opt;
750 751 752
	if (flowlabel)
		opt = fl6_merge_options(&opt_space, flowlabel, opt);
	opt = ipv6_fixup_options(&opt_space, opt);
Linus Torvalds's avatar
Linus Torvalds committed
753

754
	fl.proto = sk->sk_protocol;
755 756 757 758
	if (!ipv6_addr_any(daddr))
		ipv6_addr_copy(&fl.fl6_dst, daddr);
	else
		fl.fl6_dst.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
Herbert Xu's avatar
Herbert Xu committed
759 760 761
	if (ipv6_addr_any(&fl.fl6_src) && !ipv6_addr_any(&np->saddr))
		ipv6_addr_copy(&fl.fl6_src, &np->saddr);
	fl.fl_ip_sport = inet->sport;
762

Linus Torvalds's avatar
Linus Torvalds committed
763 764 765
	/* merge ip6_build_xmit from ip6_output */
	if (opt && opt->srcrt) {
		struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
Herbert Xu's avatar
Herbert Xu committed
766 767
		ipv6_addr_copy(&final, &fl.fl6_dst);
		ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
Linus Torvalds's avatar
Linus Torvalds committed
768
		final_p = &final;
769
		connected = 0;
Linus Torvalds's avatar
Linus Torvalds committed
770 771
	}

Herbert Xu's avatar
Herbert Xu committed
772 773
	if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst)) {
		fl.oif = np->mcast_oif;
774 775
		connected = 0;
	}
Linus Torvalds's avatar
Linus Torvalds committed
776

Herbert Xu's avatar
Herbert Xu committed
777
	security_sk_classify_flow(sk, &fl);
778

Herbert Xu's avatar
Herbert Xu committed
779
	err = ip6_sk_dst_lookup(sk, &dst, &fl);
Linus Torvalds's avatar
Linus Torvalds committed
780 781 782
	if (err)
		goto out;
	if (final_p)
Herbert Xu's avatar
Herbert Xu committed
783
		ipv6_addr_copy(&fl.fl6_dst, final_p);
Linus Torvalds's avatar
Linus Torvalds committed
784

785
	if ((err = __xfrm_lookup(&dst, &fl, sk, XFRM_LOOKUP_WAIT)) < 0) {
786 787 788 789 790
		if (err == -EREMOTE)
			err = ip6_dst_blackhole(sk, &dst, &fl);
		if (err < 0)
			goto out;
	}
Linus Torvalds's avatar
Linus Torvalds committed
791 792

	if (hlimit < 0) {
Herbert Xu's avatar
Herbert Xu committed
793
		if (ipv6_addr_is_multicast(&fl.fl6_dst))
Linus Torvalds's avatar
Linus Torvalds committed
794 795 796 797
			hlimit = np->mcast_hops;
		else
			hlimit = np->hop_limit;
		if (hlimit < 0)
798
			hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds's avatar
Linus Torvalds committed
799 800
	}

801 802 803 804 805 806
	if (tclass < 0) {
		tclass = np->tclass;
		if (tclass < 0)
			tclass = 0;
	}

Linus Torvalds's avatar
Linus Torvalds committed
807 808 809 810 811 812 813 814 815 816
	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);

817
		LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
Linus Torvalds's avatar
Linus Torvalds committed
818 819 820 821 822 823 824 825
		err = -EINVAL;
		goto out;
	}

	up->pending = AF_INET6;

do_append_data:
	up->len += ulen;
826 827
	getfrag  =  is_udplite ?  udplite_getfrag : ip_generic_getfrag;
	err = ip6_append_data(sk, getfrag, msg->msg_iov, ulen,
Herbert Xu's avatar
Herbert Xu committed
828
		sizeof(struct udphdr), hlimit, tclass, opt, &fl,
829 830
		(struct rt6_info*)dst,
		corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
Linus Torvalds's avatar
Linus Torvalds committed
831 832 833
	if (err)
		udp_v6_flush_pending_frames(sk);
	else if (!corkreq)
834
		err = udp_v6_push_pending_frames(sk);
Herbert Xu's avatar
Herbert Xu committed
835 836
	else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
		up->pending = 0;
Linus Torvalds's avatar
Linus Torvalds committed
837

838 839 840
	if (dst) {
		if (connected) {
			ip6_dst_store(sk, dst,
Herbert Xu's avatar
Herbert Xu committed
841
				      ipv6_addr_equal(&fl.fl6_dst, &np->daddr) ?
842 843
				      &np->daddr : NULL,
#ifdef CONFIG_IPV6_SUBTREES
Herbert Xu's avatar
Herbert Xu committed
844
				      ipv6_addr_equal(&fl.fl6_src, &np->saddr) ?
845 846 847
				      &np->saddr :
#endif
				      NULL);
848 849 850
		} else {
			dst_release(dst);
		}
851
		dst = NULL;
852 853
	}

Linus Torvalds's avatar
Linus Torvalds committed
854 855 856 857
	if (err > 0)
		err = np->recverr ? net_xmit_errno(err) : 0;
	release_sock(sk);
out:
858
	dst_release(dst);
Linus Torvalds's avatar
Linus Torvalds committed
859
	fl6_sock_release(flowlabel);
860
	if (!err)
Linus Torvalds's avatar
Linus Torvalds committed
861
		return len;
862 863 864 865 866 867 868 869
	/*
	 * 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)) {
870
		UDP6_INC_STATS_USER(UDP_MIB_SNDBUFERRORS, is_udplite);
871
	}
Linus Torvalds's avatar
Linus Torvalds committed
872 873 874 875 876 877 878 879 880 881
	return err;

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

882
void udpv6_destroy_sock(struct sock *sk)
Linus Torvalds's avatar
Linus Torvalds committed
883 884 885 886 887 888 889 890 891 892 893
{
	lock_sock(sk);
	udp_v6_flush_pending_frames(sk);
	release_sock(sk);

	inet6_destroy_sock(sk);
}

/*
 *	Socket option code for UDP
 */
894 895
int udpv6_setsockopt(struct sock *sk, int level, int optname,
		     char __user *optval, int optlen)
896
{
897
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
898 899
		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
					  udp_v6_push_pending_frames);
900
	return ipv6_setsockopt(sk, level, optname, optval, optlen);
901 902 903
}

#ifdef CONFIG_COMPAT
904 905
int compat_udpv6_setsockopt(struct sock *sk, int level, int optname,
			    char __user *optval, int optlen)
906
{
907
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
908 909
		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
					  udp_v6_push_pending_frames);
910
	return compat_ipv6_setsockopt(sk, level, optname, optval, optlen);
911 912 913
}
#endif

914 915
int udpv6_getsockopt(struct sock *sk, int level, int optname,
		     char __user *optval, int __user *optlen)
916
{
917
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
918
		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
919
	return ipv6_getsockopt(sk, level, optname, optval, optlen);
920 921 922
}

#ifdef CONFIG_COMPAT
923 924
int compat_udpv6_getsockopt(struct sock *sk, int level, int optname,
			    char __user *optval, int __user *optlen)
925
{
926
	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
927
		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
928
	return compat_ipv6_getsockopt(sk, level, optname, optval, optlen);
929 930 931
}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959
static struct inet6_protocol udpv6_protocol = {
	.handler	=	udpv6_rcv,
	.err_handler	=	udpv6_err,
	.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;
	destp = ntohs(inet->dport);
	srcp  = ntohs(inet->sport);
	seq_printf(seq,
		   "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
		   "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p\n",
		   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,
960
		   sp->sk_state,
Linus Torvalds's avatar
Linus Torvalds committed
961 962 963 964 965 966 967 968
		   atomic_read(&sp->sk_wmem_alloc),
		   atomic_read(&sp->sk_rmem_alloc),
		   0, 0L, 0,
		   sock_i_uid(sp), 0,
		   sock_i_ino(sp),
		   atomic_read(&sp->sk_refcnt), sp);
}

969
int udp6_seq_show(struct seq_file *seq, void *v)
Linus Torvalds's avatar
Linus Torvalds committed
970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
{
	if (v == SEQ_START_TOKEN)
		seq_printf(seq,
			   "  sl  "
			   "local_address                         "
			   "remote_address                        "
			   "st tx_queue rx_queue tr tm->when retrnsmt"
			   "   uid  timeout inode\n");
	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,
986
	.hashtable	= udp_hash,
987 988 989
	.seq_fops	= {
		.owner	=	THIS_MODULE,
	},
990 991 992
	.seq_ops	= {
		.show		= udp6_seq_show,
	},
Linus Torvalds's avatar
Linus Torvalds committed
993 994
};

995
int udp6_proc_init(struct net *net)
Linus Torvalds's avatar
Linus Torvalds committed
996
{
997
	return udp_proc_register(net, &udp6_seq_afinfo);
Linus Torvalds's avatar
Linus Torvalds committed
998 999
}

1000 1001
void udp6_proc_exit(struct net *net) {
	udp_proc_unregister(net, &udp6_seq_afinfo);
Linus Torvalds's avatar
Linus Torvalds committed
1002 1003 1004 1005 1006 1007
}
#endif /* CONFIG_PROC_FS */

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

struct proto udpv6_prot = {
1008 1009
	.name		   = "UDPv6",
	.owner		   = THIS_MODULE,
1010
	.close		   = udp_lib_close,
1011 1012 1013 1014 1015 1016 1017 1018 1019
	.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,
1020 1021
	.hash		   = udp_lib_hash,
	.unhash		   = udp_lib_unhash,
1022
	.get_port	   = udp_v6_get_port,
Hideo Aoki's avatar
Hideo Aoki committed
1023 1024 1025