blob: 7e4f54a4ecaf0ce997dbe1211095569575c7905c [file] [log] [blame]
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001/*
2 * net/dccp/proto.c
3 *
4 * An implementation of the DCCP protocol
5 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070012#include <linux/dccp.h>
13#include <linux/module.h>
14#include <linux/types.h>
15#include <linux/sched.h>
16#include <linux/kernel.h>
17#include <linux/skbuff.h>
18#include <linux/netdevice.h>
19#include <linux/in.h>
20#include <linux/if_arp.h>
21#include <linux/init.h>
22#include <linux/random.h>
23#include <net/checksum.h>
24
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020025#include <net/inet_sock.h>
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070026#include <net/sock.h>
27#include <net/xfrm.h>
28
29#include <asm/semaphore.h>
30#include <linux/spinlock.h>
31#include <linux/timer.h>
32#include <linux/delay.h>
33#include <linux/poll.h>
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070034
35#include "ccid.h"
36#include "dccp.h"
Andrea Bittauafe00252006-03-20 17:43:56 -080037#include "feat.h"
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070038
Eric Dumazetba899662005-08-26 12:05:31 -070039DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070040
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -080041EXPORT_SYMBOL_GPL(dccp_statistics);
42
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070043atomic_t dccp_orphan_count = ATOMIC_INIT(0);
44
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -080045EXPORT_SYMBOL_GPL(dccp_orphan_count);
46
Arnaldo Carvalho de Melo075ae862006-03-20 21:24:19 -080047struct inet_hashinfo __cacheline_aligned dccp_hashinfo = {
48 .lhash_lock = RW_LOCK_UNLOCKED,
49 .lhash_users = ATOMIC_INIT(0),
50 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(dccp_hashinfo.lhash_wait),
51};
52
53EXPORT_SYMBOL_GPL(dccp_hashinfo);
54
Ian McDonaldb1308dc2006-11-20 18:30:17 -020055/* the maximum queue length for tx in packets. 0 is no limit */
56int sysctl_dccp_tx_qlen __read_mostly = 5;
57
Arnaldo Carvalho de Meloc25a18b2006-03-20 21:58:56 -080058void dccp_set_state(struct sock *sk, const int state)
59{
60 const int oldstate = sk->sk_state;
61
62 dccp_pr_debug("%s(%p) %-10.10s -> %s\n",
63 dccp_role(sk), sk,
64 dccp_state_name(oldstate), dccp_state_name(state));
65 WARN_ON(state == oldstate);
66
67 switch (state) {
68 case DCCP_OPEN:
69 if (oldstate != DCCP_OPEN)
70 DCCP_INC_STATS(DCCP_MIB_CURRESTAB);
71 break;
72
73 case DCCP_CLOSED:
74 if (oldstate == DCCP_CLOSING || oldstate == DCCP_OPEN)
75 DCCP_INC_STATS(DCCP_MIB_ESTABRESETS);
76
77 sk->sk_prot->unhash(sk);
78 if (inet_csk(sk)->icsk_bind_hash != NULL &&
79 !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
80 inet_put_port(&dccp_hashinfo, sk);
81 /* fall through */
82 default:
83 if (oldstate == DCCP_OPEN)
84 DCCP_DEC_STATS(DCCP_MIB_CURRESTAB);
85 }
86
87 /* Change state AFTER socket is unhashed to avoid closed
88 * socket sitting in hash tables.
89 */
90 sk->sk_state = state;
91}
92
93EXPORT_SYMBOL_GPL(dccp_set_state);
94
95void dccp_done(struct sock *sk)
96{
97 dccp_set_state(sk, DCCP_CLOSED);
98 dccp_clear_xmit_timers(sk);
99
100 sk->sk_shutdown = SHUTDOWN_MASK;
101
102 if (!sock_flag(sk, SOCK_DEAD))
103 sk->sk_state_change(sk);
104 else
105 inet_csk_destroy_sock(sk);
106}
107
108EXPORT_SYMBOL_GPL(dccp_done);
109
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700110const char *dccp_packet_name(const int type)
111{
112 static const char *dccp_packet_names[] = {
113 [DCCP_PKT_REQUEST] = "REQUEST",
114 [DCCP_PKT_RESPONSE] = "RESPONSE",
115 [DCCP_PKT_DATA] = "DATA",
116 [DCCP_PKT_ACK] = "ACK",
117 [DCCP_PKT_DATAACK] = "DATAACK",
118 [DCCP_PKT_CLOSEREQ] = "CLOSEREQ",
119 [DCCP_PKT_CLOSE] = "CLOSE",
120 [DCCP_PKT_RESET] = "RESET",
121 [DCCP_PKT_SYNC] = "SYNC",
122 [DCCP_PKT_SYNCACK] = "SYNCACK",
123 };
124
125 if (type >= DCCP_NR_PKT_TYPES)
126 return "INVALID";
127 else
128 return dccp_packet_names[type];
129}
130
131EXPORT_SYMBOL_GPL(dccp_packet_name);
132
133const char *dccp_state_name(const int state)
134{
135 static char *dccp_state_names[] = {
136 [DCCP_OPEN] = "OPEN",
137 [DCCP_REQUESTING] = "REQUESTING",
138 [DCCP_PARTOPEN] = "PARTOPEN",
139 [DCCP_LISTEN] = "LISTEN",
140 [DCCP_RESPOND] = "RESPOND",
141 [DCCP_CLOSING] = "CLOSING",
142 [DCCP_TIME_WAIT] = "TIME_WAIT",
143 [DCCP_CLOSED] = "CLOSED",
144 };
145
146 if (state >= DCCP_MAX_STATES)
147 return "INVALID STATE!";
148 else
149 return dccp_state_names[state];
150}
151
152EXPORT_SYMBOL_GPL(dccp_state_name);
153
Arnaldo Carvalho de Meloc985ed72006-03-20 21:23:39 -0800154void dccp_hash(struct sock *sk)
155{
156 inet_hash(&dccp_hashinfo, sk);
157}
158
159EXPORT_SYMBOL_GPL(dccp_hash);
160
161void dccp_unhash(struct sock *sk)
162{
163 inet_unhash(&dccp_hashinfo, sk);
164}
165
166EXPORT_SYMBOL_GPL(dccp_unhash);
167
Arnaldo Carvalho de Melo72478872006-03-20 22:00:37 -0800168int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800169{
170 struct dccp_sock *dp = dccp_sk(sk);
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800171 struct dccp_minisock *dmsk = dccp_msk(sk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800172 struct inet_connection_sock *icsk = inet_csk(sk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800173
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800174 dccp_minisock_init(&dp->dccps_minisock);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800175
176 /*
177 * FIXME: We're hardcoding the CCID, and doing this at this point makes
178 * the listening (master) sock get CCID control blocks, which is not
179 * necessary, but for now, to not mess with the test userspace apps,
180 * lets leave it here, later the real solution is to do this in a
181 * setsockopt(CCIDs-I-want/accept). -acme
182 */
Arnaldo Carvalho de Melo72478872006-03-20 22:00:37 -0800183 if (likely(ctl_sock_initialized)) {
Arnaldo Carvalho de Melo8ca0d172006-03-20 22:51:53 -0800184 int rc = dccp_feat_init(dmsk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800185
186 if (rc)
187 return rc;
188
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800189 if (dmsk->dccpms_send_ack_vector) {
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800190 dp->dccps_hc_rx_ackvec = dccp_ackvec_alloc(GFP_KERNEL);
191 if (dp->dccps_hc_rx_ackvec == NULL)
192 return -ENOMEM;
193 }
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800194 dp->dccps_hc_rx_ccid = ccid_hc_rx_new(dmsk->dccpms_rx_ccid,
195 sk, GFP_KERNEL);
196 dp->dccps_hc_tx_ccid = ccid_hc_tx_new(dmsk->dccpms_tx_ccid,
197 sk, GFP_KERNEL);
Arnaldo Carvalho de Melo8109b022006-12-10 16:01:18 -0200198 if (unlikely(dp->dccps_hc_rx_ccid == NULL ||
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800199 dp->dccps_hc_tx_ccid == NULL)) {
200 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
201 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800202 if (dmsk->dccpms_send_ack_vector) {
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800203 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
204 dp->dccps_hc_rx_ackvec = NULL;
205 }
206 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
207 return -ENOMEM;
208 }
209 } else {
210 /* control socket doesn't need feat nego */
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800211 INIT_LIST_HEAD(&dmsk->dccpms_pending);
212 INIT_LIST_HEAD(&dmsk->dccpms_conf);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800213 }
214
215 dccp_init_xmit_timers(sk);
216 icsk->icsk_rto = DCCP_TIMEOUT_INIT;
Gerrit Renker2e2e9e92006-11-13 13:23:52 -0200217 icsk->icsk_syn_retries = sysctl_dccp_request_retries;
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800218 sk->sk_state = DCCP_CLOSED;
219 sk->sk_write_space = dccp_write_space;
220 icsk->icsk_sync_mss = dccp_sync_mss;
221 dp->dccps_mss_cache = 536;
Gerrit Renkera94f0f92007-09-26 11:31:49 -0300222 dp->dccps_rate_last = jiffies;
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800223 dp->dccps_role = DCCP_ROLE_UNDEFINED;
Gerrit Renker00e4d112006-09-22 09:33:58 +0100224 dp->dccps_service = DCCP_SERVICE_CODE_IS_ABSENT;
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800225 dp->dccps_l_ack_ratio = dp->dccps_r_ack_ratio = 1;
226
227 return 0;
228}
229
230EXPORT_SYMBOL_GPL(dccp_init_sock);
231
232int dccp_destroy_sock(struct sock *sk)
233{
234 struct dccp_sock *dp = dccp_sk(sk);
Arnaldo Carvalho de Melo8ca0d172006-03-20 22:51:53 -0800235 struct dccp_minisock *dmsk = dccp_msk(sk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800236
237 /*
238 * DCCP doesn't use sk_write_queue, just sk_send_head
239 * for retransmissions
240 */
241 if (sk->sk_send_head != NULL) {
242 kfree_skb(sk->sk_send_head);
243 sk->sk_send_head = NULL;
244 }
245
246 /* Clean up a referenced DCCP bind bucket. */
247 if (inet_csk(sk)->icsk_bind_hash != NULL)
248 inet_put_port(&dccp_hashinfo, sk);
249
250 kfree(dp->dccps_service_list);
251 dp->dccps_service_list = NULL;
252
Arnaldo Carvalho de Melo8ca0d172006-03-20 22:51:53 -0800253 if (dmsk->dccpms_send_ack_vector) {
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800254 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
255 dp->dccps_hc_rx_ackvec = NULL;
256 }
257 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
258 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
259 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
260
261 /* clean up feature negotiation state */
Arnaldo Carvalho de Melo8ca0d172006-03-20 22:51:53 -0800262 dccp_feat_clean(dmsk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800263
264 return 0;
265}
266
267EXPORT_SYMBOL_GPL(dccp_destroy_sock);
268
Eric Dumazet72a3eff2006-11-16 02:30:37 -0800269static inline int dccp_listen_start(struct sock *sk, int backlog)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700270{
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700271 struct dccp_sock *dp = dccp_sk(sk);
272
273 dp->dccps_role = DCCP_ROLE_LISTEN;
Eric Dumazet72a3eff2006-11-16 02:30:37 -0800274 return inet_csk_listen_start(sk, backlog);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700275}
276
277int dccp_disconnect(struct sock *sk, int flags)
278{
279 struct inet_connection_sock *icsk = inet_csk(sk);
280 struct inet_sock *inet = inet_sk(sk);
281 int err = 0;
282 const int old_state = sk->sk_state;
283
284 if (old_state != DCCP_CLOSED)
285 dccp_set_state(sk, DCCP_CLOSED);
286
287 /* ABORT function of RFC793 */
288 if (old_state == DCCP_LISTEN) {
289 inet_csk_listen_stop(sk);
290 /* FIXME: do the active reset thing */
291 } else if (old_state == DCCP_REQUESTING)
292 sk->sk_err = ECONNRESET;
293
294 dccp_clear_xmit_timers(sk);
295 __skb_queue_purge(&sk->sk_receive_queue);
296 if (sk->sk_send_head != NULL) {
297 __kfree_skb(sk->sk_send_head);
298 sk->sk_send_head = NULL;
299 }
300
301 inet->dport = 0;
302
303 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
304 inet_reset_saddr(sk);
305
306 sk->sk_shutdown = 0;
307 sock_reset_flag(sk, SOCK_DONE);
308
309 icsk->icsk_backoff = 0;
310 inet_csk_delack_init(sk);
311 __sk_dst_reset(sk);
312
313 BUG_TRAP(!inet->num || icsk->icsk_bind_hash);
314
315 sk->sk_error_report(sk);
316 return err;
317}
318
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800319EXPORT_SYMBOL_GPL(dccp_disconnect);
320
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700321/*
322 * Wait for a DCCP event.
323 *
324 * Note that we don't need to lock the socket, as the upper poll layers
325 * take care of normal races (between the test and the event) and we don't
326 * go look at any of the socket buffers directly.
327 */
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800328unsigned int dccp_poll(struct file *file, struct socket *sock,
329 poll_table *wait)
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700330{
331 unsigned int mask;
332 struct sock *sk = sock->sk;
333
334 poll_wait(file, sk->sk_sleep, wait);
335 if (sk->sk_state == DCCP_LISTEN)
336 return inet_csk_listen_poll(sk);
337
338 /* Socket is not locked. We are protected from async events
339 by poll logic and correct handling of state changes
340 made by another threads is impossible in any case.
341 */
342
343 mask = 0;
344 if (sk->sk_err)
345 mask = POLLERR;
346
347 if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
348 mask |= POLLHUP;
349 if (sk->sk_shutdown & RCV_SHUTDOWN)
Davide Libenzif348d702006-03-25 03:07:39 -0800350 mask |= POLLIN | POLLRDNORM | POLLRDHUP;
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700351
352 /* Connected? */
353 if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
354 if (atomic_read(&sk->sk_rmem_alloc) > 0)
355 mask |= POLLIN | POLLRDNORM;
356
357 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
358 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
359 mask |= POLLOUT | POLLWRNORM;
360 } else { /* send SIGIO later */
361 set_bit(SOCK_ASYNC_NOSPACE,
362 &sk->sk_socket->flags);
363 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
364
365 /* Race breaker. If space is freed after
366 * wspace test but before the flags are set,
367 * IO signal will be lost.
368 */
369 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
370 mask |= POLLOUT | POLLWRNORM;
371 }
372 }
373 }
374 return mask;
375}
376
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800377EXPORT_SYMBOL_GPL(dccp_poll);
378
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700379int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
380{
381 dccp_pr_debug("entry\n");
382 return -ENOIOCTLCMD;
383}
384
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800385EXPORT_SYMBOL_GPL(dccp_ioctl);
386
Andrea Bittau60fe62e2006-03-20 19:23:32 -0800387static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700388 char __user *optval, int optlen)
389{
390 struct dccp_sock *dp = dccp_sk(sk);
391 struct dccp_service_list *sl = NULL;
392
Arnaldo Carvalho de Melo8109b022006-12-10 16:01:18 -0200393 if (service == DCCP_SERVICE_INVALID_VALUE ||
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700394 optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
395 return -EINVAL;
396
397 if (optlen > sizeof(service)) {
398 sl = kmalloc(optlen, GFP_KERNEL);
399 if (sl == NULL)
400 return -ENOMEM;
401
402 sl->dccpsl_nr = optlen / sizeof(u32) - 1;
403 if (copy_from_user(sl->dccpsl_list,
404 optval + sizeof(service),
405 optlen - sizeof(service)) ||
406 dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
407 kfree(sl);
408 return -EFAULT;
409 }
410 }
411
412 lock_sock(sk);
413 dp->dccps_service = service;
414
Jesper Juhla51482b2005-11-08 09:41:34 -0800415 kfree(dp->dccps_service_list);
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700416
417 dp->dccps_service_list = sl;
418 release_sock(sk);
419 return 0;
420}
421
Andrea Bittauafe00252006-03-20 17:43:56 -0800422/* byte 1 is feature. the rest is the preference list */
423static int dccp_setsockopt_change(struct sock *sk, int type,
424 struct dccp_so_feat __user *optval)
425{
426 struct dccp_so_feat opt;
427 u8 *val;
428 int rc;
429
430 if (copy_from_user(&opt, optval, sizeof(opt)))
431 return -EFAULT;
432
433 val = kmalloc(opt.dccpsf_len, GFP_KERNEL);
434 if (!val)
435 return -ENOMEM;
436
437 if (copy_from_user(val, opt.dccpsf_val, opt.dccpsf_len)) {
438 rc = -EFAULT;
439 goto out_free_val;
440 }
441
Arnaldo Carvalho de Melo8ca0d172006-03-20 22:51:53 -0800442 rc = dccp_feat_change(dccp_msk(sk), type, opt.dccpsf_feat,
443 val, opt.dccpsf_len, GFP_KERNEL);
Andrea Bittauafe00252006-03-20 17:43:56 -0800444 if (rc)
445 goto out_free_val;
446
447out:
448 return rc;
449
450out_free_val:
451 kfree(val);
452 goto out;
453}
454
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800455static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
456 char __user *optval, int optlen)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700457{
Gerrit Renker09dbc382006-11-14 12:57:34 -0200458 struct dccp_sock *dp = dccp_sk(sk);
459 int val, err = 0;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700460
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300461 if (optlen < sizeof(int))
462 return -EINVAL;
463
464 if (get_user(val, (int __user *)optval))
465 return -EFAULT;
466
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700467 if (optname == DCCP_SOCKOPT_SERVICE)
468 return dccp_setsockopt_service(sk, val, optval, optlen);
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300469
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700470 lock_sock(sk);
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300471 switch (optname) {
472 case DCCP_SOCKOPT_PACKET_SIZE:
Gerrit Renker5aed3242006-11-28 19:33:36 -0200473 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
Arnaldo Carvalho de Melo841bac12006-11-28 19:42:03 -0200474 err = 0;
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300475 break;
Andrea Bittauafe00252006-03-20 17:43:56 -0800476 case DCCP_SOCKOPT_CHANGE_L:
477 if (optlen != sizeof(struct dccp_so_feat))
478 err = -EINVAL;
479 else
480 err = dccp_setsockopt_change(sk, DCCPO_CHANGE_L,
YOSHIFUJI Hideakic9eaf172007-02-09 23:24:38 +0900481 (struct dccp_so_feat __user *)
Andrea Bittauafe00252006-03-20 17:43:56 -0800482 optval);
483 break;
Andrea Bittauafe00252006-03-20 17:43:56 -0800484 case DCCP_SOCKOPT_CHANGE_R:
485 if (optlen != sizeof(struct dccp_so_feat))
486 err = -EINVAL;
487 else
488 err = dccp_setsockopt_change(sk, DCCPO_CHANGE_R,
Alan Cox9faefb62006-07-10 14:24:23 -0700489 (struct dccp_so_feat __user *)
Andrea Bittauafe00252006-03-20 17:43:56 -0800490 optval);
491 break;
Gerrit Renker6f4e5ff2006-11-10 17:43:06 -0200492 case DCCP_SOCKOPT_SEND_CSCOV: /* sender side, RFC 4340, sec. 9.2 */
493 if (val < 0 || val > 15)
494 err = -EINVAL;
495 else
496 dp->dccps_pcslen = val;
497 break;
498 case DCCP_SOCKOPT_RECV_CSCOV: /* receiver side, RFC 4340 sec. 9.2.1 */
499 if (val < 0 || val > 15)
500 err = -EINVAL;
501 else {
502 dp->dccps_pcrlen = val;
503 /* FIXME: add feature negotiation,
504 * ChangeL(MinimumChecksumCoverage, val) */
505 }
506 break;
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300507 default:
508 err = -ENOPROTOOPT;
509 break;
510 }
Gerrit Renker6f4e5ff2006-11-10 17:43:06 -0200511
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300512 release_sock(sk);
513 return err;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700514}
515
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800516int dccp_setsockopt(struct sock *sk, int level, int optname,
517 char __user *optval, int optlen)
518{
519 if (level != SOL_DCCP)
520 return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
521 optname, optval,
522 optlen);
523 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
524}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800525
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800526EXPORT_SYMBOL_GPL(dccp_setsockopt);
527
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800528#ifdef CONFIG_COMPAT
529int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800530 char __user *optval, int optlen)
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800531{
Arnaldo Carvalho de Melodec73ff2006-03-20 22:46:16 -0800532 if (level != SOL_DCCP)
533 return inet_csk_compat_setsockopt(sk, level, optname,
534 optval, optlen);
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800535 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
536}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800537
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800538EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
539#endif
540
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700541static int dccp_getsockopt_service(struct sock *sk, int len,
Andrea Bittau60fe62e2006-03-20 19:23:32 -0800542 __be32 __user *optval,
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700543 int __user *optlen)
544{
545 const struct dccp_sock *dp = dccp_sk(sk);
546 const struct dccp_service_list *sl;
547 int err = -ENOENT, slen = 0, total_len = sizeof(u32);
548
549 lock_sock(sk);
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700550 if ((sl = dp->dccps_service_list) != NULL) {
551 slen = sl->dccpsl_nr * sizeof(u32);
552 total_len += slen;
553 }
554
555 err = -EINVAL;
556 if (total_len > len)
557 goto out;
558
559 err = 0;
560 if (put_user(total_len, optlen) ||
561 put_user(dp->dccps_service, optval) ||
562 (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
563 err = -EFAULT;
564out:
565 release_sock(sk);
566 return err;
567}
568
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800569static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
Arnaldo Carvalho de Meloa1d3a352005-08-13 22:42:25 -0300570 char __user *optval, int __user *optlen)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700571{
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300572 struct dccp_sock *dp;
573 int val, len;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700574
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300575 if (get_user(len, optlen))
576 return -EFAULT;
577
Arnaldo Carvalho de Melo39ebc022007-03-28 11:54:32 -0700578 if (len < (int)sizeof(int))
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300579 return -EINVAL;
580
581 dp = dccp_sk(sk);
582
583 switch (optname) {
584 case DCCP_SOCKOPT_PACKET_SIZE:
Gerrit Renker5aed3242006-11-28 19:33:36 -0200585 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
Arnaldo Carvalho de Melo841bac12006-11-28 19:42:03 -0200586 return 0;
Arnaldo Carvalho de Melo88f964d2005-09-18 00:19:32 -0700587 case DCCP_SOCKOPT_SERVICE:
588 return dccp_getsockopt_service(sk, len,
Andrea Bittau60fe62e2006-03-20 19:23:32 -0800589 (__be32 __user *)optval, optlen);
Gerrit Renker6f4e5ff2006-11-10 17:43:06 -0200590 case DCCP_SOCKOPT_SEND_CSCOV:
591 val = dp->dccps_pcslen;
Arnaldo Carvalho de Melo39ebc022007-03-28 11:54:32 -0700592 len = sizeof(val);
Gerrit Renker6f4e5ff2006-11-10 17:43:06 -0200593 break;
594 case DCCP_SOCKOPT_RECV_CSCOV:
595 val = dp->dccps_pcrlen;
Arnaldo Carvalho de Melo39ebc022007-03-28 11:54:32 -0700596 len = sizeof(val);
Gerrit Renker6f4e5ff2006-11-10 17:43:06 -0200597 break;
Arnaldo Carvalho de Melo88f964d2005-09-18 00:19:32 -0700598 case 128 ... 191:
599 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
600 len, (u32 __user *)optval, optlen);
601 case 192 ... 255:
602 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
603 len, (u32 __user *)optval, optlen);
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300604 default:
605 return -ENOPROTOOPT;
606 }
607
608 if (put_user(len, optlen) || copy_to_user(optval, &val, len))
609 return -EFAULT;
610
611 return 0;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700612}
613
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800614int dccp_getsockopt(struct sock *sk, int level, int optname,
615 char __user *optval, int __user *optlen)
616{
617 if (level != SOL_DCCP)
618 return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
619 optname, optval,
620 optlen);
621 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
622}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800623
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800624EXPORT_SYMBOL_GPL(dccp_getsockopt);
625
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800626#ifdef CONFIG_COMPAT
627int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800628 char __user *optval, int __user *optlen)
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800629{
Arnaldo Carvalho de Melodec73ff2006-03-20 22:46:16 -0800630 if (level != SOL_DCCP)
631 return inet_csk_compat_getsockopt(sk, level, optname,
632 optval, optlen);
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800633 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
634}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800635
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800636EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
637#endif
638
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700639int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
640 size_t len)
641{
642 const struct dccp_sock *dp = dccp_sk(sk);
643 const int flags = msg->msg_flags;
644 const int noblock = flags & MSG_DONTWAIT;
645 struct sk_buff *skb;
646 int rc, size;
647 long timeo;
648
649 if (len > dp->dccps_mss_cache)
650 return -EMSGSIZE;
651
652 lock_sock(sk);
Ian McDonaldb1308dc2006-11-20 18:30:17 -0200653
654 if (sysctl_dccp_tx_qlen &&
655 (sk->sk_write_queue.qlen >= sysctl_dccp_tx_qlen)) {
656 rc = -EAGAIN;
657 goto out_release;
658 }
659
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700660 timeo = sock_sndtimeo(sk, noblock);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700661
662 /*
663 * We have to use sk_stream_wait_connect here to set sk_write_pending,
664 * so that the trick in dccp_rcv_request_sent_state_process.
665 */
666 /* Wait for a connection to finish. */
Gerrit Renkercecd8d02007-09-26 19:36:08 -0300667 if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700668 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700669 goto out_release;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700670
671 size = sk->sk_prot->max_header + len;
672 release_sock(sk);
673 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
674 lock_sock(sk);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700675 if (skb == NULL)
676 goto out_release;
677
678 skb_reserve(skb, sk->sk_prot->max_header);
679 rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700680 if (rc != 0)
681 goto out_discard;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700682
Ian McDonald97e58482006-08-26 19:16:45 -0700683 skb_queue_tail(&sk->sk_write_queue, skb);
684 dccp_write_xmit(sk,0);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700685out_release:
686 release_sock(sk);
687 return rc ? : len;
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700688out_discard:
689 kfree_skb(skb);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700690 goto out_release;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700691}
692
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800693EXPORT_SYMBOL_GPL(dccp_sendmsg);
694
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700695int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
696 size_t len, int nonblock, int flags, int *addr_len)
697{
698 const struct dccp_hdr *dh;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700699 long timeo;
700
701 lock_sock(sk);
702
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300703 if (sk->sk_state == DCCP_LISTEN) {
704 len = -ENOTCONN;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700705 goto out;
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300706 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700707
708 timeo = sock_rcvtimeo(sk, nonblock);
709
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700710 do {
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300711 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700712
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300713 if (skb == NULL)
714 goto verify_sock_status;
715
716 dh = dccp_hdr(skb);
717
718 if (dh->dccph_type == DCCP_PKT_DATA ||
719 dh->dccph_type == DCCP_PKT_DATAACK)
720 goto found_ok_skb;
721
722 if (dh->dccph_type == DCCP_PKT_RESET ||
723 dh->dccph_type == DCCP_PKT_CLOSE) {
724 dccp_pr_debug("found fin ok!\n");
725 len = 0;
726 goto found_fin_ok;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700727 }
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300728 dccp_pr_debug("packet_type=%s\n",
729 dccp_packet_name(dh->dccph_type));
Chris Leech624d1162006-05-23 18:01:28 -0700730 sk_eat_skb(sk, skb, 0);
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300731verify_sock_status:
732 if (sock_flag(sk, SOCK_DONE)) {
733 len = 0;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700734 break;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700735 }
736
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300737 if (sk->sk_err) {
738 len = sock_error(sk);
739 break;
740 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700741
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300742 if (sk->sk_shutdown & RCV_SHUTDOWN) {
743 len = 0;
744 break;
745 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700746
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300747 if (sk->sk_state == DCCP_CLOSED) {
748 if (!sock_flag(sk, SOCK_DONE)) {
749 /* This occurs when user tries to read
750 * from never connected socket.
751 */
752 len = -ENOTCONN;
753 break;
754 }
755 len = 0;
756 break;
757 }
758
759 if (!timeo) {
760 len = -EAGAIN;
761 break;
762 }
763
764 if (signal_pending(current)) {
765 len = sock_intr_errno(timeo);
766 break;
767 }
768
769 sk_wait_data(sk, &timeo);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700770 continue;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700771 found_ok_skb:
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300772 if (len > skb->len)
773 len = skb->len;
774 else if (len < skb->len)
775 msg->msg_flags |= MSG_TRUNC;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700776
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300777 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) {
778 /* Exception. Bailout! */
779 len = -EFAULT;
780 break;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700781 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700782 found_fin_ok:
783 if (!(flags & MSG_PEEK))
Chris Leech624d1162006-05-23 18:01:28 -0700784 sk_eat_skb(sk, skb, 0);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700785 break;
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300786 } while (1);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700787out:
788 release_sock(sk);
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300789 return len;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700790}
791
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800792EXPORT_SYMBOL_GPL(dccp_recvmsg);
793
794int inet_dccp_listen(struct socket *sock, int backlog)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700795{
796 struct sock *sk = sock->sk;
797 unsigned char old_state;
798 int err;
799
800 lock_sock(sk);
801
802 err = -EINVAL;
803 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
804 goto out;
805
806 old_state = sk->sk_state;
807 if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
808 goto out;
809
810 /* Really, if the socket is already in listen state
811 * we can only allow the backlog to be adjusted.
812 */
813 if (old_state != DCCP_LISTEN) {
814 /*
815 * FIXME: here it probably should be sk->sk_prot->listen_start
816 * see tcp_listen_start
817 */
Eric Dumazet72a3eff2006-11-16 02:30:37 -0800818 err = dccp_listen_start(sk, backlog);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700819 if (err)
820 goto out;
821 }
822 sk->sk_max_ack_backlog = backlog;
823 err = 0;
824
825out:
826 release_sock(sk);
827 return err;
828}
829
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800830EXPORT_SYMBOL_GPL(inet_dccp_listen);
831
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700832static const unsigned char dccp_new_state[] = {
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -0300833 /* current state: new state: action: */
834 [0] = DCCP_CLOSED,
Arnaldo Carvalho de Melo8109b022006-12-10 16:01:18 -0200835 [DCCP_OPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -0300836 [DCCP_REQUESTING] = DCCP_CLOSED,
837 [DCCP_PARTOPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
838 [DCCP_LISTEN] = DCCP_CLOSED,
839 [DCCP_RESPOND] = DCCP_CLOSED,
840 [DCCP_CLOSING] = DCCP_CLOSED,
841 [DCCP_TIME_WAIT] = DCCP_CLOSED,
842 [DCCP_CLOSED] = DCCP_CLOSED,
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700843};
844
845static int dccp_close_state(struct sock *sk)
846{
847 const int next = dccp_new_state[sk->sk_state];
848 const int ns = next & DCCP_STATE_MASK;
849
850 if (ns != sk->sk_state)
851 dccp_set_state(sk, ns);
852
853 return next & DCCP_ACTION_FIN;
854}
855
856void dccp_close(struct sock *sk, long timeout)
857{
Ian McDonald97e58482006-08-26 19:16:45 -0700858 struct dccp_sock *dp = dccp_sk(sk);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700859 struct sk_buff *skb;
Herbert Xu134af342006-05-05 17:09:13 -0700860 int state;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700861
862 lock_sock(sk);
863
864 sk->sk_shutdown = SHUTDOWN_MASK;
865
866 if (sk->sk_state == DCCP_LISTEN) {
867 dccp_set_state(sk, DCCP_CLOSED);
868
869 /* Special case. */
870 inet_csk_listen_stop(sk);
871
872 goto adjudge_to_death;
873 }
874
Ian McDonald97e58482006-08-26 19:16:45 -0700875 sk_stop_timer(sk, &dp->dccps_xmit_timer);
876
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700877 /*
878 * We need to flush the recv. buffs. We do this only on the
879 * descriptor close, not protocol-sourced closes, because the
880 *reader process may not have drained the data yet!
881 */
882 /* FIXME: check for unread data */
883 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
884 __kfree_skb(skb);
885 }
886
887 if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
888 /* Check zero linger _after_ checking for unread data. */
889 sk->sk_prot->disconnect(sk, 0);
890 } else if (dccp_close_state(sk)) {
Arnaldo Carvalho de Melo7ad07e72005-08-23 21:50:06 -0700891 dccp_send_close(sk, 1);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700892 }
893
894 sk_stream_wait_close(sk, timeout);
895
896adjudge_to_death:
Herbert Xu134af342006-05-05 17:09:13 -0700897 state = sk->sk_state;
898 sock_hold(sk);
899 sock_orphan(sk);
900 atomic_inc(sk->sk_prot->orphan_count);
901
Arnaldo Carvalho de Melo7ad07e72005-08-23 21:50:06 -0700902 /*
903 * It is the last release_sock in its life. It will remove backlog.
904 */
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700905 release_sock(sk);
906 /*
907 * Now socket is owned by kernel and we acquire BH lock
908 * to finish close. No need to check for user refs.
909 */
910 local_bh_disable();
911 bh_lock_sock(sk);
912 BUG_TRAP(!sock_owned_by_user(sk));
913
Herbert Xu134af342006-05-05 17:09:13 -0700914 /* Have we already been destroyed by a softirq or backlog? */
915 if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
916 goto out;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700917
Arnaldo Carvalho de Melo7ad07e72005-08-23 21:50:06 -0700918 /*
919 * The last release_sock may have processed the CLOSE or RESET
920 * packet moving sock to CLOSED state, if not we have to fire
921 * the CLOSE/CLOSEREQ retransmission timer, see "8.3. Termination"
922 * in draft-ietf-dccp-spec-11. -acme
923 */
924 if (sk->sk_state == DCCP_CLOSING) {
925 /* FIXME: should start at 2 * RTT */
926 /* Timer for repeating the CLOSE/CLOSEREQ until an answer. */
927 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
928 inet_csk(sk)->icsk_rto,
929 DCCP_RTO_MAX);
930#if 0
931 /* Yeah, we should use sk->sk_prot->orphan_count, etc */
932 dccp_set_state(sk, DCCP_CLOSED);
933#endif
934 }
935
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700936 if (sk->sk_state == DCCP_CLOSED)
937 inet_csk_destroy_sock(sk);
938
939 /* Otherwise, socket is reprieved until protocol close. */
940
Herbert Xu134af342006-05-05 17:09:13 -0700941out:
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700942 bh_unlock_sock(sk);
943 local_bh_enable();
944 sock_put(sk);
945}
946
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800947EXPORT_SYMBOL_GPL(dccp_close);
948
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700949void dccp_shutdown(struct sock *sk, int how)
950{
951 dccp_pr_debug("entry\n");
952}
953
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800954EXPORT_SYMBOL_GPL(dccp_shutdown);
955
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -0800956static int __init dccp_mib_init(void)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700957{
958 int rc = -ENOMEM;
959
960 dccp_statistics[0] = alloc_percpu(struct dccp_mib);
961 if (dccp_statistics[0] == NULL)
962 goto out;
963
964 dccp_statistics[1] = alloc_percpu(struct dccp_mib);
965 if (dccp_statistics[1] == NULL)
966 goto out_free_one;
967
968 rc = 0;
969out:
970 return rc;
971out_free_one:
972 free_percpu(dccp_statistics[0]);
973 dccp_statistics[0] = NULL;
974 goto out;
975
976}
977
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -0800978static void dccp_mib_exit(void)
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -0800979{
980 free_percpu(dccp_statistics[0]);
981 free_percpu(dccp_statistics[1]);
982 dccp_statistics[0] = dccp_statistics[1] = NULL;
983}
984
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700985static int thash_entries;
986module_param(thash_entries, int, 0444);
987MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
988
Arnaldo Carvalho de Meloa1d3a352005-08-13 22:42:25 -0300989#ifdef CONFIG_IP_DCCP_DEBUG
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700990int dccp_debug;
991module_param(dccp_debug, int, 0444);
992MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800993
994EXPORT_SYMBOL_GPL(dccp_debug);
Arnaldo Carvalho de Meloa1d3a352005-08-13 22:42:25 -0300995#endif
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700996
997static int __init dccp_init(void)
998{
999 unsigned long goal;
1000 int ehash_order, bhash_order, i;
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -08001001 int rc = -ENOBUFS;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001002
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001003 dccp_hashinfo.bind_bucket_cachep =
1004 kmem_cache_create("dccp_bind_bucket",
1005 sizeof(struct inet_bind_bucket), 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09001006 SLAB_HWCACHE_ALIGN, NULL);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001007 if (!dccp_hashinfo.bind_bucket_cachep)
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -08001008 goto out;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001009
1010 /*
1011 * Size and allocate the main established and bind bucket
1012 * hash tables.
1013 *
1014 * The methodology is similar to that of the buffer cache.
1015 */
1016 if (num_physpages >= (128 * 1024))
1017 goal = num_physpages >> (21 - PAGE_SHIFT);
1018 else
1019 goal = num_physpages >> (23 - PAGE_SHIFT);
1020
1021 if (thash_entries)
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001022 goal = (thash_entries *
1023 sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001024 for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
1025 ;
1026 do {
1027 dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE /
1028 sizeof(struct inet_ehash_bucket);
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001029 while (dccp_hashinfo.ehash_size &
1030 (dccp_hashinfo.ehash_size - 1))
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001031 dccp_hashinfo.ehash_size--;
1032 dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
1033 __get_free_pages(GFP_ATOMIC, ehash_order);
1034 } while (!dccp_hashinfo.ehash && --ehash_order > 0);
1035
1036 if (!dccp_hashinfo.ehash) {
Gerrit Renker59348b12006-11-20 18:39:23 -02001037 DCCP_CRIT("Failed to allocate DCCP established hash table");
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001038 goto out_free_bind_bucket_cachep;
1039 }
1040
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08001041 for (i = 0; i < dccp_hashinfo.ehash_size; i++) {
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001042 rwlock_init(&dccp_hashinfo.ehash[i].lock);
1043 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain);
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08001044 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].twchain);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001045 }
1046
1047 bhash_order = ehash_order;
1048
1049 do {
1050 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
1051 sizeof(struct inet_bind_hashbucket);
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001052 if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
1053 bhash_order > 0)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001054 continue;
1055 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
1056 __get_free_pages(GFP_ATOMIC, bhash_order);
1057 } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
1058
1059 if (!dccp_hashinfo.bhash) {
Gerrit Renker59348b12006-11-20 18:39:23 -02001060 DCCP_CRIT("Failed to allocate DCCP bind hash table");
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001061 goto out_free_dccp_ehash;
1062 }
1063
1064 for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
1065 spin_lock_init(&dccp_hashinfo.bhash[i].lock);
1066 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
1067 }
1068
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001069 rc = dccp_mib_init();
Arnaldo Carvalho de Melofa23e2e2006-03-20 17:16:01 -08001070 if (rc)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001071 goto out_free_dccp_bhash;
1072
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001073 rc = dccp_ackvec_init();
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001074 if (rc)
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -08001075 goto out_free_dccp_mib;
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001076
Arnaldo Carvalho de Meloe55d9122006-03-20 19:25:02 -08001077 rc = dccp_sysctl_init();
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001078 if (rc)
1079 goto out_ackvec_exit;
Gerrit Renker4c70f382007-09-25 22:40:13 -07001080
1081 dccp_timestamping_init();
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001082out:
1083 return rc;
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001084out_ackvec_exit:
1085 dccp_ackvec_exit();
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -08001086out_free_dccp_mib:
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001087 dccp_mib_exit();
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001088out_free_dccp_bhash:
1089 free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
1090 dccp_hashinfo.bhash = NULL;
1091out_free_dccp_ehash:
1092 free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
1093 dccp_hashinfo.ehash = NULL;
1094out_free_bind_bucket_cachep:
1095 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1096 dccp_hashinfo.bind_bucket_cachep = NULL;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001097 goto out;
1098}
1099
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001100static void __exit dccp_fini(void)
1101{
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001102 dccp_mib_exit();
Arnaldo Carvalho de Melo725ba8e2005-08-13 20:35:39 -03001103 free_pages((unsigned long)dccp_hashinfo.bhash,
1104 get_order(dccp_hashinfo.bhash_size *
1105 sizeof(struct inet_bind_hashbucket)));
1106 free_pages((unsigned long)dccp_hashinfo.ehash,
1107 get_order(dccp_hashinfo.ehash_size *
1108 sizeof(struct inet_ehash_bucket)));
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001109 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001110 dccp_ackvec_exit();
Arnaldo Carvalho de Meloe55d9122006-03-20 19:25:02 -08001111 dccp_sysctl_exit();
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001112}
1113
1114module_init(dccp_init);
1115module_exit(dccp_fini);
1116
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001117MODULE_LICENSE("GPL");
1118MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
1119MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");