proto.c 27.4 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 70 71 72
		      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);
		break;

	case DCCP_CLOSED:
73 74
		if (oldstate == DCCP_OPEN || oldstate == DCCP_ACTIVE_CLOSEREQ ||
		    oldstate == DCCP_CLOSING)
75 76 77 78 79
			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))
80
			inet_put_port(sk);
81 82 83 84 85 86 87 88 89 90 91 92 93 94
		/* 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);

95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
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);
	}
}

113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
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);

128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
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[] = {
154 155 156 157 158 159 160 161 162 163 164
	[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",
165 166 167 168 169 170 171 172 173 174
	};

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

EXPORT_SYMBOL_GPL(dccp_state_name);

175
int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
176 177
{
	struct dccp_sock *dp = dccp_sk(sk);
178
	struct dccp_minisock *dmsk = dccp_msk(sk);
179 180
	struct inet_connection_sock *icsk = inet_csk(sk);

181
	dccp_minisock_init(&dp->dccps_minisock);
182

183 184 185 186 187 188 189 190 191 192 193 194 195
	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;
	dp->dccps_l_ack_ratio	= dp->dccps_r_ack_ratio = 1;

	dccp_init_xmit_timers(sk);

196 197 198 199 200 201 202
	/*
	 * FIXME: We're hardcoding the CCID, and doing this at this point makes
	 * the listening (master) sock get CCID control blocks, which is not
	 * necessary, but for now, to not mess with the test userspace apps,
	 * lets leave it here, later the real solution is to do this in a
	 * setsockopt(CCIDs-I-want/accept). -acme
	 */
203
	if (likely(ctl_sock_initialized)) {
204
		int rc = dccp_feat_init(dmsk);
205 206 207 208

		if (rc)
			return rc;

209
		if (dmsk->dccpms_send_ack_vector) {
210 211 212 213
			dp->dccps_hc_rx_ackvec = dccp_ackvec_alloc(GFP_KERNEL);
			if (dp->dccps_hc_rx_ackvec == NULL)
				return -ENOMEM;
		}
214 215 216 217
		dp->dccps_hc_rx_ccid = ccid_hc_rx_new(dmsk->dccpms_rx_ccid,
						      sk, GFP_KERNEL);
		dp->dccps_hc_tx_ccid = ccid_hc_tx_new(dmsk->dccpms_tx_ccid,
						      sk, GFP_KERNEL);
218
		if (unlikely(dp->dccps_hc_rx_ccid == NULL ||
219 220 221
			     dp->dccps_hc_tx_ccid == NULL)) {
			ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
			ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
222
			if (dmsk->dccpms_send_ack_vector) {
223 224 225 226 227 228 229 230
				dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
				dp->dccps_hc_rx_ackvec = NULL;
			}
			dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
			return -ENOMEM;
		}
	} else {
		/* control socket doesn't need feat nego */
231 232
		INIT_LIST_HEAD(&dmsk->dccpms_pending);
		INIT_LIST_HEAD(&dmsk->dccpms_conf);
233 234 235 236 237 238 239
	}

	return 0;
}

EXPORT_SYMBOL_GPL(dccp_init_sock);

240
void dccp_destroy_sock(struct sock *sk)
241 242
{
	struct dccp_sock *dp = dccp_sk(sk);
243
	struct dccp_minisock *dmsk = dccp_msk(sk);
244 245 246 247 248 249 250 251 252 253 254 255

	/*
	 * 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)
256
		inet_put_port(sk);
257 258 259 260

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

261
	if (dmsk->dccpms_send_ack_vector) {
262 263 264 265 266 267 268 269
		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 */
270
	dccp_feat_clean(dmsk);
271 272 273 274
}

EXPORT_SYMBOL_GPL(dccp_destroy_sock);

275
static inline int dccp_listen_start(struct sock *sk, int backlog)
276
{
277 278 279
	struct dccp_sock *dp = dccp_sk(sk);

	dp->dccps_role = DCCP_ROLE_LISTEN;
280
	return inet_csk_listen_start(sk, backlog);
281 282
}

283 284 285 286 287 288
static inline int dccp_need_reset(int state)
{
	return state != DCCP_CLOSED && state != DCCP_LISTEN &&
	       state != DCCP_REQUESTING;
}

