proto.c 27.6 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
	} else if (old_state == DCCP_REQUESTING)
		sk->sk_err = ECONNRESET;

	dccp_clear_xmit_timers(sk);
312

313
	__skb_queue_purge(&sk->sk_receive_queue);
314
	__skb_queue_purge(&sk->sk_write_queue);
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
	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);

332
	WARN_ON(inet->num && !icsk->icsk_bind_hash);
333
334
335
336
337

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

338
339
EXPORT_SYMBOL_GPL(dccp_disconnect);

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

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

396
397
EXPORT_SYMBOL_GPL(dccp_poll);

398
399
int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
{
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
428
429
	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;
430
431
}

432
433
EXPORT_SYMBOL_GPL(dccp_ioctl);

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

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

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

469
470
471
472
473
474
475
476
477
478
/* 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;
479
480
481
482
483
	/*
	 * rfc4340: 6.1. Change Options
	 */
	if (opt.dccpsf_len < 1)
		return -EINVAL;
484
485
486
487
488
489
490
491
492
493

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

494
495
	rc = dccp_feat_change(dccp_msk(sk), type, opt.dccpsf_feat,
			      val, opt.dccpsf_len, GFP_KERNEL);
496
497
498
499
500
501
502
503
504
505
506
	if (rc)
		goto out_free_val;

out:
	return rc;

out_free_val:
	kfree(val);
	goto out;
}

507
508
static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
		char __user *optval, int optlen)
509
{
510
511
	struct dccp_sock *dp = dccp_sk(sk);
	int val, err = 0;
512

513
514
515
516
517
518
	if (optlen < sizeof(int))
		return -EINVAL;

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

519
520
	if (optname == DCCP_SOCKOPT_SERVICE)
		return dccp_setsockopt_service(sk, val, optval, optlen);
521

522
	lock_sock(sk);
523
524
	switch (optname) {
	case DCCP_SOCKOPT_PACKET_SIZE:
525
		DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
526
		err = 0;
527
		break;
528
529
530
531
532
	case DCCP_SOCKOPT_CHANGE_L:
		if (optlen != sizeof(struct dccp_so_feat))
			err = -EINVAL;
		else
			err = dccp_setsockopt_change(sk, DCCPO_CHANGE_L,
533
						     (struct dccp_so_feat __user *)
534
535
536
537
538
539
540
						     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
541
						     (struct dccp_so_feat __user *)
542
543
						     optval);
		break;
544
545
546
547
548
549
	case DCCP_SOCKOPT_SERVER_TIMEWAIT:
		if (dp->dccps_role != DCCP_ROLE_SERVER)
			err = -EOPNOTSUPP;
		else
			dp->dccps_server_timewait = (val != 0);
		break;
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
	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;
565
566
567
568
	default:
		err = -ENOPROTOOPT;
		break;
	}
569

570
571
	release_sock(sk);
	return err;
572
573
}

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

584
585
EXPORT_SYMBOL_GPL(dccp_setsockopt);

586
587
#ifdef CONFIG_COMPAT
int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
588
			   char __user *optval, int optlen)
589
{
590
591
592
	if (level != SOL_DCCP)
		return inet_csk_compat_setsockopt(sk, level, optname,
						  optval, optlen);
593
594
	return do_dccp_setsockopt(sk, level, optname, optval, optlen);
}
595

596
597
598
EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
#endif

599
static int dccp_getsockopt_service(struct sock *sk, int len,
600
				   __be32 __user *optval,
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
				   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;
}

627
static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
628
		    char __user *optval, int __user *optlen)
629
{
630
631
	struct dccp_sock *dp;
	int val, len;
632

633
634
635
	if (get_user(len, optlen))
		return -EFAULT;

636
	if (len < (int)sizeof(int))
637
638
639
640
641
642
		return -EINVAL;

	dp = dccp_sk(sk);

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

670
	len = sizeof(val);
671
672
673
674
	if (put_user(len, optlen) || copy_to_user(optval, &val, len))
		return -EFAULT;

	return 0;
675
676
}

677
678
679
680
681
682
683
684
685
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);
}
686

687
688
EXPORT_SYMBOL_GPL(dccp_getsockopt);

689
690
#ifdef CONFIG_COMPAT
int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
691
			   char __user *optval, int __user *optlen)
692
{
693
694
695
	if (level != SOL_DCCP)
		return inet_csk_compat_getsockopt(sk, level, optname,
						  optval, optlen);
696
697
	return do_dccp_getsockopt(sk, level, optname, optval, optlen);
}
698

699
700
701
EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
#endif

702
703
704
705
706
707
708
709
710
711
712
713
714
715
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);
716
717
718
719
720
721
722

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

