proto.c 29.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 *  net/dccp/proto.c
 *
 *  An implementation of the DCCP protocol
 *  Arnaldo Carvalho de Melo <acme@conectiva.com.br>
 *
 *	This program is free software; you can redistribute it and/or modify it
 *	under the terms of the GNU General Public License version 2 as
 *	published by the Free Software Foundation.
 */

#include <linux/dccp.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/in.h>
#include <linux/if_arp.h>
#include <linux/init.h>
#include <linux/random.h>
#include <net/checksum.h>

25
#include <net/inet_sock.h>
26 27 28
#include <net/sock.h>
#include <net/xfrm.h>

29
#include <asm/ioctls.h>
30 31 32 33 34 35 36
#include <linux/spinlock.h>
#include <linux/timer.h>
#include <linux/delay.h>
#include <linux/poll.h>

#include "ccid.h"
#include "dccp.h"
37
#include "feat.h"
38

39
DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
40

41 42
EXPORT_SYMBOL_GPL(dccp_statistics);

43 44
atomic_t dccp_orphan_count = ATOMIC_INIT(0);

45 46
EXPORT_SYMBOL_GPL(dccp_orphan_count);

47 48 49 50 51 52 53 54
struct inet_hashinfo __cacheline_aligned dccp_hashinfo = {
	.lhash_lock	= RW_LOCK_UNLOCKED,
	.lhash_users	= ATOMIC_INIT(0),
	.lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(dccp_hashinfo.lhash_wait),
};

EXPORT_SYMBOL_GPL(dccp_hashinfo);

55 56 57
/* the maximum queue length for tx in packets. 0 is no limit */
int sysctl_dccp_tx_qlen __read_mostly = 5;

58 59 60 61
void dccp_set_state(struct sock *sk, const int state)
{
	const int oldstate = sk->sk_state;

62
	dccp_pr_debug("%s(%p)  %s  -->  %s\n", dccp_role(sk), sk,
63 64 65 66 67 68 69
		      dccp_state_name(oldstate), dccp_state_name(state));
	WARN_ON(state == oldstate);

	switch (state) {
	case DCCP_OPEN:
		if (oldstate != DCCP_OPEN)
			DCCP_INC_STATS(DCCP_MIB_CURRESTAB);
70 71 72
		/* Client retransmits all Confirm options until entering OPEN */
		if (oldstate == DCCP_PARTOPEN)
			dccp_feat_list_purge(&dccp_sk(sk)->dccps_featneg);
73 74 75
		break;

	case DCCP_CLOSED:
76 77
		if (oldstate == DCCP_OPEN || oldstate == DCCP_ACTIVE_CLOSEREQ ||
		    oldstate == DCCP_CLOSING)
78 79 80 81 82
			DCCP_INC_STATS(DCCP_MIB_ESTABRESETS);

		sk->sk_prot->unhash(sk);
		if (inet_csk(sk)->icsk_bind_hash != NULL &&
		    !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
83
			inet_put_port(sk);
84 85 86 87 88 89 90 91 92 93 94 95 96 97
		/* fall through */
	default:
		if (oldstate == DCCP_OPEN)
			DCCP_DEC_STATS(DCCP_MIB_CURRESTAB);
	}

	/* Change state AFTER socket is unhashed to avoid closed
	 * socket sitting in hash tables.
	 */
	sk->sk_state = state;
}

EXPORT_SYMBOL_GPL(dccp_set_state);

98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
static void dccp_finish_passive_close(struct sock *sk)
{
	switch (sk->sk_state) {
	case DCCP_PASSIVE_CLOSE:
		/* Node (client or server) has received Close packet. */
		dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED);
		dccp_set_state(sk, DCCP_CLOSED);
		break;
	case DCCP_PASSIVE_CLOSEREQ:
		/*
		 * Client received CloseReq. We set the `active' flag so that
		 * dccp_send_close() retransmits the Close as per RFC 4340, 8.3.
		 */
		dccp_send_close(sk, 1);
		dccp_set_state(sk, DCCP_CLOSING);
	}
}

116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
void dccp_done(struct sock *sk)
{
	dccp_set_state(sk, DCCP_CLOSED);
	dccp_clear_xmit_timers(sk);

	sk->sk_shutdown = SHUTDOWN_MASK;

	if (!sock_flag(sk, SOCK_DEAD))
		sk->sk_state_change(sk);
	else
		inet_csk_destroy_sock(sk);
}

EXPORT_SYMBOL_GPL(dccp_done);

131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
const char *dccp_packet_name(const int type)
{
	static const char *dccp_packet_names[] = {
		[DCCP_PKT_REQUEST]  = "REQUEST",
		[DCCP_PKT_RESPONSE] = "RESPONSE",
		[DCCP_PKT_DATA]	    = "DATA",
		[DCCP_PKT_ACK]	    = "ACK",
		[DCCP_PKT_DATAACK]  = "DATAACK",
		[DCCP_PKT_CLOSEREQ] = "CLOSEREQ",
		[DCCP_PKT_CLOSE]    = "CLOSE",
		[DCCP_PKT_RESET]    = "RESET",
		[DCCP_PKT_SYNC]	    = "SYNC",
		[DCCP_PKT_SYNCACK]  = "SYNCACK",
	};

	if (type >= DCCP_NR_PKT_TYPES)
		return "INVALID";
	else
		return dccp_packet_names[type];
}