289 290 291 292 293 294 295 296 297 298
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);

299 300 301 302
	/*
	 * This corresponds to the ABORT function of RFC793, sec. 3.8
	 * TCP uses a RST segment, DCCP a Reset packet with Code 2, "Aborted".
	 */
303 304
	if (old_state == DCCP_LISTEN) {
		inet_csk_listen_stop(sk);
305 306 307
	} else if (dccp_need_reset(old_state)) {
		dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
		sk->sk_err = ECONNRESET;
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
	} else if (old_state == DCCP_REQUESTING)
		sk->sk_err = ECONNRESET;

	dccp_clear_xmit_timers(sk);
	__skb_queue_purge(&sk->sk_receive_queue);
	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);

	BUG_TRAP(!inet->num || icsk->icsk_bind_hash);

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

336 337
EXPORT_SYMBOL_GPL(dccp_disconnect);

338 339 340 341 342 343 344
/*
 *	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.
 */
345 346
unsigned int dccp_poll(struct file *file, struct socket *sock,
		       poll_table *wait)
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
{
	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)
367
		mask |= POLLIN | POLLRDNORM | POLLRDHUP;
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

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

394 395
EXPORT_SYMBOL_GPL(dccp_poll);

396 397
int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
{
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
	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;
428 429
}

430 431
EXPORT_SYMBOL_GPL(dccp_ioctl);

432
static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
433 434 435 436 437
				   char __user *optval, int optlen)
{
	struct dccp_sock *dp = dccp_sk(sk);
	struct dccp_service_list *sl = NULL;

438
	if (service == DCCP_SERVICE_INVALID_VALUE ||
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
	    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
460
	kfree(dp->dccps_service_list);
461 462 463 464 465 466

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

467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
/* byte 1 is feature.  the rest is the preference list */
static int dccp_setsockopt_change(struct sock *sk, int type,
				  struct dccp_so_feat __user *optval)
{
	struct dccp_so_feat opt;
	u8 *val;
	int rc;

	if (copy_from_user(&opt, optval, sizeof(opt)))
		return -EFAULT;

	val = kmalloc(opt.dccpsf_len, GFP_KERNEL);
	if (!val)
		return -ENOMEM;

	if (copy_from_user(val, opt.dccpsf_val, opt.dccpsf_len)) {
		rc = -EFAULT;
		goto out_free_val;
	}

487 488
	rc = dccp_feat_change(dccp_msk(sk), type, opt.dccpsf_feat,
			      val, opt.dccpsf_len, GFP_KERNEL);
489 490 491 492 493 494 495 496 497 498 499
	if (rc)
		goto out_free_val;

out:
	return rc;

out_free_val:
	kfree(val);
	goto out;
}

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

506 507 508 509 510 511
	if (optlen < sizeof(int))
		return -EINVAL;

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

512 513
	if (optname == DCCP_SOCKOPT_SERVICE)
		return dccp_setsockopt_service(sk, val, optval, optlen);
514

515
	lock_sock(sk);
516 517
	switch (optname) {
	case DCCP_SOCKOPT_PACKET_SIZE:
518
		DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
519
		err = 0;
520
		break;
521 522 523 524 525
	case DCCP_SOCKOPT_CHANGE_L:
		if (optlen != sizeof(struct dccp_so_feat))
			err = -EINVAL;
		else
			err = dccp_setsockopt_change(sk, DCCPO_CHANGE_L,
526
						     (struct dccp_so_feat __user *)
527 528 529 530 531 532 533
						     optval);
		break;
	case DCCP_SOCKOPT_CHANGE_R:
		if (optlen != sizeof(struct dccp_so_feat))
			err = -EINVAL;
		else
			err = dccp_setsockopt_change(sk, DCCPO_CHANGE_R,
Alan Cox's avatar
Alan Cox committed
534
						     (struct dccp_so_feat __user *)
535 536
						     optval);
		break;
537 538 539 540 541 542
	case DCCP_SOCKOPT_SERVER_TIMEWAIT:
		if (dp->dccps_role != DCCP_ROLE_SERVER)
			err = -EOPNOTSUPP;
		else
			dp->dccps_server_timewait = (val != 0);
		break;
543 544 545 546 547 548 549 550 551 552 553 554 555 556 557
	case DCCP_SOCKOPT_SEND_CSCOV:	/* sender side, RFC 4340, sec. 9.2 */
		if (val < 0 || val > 15)
			err = -EINVAL;
		else
			dp->dccps_pcslen = val;
		break;
	case DCCP_SOCKOPT_RECV_CSCOV:	/* receiver side, RFC 4340 sec. 9.2.1 */
		if (val < 0 || val > 15)
			err = -EINVAL;
		else {
			dp->dccps_pcrlen = val;
			/* FIXME: add feature negotiation,
			 * ChangeL(MinimumChecksumCoverage, val) */
		}
		break;
558 559 560 561
	default:
		err = -ENOPROTOOPT;
		break;
	}
562

563 564
	release_sock(sk);
	return err;
565 566
}

567 568 569 570 571 572 573 574 575
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);
}
576