723
	timeo = sock_sndtimeo(sk, noblock);
724
725
726
727
728
729

	/*
	 * 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. */
730
	if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
731
		if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
732
			goto out_release;
733
734
735
736
737
738
739
740
741
742

	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);
743
744
745
	if (rc != 0)
		goto out_discard;

Ian McDonald's avatar
Ian McDonald committed
746
747
	skb_queue_tail(&sk->sk_write_queue, skb);
	dccp_write_xmit(sk,0);
748
749
750
out_release:
	release_sock(sk);
	return rc ? : len;
751
752
out_discard:
	kfree_skb(skb);
753
754
755
	goto out_release;
}

756
757
EXPORT_SYMBOL_GPL(dccp_sendmsg);

758
759
760
761
762
763
764
765
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);

766
767
	if (sk->sk_state == DCCP_LISTEN) {
		len = -ENOTCONN;
768
769
770
		goto out;
	}

771
	timeo = sock_rcvtimeo(sk, nonblock);
772
773

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

776
777
		if (skb == NULL)
			goto verify_sock_status;
778

779
		dh = dccp_hdr(skb);
780

781
782
783
		switch (dh->dccph_type) {
		case DCCP_PKT_DATA:
		case DCCP_PKT_DATAACK:
784
			goto found_ok_skb;
785

786
787
788
789
790
791
792
793
		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));
794
795
			len = 0;
			goto found_fin_ok;
796
797
798
799
		default:
			dccp_pr_debug("packet_type=%s\n",
				      dccp_packet_name(dh->dccph_type));
			sk_eat_skb(sk, skb, 0);
800
801
802
803
		}
verify_sock_status:
		if (sock_flag(sk, SOCK_DONE)) {
			len = 0;
804
			break;
805
		}
806

807
808
809
810
		if (sk->sk_err) {
			len = sock_error(sk);
			break;
		}
811

812
813
814
815
		if (sk->sk_shutdown & RCV_SHUTDOWN) {
			len = 0;
			break;
		}
816

817
818
819
820
821
822
		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;
823
824
				break;
			}
825
826
			len = 0;
			break;
827
828
		}

829
830
831
832
		if (!timeo) {
			len = -EAGAIN;
			break;
		}
833

834
835
836
837
		if (signal_pending(current)) {
			len = sock_intr_errno(timeo);
			break;
		}
838

839
		sk_wait_data(sk, &timeo);
840
841
		continue;
	found_ok_skb:
842
843
844
845
846
847
848
849
850
		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;
851
852
853
		}
	found_fin_ok:
		if (!(flags & MSG_PEEK))
854
			sk_eat_skb(sk, skb, 0);
855
		break;
856
	} while (1);
857
858
out:
	release_sock(sk);
859
	return len;
860
861
}

862
863
864
EXPORT_SYMBOL_GPL(dccp_recvmsg);

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

out:
	release_sock(sk);
	return err;
}

900
901
EXPORT_SYMBOL_GPL(inet_dccp_listen);

902
static void dccp_terminate_connection(struct sock *sk)
903
{
904
	u8 next_state = DCCP_CLOSED;
905

906
907
908
909
910
911
912
913
914
915
916
	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);
917

918
919
		if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER &&
		    !dccp_sk(sk)->dccps_server_timewait)
920
921
922
923
924
925
926
			next_state = DCCP_ACTIVE_CLOSEREQ;
		else
			next_state = DCCP_CLOSING;
		/* fall through */
	default:
		dccp_set_state(sk, next_state);
	}
927
928
929
930
}

void dccp_close(struct sock *sk, long timeout)
{
Ian McDonald's avatar
Ian McDonald committed
931
	struct dccp_sock *dp = dccp_sk(sk);
932
	struct sk_buff *skb;
933
	u32 data_was_unread = 0;
Herbert Xu's avatar
Herbert Xu committed
934
	int state;
935
936
937
938
939
940
941
942
943
944
945
946
947
948

	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
949
950
	sk_stop_timer(sk, &dp->dccps_xmit_timer);

951
952
953
954
955
956
	/*
	 * 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) {
957
		data_was_unread += skb->len;
958
959
960
		__kfree_skb(skb);
	}

961
962
963
964
965
966
	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) {
967
968
		/* Check zero linger _after_ checking for unread data. */
		sk->sk_prot->disconnect(sk, 0);
969
970
	} else if (sk->sk_state != DCCP_CLOSED) {
		dccp_terminate_connection(sk);
971
972
973
974
975
	}

	sk_stream_wait_close(sk, timeout);