EXPORT_SYMBOL_GPL(dccp_packet_name);

const char *dccp_state_name(const int state)
{
	static char *dccp_state_names[] = {
157 158 159 160 161 162 163 164 165 166 167
	[DCCP_OPEN]		= "OPEN",
	[DCCP_REQUESTING]	= "REQUESTING",
	[DCCP_PARTOPEN]		= "PARTOPEN",
	[DCCP_LISTEN]		= "LISTEN",
	[DCCP_RESPOND]		= "RESPOND",
	[DCCP_CLOSING]		= "CLOSING",
	[DCCP_ACTIVE_CLOSEREQ]	= "CLOSEREQ",
	[DCCP_PASSIVE_CLOSE]	= "PASSIVE_CLOSE",
	[DCCP_PASSIVE_CLOSEREQ]	= "PASSIVE_CLOSEREQ",
	[DCCP_TIME_WAIT]	= "TIME_WAIT",
	[DCCP_CLOSED]		= "CLOSED",
168 169 170 171 172 173 174 175 176 177
	};

	if (state >= DCCP_MAX_STATES)
		return "INVALID STATE!";
	else
		return dccp_state_names[state];
}

EXPORT_SYMBOL_GPL(dccp_state_name);

178
int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
179 180 181 182
{
	struct dccp_sock *dp = dccp_sk(sk);
	struct inet_connection_sock *icsk = inet_csk(sk);

183 184 185 186 187 188 189 190 191
	icsk->icsk_rto		= DCCP_TIMEOUT_INIT;
	icsk->icsk_syn_retries	= sysctl_dccp_request_retries;
	sk->sk_state		= DCCP_CLOSED;
	sk->sk_write_space	= dccp_write_space;
	icsk->icsk_sync_mss	= dccp_sync_mss;
	dp->dccps_mss_cache	= 536;
	dp->dccps_rate_last	= jiffies;
	dp->dccps_role		= DCCP_ROLE_UNDEFINED;
	dp->dccps_service	= DCCP_SERVICE_CODE_IS_ABSENT;
192
	dp->dccps_tx_qlen	= sysctl_dccp_tx_qlen;
193 194 195

	dccp_init_xmit_timers(sk);

196
	INIT_LIST_HEAD(&dp->dccps_featneg);
197 198 199
	/* control socket doesn't need feat nego */
	if (likely(ctl_sock_initialized))
		return dccp_feat_init(sk);
200 201 202 203 204
	return 0;
}

EXPORT_SYMBOL_GPL(dccp_init_sock);

205
void dccp_destroy_sock(struct sock *sk)
206 207 208 209 210 211 212 213 214 215 216 217 218 219
{
	struct dccp_sock *dp = dccp_sk(sk);

	/*
	 * DCCP doesn't use sk_write_queue, just sk_send_head
	 * for retransmissions
	 */
	if (sk->sk_send_head != NULL) {
		kfree_skb(sk->sk_send_head);
		sk->sk_send_head = NULL;
	}

	/* Clean up a referenced DCCP bind bucket. */
	if (inet_csk(sk)->icsk_bind_hash != NULL)
220
		inet_put_port(sk);
221 222 223 224

	kfree(dp->dccps_service_list);
	dp->dccps_service_list = NULL;

225
	if (dp->dccps_hc_rx_ackvec != NULL) {
226 227 228 229 230 231 232 233
		dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
		dp->dccps_hc_rx_ackvec = NULL;
	}
	ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
	ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
	dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;

	/* clean up feature negotiation state */
234
	dccp_feat_list_purge(&dp->dccps_featneg);
235 236 237 238
}

EXPORT_SYMBOL_GPL(dccp_destroy_sock);

239
static inline int dccp_listen_start(struct sock *sk, int backlog)
240
{
241 242 243
	struct dccp_sock *dp = dccp_sk(sk);

	dp->dccps_role = DCCP_ROLE_LISTEN;
244 245 246
	/* do not start to listen if feature negotiation setup fails */
	if (dccp_feat_finalise_settings(dp))
		return -EPROTO;
247
	return inet_csk_listen_start(sk, backlog);
248 249
}

250 251 252 253 254 255
static inline int dccp_need_reset(int state)
{
	return state != DCCP_CLOSED && state != DCCP_LISTEN &&
	       state != DCCP_REQUESTING;
}

