4 * An implementation of the DCCP protocol
5 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
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.
12 #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>
20 #include <linux/if_arp.h>
21 #include <linux/init.h>
22 #include <linux/random.h>
23 #include <net/checksum.h>
25 #include <net/inet_sock.h>
29 #include <asm/ioctls.h>
30 #include <asm/semaphore.h>
31 #include <linux/spinlock.h>
32 #include <linux/timer.h>
33 #include <linux/delay.h>
34 #include <linux/poll.h>
40 DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
42 EXPORT_SYMBOL_GPL(dccp_statistics);
44 atomic_t dccp_orphan_count = ATOMIC_INIT(0);
46 EXPORT_SYMBOL_GPL(dccp_orphan_count);
48 struct inet_hashinfo __cacheline_aligned dccp_hashinfo = {
49 .lhash_lock = RW_LOCK_UNLOCKED,
50 .lhash_users = ATOMIC_INIT(0),
51 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(dccp_hashinfo.lhash_wait),
54 EXPORT_SYMBOL_GPL(dccp_hashinfo);
56 /* the maximum queue length for tx in packets. 0 is no limit */
57 int sysctl_dccp_tx_qlen __read_mostly = 5;
59 void dccp_set_state(struct sock *sk, const int state)
61 const int oldstate = sk->sk_state;
63 dccp_pr_debug("%s(%p) %s --> %s\n", dccp_role(sk), sk,
64 dccp_state_name(oldstate), dccp_state_name(state));
65 WARN_ON(state == oldstate);
69 if (oldstate != DCCP_OPEN)
70 DCCP_INC_STATS(DCCP_MIB_CURRESTAB);
74 if (oldstate == DCCP_CLOSING || oldstate == DCCP_OPEN)
75 DCCP_INC_STATS(DCCP_MIB_ESTABRESETS);
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);
83 if (oldstate == DCCP_OPEN)
84 DCCP_DEC_STATS(DCCP_MIB_CURRESTAB);
87 /* Change state AFTER socket is unhashed to avoid closed
88 * socket sitting in hash tables.
93 EXPORT_SYMBOL_GPL(dccp_set_state);
95 void dccp_done(struct sock *sk)
97 dccp_set_state(sk, DCCP_CLOSED);
98 dccp_clear_xmit_timers(sk);
100 sk->sk_shutdown = SHUTDOWN_MASK;
102 if (!sock_flag(sk, SOCK_DEAD))
103 sk->sk_state_change(sk);
105 inet_csk_destroy_sock(sk);
108 EXPORT_SYMBOL_GPL(dccp_done);
110 const char *dccp_packet_name(const int type)
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",
125 if (type >= DCCP_NR_PKT_TYPES)
128 return dccp_packet_names[type];
131 EXPORT_SYMBOL_GPL(dccp_packet_name);
133 const char *dccp_state_name(const int state)
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_ACTIVE_CLOSEREQ] = "CLOSEREQ",
143 [DCCP_PASSIVE_CLOSE] = "PASSIVE_CLOSE",
144 [DCCP_PASSIVE_CLOSEREQ] = "PASSIVE_CLOSEREQ",
145 [DCCP_TIME_WAIT] = "TIME_WAIT",
146 [DCCP_CLOSED] = "CLOSED",
149 if (state >= DCCP_MAX_STATES)
150 return "INVALID STATE!";
152 return dccp_state_names[state];
155 EXPORT_SYMBOL_GPL(dccp_state_name);
157 void dccp_hash(struct sock *sk)
159 inet_hash(&dccp_hashinfo, sk);
162 EXPORT_SYMBOL_GPL(dccp_hash);
164 void dccp_unhash(struct sock *sk)
166 inet_unhash(&dccp_hashinfo, sk);
169 EXPORT_SYMBOL_GPL(dccp_unhash);
171 int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
173 struct dccp_sock *dp = dccp_sk(sk);
174 struct dccp_minisock *dmsk = dccp_msk(sk);
175 struct inet_connection_sock *icsk = inet_csk(sk);
177 dccp_minisock_init(&dp->dccps_minisock);
179 icsk->icsk_rto = DCCP_TIMEOUT_INIT;
180 icsk->icsk_syn_retries = sysctl_dccp_request_retries;
181 sk->sk_state = DCCP_CLOSED;
182 sk->sk_write_space = dccp_write_space;
183 icsk->icsk_sync_mss = dccp_sync_mss;
184 dp->dccps_mss_cache = 536;
185 dp->dccps_rate_last = jiffies;
186 dp->dccps_role = DCCP_ROLE_UNDEFINED;
187 dp->dccps_service = DCCP_SERVICE_CODE_IS_ABSENT;
188 dp->dccps_l_ack_ratio = dp->dccps_r_ack_ratio = 1;
190 dccp_init_xmit_timers(sk);
193 * FIXME: We're hardcoding the CCID, and doing this at this point makes
194 * the listening (master) sock get CCID control blocks, which is not
195 * necessary, but for now, to not mess with the test userspace apps,
196 * lets leave it here, later the real solution is to do this in a
197 * setsockopt(CCIDs-I-want/accept). -acme
199 if (likely(ctl_sock_initialized)) {
200 int rc = dccp_feat_init(dmsk);
205 if (dmsk->dccpms_send_ack_vector) {
206 dp->dccps_hc_rx_ackvec = dccp_ackvec_alloc(GFP_KERNEL);
207 if (dp->dccps_hc_rx_ackvec == NULL)
210 dp->dccps_hc_rx_ccid = ccid_hc_rx_new(dmsk->dccpms_rx_ccid,
212 dp->dccps_hc_tx_ccid = ccid_hc_tx_new(dmsk->dccpms_tx_ccid,
214 if (unlikely(dp->dccps_hc_rx_ccid == NULL ||
215 dp->dccps_hc_tx_ccid == NULL)) {
216 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
217 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
218 if (dmsk->dccpms_send_ack_vector) {
219 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
220 dp->dccps_hc_rx_ackvec = NULL;
222 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
226 /* control socket doesn't need feat nego */
227 INIT_LIST_HEAD(&dmsk->dccpms_pending);
228 INIT_LIST_HEAD(&dmsk->dccpms_conf);
234 EXPORT_SYMBOL_GPL(dccp_init_sock);
236 int dccp_destroy_sock(struct sock *sk)
238 struct dccp_sock *dp = dccp_sk(sk);
239 struct dccp_minisock *dmsk = dccp_msk(sk);
242 * DCCP doesn't use sk_write_queue, just sk_send_head
243 * for retransmissions
245 if (sk->sk_send_head != NULL) {
246 kfree_skb(sk->sk_send_head);
247 sk->sk_send_head = NULL;
250 /* Clean up a referenced DCCP bind bucket. */
251 if (inet_csk(sk)->icsk_bind_hash != NULL)
252 inet_put_port(&dccp_hashinfo, sk);
254 kfree(dp->dccps_service_list);
255 dp->dccps_service_list = NULL;
257 if (dmsk->dccpms_send_ack_vector) {
258 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
259 dp->dccps_hc_rx_ackvec = NULL;
261 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
262 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
263 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
265 /* clean up feature negotiation state */
266 dccp_feat_clean(dmsk);
271 EXPORT_SYMBOL_GPL(dccp_destroy_sock);
273 static inline int dccp_listen_start(struct sock *sk, int backlog)
275 struct dccp_sock *dp = dccp_sk(sk);
277 dp->dccps_role = DCCP_ROLE_LISTEN;
278 return inet_csk_listen_start(sk, backlog);
281 static inline int dccp_need_reset(int state)
283 return state != DCCP_CLOSED && state != DCCP_LISTEN &&
284 state != DCCP_REQUESTING;
287 int dccp_disconnect(struct sock *sk, int flags)
289 struct inet_connection_sock *icsk = inet_csk(sk);
290 struct inet_sock *inet = inet_sk(sk);
292 const int old_state = sk->sk_state;
294 if (old_state != DCCP_CLOSED)
295 dccp_set_state(sk, DCCP_CLOSED);
298 * This corresponds to the ABORT function of RFC793, sec. 3.8
299 * TCP uses a RST segment, DCCP a Reset packet with Code 2, "Aborted".
301 if (old_state == DCCP_LISTEN) {
302 inet_csk_listen_stop(sk);
303 } else if (dccp_need_reset(old_state)) {
304 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
305 sk->sk_err = ECONNRESET;
306 } else if (old_state == DCCP_REQUESTING)
307 sk->sk_err = ECONNRESET;
309 dccp_clear_xmit_timers(sk);
310 __skb_queue_purge(&sk->sk_receive_queue);
311 if (sk->sk_send_head != NULL) {
312 __kfree_skb(sk->sk_send_head);
313 sk->sk_send_head = NULL;
318 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
319 inet_reset_saddr(sk);
322 sock_reset_flag(sk, SOCK_DONE);
324 icsk->icsk_backoff = 0;
325 inet_csk_delack_init(sk);
328 BUG_TRAP(!inet->num || icsk->icsk_bind_hash);
330 sk->sk_error_report(sk);
334 EXPORT_SYMBOL_GPL(dccp_disconnect);
337 * Wait for a DCCP event.
339 * Note that we don't need to lock the socket, as the upper poll layers
340 * take care of normal races (between the test and the event) and we don't
341 * go look at any of the socket buffers directly.
343 unsigned int dccp_poll(struct file *file, struct socket *sock,
347 struct sock *sk = sock->sk;
349 poll_wait(file, sk->sk_sleep, wait);
350 if (sk->sk_state == DCCP_LISTEN)
351 return inet_csk_listen_poll(sk);
353 /* Socket is not locked. We are protected from async events
354 by poll logic and correct handling of state changes
355 made by another threads is impossible in any case.
362 if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
364 if (sk->sk_shutdown & RCV_SHUTDOWN)
365 mask |= POLLIN | POLLRDNORM | POLLRDHUP;
368 if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
369 if (atomic_read(&sk->sk_rmem_alloc) > 0)
370 mask |= POLLIN | POLLRDNORM;
372 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
373 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
374 mask |= POLLOUT | POLLWRNORM;
375 } else { /* send SIGIO later */
376 set_bit(SOCK_ASYNC_NOSPACE,
377 &sk->sk_socket->flags);
378 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
380 /* Race breaker. If space is freed after
381 * wspace test but before the flags are set,
382 * IO signal will be lost.
384 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
385 mask |= POLLOUT | POLLWRNORM;
392 EXPORT_SYMBOL_GPL(dccp_poll);
394 int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
400 if (sk->sk_state == DCCP_LISTEN)
406 unsigned long amount = 0;
408 skb = skb_peek(&sk->sk_receive_queue);
411 * We will only return the amount of this packet since
412 * that is all that will be read.
416 rc = put_user(amount, (int __user *)arg);
428 EXPORT_SYMBOL_GPL(dccp_ioctl);
430 static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
431 char __user *optval, int optlen)
433 struct dccp_sock *dp = dccp_sk(sk);
434 struct dccp_service_list *sl = NULL;
436 if (service == DCCP_SERVICE_INVALID_VALUE ||
437 optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
440 if (optlen > sizeof(service)) {
441 sl = kmalloc(optlen, GFP_KERNEL);
445 sl->dccpsl_nr = optlen / sizeof(u32) - 1;
446 if (copy_from_user(sl->dccpsl_list,
447 optval + sizeof(service),
448 optlen - sizeof(service)) ||
449 dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
456 dp->dccps_service = service;
458 kfree(dp->dccps_service_list);
460 dp->dccps_service_list = sl;
465 /* byte 1 is feature. the rest is the preference list */
466 static int dccp_setsockopt_change(struct sock *sk, int type,
467 struct dccp_so_feat __user *optval)
469 struct dccp_so_feat opt;
473 if (copy_from_user(&opt, optval, sizeof(opt)))
476 val = kmalloc(opt.dccpsf_len, GFP_KERNEL);
480 if (copy_from_user(val, opt.dccpsf_val, opt.dccpsf_len)) {
485 rc = dccp_feat_change(dccp_msk(sk), type, opt.dccpsf_feat,
486 val, opt.dccpsf_len, GFP_KERNEL);
498 static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
499 char __user *optval, int optlen)
501 struct dccp_sock *dp = dccp_sk(sk);
504 if (optlen < sizeof(int))
507 if (get_user(val, (int __user *)optval))
510 if (optname == DCCP_SOCKOPT_SERVICE)
511 return dccp_setsockopt_service(sk, val, optval, optlen);
515 case DCCP_SOCKOPT_PACKET_SIZE:
516 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
519 case DCCP_SOCKOPT_CHANGE_L:
520 if (optlen != sizeof(struct dccp_so_feat))
523 err = dccp_setsockopt_change(sk, DCCPO_CHANGE_L,
524 (struct dccp_so_feat __user *)
527 case DCCP_SOCKOPT_CHANGE_R:
528 if (optlen != sizeof(struct dccp_so_feat))
531 err = dccp_setsockopt_change(sk, DCCPO_CHANGE_R,
532 (struct dccp_so_feat __user *)
535 case DCCP_SOCKOPT_SEND_CSCOV: /* sender side, RFC 4340, sec. 9.2 */
536 if (val < 0 || val > 15)
539 dp->dccps_pcslen = val;
541 case DCCP_SOCKOPT_RECV_CSCOV: /* receiver side, RFC 4340 sec. 9.2.1 */
542 if (val < 0 || val > 15)
545 dp->dccps_pcrlen = val;
546 /* FIXME: add feature negotiation,
547 * ChangeL(MinimumChecksumCoverage, val) */
559 int dccp_setsockopt(struct sock *sk, int level, int optname,
560 char __user *optval, int optlen)
562 if (level != SOL_DCCP)
563 return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
566 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
569 EXPORT_SYMBOL_GPL(dccp_setsockopt);
572 int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
573 char __user *optval, int optlen)
575 if (level != SOL_DCCP)
576 return inet_csk_compat_setsockopt(sk, level, optname,
578 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
581 EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
584 static int dccp_getsockopt_service(struct sock *sk, int len,
585 __be32 __user *optval,
588 const struct dccp_sock *dp = dccp_sk(sk);
589 const struct dccp_service_list *sl;
590 int err = -ENOENT, slen = 0, total_len = sizeof(u32);
593 if ((sl = dp->dccps_service_list) != NULL) {
594 slen = sl->dccpsl_nr * sizeof(u32);
603 if (put_user(total_len, optlen) ||
604 put_user(dp->dccps_service, optval) ||
605 (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
612 static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
613 char __user *optval, int __user *optlen)
615 struct dccp_sock *dp;
618 if (get_user(len, optlen))
621 if (len < (int)sizeof(int))
627 case DCCP_SOCKOPT_PACKET_SIZE:
628 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
630 case DCCP_SOCKOPT_SERVICE:
631 return dccp_getsockopt_service(sk, len,
632 (__be32 __user *)optval, optlen);
633 case DCCP_SOCKOPT_GET_CUR_MPS:
634 val = dp->dccps_mss_cache;
637 case DCCP_SOCKOPT_SEND_CSCOV:
638 val = dp->dccps_pcslen;
641 case DCCP_SOCKOPT_RECV_CSCOV:
642 val = dp->dccps_pcrlen;
646 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
647 len, (u32 __user *)optval, optlen);
649 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
650 len, (u32 __user *)optval, optlen);
655 if (put_user(len, optlen) || copy_to_user(optval, &val, len))
661 int dccp_getsockopt(struct sock *sk, int level, int optname,
662 char __user *optval, int __user *optlen)
664 if (level != SOL_DCCP)
665 return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
668 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
671 EXPORT_SYMBOL_GPL(dccp_getsockopt);
674 int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
675 char __user *optval, int __user *optlen)
677 if (level != SOL_DCCP)
678 return inet_csk_compat_getsockopt(sk, level, optname,
680 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
683 EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
686 int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
689 const struct dccp_sock *dp = dccp_sk(sk);
690 const int flags = msg->msg_flags;
691 const int noblock = flags & MSG_DONTWAIT;
696 if (len > dp->dccps_mss_cache)
701 if (sysctl_dccp_tx_qlen &&
702 (sk->sk_write_queue.qlen >= sysctl_dccp_tx_qlen)) {
707 timeo = sock_sndtimeo(sk, noblock);
710 * We have to use sk_stream_wait_connect here to set sk_write_pending,
711 * so that the trick in dccp_rcv_request_sent_state_process.
713 /* Wait for a connection to finish. */
714 if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
715 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
718 size = sk->sk_prot->max_header + len;
720 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
725 skb_reserve(skb, sk->sk_prot->max_header);
726 rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
730 skb_queue_tail(&sk->sk_write_queue, skb);
731 dccp_write_xmit(sk,0);
740 EXPORT_SYMBOL_GPL(dccp_sendmsg);
742 int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
743 size_t len, int nonblock, int flags, int *addr_len)
745 const struct dccp_hdr *dh;
750 if (sk->sk_state == DCCP_LISTEN) {
755 timeo = sock_rcvtimeo(sk, nonblock);
758 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
761 goto verify_sock_status;
765 if (dh->dccph_type == DCCP_PKT_DATA ||
766 dh->dccph_type == DCCP_PKT_DATAACK)
769 if (dh->dccph_type == DCCP_PKT_RESET ||
770 dh->dccph_type == DCCP_PKT_CLOSE) {
771 dccp_pr_debug("found fin ok!\n");
775 dccp_pr_debug("packet_type=%s\n",
776 dccp_packet_name(dh->dccph_type));
777 sk_eat_skb(sk, skb, 0);
779 if (sock_flag(sk, SOCK_DONE)) {
785 len = sock_error(sk);
789 if (sk->sk_shutdown & RCV_SHUTDOWN) {
794 if (sk->sk_state == DCCP_CLOSED) {
795 if (!sock_flag(sk, SOCK_DONE)) {
796 /* This occurs when user tries to read
797 * from never connected socket.
811 if (signal_pending(current)) {
812 len = sock_intr_errno(timeo);
816 sk_wait_data(sk, &timeo);
821 else if (len < skb->len)
822 msg->msg_flags |= MSG_TRUNC;
824 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) {
825 /* Exception. Bailout! */
830 if (!(flags & MSG_PEEK))
831 sk_eat_skb(sk, skb, 0);
839 EXPORT_SYMBOL_GPL(dccp_recvmsg);
841 int inet_dccp_listen(struct socket *sock, int backlog)
843 struct sock *sk = sock->sk;
844 unsigned char old_state;
850 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
853 old_state = sk->sk_state;
854 if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
857 /* Really, if the socket is already in listen state
858 * we can only allow the backlog to be adjusted.
860 if (old_state != DCCP_LISTEN) {
862 * FIXME: here it probably should be sk->sk_prot->listen_start
863 * see tcp_listen_start
865 err = dccp_listen_start(sk, backlog);
869 sk->sk_max_ack_backlog = backlog;
877 EXPORT_SYMBOL_GPL(inet_dccp_listen);
879 static const unsigned char dccp_new_state[] = {
880 /* current state: new state: action: */
882 [DCCP_OPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
883 [DCCP_REQUESTING] = DCCP_CLOSED,
884 [DCCP_PARTOPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
885 [DCCP_LISTEN] = DCCP_CLOSED,
886 [DCCP_RESPOND] = DCCP_CLOSED,
887 [DCCP_CLOSING] = DCCP_CLOSED,
888 [DCCP_TIME_WAIT] = DCCP_CLOSED,
889 [DCCP_CLOSED] = DCCP_CLOSED,
892 static int dccp_close_state(struct sock *sk)
894 const int next = dccp_new_state[sk->sk_state];
895 const int ns = next & DCCP_STATE_MASK;
897 if (ns != sk->sk_state)
898 dccp_set_state(sk, ns);
900 return next & DCCP_ACTION_FIN;
903 void dccp_close(struct sock *sk, long timeout)
905 struct dccp_sock *dp = dccp_sk(sk);
907 u32 data_was_unread = 0;
912 sk->sk_shutdown = SHUTDOWN_MASK;
914 if (sk->sk_state == DCCP_LISTEN) {
915 dccp_set_state(sk, DCCP_CLOSED);
918 inet_csk_listen_stop(sk);
920 goto adjudge_to_death;
923 sk_stop_timer(sk, &dp->dccps_xmit_timer);
926 * We need to flush the recv. buffs. We do this only on the
927 * descriptor close, not protocol-sourced closes, because the
928 *reader process may not have drained the data yet!
930 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
931 data_was_unread += skb->len;
935 if (data_was_unread) {
936 /* Unread data was tossed, send an appropriate Reset Code */
937 DCCP_WARN("DCCP: ABORT -- %u bytes unread\n", data_was_unread);
938 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
939 dccp_set_state(sk, DCCP_CLOSED);
940 } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
941 /* Check zero linger _after_ checking for unread data. */
942 sk->sk_prot->disconnect(sk, 0);
943 } else if (dccp_close_state(sk)) {
944 dccp_send_close(sk, 1);
947 sk_stream_wait_close(sk, timeout);
950 state = sk->sk_state;
953 atomic_inc(sk->sk_prot->orphan_count);
956 * It is the last release_sock in its life. It will remove backlog.
960 * Now socket is owned by kernel and we acquire BH lock
961 * to finish close. No need to check for user refs.
965 BUG_TRAP(!sock_owned_by_user(sk));
967 /* Have we already been destroyed by a softirq or backlog? */
968 if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
972 * The last release_sock may have processed the CLOSE or RESET
973 * packet moving sock to CLOSED state, if not we have to fire
974 * the CLOSE/CLOSEREQ retransmission timer, see "8.3. Termination"
975 * in draft-ietf-dccp-spec-11. -acme
977 if (sk->sk_state == DCCP_CLOSING) {
978 /* FIXME: should start at 2 * RTT */
979 /* Timer for repeating the CLOSE/CLOSEREQ until an answer. */
980 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
981 inet_csk(sk)->icsk_rto,
984 /* Yeah, we should use sk->sk_prot->orphan_count, etc */
985 dccp_set_state(sk, DCCP_CLOSED);
989 if (sk->sk_state == DCCP_CLOSED)
990 inet_csk_destroy_sock(sk);
992 /* Otherwise, socket is reprieved until protocol close. */
1000 EXPORT_SYMBOL_GPL(dccp_close);
1002 void dccp_shutdown(struct sock *sk, int how)
1004 dccp_pr_debug("called shutdown(%x)\n", how);
1007 EXPORT_SYMBOL_GPL(dccp_shutdown);
1009 static int __init dccp_mib_init(void)
1013 dccp_statistics[0] = alloc_percpu(struct dccp_mib);
1014 if (dccp_statistics[0] == NULL)
1017 dccp_statistics[1] = alloc_percpu(struct dccp_mib);
1018 if (dccp_statistics[1] == NULL)
1025 free_percpu(dccp_statistics[0]);
1026 dccp_statistics[0] = NULL;
1031 static void dccp_mib_exit(void)
1033 free_percpu(dccp_statistics[0]);
1034 free_percpu(dccp_statistics[1]);
1035 dccp_statistics[0] = dccp_statistics[1] = NULL;
1038 static int thash_entries;
1039 module_param(thash_entries, int, 0444);
1040 MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
1042 #ifdef CONFIG_IP_DCCP_DEBUG
1044 module_param(dccp_debug, bool, 0444);
1045 MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
1047 EXPORT_SYMBOL_GPL(dccp_debug);
1050 static int __init dccp_init(void)
1053 int ehash_order, bhash_order, i;
1056 dccp_hashinfo.bind_bucket_cachep =
1057 kmem_cache_create("dccp_bind_bucket",
1058 sizeof(struct inet_bind_bucket), 0,
1059 SLAB_HWCACHE_ALIGN, NULL);
1060 if (!dccp_hashinfo.bind_bucket_cachep)
1064 * Size and allocate the main established and bind bucket
1067 * The methodology is similar to that of the buffer cache.
1069 if (num_physpages >= (128 * 1024))
1070 goal = num_physpages >> (21 - PAGE_SHIFT);
1072 goal = num_physpages >> (23 - PAGE_SHIFT);
1075 goal = (thash_entries *
1076 sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
1077 for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
1080 dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE /
1081 sizeof(struct inet_ehash_bucket);
1082 while (dccp_hashinfo.ehash_size &
1083 (dccp_hashinfo.ehash_size - 1))
1084 dccp_hashinfo.ehash_size--;
1085 dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
1086 __get_free_pages(GFP_ATOMIC, ehash_order);
1087 } while (!dccp_hashinfo.ehash && --ehash_order > 0);
1089 if (!dccp_hashinfo.ehash) {
1090 DCCP_CRIT("Failed to allocate DCCP established hash table");
1091 goto out_free_bind_bucket_cachep;
1094 for (i = 0; i < dccp_hashinfo.ehash_size; i++) {
1095 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain);
1096 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].twchain);
1099 if (inet_ehash_locks_alloc(&dccp_hashinfo))
1100 goto out_free_dccp_ehash;
1102 bhash_order = ehash_order;
1105 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
1106 sizeof(struct inet_bind_hashbucket);
1107 if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
1110 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
1111 __get_free_pages(GFP_ATOMIC, bhash_order);
1112 } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
1114 if (!dccp_hashinfo.bhash) {
1115 DCCP_CRIT("Failed to allocate DCCP bind hash table");
1116 goto out_free_dccp_locks;
1119 for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
1120 spin_lock_init(&dccp_hashinfo.bhash[i].lock);
1121 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
1124 rc = dccp_mib_init();
1126 goto out_free_dccp_bhash;
1128 rc = dccp_ackvec_init();
1130 goto out_free_dccp_mib;
1132 rc = dccp_sysctl_init();
1134 goto out_ackvec_exit;
1136 dccp_timestamping_init();
1143 out_free_dccp_bhash:
1144 free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
1145 dccp_hashinfo.bhash = NULL;
1146 out_free_dccp_locks:
1147 inet_ehash_locks_free(&dccp_hashinfo);
1148 out_free_dccp_ehash:
1149 free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
1150 dccp_hashinfo.ehash = NULL;
1151 out_free_bind_bucket_cachep:
1152 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1153 dccp_hashinfo.bind_bucket_cachep = NULL;
1157 static void __exit dccp_fini(void)
1160 free_pages((unsigned long)dccp_hashinfo.bhash,
1161 get_order(dccp_hashinfo.bhash_size *
1162 sizeof(struct inet_bind_hashbucket)));
1163 free_pages((unsigned long)dccp_hashinfo.ehash,
1164 get_order(dccp_hashinfo.ehash_size *
1165 sizeof(struct inet_ehash_bucket)));
1166 inet_ehash_locks_free(&dccp_hashinfo);
1167 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1172 module_init(dccp_init);
1173 module_exit(dccp_fini);
1175 MODULE_LICENSE("GPL");
1176 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
1177 MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");