577 578
EXPORT_SYMBOL_GPL(dccp_setsockopt);

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

589 590 591
EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
#endif

592
static int dccp_getsockopt_service(struct sock *sk, int len,
593
				   __be32 __user *optval,
594 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
				   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;
}

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

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

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

	dp = dccp_sk(sk);

	switch (optname) {
	case DCCP_SOCKOPT_PACKET_SIZE:
636
		DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
637
		return 0;
638 639
	case DCCP_SOCKOPT_SERVICE:
		return dccp_getsockopt_service(sk, len,
640
					       (__be32 __user *)optval, optlen);
641 642 643
	case DCCP_SOCKOPT_GET_CUR_MPS:
		val = dp->dccps_mss_cache;
		break;
644 645 646
	case DCCP_SOCKOPT_SERVER_TIMEWAIT:
		val = dp->dccps_server_timewait;
		break;
647 648 649 650 651 652
	case DCCP_SOCKOPT_SEND_CSCOV:
		val = dp->dccps_pcslen;
		break;
	case DCCP_SOCKOPT_RECV_CSCOV:
		val = dp->dccps_pcrlen;
		break;
653 654 655 656 657 658
	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);
659 660 661 662
	default:
		return -ENOPROTOOPT;
	}

663
	len = sizeof(val);
664 665 666 667
	if (put_user(len, optlen) || copy_to_user(optval, &val, len))
		return -EFAULT;

	return 0;
668 669
}

670 671 672 673 674 675 676 677 678
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);
}
679

680 681
EXPORT_SYMBOL_GPL(dccp_getsockopt);

682 683
#ifdef CONFIG_COMPAT
int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
684
			   char __user *optval, int __user *optlen)
685
{
686 687 688
	if (level != SOL_DCCP)
		return inet_csk_compat_getsockopt(sk, level, optname,
						  optval, optlen);
689 690
	return do_dccp_getsockopt(sk, level, optname, optval, optlen);
}
691

692 693 694
EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
#endif

695 696 697 698 699 700 701 702 703 704 705 706 707 708
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);
709 710 711 712 713 714 715

	if (sysctl_dccp_tx_qlen &&
	    (sk->sk_write_queue.qlen >= sysctl_dccp_tx_qlen)) {
		rc = -EAGAIN;
		goto out_release;
	}

716
	timeo = sock_sndtimeo(sk, noblock);
717 718 719 720 721 722

	/*
	 * 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. */
723
	if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
724
		if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
725
			goto out_release;
726 727 728 729 730 731 732 733 734 735

	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);
736 737 738
	if (rc != 0)
		goto out_discard;

Ian McDonald's avatar
Ian McDonald committed
739 740
	skb_queue_tail(&sk->sk_write_queue, skb);
	dccp_write_xmit(sk,0);
741 742 743
out_release:
	release_sock(sk);
	return rc ? : len;
744 745
out_discard:
	kfree_skb(skb);
746 747 748
	goto out_release;
}

749 750
EXPORT_SYMBOL_GPL(dccp_sendmsg);

751 752 753 754 755 756 757 758
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);

759 760
	if (sk->sk_state == DCCP_LISTEN) {
		len = -ENOTCONN;
761 762 763
		goto out;
	}

764
	timeo = sock_rcvtimeo(sk, nonblock);
765 766

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

769 770
		if (skb == NULL)
			goto verify_sock_status;