256 257 258 259 260 261 262 263 264 265
int dccp_disconnect(struct sock *sk, int flags)
{
	struct inet_connection_sock *icsk = inet_csk(sk);
	struct inet_sock *inet = inet_sk(sk);
	int err = 0;
	const int old_state = sk->sk_state;

	if (old_state != DCCP_CLOSED)
		dccp_set_state(sk, DCCP_CLOSED);

266 267 268 269
	/*
	 * This corresponds to the ABORT function of RFC793, sec. 3.8
	 * TCP uses a RST segment, DCCP a Reset packet with Code 2, "Aborted".
	 */
270 271
	if (old_state == DCCP_LISTEN) {
		inet_csk_listen_stop(sk);
272 273 274
	} else if (dccp_need_reset(old_state)) {
		dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
		sk->sk_err = ECONNRESET;
275 276 277 278
	} else if (old_state == DCCP_REQUESTING)
		sk->sk_err = ECONNRESET;

	dccp_clear_xmit_timers(sk);
279

280
	__skb_queue_purge(&sk->sk_receive_queue);
281
	__skb_queue_purge(&sk->sk_write_queue);
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
	if (sk->sk_send_head != NULL) {
		__kfree_skb(sk->sk_send_head);
		sk->sk_send_head = NULL;
	}

	inet->dport = 0;

	if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
		inet_reset_saddr(sk);

	sk->sk_shutdown = 0;
	sock_reset_flag(sk, SOCK_DONE);

	icsk->icsk_backoff = 0;
	inet_csk_delack_init(sk);
	__sk_dst_reset(sk);

299
	WARN_ON(inet->num && !icsk->icsk_bind_hash);
300 301 302 303 304

	sk->sk_error_report(sk);
	return err;
}

305 306
EXPORT_SYMBOL_GPL(dccp_disconnect);

307 308 309 310 311 312 313
/*
 *	Wait for a DCCP event.
 *
 *	Note that we don't need to lock the socket, as the upper poll layers
 *	take care of normal races (between the test and the event) and we don't
 *	go look at any of the socket buffers directly.
 */
314 315
unsigned int dccp_poll(struct file *file, struct socket *sock,
		       poll_table *wait)
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
{
	unsigned int mask;
	struct sock *sk = sock->sk;

	poll_wait(file, sk->sk_sleep, wait);
	if (sk->sk_state == DCCP_LISTEN)
		return inet_csk_listen_poll(sk);

	/* Socket is not locked. We are protected from async events
	   by poll logic and correct handling of state changes
	   made by another threads is impossible in any case.
	 */

	mask = 0;
	if (sk->sk_err)
		mask = POLLERR;

	if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
		mask |= POLLHUP;
	if (sk->sk_shutdown & RCV_SHUTDOWN)
336
		mask |= POLLIN | POLLRDNORM | POLLRDHUP;
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362

	/* Connected? */
	if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
		if (atomic_read(&sk->sk_rmem_alloc) > 0)
			mask |= POLLIN | POLLRDNORM;

		if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
			if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
				mask |= POLLOUT | POLLWRNORM;
			} else {  /* send SIGIO later */
				set_bit(SOCK_ASYNC_NOSPACE,
					&sk->sk_socket->flags);
				set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);

				/* Race breaker. If space is freed after
				 * wspace test but before the flags are set,
				 * IO signal will be lost.
				 */
				if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
					mask |= POLLOUT | POLLWRNORM;
			}
		}
	}
	return mask;
}

363 364
EXPORT_SYMBOL_GPL(dccp_poll);

365 366
int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
{
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
	int rc = -ENOTCONN;

	lock_sock(sk);

	if (sk->sk_state == DCCP_LISTEN)
		goto out;

	switch (cmd) {
	case SIOCINQ: {
		struct sk_buff *skb;
		unsigned long amount = 0;

		skb = skb_peek(&sk->sk_receive_queue);
		if (skb != NULL) {
			/*
			 * We will only return the amount of this packet since
			 * that is all that will be read.
			 */
			amount = skb->len;
		}
		rc = put_user(amount, (int __user *)arg);
	}
		break;
	default:
		rc = -ENOIOCTLCMD;
		break;
	}
out:
	release_sock(sk);
	return rc;
397 398
}

399 400
EXPORT_SYMBOL_GPL(dccp_ioctl);

401
static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
402 403 404 405 406
				   char __user *optval, int optlen)
{
	struct dccp_sock *dp = dccp_sk(sk);
	struct dccp_service_list *sl = NULL;

407
	if (service == DCCP_SERVICE_INVALID_VALUE ||
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
	    optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
		return -EINVAL;

	if (optlen > sizeof(service)) {
		sl = kmalloc(optlen, GFP_KERNEL);
		if (sl == NULL)
			return -ENOMEM;

		sl->dccpsl_nr = optlen / sizeof(u32) - 1;
		if (copy_from_user(sl->dccpsl_list,
				   optval + sizeof(service),
				   optlen - sizeof(service)) ||
		    dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
			kfree(sl);
			return -EFAULT;
		}
	}

	lock_sock(sk);
	dp->dccps_service = service;

Jesper Juhl's avatar
Jesper Juhl committed
429
	kfree(dp->dccps_service_list);
430 431 432 433 434 435

	dp->dccps_service_list = sl;
	release_sock(sk);
	return 0;
}

436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
static int dccp_setsockopt_cscov(struct sock *sk, int cscov, bool rx)
{
	u8 *list, len;
	int i, rc;

	if (cscov < 0 || cscov > 15)
		return -EINVAL;
	/*
	 * Populate a list of permissible values, in the range cscov...15. This
	 * is necessary since feature negotiation of single values only works if
	 * both sides incidentally choose the same value. Since the list starts
	 * lowest-value first, negotiation will pick the smallest shared value.
	 */
	if (cscov == 0)
		return 0;
	len = 16 - cscov;

	list = kmalloc(len, GFP_KERNEL);
	if (list == NULL)
		return -ENOBUFS;

	for (i = 0; i < len; i++)
		list[i] = cscov++;

	rc = dccp_feat_register_sp(sk, DCCPF_MIN_CSUM_COVER, rx, list, len);

	if (rc == 0) {
		if (rx)
			dccp_sk(sk)->dccps_pcrlen = cscov;
		else
			dccp_sk(sk)->dccps_pcslen = cscov;
	}
	kfree(list);
	return rc;
}

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
static int dccp_setsockopt_ccid(struct sock *sk, int type,
				char __user *optval, int optlen)
{
	u8 *val;
	int rc = 0;

	if (optlen < 1 || optlen > DCCP_FEAT_MAX_SP_VALS)
		return -EINVAL;

	val = kmalloc(optlen, GFP_KERNEL);
	if (val == NULL)
		return -ENOMEM;

	if (copy_from_user(val, optval, optlen)) {
		kfree(val);
		return -EFAULT;
	}

	lock_sock(sk);
	if (type == DCCP_SOCKOPT_TX_CCID || type == DCCP_SOCKOPT_CCID)
		rc = dccp_feat_register_sp(sk, DCCPF_CCID, 1, val, optlen);

	if (!rc && (type == DCCP_SOCKOPT_RX_CCID || type == DCCP_SOCKOPT_CCID))
		rc = dccp_feat_register_sp(sk, DCCPF_CCID, 0, val, optlen);
	release_sock(sk);

	kfree(val);
	return rc;
}

502 503
static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
		char __user *optval, int optlen)