adjudge_to_death:
Herbert Xu's avatar
Herbert Xu committed
976
977
978
979
980
	state = sk->sk_state;
	sock_hold(sk);
	sock_orphan(sk);
	atomic_inc(sk->sk_prot->orphan_count);

981
982
983
	/*
	 * It is the last release_sock in its life. It will remove backlog.
	 */
984
985
986
987
988
989
990
	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);
991
	WARN_ON(sock_owned_by_user(sk));
992

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

997
998
999
1000
1001
	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
1002
out:
1003
1004
1005
1006
1007
	bh_unlock_sock(sk);
	local_bh_enable();
	sock_put(sk);
}

1008
1009
EXPORT_SYMBOL_GPL(dccp_close);

1010
1011
void dccp_shutdown(struct sock *sk, int how)
{
1012
	dccp_pr_debug("called shutdown(%x)\n", how);
1013
1014
}

1015
1016
EXPORT_SYMBOL_GPL(dccp_shutdown);

1017
static inline int dccp_mib_init(void)
1018
{
1019
	return snmp_mib_init((void**)dccp_statistics, sizeof(struct dccp_mib));
1020
1021
}

1022
static inline void dccp_mib_exit(void)
1023
{
1024
	snmp_mib_free((void**)dccp_statistics);
1025
1026
}

1027
1028
1029
1030
static int thash_entries;
module_param(thash_entries, int, 0444);
MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");

1031
#ifdef CONFIG_IP_DCCP_DEBUG
1032
int dccp_debug;
1033
module_param(dccp_debug, bool, 0644);
1034
MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
1035
1036

EXPORT_SYMBOL_GPL(dccp_debug);
1037
#endif
1038
1039
1040
1041
1042

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

1045
1046
1047
	BUILD_BUG_ON(sizeof(struct dccp_skb_cb) >
		     FIELD_SIZEOF(struct sk_buff, cb));

1048
1049
1050
	dccp_hashinfo.bind_bucket_cachep =
		kmem_cache_create("dccp_bind_bucket",
				  sizeof(struct inet_bind_bucket), 0,
1051
				  SLAB_HWCACHE_ALIGN, NULL);
1052
	if (!dccp_hashinfo.bind_bucket_cachep)
1053
		goto out;
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066

	/*
	 * 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)
1067
1068
		goal = (thash_entries *
			sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
1069
1070
1071
1072
1073
	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);
1074
1075
		while (dccp_hashinfo.ehash_size &
		       (dccp_hashinfo.ehash_size - 1))
1076
1077
1078
1079
1080
1081
			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) {
1082
		DCCP_CRIT("Failed to allocate DCCP established hash table");
1083
1084
1085
		goto out_free_bind_bucket_cachep;
	}

1086
	for (i = 0; i < dccp_hashinfo.ehash_size; i++) {
1087
		INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain);
1088
		INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].twchain);
1089
1090
	}

1091
1092
1093
	if (inet_ehash_locks_alloc(&dccp_hashinfo))
			goto out_free_dccp_ehash;

1094
1095
1096
1097
1098
	bhash_order = ehash_order;

	do {
		dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
					sizeof(struct inet_bind_hashbucket);
1099
1100
		if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
		    bhash_order > 0)
1101
1102
1103
1104
1105
1106
			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) {
1107
		DCCP_CRIT("Failed to allocate DCCP bind hash table");
1108
		goto out_free_dccp_locks;
1109
1110
1111
1112
1113
1114
1115
	}

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

1116
	rc = dccp_mib_init();
1117
	if (rc)
1118
1119
		goto out_free_dccp_bhash;

1120
	rc = dccp_ackvec_init();
1121
	if (rc)
1122
		goto out_free_dccp_mib;
1123

1124
	rc = dccp_sysctl_init();
1125
1126
	if (rc)
		goto out_ackvec_exit;
1127
1128

	dccp_timestamping_init();
1129
1130
out:
	return rc;
1131
1132
out_ackvec_exit:
	dccp_ackvec_exit();
1133
out_free_dccp_mib:
1134
	dccp_mib_exit();
1135
1136
1137
out_free_dccp_bhash:
	free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
	dccp_hashinfo.bhash = NULL;
1138
1139
out_free_dccp_locks:
	inet_ehash_locks_free(&dccp_hashinfo);
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
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)
{
1151
	dccp_mib_exit();
1152
1153
1154
1155
1156
1157
	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)));
1158
	inet_ehash_locks_free(&dccp_hashinfo);
1159
	kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1160
	dccp_ackvec_exit();
1161
	dccp_sysctl_exit();
1162
1163
1164
1165
1166
1167
1168
1169
}

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