771

772
		dh = dccp_hdr(skb);
773

774 775 776
		switch (dh->dccph_type) {
		case DCCP_PKT_DATA:
		case DCCP_PKT_DATAACK:
777
			goto found_ok_skb;
778

779 780 781 782 783 784 785 786
		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));
787 788
			len = 0;
			goto found_fin_ok;
789 790 791 792
		default:
			dccp_pr_debug("packet_type=%s\n",
				      dccp_packet_name(dh->dccph_type));
			sk_eat_skb(sk, skb, 0);
793 794 795 796
		}
verify_sock_status:
		if (sock_flag(sk, SOCK_DONE)) {
			len = 0;
797
			break;
798
		}
799

800 801 802 803
		if (sk->sk_err) {
			len = sock_error(sk);
			break;
		}
804

805 806 807 808
		if (sk->sk_shutdown & RCV_SHUTDOWN) {
			len = 0;
			break;
		}
809

810 811 812 813 814 815
		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;
816 817
				break;
			}
818 819
			len = 0;
			break;
820 821
		}

822 823 824 825
		if (!timeo) {
			len = -EAGAIN;
			break;
		}
826

827 828 829 830
		if (signal_pending(current)) {
			len = sock_intr_errno(timeo);
			break;
		}
831

832
		sk_wait_data(sk, &timeo);
833 834
		continue;
	found_ok_skb:
835 836 837 838 839 840 841 842 843
		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;
844 845 846
		}
	found_fin_ok:
		if (!(flags & MSG_PEEK))
847
			sk_eat_skb(sk, skb, 0);
848
		break;
849
	} while (1);
850 851
out:
	release_sock(sk);
852
	return len;
853 854
}

855 856 857
EXPORT_SYMBOL_GPL(dccp_recvmsg);

int inet_dccp_listen(struct socket *sock, int backlog)
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880
{
	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
		 */
881
		err = dccp_listen_start(sk, backlog);
882 883 884 885 886 887 888 889 890 891 892
		if (err)
			goto out;
	}
	sk->sk_max_ack_backlog = backlog;
	err = 0;

out:
	release_sock(sk);
	return err;
}

893 894
EXPORT_SYMBOL_GPL(inet_dccp_listen);

895
static void dccp_terminate_connection(struct sock *sk)
896
{
897
	u8 next_state = DCCP_CLOSED;
898

899 900 901 902 903 904 905 906 907 908 909
	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);
910

911 912
		if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER &&
		    !dccp_sk(sk)->dccps_server_timewait)
913 914 915 916 917 918 919
			next_state = DCCP_ACTIVE_CLOSEREQ;
		else
			next_state = DCCP_CLOSING;
		/* fall through */
	default:
		dccp_set_state(sk, next_state);
	}
920 921 922 923
}

void dccp_close(struct sock *sk, long timeout)
{
Ian McDonald's avatar
Ian McDonald committed
924
	struct dccp_sock *dp = dccp_sk(sk);
925
	struct sk_buff *skb;
926
	u32 data_was_unread = 0;
Herbert Xu's avatar
Herbert Xu committed
927
	int state;
928 929 930 931 932 933 934 935 936 937 938 939 940 941

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

Ian McDonald's avatar
Ian McDonald committed
942 943
	sk_stop_timer(sk, &dp->dccps_xmit_timer);

944 945 946 947 948 949
	/*
	 * 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) {
950
		data_was_unread += skb->len;
951 952 953
		__kfree_skb(skb);
	}

954 955 956 957 958 959
	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) {
960 961
		/* Check zero linger _after_ checking for unread data. */
		sk->sk_prot->disconnect(sk, 0);
962 963
	} else if (sk->sk_state != DCCP_CLOSED) {
		dccp_terminate_connection(sk);
964 965 966 967 968
	}

	sk_stream_wait_close(sk, timeout);

adjudge_to_death:
Herbert Xu's avatar
Herbert Xu committed
969 970 971 972 973
	state = sk->sk_state;
	sock_hold(sk);
	sock_orphan(sk);
	atomic_inc(sk->sk_prot->orphan_count);

974 975 976
	/*
	 * It is the last release_sock in its life. It will remove backlog.
	 */