504
{
505 506
	struct dccp_sock *dp = dccp_sk(sk);
	int val, err = 0;
507

508 509 510 511 512 513 514 515
	switch (optname) {
	case DCCP_SOCKOPT_PACKET_SIZE:
		DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
		return 0;
	case DCCP_SOCKOPT_CHANGE_L:
	case DCCP_SOCKOPT_CHANGE_R:
		DCCP_WARN("sockopt(CHANGE_L/R) is deprecated: fix your app\n");
		return 0;
516 517 518 519
	case DCCP_SOCKOPT_CCID:
	case DCCP_SOCKOPT_RX_CCID:
	case DCCP_SOCKOPT_TX_CCID:
		return dccp_setsockopt_ccid(sk, optname, optval, optlen);
520 521 522
	}

	if (optlen < (int)sizeof(int))
523 524 525 526 527
		return -EINVAL;

	if (get_user(val, (int __user *)optval))
		return -EFAULT;

528 529
	if (optname == DCCP_SOCKOPT_SERVICE)
		return dccp_setsockopt_service(sk, val, optval, optlen);
530

531
	lock_sock(sk);
532
	switch (optname) {
533 534 535 536 537 538
	case DCCP_SOCKOPT_SERVER_TIMEWAIT:
		if (dp->dccps_role != DCCP_ROLE_SERVER)
			err = -EOPNOTSUPP;
		else
			dp->dccps_server_timewait = (val != 0);
		break;
539 540
	case DCCP_SOCKOPT_SEND_CSCOV:
		err = dccp_setsockopt_cscov(sk, val, false);
541
		break;
542 543
	case DCCP_SOCKOPT_RECV_CSCOV:
		err = dccp_setsockopt_cscov(sk, val, true);
544
		break;
545 546 547 548 549 550 551 552 553 554 555 556 557 558
	case DCCP_SOCKOPT_QPOLICY_ID:
		if (sk->sk_state != DCCP_CLOSED)
			err = -EISCONN;
		else if (val < 0 || val >= DCCPQ_POLICY_MAX)
			err = -EINVAL;
		else
			dp->dccps_qpolicy = val;
		break;
	case DCCP_SOCKOPT_QPOLICY_TXQLEN:
		if (val < 0)
			err = -EINVAL;
		else
			dp->dccps_tx_qlen = val;
		break;
559 560 561 562 563
	default:
		err = -ENOPROTOOPT;
		break;
	}
	release_sock(sk);
564

565
	return err;
566 567
}

568 569 570 571 572 573 574 575 576
int dccp_setsockopt(struct sock *sk, int level, int optname,
		    char __user *optval, int optlen)
{
	if (level != SOL_DCCP)
		return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
							     optname, optval,
							     optlen);
	return do_dccp_setsockopt(sk, level, optname, optval, optlen);
}
577

578 579
EXPORT_SYMBOL_GPL(dccp_setsockopt);

580 581
#ifdef CONFIG_COMPAT
int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
582
			   char __user *optval, int optlen)
583
{
584 585 586
	if (level != SOL_DCCP)
		return inet_csk_compat_setsockopt(sk, level, optname,
						  optval, optlen);
587 588
	return do_dccp_setsockopt(sk, level, optname, optval, optlen);
}
589

590 591 592
EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
#endif

