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 <linux/spinlock.h>
31 #include <linux/timer.h>
32 #include <linux/delay.h>
33 #include <linux/poll.h>
39 DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
41 EXPORT_SYMBOL_GPL(dccp_statistics);
43 atomic_t dccp_orphan_count = ATOMIC_INIT(0);
45 EXPORT_SYMBOL_GPL(dccp_orphan_count);
47 struct inet_hashinfo dccp_hashinfo;
48 EXPORT_SYMBOL_GPL(dccp_hashinfo);
50 /* the maximum queue length for tx in packets. 0 is no limit */
51 int sysctl_dccp_tx_qlen __read_mostly = 5;
53 void dccp_set_state(struct sock *sk, const int state)
55 const int oldstate = sk->sk_state;
57 dccp_pr_debug("%s(%p) %s --> %s\n", dccp_role(sk), sk,
58 dccp_state_name(oldstate), dccp_state_name(state));
59 WARN_ON(state == oldstate);
63 if (oldstate != DCCP_OPEN)
64 DCCP_INC_STATS(DCCP_MIB_CURRESTAB);
68 if (oldstate == DCCP_OPEN || oldstate == DCCP_ACTIVE_CLOSEREQ ||
69 oldstate == DCCP_CLOSING)
70 DCCP_INC_STATS(DCCP_MIB_ESTABRESETS);
72 sk->sk_prot->unhash(sk);
73 if (inet_csk(sk)->icsk_bind_hash != NULL &&
74 !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
78 if (oldstate == DCCP_OPEN)
79 DCCP_DEC_STATS(DCCP_MIB_CURRESTAB);
82 /* Change state AFTER socket is unhashed to avoid closed
83 * socket sitting in hash tables.
88 EXPORT_SYMBOL_GPL(dccp_set_state);
90 static void dccp_finish_passive_close(struct sock *sk)
92 switch (sk->sk_state) {
93 case DCCP_PASSIVE_CLOSE:
94 /* Node (client or server) has received Close packet. */
95 dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED);
96 dccp_set_state(sk, DCCP_CLOSED);
98 case DCCP_PASSIVE_CLOSEREQ:
100 * Client received CloseReq. We set the `active' flag so that
101 * dccp_send_close() retransmits the Close as per RFC 4340, 8.3.
103 dccp_send_close(sk, 1);
104 dccp_set_state(sk, DCCP_CLOSING);
108 void dccp_done(struct sock *sk)
110 dccp_set_state(sk, DCCP_CLOSED);
111 dccp_clear_xmit_timers(sk);
113 sk->sk_shutdown = SHUTDOWN_MASK;
115 if (!sock_flag(sk, SOCK_DEAD))
116 sk->sk_state_change(sk);
118 inet_csk_destroy_sock(sk);
121 EXPORT_SYMBOL_GPL(dccp_done);
123 const char *dccp_packet_name(const int type)
125 static const char *dccp_packet_names[] = {
126 [DCCP_PKT_REQUEST] = "REQUEST",
127 [DCCP_PKT_RESPONSE] = "RESPONSE",
128 [DCCP_PKT_DATA] = "DATA",
129 [DCCP_PKT_ACK] = "ACK",
130 [DCCP_PKT_DATAACK] = "DATAACK",
131 [DCCP_PKT_CLOSEREQ] = "CLOSEREQ",
132 [DCCP_PKT_CLOSE] = "CLOSE",
133 [DCCP_PKT_RESET] = "RESET",
134 [DCCP_PKT_SYNC] = "SYNC",
135 [DCCP_PKT_SYNCACK] = "SYNCACK",
138 if (type >= DCCP_NR_PKT_TYPES)
141 return dccp_packet_names[type];
144 EXPORT_SYMBOL_GPL(dccp_packet_name);
146 const char *dccp_state_name(const int state)
148 static char *dccp_state_names[] = {
149 [DCCP_OPEN] = "OPEN",
150 [DCCP_REQUESTING] = "REQUESTING",
151 [DCCP_PARTOPEN] = "PARTOPEN",
152 [DCCP_LISTEN] = "LISTEN",
153 [DCCP_RESPOND] = "RESPOND",
154 [DCCP_CLOSING] = "CLOSING",
155 [DCCP_ACTIVE_CLOSEREQ] = "CLOSEREQ",
156 [DCCP_PASSIVE_CLOSE] = "PASSIVE_CLOSE",
157 [DCCP_PASSIVE_CLOSEREQ] = "PASSIVE_CLOSEREQ",
158 [DCCP_TIME_WAIT] = "TIME_WAIT",
159 [DCCP_CLOSED] = "CLOSED",
162 if (state >= DCCP_MAX_STATES)
163 return "INVALID STATE!";
165 return dccp_state_names[state];
168 EXPORT_SYMBOL_GPL(dccp_state_name);
170 int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
172 struct dccp_sock *dp = dccp_sk(sk);
173 struct dccp_minisock *dmsk = dccp_msk(sk);
174 struct inet_connection_sock *icsk = inet_csk(sk);
176 dccp_minisock_init(&dp->dccps_minisock);
178 icsk->icsk_rto = DCCP_TIMEOUT_INIT;
179 icsk->icsk_syn_retries = sysctl_dccp_request_retries;
180 sk->sk_state = DCCP_CLOSED;
181 sk->sk_write_space = dccp_write_space;
182 icsk->icsk_sync_mss = dccp_sync_mss;
183 dp->dccps_mss_cache = 536;
184 dp->dccps_rate_last = jiffies;
185 dp->dccps_role = DCCP_ROLE_UNDEFINED;
186 dp->dccps_service = DCCP_SERVICE_CODE_IS_ABSENT;
187 dp->dccps_l_ack_ratio = dp->dccps_r_ack_ratio = 1;
189 dccp_init_xmit_timers(sk);
191 INIT_LIST_HEAD(&dp->dccps_featneg);
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(sk);
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 void 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)
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_list_purge(&dp->dccps_featneg);
269 EXPORT_SYMBOL_GPL(dccp_destroy_sock);
271 static inline int dccp_listen_start(struct sock *sk, int backlog)
273 struct dccp_sock *dp = dccp_sk(sk);
275 dp->dccps_role = DCCP_ROLE_LISTEN;
276 /* do not start to listen if feature negotiation setup fails */
277 if (dccp_feat_finalise_settings(dp))
279 return inet_csk_listen_start(sk, backlog);
282 static inline int dccp_need_reset(int state)
284 return state != DCCP_CLOSED && state != DCCP_LISTEN &&
285 state != DCCP_REQUESTING;
288 int dccp_disconnect(struct sock *sk, int flags)
290 struct inet_connection_sock *icsk = inet_csk(sk);
291 struct inet_sock *inet = inet_sk(sk);
293 const int old_state = sk->sk_state;
295 if (old_state != DCCP_CLOSED)
296 dccp_set_state(sk, DCCP_CLOSED);
299 * This corresponds to the ABORT function of RFC793, sec. 3.8
300 * TCP uses a RST segment, DCCP a Reset packet with Code 2, "Aborted".
302 if (old_state == DCCP_LISTEN) {
303 inet_csk_listen_stop(sk);
304 } else if (dccp_need_reset(old_state)) {
305 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
306 sk->sk_err = ECONNRESET;
307 } else if (old_state == DCCP_REQUESTING)
308 sk->sk_err = ECONNRESET;
310 dccp_clear_xmit_timers(sk);
312 __skb_queue_purge(&sk->sk_receive_queue);
313 __skb_queue_purge(&sk->sk_write_queue);
314 if (sk->sk_send_head != NULL) {
315 __kfree_skb(sk->sk_send_head);
316 sk->sk_send_head = NULL;
321 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
322 inet_reset_saddr(sk);
325 sock_reset_flag(sk, SOCK_DONE);
327 icsk->icsk_backoff = 0;
328 inet_csk_delack_init(sk);
331 WARN_ON(inet->num && !icsk->icsk_bind_hash);
333 sk->sk_error_report(sk);
337 EXPORT_SYMBOL_GPL(dccp_disconnect);
340 * Wait for a DCCP event.
342 * Note that we don't need to lock the socket, as the upper poll layers
343 * take care of normal races (between the test and the event) and we don't
344 * go look at any of the socket buffers directly.
346 unsigned int dccp_poll(struct file *file, struct socket *sock,
350 struct sock *sk = sock->sk;
352 poll_wait(file, sk->sk_sleep, wait);
353 if (sk->sk_state == DCCP_LISTEN)
354 return inet_csk_listen_poll(sk);
356 /* Socket is not locked. We are protected from async events
357 by poll logic and correct handling of state changes
358 made by another threads is impossible in any case.
365 if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
367 if (sk->sk_shutdown & RCV_SHUTDOWN)
368 mask |= POLLIN | POLLRDNORM | POLLRDHUP;
371 if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
372 if (atomic_read(&sk->sk_rmem_alloc) > 0)
373 mask |= POLLIN | POLLRDNORM;
375 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
376 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
377 mask |= POLLOUT | POLLWRNORM;
378 } else { /* send SIGIO later */
379 set_bit(SOCK_ASYNC_NOSPACE,
380 &sk->sk_socket->flags);
381 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
383 /* Race breaker. If space is freed after
384 * wspace test but before the flags are set,
385 * IO signal will be lost.
387 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
388 mask |= POLLOUT | POLLWRNORM;
395 EXPORT_SYMBOL_GPL(dccp_poll);
397 int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
403 if (sk->sk_state == DCCP_LISTEN)
409 unsigned long amount = 0;
411 skb = skb_peek(&sk->sk_receive_queue);
414 * We will only return the amount of this packet since
415 * that is all that will be read.
419 rc = put_user(amount, (int __user *)arg);
431 EXPORT_SYMBOL_GPL(dccp_ioctl);
433 static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
434 char __user *optval, int optlen)
436 struct dccp_sock *dp = dccp_sk(sk);
437 struct dccp_service_list *sl = NULL;
439 if (service == DCCP_SERVICE_INVALID_VALUE ||
440 optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
443 if (optlen > sizeof(service)) {
444 sl = kmalloc(optlen, GFP_KERNEL);
448 sl->dccpsl_nr = optlen / sizeof(u32) - 1;
449 if (copy_from_user(sl->dccpsl_list,
450 optval + sizeof(service),
451 optlen - sizeof(service)) ||
452 dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
459 dp->dccps_service = service;
461 kfree(dp->dccps_service_list);
463 dp->dccps_service_list = sl;
468 static int dccp_setsockopt_cscov(struct sock *sk, int cscov, bool rx)
473 if (cscov < 0 || cscov > 15)
476 * Populate a list of permissible values, in the range cscov...15. This
477 * is necessary since feature negotiation of single values only works if
478 * both sides incidentally choose the same value. Since the list starts
479 * lowest-value first, negotiation will pick the smallest shared value.
485 list = kmalloc(len, GFP_KERNEL);
489 for (i = 0; i < len; i++)
492 rc = dccp_feat_register_sp(sk, DCCPF_MIN_CSUM_COVER, rx, list, len);
496 dccp_sk(sk)->dccps_pcrlen = cscov;
498 dccp_sk(sk)->dccps_pcslen = cscov;
504 static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
505 char __user *optval, int optlen)
507 struct dccp_sock *dp = dccp_sk(sk);
511 case DCCP_SOCKOPT_PACKET_SIZE:
512 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
514 case DCCP_SOCKOPT_CHANGE_L:
515 case DCCP_SOCKOPT_CHANGE_R:
516 DCCP_WARN("sockopt(CHANGE_L/R) is deprecated: fix your app\n");
520 if (optlen < (int)sizeof(int))
523 if (get_user(val, (int __user *)optval))
526 if (optname == DCCP_SOCKOPT_SERVICE)
527 return dccp_setsockopt_service(sk, val, optval, optlen);
531 case DCCP_SOCKOPT_SERVER_TIMEWAIT:
532 if (dp->dccps_role != DCCP_ROLE_SERVER)
535 dp->dccps_server_timewait = (val != 0);
537 case DCCP_SOCKOPT_SEND_CSCOV:
538 err = dccp_setsockopt_cscov(sk, val, false);
540 case DCCP_SOCKOPT_RECV_CSCOV:
541 err = dccp_setsockopt_cscov(sk, val, true);
552 int dccp_setsockopt(struct sock *sk, int level, int optname,
553 char __user *optval, int optlen)
555 if (level != SOL_DCCP)
556 return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
559 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
562 EXPORT_SYMBOL_GPL(dccp_setsockopt);
565 int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
566 char __user *optval, int optlen)
568 if (level != SOL_DCCP)
569 return inet_csk_compat_setsockopt(sk, level, optname,
571 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
574 EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
577 static int dccp_getsockopt_service(struct sock *sk, int len,
578 __be32 __user *optval,
581 const struct dccp_sock *dp = dccp_sk(sk);
582 const struct dccp_service_list *sl;
583 int err = -ENOENT, slen = 0, total_len = sizeof(u32);
586 if ((sl = dp->dccps_service_list) != NULL) {
587 slen = sl->dccpsl_nr * sizeof(u32);
596 if (put_user(total_len, optlen) ||
597 put_user(dp->dccps_service, optval) ||
598 (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
605 static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
606 char __user *optval, int __user *optlen)
608 struct dccp_sock *dp;
611 if (get_user(len, optlen))
614 if (len < (int)sizeof(int))
620 case DCCP_SOCKOPT_PACKET_SIZE:
621 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
623 case DCCP_SOCKOPT_SERVICE:
624 return dccp_getsockopt_service(sk, len,
625 (__be32 __user *)optval, optlen);
626 case DCCP_SOCKOPT_GET_CUR_MPS:
627 val = dp->dccps_mss_cache;
629 case DCCP_SOCKOPT_AVAILABLE_CCIDS:
630 return ccid_getsockopt_builtin_ccids(sk, len, optval, optlen);
631 case DCCP_SOCKOPT_SERVER_TIMEWAIT:
632 val = dp->dccps_server_timewait;
634 case DCCP_SOCKOPT_SEND_CSCOV:
635 val = dp->dccps_pcslen;
637 case DCCP_SOCKOPT_RECV_CSCOV:
638 val = dp->dccps_pcrlen;
641 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
642 len, (u32 __user *)optval, optlen);
644 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
645 len, (u32 __user *)optval, optlen);
651 if (put_user(len, optlen) || copy_to_user(optval, &val, len))
657 int dccp_getsockopt(struct sock *sk, int level, int optname,
658 char __user *optval, int __user *optlen)
660 if (level != SOL_DCCP)
661 return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
664 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
667 EXPORT_SYMBOL_GPL(dccp_getsockopt);
670 int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
671 char __user *optval, int __user *optlen)
673 if (level != SOL_DCCP)
674 return inet_csk_compat_getsockopt(sk, level, optname,
676 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
679 EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
682 int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
685 const struct dccp_sock *dp = dccp_sk(sk);
686 const int flags = msg->msg_flags;
687 const int noblock = flags & MSG_DONTWAIT;
692 if (len > dp->dccps_mss_cache)
697 if (sysctl_dccp_tx_qlen &&
698 (sk->sk_write_queue.qlen >= sysctl_dccp_tx_qlen)) {
703 timeo = sock_sndtimeo(sk, noblock);
706 * We have to use sk_stream_wait_connect here to set sk_write_pending,
707 * so that the trick in dccp_rcv_request_sent_state_process.
709 /* Wait for a connection to finish. */
710 if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
711 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
714 size = sk->sk_prot->max_header + len;
716 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
721 skb_reserve(skb, sk->sk_prot->max_header);
722 rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
726 skb_queue_tail(&sk->sk_write_queue, skb);
727 dccp_write_xmit(sk,0);
736 EXPORT_SYMBOL_GPL(dccp_sendmsg);
738 int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
739 size_t len, int nonblock, int flags, int *addr_len)
741 const struct dccp_hdr *dh;
746 if (sk->sk_state == DCCP_LISTEN) {
751 timeo = sock_rcvtimeo(sk, nonblock);
754 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
757 goto verify_sock_status;
761 switch (dh->dccph_type) {
763 case DCCP_PKT_DATAACK:
767 case DCCP_PKT_CLOSEREQ:
768 if (!(flags & MSG_PEEK))
769 dccp_finish_passive_close(sk);
772 dccp_pr_debug("found fin (%s) ok!\n",
773 dccp_packet_name(dh->dccph_type));
777 dccp_pr_debug("packet_type=%s\n",
778 dccp_packet_name(dh->dccph_type));
779 sk_eat_skb(sk, skb, 0);
782 if (sock_flag(sk, SOCK_DONE)) {
788 len = sock_error(sk);
792 if (sk->sk_shutdown & RCV_SHUTDOWN) {
797 if (sk->sk_state == DCCP_CLOSED) {
798 if (!sock_flag(sk, SOCK_DONE)) {
799 /* This occurs when user tries to read
800 * from never connected socket.
814 if (signal_pending(current)) {
815 len = sock_intr_errno(timeo);
819 sk_wait_data(sk, &timeo);
824 else if (len < skb->len)
825 msg->msg_flags |= MSG_TRUNC;
827 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) {
828 /* Exception. Bailout! */
833 if (!(flags & MSG_PEEK))
834 sk_eat_skb(sk, skb, 0);
842 EXPORT_SYMBOL_GPL(dccp_recvmsg);
844 int inet_dccp_listen(struct socket *sock, int backlog)
846 struct sock *sk = sock->sk;
847 unsigned char old_state;
853 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
856 old_state = sk->sk_state;
857 if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
860 /* Really, if the socket is already in listen state
861 * we can only allow the backlog to be adjusted.
863 if (old_state != DCCP_LISTEN) {
865 * FIXME: here it probably should be sk->sk_prot->listen_start
866 * see tcp_listen_start
868 err = dccp_listen_start(sk, backlog);
872 sk->sk_max_ack_backlog = backlog;
880 EXPORT_SYMBOL_GPL(inet_dccp_listen);
882 static void dccp_terminate_connection(struct sock *sk)
884 u8 next_state = DCCP_CLOSED;
886 switch (sk->sk_state) {
887 case DCCP_PASSIVE_CLOSE:
888 case DCCP_PASSIVE_CLOSEREQ:
889 dccp_finish_passive_close(sk);
892 dccp_pr_debug("Stop PARTOPEN timer (%p)\n", sk);
893 inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
896 dccp_send_close(sk, 1);
898 if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER &&
899 !dccp_sk(sk)->dccps_server_timewait)
900 next_state = DCCP_ACTIVE_CLOSEREQ;
902 next_state = DCCP_CLOSING;
905 dccp_set_state(sk, next_state);
909 void dccp_close(struct sock *sk, long timeout)
911 struct dccp_sock *dp = dccp_sk(sk);
913 u32 data_was_unread = 0;
918 sk->sk_shutdown = SHUTDOWN_MASK;
920 if (sk->sk_state == DCCP_LISTEN) {
921 dccp_set_state(sk, DCCP_CLOSED);
924 inet_csk_listen_stop(sk);
926 goto adjudge_to_death;
929 sk_stop_timer(sk, &dp->dccps_xmit_timer);
932 * We need to flush the recv. buffs. We do this only on the
933 * descriptor close, not protocol-sourced closes, because the
934 *reader process may not have drained the data yet!
936 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
937 data_was_unread += skb->len;
941 if (data_was_unread) {
942 /* Unread data was tossed, send an appropriate Reset Code */
943 DCCP_WARN("DCCP: ABORT -- %u bytes unread\n", data_was_unread);
944 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
945 dccp_set_state(sk, DCCP_CLOSED);
946 } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
947 /* Check zero linger _after_ checking for unread data. */
948 sk->sk_prot->disconnect(sk, 0);
949 } else if (sk->sk_state != DCCP_CLOSED) {
950 dccp_terminate_connection(sk);
953 sk_stream_wait_close(sk, timeout);
956 state = sk->sk_state;
959 atomic_inc(sk->sk_prot->orphan_count);
962 * It is the last release_sock in its life. It will remove backlog.
966 * Now socket is owned by kernel and we acquire BH lock
967 * to finish close. No need to check for user refs.
971 WARN_ON(sock_owned_by_user(sk));
973 /* Have we already been destroyed by a softirq or backlog? */
974 if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
977 if (sk->sk_state == DCCP_CLOSED)
978 inet_csk_destroy_sock(sk);
980 /* Otherwise, socket is reprieved until protocol close. */
988 EXPORT_SYMBOL_GPL(dccp_close);
990 void dccp_shutdown(struct sock *sk, int how)
992 dccp_pr_debug("called shutdown(%x)\n", how);
995 EXPORT_SYMBOL_GPL(dccp_shutdown);
997 static inline int dccp_mib_init(void)
999 return snmp_mib_init((void**)dccp_statistics, sizeof(struct dccp_mib));
1002 static inline void dccp_mib_exit(void)
1004 snmp_mib_free((void**)dccp_statistics);
1007 static int thash_entries;
1008 module_param(thash_entries, int, 0444);
1009 MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
1011 #ifdef CONFIG_IP_DCCP_DEBUG
1013 module_param(dccp_debug, bool, 0644);
1014 MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
1016 EXPORT_SYMBOL_GPL(dccp_debug);
1019 static int __init dccp_init(void)
1022 int ehash_order, bhash_order, i;
1025 BUILD_BUG_ON(sizeof(struct dccp_skb_cb) >
1026 FIELD_SIZEOF(struct sk_buff, cb));
1028 inet_hashinfo_init(&dccp_hashinfo);
1029 dccp_hashinfo.bind_bucket_cachep =
1030 kmem_cache_create("dccp_bind_bucket",
1031 sizeof(struct inet_bind_bucket), 0,
1032 SLAB_HWCACHE_ALIGN, NULL);
1033 if (!dccp_hashinfo.bind_bucket_cachep)
1037 * Size and allocate the main established and bind bucket
1040 * The methodology is similar to that of the buffer cache.
1042 if (num_physpages >= (128 * 1024))
1043 goal = num_physpages >> (21 - PAGE_SHIFT);
1045 goal = num_physpages >> (23 - PAGE_SHIFT);
1048 goal = (thash_entries *
1049 sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
1050 for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
1053 dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE /
1054 sizeof(struct inet_ehash_bucket);
1055 while (dccp_hashinfo.ehash_size &
1056 (dccp_hashinfo.ehash_size - 1))
1057 dccp_hashinfo.ehash_size--;
1058 dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
1059 __get_free_pages(GFP_ATOMIC, ehash_order);
1060 } while (!dccp_hashinfo.ehash && --ehash_order > 0);
1062 if (!dccp_hashinfo.ehash) {
1063 DCCP_CRIT("Failed to allocate DCCP established hash table");
1064 goto out_free_bind_bucket_cachep;
1067 for (i = 0; i < dccp_hashinfo.ehash_size; i++) {
1068 INIT_HLIST_NULLS_HEAD(&dccp_hashinfo.ehash[i].chain, i);
1069 INIT_HLIST_NULLS_HEAD(&dccp_hashinfo.ehash[i].twchain, i);
1072 if (inet_ehash_locks_alloc(&dccp_hashinfo))
1073 goto out_free_dccp_ehash;
1075 bhash_order = ehash_order;
1078 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
1079 sizeof(struct inet_bind_hashbucket);
1080 if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
1083 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
1084 __get_free_pages(GFP_ATOMIC, bhash_order);
1085 } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
1087 if (!dccp_hashinfo.bhash) {
1088 DCCP_CRIT("Failed to allocate DCCP bind hash table");
1089 goto out_free_dccp_locks;
1092 for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
1093 spin_lock_init(&dccp_hashinfo.bhash[i].lock);
1094 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
1097 rc = dccp_mib_init();
1099 goto out_free_dccp_bhash;
1101 rc = dccp_ackvec_init();
1103 goto out_free_dccp_mib;
1105 rc = dccp_sysctl_init();
1107 goto out_ackvec_exit;
1109 dccp_timestamping_init();
1116 out_free_dccp_bhash:
1117 free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
1118 dccp_hashinfo.bhash = NULL;
1119 out_free_dccp_locks:
1120 inet_ehash_locks_free(&dccp_hashinfo);
1121 out_free_dccp_ehash:
1122 free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
1123 dccp_hashinfo.ehash = NULL;
1124 out_free_bind_bucket_cachep:
1125 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1126 dccp_hashinfo.bind_bucket_cachep = NULL;
1130 static void __exit dccp_fini(void)
1133 free_pages((unsigned long)dccp_hashinfo.bhash,
1134 get_order(dccp_hashinfo.bhash_size *
1135 sizeof(struct inet_bind_hashbucket)));
1136 free_pages((unsigned long)dccp_hashinfo.ehash,
1137 get_order(dccp_hashinfo.ehash_size *
1138 sizeof(struct inet_ehash_bucket)));
1139 inet_ehash_locks_free(&dccp_hashinfo);
1140 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1145 module_init(dccp_init);
1146 module_exit(dccp_fini);
1148 MODULE_LICENSE("GPL");
1149 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
1150 MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");