977 978 979 980 981 982 983 984 985
	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);
	BUG_TRAP(!sock_owned_by_user(sk));

Herbert Xu's avatar
Herbert Xu committed
986 987 988
	/* Have we already been destroyed by a softirq or backlog? */
	if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
		goto out;
989

990 991 992 993 994
	if (sk->sk_state == DCCP_CLOSED)
		inet_csk_destroy_sock(sk);

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

Herbert Xu's avatar
Herbert Xu committed
995
out:
996 997 998 999 1000
	bh_unlock_sock(sk);
	local_bh_enable();
	sock_put(sk);
}

1001 1002
EXPORT_SYMBOL_GPL(dccp_close);

1003 1004
void dccp_shutdown(struct sock *sk, int how)
{
1005
	dccp_pr_debug("called shutdown(%x)\n", how);
1006 1007
}

1008 1009
EXPORT_SYMBOL_GPL(dccp_shutdown);

1010
static inline int dccp_mib_init(void)
1011
{
1012
	return snmp_mib_init((void**)dccp_statistics, sizeof(struct dccp_mib));
1013 1014
}

1015
static inline void dccp_mib_exit(void)
1016
{
1017
	snmp_mib_free((void**)dccp_statistics);
1018 1019
}

1020 1021 1022 1023
static int thash_entries;
module_param(thash_entries, int, 0444);
MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");

1024
#ifdef CONFIG_IP_DCCP_DEBUG
1025
int dccp_debug;
1026
module_param(dccp_debug, bool, 0444);
1027
MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
1028 1029

EXPORT_SYMBOL_GPL(dccp_debug);
1030
#endif
1031 1032 1033 1034 1035

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

1038 1039 1040
	BUILD_BUG_ON(sizeof(struct dccp_skb_cb) >
		     FIELD_SIZEOF(struct sk_buff, cb));

1041 1042 1043
	dccp_hashinfo.bind_bucket_cachep =
		kmem_cache_create("dccp_bind_bucket",
				  sizeof(struct inet_bind_bucket), 0,
1044
				  SLAB_HWCACHE_ALIGN, NULL);
1045
	if (!dccp_hashinfo.bind_bucket_cachep)
1046
		goto out;
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059

	/*
	 * 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)
1060 1061
		goal = (thash_entries *
			sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
1062 1063 1064 1065 1066
	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);
1067 1068
		while (dccp_hashinfo.ehash_size &
		       (dccp_hashinfo.ehash_size - 1))
1069 1070 1071 1072 1073 1074
			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) {
1075
		DCCP_CRIT("Failed to allocate DCCP established hash table");
1076 1077 1078
		goto out_free_bind_bucket_cachep;
	}

1079
	for (i = 0; i < dccp_hashinfo.ehash_size; i++) {
1080
		INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain);
1081
		INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].twchain);
1082 1083
	}

1084 1085 1086
	if (inet_ehash_locks_alloc(&dccp_hashinfo))
			goto out_free_dccp_ehash;

1087 1088 1089 1090 1091
	bhash_order = ehash_order;

	do {
		dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
					sizeof(struct inet_bind_hashbucket);
1092 1093
		if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
		    bhash_order > 0)
1094 1095 1096 1097 1098 1099
			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) {
1100
		DCCP_CRIT("Failed to allocate DCCP bind hash table");
1101
		goto out_free_dccp_locks;
1102 1103 1104 1105 1106 1107 1108
	}

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

1109
	rc = dccp_mib_init();
1110
	if (rc)
1111 1112
		goto out_free_dccp_bhash;

1113
	rc = dccp_ackvec_init();
1114
	if (rc)
1115
		goto out_free_dccp_mib;
1116

1117
	rc = dccp_sysctl_init();
1118 1119
	if (rc)
		goto out_ackvec_exit;
1120 1121

	dccp_timestamping_init();
1122 1123
out:
	return rc;
1124 1125
out_ackvec_exit:
	dccp_ackvec_exit();
1126
out_free_dccp_mib:
1127
	dccp_mib_exit();
1128 1129 1130
out_free_dccp_bhash:
	free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
	dccp_hashinfo.bhash = NULL;
1131 1132
out_free_dccp_locks:
	inet_ehash_locks_free(&dccp_hashinfo);