593
static int dccp_getsockopt_service(struct sock *sk, int len,
594
				   __be32 __user *optval,
595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
				   int __user *optlen)
{
	const struct dccp_sock *dp = dccp_sk(sk);
	const struct dccp_service_list *sl;
	int err = -ENOENT, slen = 0, total_len = sizeof(u32);

	lock_sock(sk);
	if ((sl = dp->dccps_service_list) != NULL) {
		slen = sl->dccpsl_nr * sizeof(u32);
		total_len += slen;
	}

	err = -EINVAL;
	if (total_len > len)
		goto out;

	err = 0;
	if (put_user(total_len, optlen) ||
	    put_user(dp->dccps_service, optval) ||
	    (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
		err = -EFAULT;
out:
	release_sock(sk);
	return err;
}

621
static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
622
		    char __user *optval, int __user *optlen)
623
{
624 625
	struct dccp_sock *dp;
	int val, len;
626

627 628 629
	if (get_user(len, optlen))
		return -EFAULT;

630
	if (len < (int)sizeof(int))
631 632 633 634 635 636
		return -EINVAL;

	dp = dccp_sk(sk);

	switch (optname) {
	case DCCP_SOCKOPT_PACKET_SIZE:
637
		DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
638
		return 0;
639 640
	case DCCP_SOCKOPT_SERVICE:
		return dccp_getsockopt_service(sk, len,
641
					       (__be32 __user *)optval, optlen);
642 643 644
	case DCCP_SOCKOPT_GET_CUR_MPS:
		val = dp->dccps_mss_cache;
		break;
Gerrit Renker's avatar
Gerrit Renker committed
645 646
	case DCCP_SOCKOPT_AVAILABLE_CCIDS:
		return ccid_getsockopt_builtin_ccids(sk, len, optval, optlen);
647 648 649 650 651 652 653 654 655 656
	case DCCP_SOCKOPT_TX_CCID:
		val = ccid_get_current_tx_ccid(dp);
		if (val < 0)
			return -ENOPROTOOPT;
		break;
	case DCCP_SOCKOPT_RX_CCID:
		val = ccid_get_current_rx_ccid(dp);
		if (val < 0)
			return -ENOPROTOOPT;
		break;
657 658 659
	case DCCP_SOCKOPT_SERVER_TIMEWAIT:
		val = dp->dccps_server_timewait;
		break;
660 661 662 663 664 665
	case DCCP_SOCKOPT_SEND_CSCOV:
		val = dp->dccps_pcslen;
		break;
	case DCCP_SOCKOPT_RECV_CSCOV:
		val = dp->dccps_pcrlen;
		break;
666 667 668 669 670 671
	case DCCP_SOCKOPT_QPOLICY_ID:
		val = dp->dccps_qpolicy;
		break;
	case DCCP_SOCKOPT_QPOLICY_TXQLEN:
		val = dp->dccps_tx_qlen;
		break;
672 673 674 675 676 677
	case 128 ... 191:
		return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
					     len, (u32 __user *)optval, optlen);
	case 192 ... 255:
		return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
					     len, (u32 __user *)optval, optlen);
678 679 680 681
	default:
		return -ENOPROTOOPT;
	}

682
	len = sizeof(val);
683 684 685 686
	if (put_user(len, optlen) || copy_to_user(optval, &val, len))
		return -EFAULT;

	return 0;
687 688
}

689 690 691 692 693 694 695 696 697
int dccp_getsockopt(struct sock *sk, int level, int optname,
		    char __user *optval, int __user *optlen)
{
	if (level != SOL_DCCP)
		return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
							     optname, optval,
							     optlen);
	return do_dccp_getsockopt(sk, level, optname, optval, optlen);
}
698

699 700
EXPORT_SYMBOL_GPL(dccp_getsockopt);

701 702
#ifdef CONFIG_COMPAT
int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
703
			   char __user *optval, int __user *optlen)
704
{
705 706 707
	if (level != SOL_DCCP)
		return inet_csk_compat_getsockopt(sk, level, optname,
						  optval, optlen);
708 709
	return do_dccp_getsockopt(sk, level, optname, optval, optlen);
}
710

711 712 713
EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
#endif

714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750
static int dccp_msghdr_parse(struct msghdr *msg, struct sk_buff *skb)
{
	struct cmsghdr *cmsg = CMSG_FIRSTHDR(msg);

	/*
	 * Assign an (opaque) qpolicy priority value to skb->priority.
	 *
	 * We are overloading this skb field for use with the qpolicy subystem.
	 * The skb->priority is normally used for the SO_PRIORITY option, which
	 * is initialised from sk_priority. Since the assignment of sk_priority
	 * to skb->priority happens later (on layer 3), we overload this field
	 * for use with queueing priorities as long as the skb is on layer 4.
	 * The default priority value (if nothing is set) is 0.
	 */
	skb->priority = 0;

	for (; cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg)) {

		if (!CMSG_OK(msg, cmsg))
			return -EINVAL;

		if (cmsg->cmsg_level != SOL_DCCP)
			continue;

		switch (cmsg->cmsg_type) {
		case DCCP_SCM_PRIORITY:
			if (cmsg->cmsg_len != CMSG_LEN(sizeof(__u32)))
				return -EINVAL;
			skb->priority = *(__u32 *)CMSG_DATA(cmsg);
			break;
		default:
			return -EINVAL;
		}
	}
	return 0;
}

751 752 753 754 755 756 757 758 759 760 761 762 763 764
int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
		 size_t len)
{
	const struct dccp_sock *dp = dccp_sk(sk);
	const int flags = msg->msg_flags;
	const int noblock = flags & MSG_DONTWAIT;
	struct sk_buff *skb;
	int rc, size;
	long timeo;

	if (len > dp->dccps_mss_cache)
		return -EMSGSIZE;

	lock_sock(sk);
765

766
	if (dccp_qpolicy_full(sk)) {
767 768 769 770
		rc = -EAGAIN;
		goto out_release;
	}

771
	timeo = sock_sndtimeo(sk, noblock);
772 773 774 775 776 777

	/*
	 * We have to use sk_stream_wait_connect here to set sk_write_pending,
	 * so that the trick in dccp_rcv_request_sent_state_process.
	 */
	/* Wait for a connection to finish. */
778
	if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
779
		if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
780
			goto out_release;
781 782 783 784 785 786 787 788 789 790

	size = sk->sk_prot->max_header + len;
	release_sock(sk);
	skb = sock_alloc_send_skb(sk, size, noblock, &rc);
	lock_sock(sk);
	if (skb == NULL)
		goto out_release;

	skb_reserve(skb, sk->sk_prot->max_header);
	rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
791 792 793
	if (rc != 0)
		goto out_discard;

794 795 796 797 798
	rc = dccp_msghdr_parse(msg, skb);
	if (rc != 0)
		goto out_discard;

	dccp_qpolicy_push(sk, skb);
799
	dccp_write_xmit(sk);
800 801 802
out_release:
	release_sock(sk);
	return rc ? : len;
803 804
out_discard:
	kfree_skb(skb);
805 806 807
	goto out_release;
}

808 809
EXPORT_SYMBOL_GPL(dccp_sendmsg);

810 811 812 813 814 815 816 817
int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
		 size_t len, int nonblock, int flags, int *addr_len)
{
	const struct dccp_hdr *dh;
	long timeo;

	lock_sock(sk);

818 819
	if (sk->sk_state == DCCP_LISTEN) {
		len = -ENOTCONN;
820 821 822
		goto out;
	}

823
	timeo = sock_rcvtimeo(sk, nonblock);
824 825

	do {
826
		struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
827

828 829
		if (skb == NULL)
			goto verify_sock_status;
830

831
		dh = dccp_hdr(skb);
832

833 834 835
		switch (dh->dccph_type) {
		case DCCP_PKT_DATA:
		case DCCP_PKT_DATAACK:
836
			goto found_ok_skb;
837

838 839 840 841 842 843 844 845
		case DCCP_PKT_CLOSE:
		case DCCP_PKT_CLOSEREQ:
			if (!(flags & MSG_PEEK))
				dccp_finish_passive_close(sk);
			/* fall through */
		case DCCP_PKT_RESET:
			dccp_pr_debug("found fin (%s) ok!\n",
				      dccp_packet_name(dh->dccph_type));
846 847
			len = 0;
			goto found_fin_ok;
848 849 850 851
		default:
			dccp_pr_debug("packet_type=%s\n",
				      dccp_packet_name(dh->dccph_type));
			sk_eat_skb(sk, skb, 0);
852 853 854 855
		}
verify_sock_status:
		if (sock_flag(sk, SOCK_DONE)) {
			len = 0;
856
			break;
857
		}
858

859 860 861 862
		if (sk->sk_err) {
			len = sock_error(sk);
			break;
		}
863

864 865 866 867
		if (sk->sk_shutdown & RCV_SHUTDOWN) {
			len = 0;
			break;
		}
868

869 870 871 872 873 874
		if (sk->sk_state == DCCP_CLOSED) {
			if (!sock_flag(sk, SOCK_DONE)) {
				/* This occurs when user tries to read
				 * from never connected socket.
				 */
				len = -ENOTCONN;
875 876
				break;
			}
877 878
			len = 0;
			break;
879 880
		}

881 882 883 884
		if (!timeo) {
			len = -EAGAIN;
			break;
		}
885

886 887 888 889
		if (signal_pending(current)) {
			len = sock_intr_errno(timeo);
			break;
		}
890

891
		sk_wait_data(sk, &timeo);
892 893
		continue;
	found_ok_skb:
894 895 896 897 898 899 900 901 902
		if (len > skb->len)
			len = skb->len;
		else if (len < skb->len)
			msg->msg_flags |= MSG_TRUNC;

		if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) {
			/* Exception. Bailout! */
			len = -EFAULT;
			break;
903 904 905
		}
	found_fin_ok:
		if (!(flags & MSG_PEEK))
906
			sk_eat_skb(sk, skb, 0);
907
		break;
908
	} while (1);
909 910
out:
	release_sock(sk);
911
	return len;
912 913
}

914 915 916
EXPORT_SYMBOL_GPL(dccp_recvmsg);

int inet_dccp_listen(struct socket *sock, int backlog)
917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939
{
	struct sock *sk = sock->sk;
	unsigned char old_state;
	int err;

	lock_sock(sk);

	err = -EINVAL;
	if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
		goto out;

	old_state = sk->sk_state;
	if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
		goto out;

	/* Really, if the socket is already in listen state
	 * we can only allow the backlog to be adjusted.
	 */
	if (old_state != DCCP_LISTEN) {
		/*
		 * FIXME: here it probably should be sk->sk_prot->listen_start
		 * see tcp_listen_start
		 */
940
		err = dccp_listen_start(sk, backlog);
941 942 943 944 945 946 947 948 949 950 951
		if (err)
			goto out;
	}
	sk->sk_max_ack_backlog = backlog;
	err = 0;

out:
	release_sock(sk);
	return err;
}

952 953
EXPORT_SYMBOL_GPL(inet_dccp_listen);

954
static void dccp_terminate_connection(struct sock *sk)
955
{
956
	u8 next_state = DCCP_CLOSED;
957

958 959 960 961 962 963 964 965 966 967 968
	switch (sk->sk_state) {
	case DCCP_PASSIVE_CLOSE:
	case DCCP_PASSIVE_CLOSEREQ:
		dccp_finish_passive_close(sk);
		break;
	case DCCP_PARTOPEN:
		dccp_pr_debug("Stop PARTOPEN timer (%p)\n", sk);
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
		/* fall through */
	case DCCP_OPEN:
		dccp_send_close(sk, 1);
969

970 971
		if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER &&
		    !dccp_sk(sk)->dccps_server_timewait)
972 973 974 975 976 977 978
			next_state = DCCP_ACTIVE_CLOSEREQ;
		else
			next_state = DCCP_CLOSING;
		/* fall through */
	default:
		dccp_set_state(sk, next_state);
	}
979 980 981 982
}

void dccp_close(struct sock *sk, long timeout)
{
983
	struct dccp_sock *dp = dccp_sk(sk);
984
	struct sk_buff *skb;
985
	u32 data_was_unread = 0;
986
	int state;
987 988 989 990 991 992 993 994 995 996 997 998 999 1000

	lock_sock(sk);

	sk->sk_shutdown = SHUTDOWN_MASK;

	if (sk->sk_state == DCCP_LISTEN) {
		dccp_set_state(sk, DCCP_CLOSED);

		/* Special case. */
		inet_csk_listen_stop(sk);

		goto adjudge_to_death;
	}

1001 1002
	sk_stop_timer(sk, &dp->dccps_xmit_timer);

1003 1004 1005 1006 1007 1008
	/*
	 * We need to flush the recv. buffs.  We do this only on the
	 * descriptor close, not protocol-sourced closes, because the
	  *reader process may not have drained the data yet!
	 */
	while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
1009
		data_was_unread += skb->len;
1010 1011 1012
		__kfree_skb(skb);
	}

1013 1014 1015 1016 1017 1018
	if (data_was_unread) {
		/* Unread data was tossed, send an appropriate Reset Code */
		DCCP_WARN("DCCP: ABORT -- %u bytes unread\n", data_was_unread);
		dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
		dccp_set_state(sk, DCCP_CLOSED);
	} else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
1019 1020
		/* Check zero linger _after_ checking for unread data. */
		sk->sk_prot->disconnect(sk, 0);
1021
	} else if (sk->sk_state != DCCP_CLOSED) {
1022 1023 1024 1025 1026
		/*
		 * Normal connection termination. May need to wait if there are
		 * still packets in the TX queue that are delayed by the CCID.
		 */
		dccp_flush_write_queue(sk, &timeout);
1027
		dccp_terminate_connection(sk);
1028 1029
	}

1030 1031 1032 1033 1034 1035 1036 1037
	/*
	 * Flush write queue. This may be necessary in several cases:
	 * - we have been closed by the peer but still have application data;
	 * - abortive termination (unread data or zero linger time),
	 * - normal termination but queue could not be flushed within time limit
	 */
	__skb_queue_purge(&sk->sk_write_queue);

1038 1039 1040
	sk_stream_wait_close(sk, timeout);

adjudge_to_death:
1041 1042 1043 1044 1045
	state = sk->sk_state;
	sock_hold(sk);
	sock_orphan(sk);
	atomic_inc(sk->sk_prot->orphan_count);

1046 1047 1048
	/*
	 * It is the last release_sock in its life. It will remove backlog.
	 */
1049 1050 1051 1052 1053 1054 1055
	release_sock(sk);
	/*
	 * Now socket is owned by kernel and we acquire BH lock
	 * to finish close. No need to check for user refs.
	 */
	local_bh_disable();
	bh_lock_sock(sk);
1056
	WARN_ON(sock_owned_by_user(sk));
1057

1058 1059 1060
	/* Have we already been destroyed by a softirq or backlog? */
	if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
		goto out;
1061

1062 1063 1064 1065 1066
	if (sk->sk_state == DCCP_CLOSED)
		inet_csk_destroy_sock(sk);

	/* Otherwise, socket is reprieved until protocol close. */

1067
out:
1068 1069 1070 1071 1072
	bh_unlock_sock(sk);
	local_bh_enable();
	sock_put(sk);
}

1073 1074
EXPORT_SYMBOL_GPL(dccp_close);

1075 1076
void dccp_shutdown(struct sock *sk, int how)
{
1077
	dccp_pr_debug("called shutdown(%x)\n", how);
1078 1079
}

1080 1081
EXPORT_SYMBOL_GPL(dccp_shutdown);

1082
static inline int dccp_mib_init(void)
1083
{
1084
	return snmp_mib_init((void**)dccp_statistics, sizeof(struct dccp_mib));
1085 1086
}

1087
static inline void dccp_mib_exit(void)
1088
{
1089
	snmp_mib_free((void**)dccp_statistics);
1090 1091
}

1092 1093 1094 1095
static int thash_entries;
module_param(thash_entries, int, 0444);
MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");

1096
#ifdef CONFIG_IP_DCCP_DEBUG
1097
int dccp_debug;
1098
module_param(dccp_debug, bool, 0644);
1099
MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
1100 1101

EXPORT_SYMBOL_GPL(dccp_debug);
1102
#endif
1103 1104 1105 1106 1107

static int __init dccp_init(void)
{
	unsigned long goal;
	int ehash_order, bhash_order, i;
1108
	int rc = -ENOBUFS;
1109

1110 1111 1112
	BUILD_BUG_ON(sizeof(struct dccp_skb_cb) >
		     FIELD_SIZEOF(struct sk_buff, cb));

1113 1114 1115
	dccp_hashinfo.bind_bucket_cachep =
		kmem_cache_create("dccp_bind_bucket",
				  sizeof(struct inet_bind_bucket), 0,
1116
				  SLAB_HWCACHE_ALIGN, NULL);
1117
	if (!dccp_hashinfo.bind_bucket_cachep)
1118
		goto out;
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131

	/*
	 * Size and allocate the main established and bind bucket
	 * hash tables.
	 *
	 * The methodology is similar to that of the buffer cache.
	 */
	if (num_physpages >= (128 * 1024))
		goal = num_physpages >> (21 - PAGE_SHIFT);
	else
		goal = num_physpages >> (23 - PAGE_SHIFT);

	if (thash_entries)
1132 1133
		goal = (thash_entries *
			sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
1134 1135 1136 1137 1138
	for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
		;
	do {
		dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE /
					sizeof(struct inet_ehash_bucket);
1139 1140
		while (dccp_hashinfo.ehash_size &
		       (dccp_hashinfo.ehash_size - 1))
1141 1142 1143 1144 1145 1146
			dccp_hashinfo.ehash_size--;
		dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
			__get_free_pages(GFP_ATOMIC, ehash_order);
	} while (!dccp_hashinfo.ehash && --ehash_order > 0);

	if (!dccp_hashinfo.ehash) {
1147
		DCCP_CRIT("Failed to allocate DCCP established hash table");
1148 1149 1150
		goto out_free_bind_bucket_cachep;
	}

1151
	for (i = 0; i < dccp_hashinfo.ehash_size; i++) {
1152
		INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain);
1153
		INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].twchain);
1154 1155
	}

1156 1157 1158
	if (inet_ehash_locks_alloc(&dccp_hashinfo))
			goto out_free_dccp_ehash;

1159 1160 1161 1162 1163
	bhash_order = ehash_order;

	do {
		dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
					sizeof(struct inet_bind_hashbucket);
1164 1165
		if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
		    bhash_order > 0)
1166 1167 1168 1169 1170 1171
			continue;
		dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
			__get_free_pages(GFP_ATOMIC, bhash_order);
	} while (!dccp_hashinfo.bhash && --bhash_order >= 0);

	if (!dccp_hashinfo.bhash) {
1172
		DCCP_CRIT("Failed to allocate DCCP bind hash table");
1173
		goto out_free_dccp_locks;
1174 1175 1176 1177 1178 1179 1180
	}

	for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
		spin_lock_init(&dccp_hashinfo.bhash[i].lock);
		INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
	}

1181
	rc = dccp_mib_init();
1182
	if (rc)
1183 1184
		goto out_free_dccp_bhash;

1185
	rc = dccp_ackvec_init();
1186
	if (rc)
1187
		goto out_free_dccp_mib;
1188

1189
	rc = dccp_sysctl_init();
1190 1191
	if (rc)
		goto out_ackvec_exit;
1192 1193

	dccp_timestamping_init();
1194 1195
out:
	return rc;
1196 1197
out_ackvec_exit:
	dccp_ackvec_exit();
1198
out_free_dccp_mib:
1199
	dccp_mib_exit();
1200 1201 1202
out_free_dccp_bhash:
	free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
	dccp_hashinfo.bhash = NULL;
1203 1204
out_free_dccp_locks:
	inet_ehash_locks_free(&dccp_hashinfo);
1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
out_free_dccp_ehash:
	free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
	dccp_hashinfo.ehash = NULL;
out_free_bind_bucket_cachep:
	kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
	dccp_hashinfo.bind_bucket_cachep = NULL;
	goto out;
}

static void __exit dccp_fini(void)
{
1216
	dccp_mib_exit();
1217 1218 1219 1220 1221 1222
	free_pages((unsigned long)dccp_hashinfo.bhash,
		   get_order(dccp_hashinfo.bhash_size *
			     sizeof(struct inet_bind_hashbucket)));
	free_pages((unsigned long)dccp_hashinfo.ehash,
		   get_order(dccp_hashinfo.ehash_size *
			     sizeof(struct inet_ehash_bucket)));
1223
	inet_ehash_locks_free(&dccp_hashinfo);
1224
	kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1225
	dccp_ackvec_exit();
1226
	dccp_sysctl_exit();
1227 1228 1229 1230 1231 1232 1233 1234
}

module_init(dccp_init);
module_exit(dccp_fini);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");