]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - net/dccp/proto.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[DCCP] ipv4: make struct dccp_v4_prot static
[mirror_ubuntu-artful-kernel.git] / net / dccp / proto.c
1 /*
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
12 #include <linux/config.h>
13 #include <linux/dccp.h>
14 #include <linux/module.h>
15 #include <linux/types.h>
16 #include <linux/sched.h>
17 #include <linux/kernel.h>
18 #include <linux/skbuff.h>
19 #include <linux/netdevice.h>
20 #include <linux/in.h>
21 #include <linux/if_arp.h>
22 #include <linux/init.h>
23 #include <linux/random.h>
24 #include <net/checksum.h>
25
26 #include <net/inet_sock.h>
27 #include <net/sock.h>
28 #include <net/xfrm.h>
29
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>
35
36 #include "ccid.h"
37 #include "dccp.h"
38 #include "feat.h"
39
40 DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
41
42 EXPORT_SYMBOL_GPL(dccp_statistics);
43
44 atomic_t dccp_orphan_count = ATOMIC_INIT(0);
45
46 EXPORT_SYMBOL_GPL(dccp_orphan_count);
47
48 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),
52 };
53
54 EXPORT_SYMBOL_GPL(dccp_hashinfo);
55
56 const char *dccp_packet_name(const int type)
57 {
58 static const char *dccp_packet_names[] = {
59 [DCCP_PKT_REQUEST] = "REQUEST",
60 [DCCP_PKT_RESPONSE] = "RESPONSE",
61 [DCCP_PKT_DATA] = "DATA",
62 [DCCP_PKT_ACK] = "ACK",
63 [DCCP_PKT_DATAACK] = "DATAACK",
64 [DCCP_PKT_CLOSEREQ] = "CLOSEREQ",
65 [DCCP_PKT_CLOSE] = "CLOSE",
66 [DCCP_PKT_RESET] = "RESET",
67 [DCCP_PKT_SYNC] = "SYNC",
68 [DCCP_PKT_SYNCACK] = "SYNCACK",
69 };
70
71 if (type >= DCCP_NR_PKT_TYPES)
72 return "INVALID";
73 else
74 return dccp_packet_names[type];
75 }
76
77 EXPORT_SYMBOL_GPL(dccp_packet_name);
78
79 const char *dccp_state_name(const int state)
80 {
81 static char *dccp_state_names[] = {
82 [DCCP_OPEN] = "OPEN",
83 [DCCP_REQUESTING] = "REQUESTING",
84 [DCCP_PARTOPEN] = "PARTOPEN",
85 [DCCP_LISTEN] = "LISTEN",
86 [DCCP_RESPOND] = "RESPOND",
87 [DCCP_CLOSING] = "CLOSING",
88 [DCCP_TIME_WAIT] = "TIME_WAIT",
89 [DCCP_CLOSED] = "CLOSED",
90 };
91
92 if (state >= DCCP_MAX_STATES)
93 return "INVALID STATE!";
94 else
95 return dccp_state_names[state];
96 }
97
98 EXPORT_SYMBOL_GPL(dccp_state_name);
99
100 void dccp_hash(struct sock *sk)
101 {
102 inet_hash(&dccp_hashinfo, sk);
103 }
104
105 EXPORT_SYMBOL_GPL(dccp_hash);
106
107 void dccp_unhash(struct sock *sk)
108 {
109 inet_unhash(&dccp_hashinfo, sk);
110 }
111
112 EXPORT_SYMBOL_GPL(dccp_unhash);
113
114 int dccp_init_sock(struct sock *sk)
115 {
116 struct dccp_sock *dp = dccp_sk(sk);
117 struct inet_connection_sock *icsk = inet_csk(sk);
118 static int dccp_ctl_socket_init = 1;
119
120 dccp_options_init(&dp->dccps_options);
121 do_gettimeofday(&dp->dccps_epoch);
122
123 /*
124 * FIXME: We're hardcoding the CCID, and doing this at this point makes
125 * the listening (master) sock get CCID control blocks, which is not
126 * necessary, but for now, to not mess with the test userspace apps,
127 * lets leave it here, later the real solution is to do this in a
128 * setsockopt(CCIDs-I-want/accept). -acme
129 */
130 if (likely(!dccp_ctl_socket_init)) {
131 int rc = dccp_feat_init(sk);
132
133 if (rc)
134 return rc;
135
136 if (dp->dccps_options.dccpo_send_ack_vector) {
137 dp->dccps_hc_rx_ackvec = dccp_ackvec_alloc(GFP_KERNEL);
138 if (dp->dccps_hc_rx_ackvec == NULL)
139 return -ENOMEM;
140 }
141 dp->dccps_hc_rx_ccid =
142 ccid_hc_rx_new(dp->dccps_options.dccpo_rx_ccid,
143 sk, GFP_KERNEL);
144 dp->dccps_hc_tx_ccid =
145 ccid_hc_tx_new(dp->dccps_options.dccpo_tx_ccid,
146 sk, GFP_KERNEL);
147 if (unlikely(dp->dccps_hc_rx_ccid == NULL ||
148 dp->dccps_hc_tx_ccid == NULL)) {
149 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
150 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
151 if (dp->dccps_options.dccpo_send_ack_vector) {
152 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
153 dp->dccps_hc_rx_ackvec = NULL;
154 }
155 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
156 return -ENOMEM;
157 }
158 } else {
159 /* control socket doesn't need feat nego */
160 INIT_LIST_HEAD(&dp->dccps_options.dccpo_pending);
161 INIT_LIST_HEAD(&dp->dccps_options.dccpo_conf);
162 dccp_ctl_socket_init = 0;
163 }
164
165 dccp_init_xmit_timers(sk);
166 icsk->icsk_rto = DCCP_TIMEOUT_INIT;
167 sk->sk_state = DCCP_CLOSED;
168 sk->sk_write_space = dccp_write_space;
169 icsk->icsk_sync_mss = dccp_sync_mss;
170 dp->dccps_mss_cache = 536;
171 dp->dccps_role = DCCP_ROLE_UNDEFINED;
172 dp->dccps_service = DCCP_SERVICE_INVALID_VALUE;
173 dp->dccps_l_ack_ratio = dp->dccps_r_ack_ratio = 1;
174
175 return 0;
176 }
177
178 EXPORT_SYMBOL_GPL(dccp_init_sock);
179
180 int dccp_destroy_sock(struct sock *sk)
181 {
182 struct dccp_sock *dp = dccp_sk(sk);
183
184 /*
185 * DCCP doesn't use sk_write_queue, just sk_send_head
186 * for retransmissions
187 */
188 if (sk->sk_send_head != NULL) {
189 kfree_skb(sk->sk_send_head);
190 sk->sk_send_head = NULL;
191 }
192
193 /* Clean up a referenced DCCP bind bucket. */
194 if (inet_csk(sk)->icsk_bind_hash != NULL)
195 inet_put_port(&dccp_hashinfo, sk);
196
197 kfree(dp->dccps_service_list);
198 dp->dccps_service_list = NULL;
199
200 if (dp->dccps_options.dccpo_send_ack_vector) {
201 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
202 dp->dccps_hc_rx_ackvec = NULL;
203 }
204 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
205 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
206 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
207
208 /* clean up feature negotiation state */
209 dccp_feat_clean(sk);
210
211 return 0;
212 }
213
214 EXPORT_SYMBOL_GPL(dccp_destroy_sock);
215
216 static inline int dccp_listen_start(struct sock *sk)
217 {
218 struct dccp_sock *dp = dccp_sk(sk);
219
220 dp->dccps_role = DCCP_ROLE_LISTEN;
221 /*
222 * Apps need to use setsockopt(DCCP_SOCKOPT_SERVICE)
223 * before calling listen()
224 */
225 if (dccp_service_not_initialized(sk))
226 return -EPROTO;
227 return inet_csk_listen_start(sk, TCP_SYNQ_HSIZE);
228 }
229
230 int dccp_disconnect(struct sock *sk, int flags)
231 {
232 struct inet_connection_sock *icsk = inet_csk(sk);
233 struct inet_sock *inet = inet_sk(sk);
234 int err = 0;
235 const int old_state = sk->sk_state;
236
237 if (old_state != DCCP_CLOSED)
238 dccp_set_state(sk, DCCP_CLOSED);
239
240 /* ABORT function of RFC793 */
241 if (old_state == DCCP_LISTEN) {
242 inet_csk_listen_stop(sk);
243 /* FIXME: do the active reset thing */
244 } else if (old_state == DCCP_REQUESTING)
245 sk->sk_err = ECONNRESET;
246
247 dccp_clear_xmit_timers(sk);
248 __skb_queue_purge(&sk->sk_receive_queue);
249 if (sk->sk_send_head != NULL) {
250 __kfree_skb(sk->sk_send_head);
251 sk->sk_send_head = NULL;
252 }
253
254 inet->dport = 0;
255
256 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
257 inet_reset_saddr(sk);
258
259 sk->sk_shutdown = 0;
260 sock_reset_flag(sk, SOCK_DONE);
261
262 icsk->icsk_backoff = 0;
263 inet_csk_delack_init(sk);
264 __sk_dst_reset(sk);
265
266 BUG_TRAP(!inet->num || icsk->icsk_bind_hash);
267
268 sk->sk_error_report(sk);
269 return err;
270 }
271
272 EXPORT_SYMBOL_GPL(dccp_disconnect);
273
274 /*
275 * Wait for a DCCP event.
276 *
277 * Note that we don't need to lock the socket, as the upper poll layers
278 * take care of normal races (between the test and the event) and we don't
279 * go look at any of the socket buffers directly.
280 */
281 unsigned int dccp_poll(struct file *file, struct socket *sock,
282 poll_table *wait)
283 {
284 unsigned int mask;
285 struct sock *sk = sock->sk;
286
287 poll_wait(file, sk->sk_sleep, wait);
288 if (sk->sk_state == DCCP_LISTEN)
289 return inet_csk_listen_poll(sk);
290
291 /* Socket is not locked. We are protected from async events
292 by poll logic and correct handling of state changes
293 made by another threads is impossible in any case.
294 */
295
296 mask = 0;
297 if (sk->sk_err)
298 mask = POLLERR;
299
300 if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
301 mask |= POLLHUP;
302 if (sk->sk_shutdown & RCV_SHUTDOWN)
303 mask |= POLLIN | POLLRDNORM;
304
305 /* Connected? */
306 if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
307 if (atomic_read(&sk->sk_rmem_alloc) > 0)
308 mask |= POLLIN | POLLRDNORM;
309
310 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
311 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
312 mask |= POLLOUT | POLLWRNORM;
313 } else { /* send SIGIO later */
314 set_bit(SOCK_ASYNC_NOSPACE,
315 &sk->sk_socket->flags);
316 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
317
318 /* Race breaker. If space is freed after
319 * wspace test but before the flags are set,
320 * IO signal will be lost.
321 */
322 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
323 mask |= POLLOUT | POLLWRNORM;
324 }
325 }
326 }
327 return mask;
328 }
329
330 EXPORT_SYMBOL_GPL(dccp_poll);
331
332 int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
333 {
334 dccp_pr_debug("entry\n");
335 return -ENOIOCTLCMD;
336 }
337
338 EXPORT_SYMBOL_GPL(dccp_ioctl);
339
340 static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
341 char __user *optval, int optlen)
342 {
343 struct dccp_sock *dp = dccp_sk(sk);
344 struct dccp_service_list *sl = NULL;
345
346 if (service == DCCP_SERVICE_INVALID_VALUE ||
347 optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
348 return -EINVAL;
349
350 if (optlen > sizeof(service)) {
351 sl = kmalloc(optlen, GFP_KERNEL);
352 if (sl == NULL)
353 return -ENOMEM;
354
355 sl->dccpsl_nr = optlen / sizeof(u32) - 1;
356 if (copy_from_user(sl->dccpsl_list,
357 optval + sizeof(service),
358 optlen - sizeof(service)) ||
359 dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
360 kfree(sl);
361 return -EFAULT;
362 }
363 }
364
365 lock_sock(sk);
366 dp->dccps_service = service;
367
368 kfree(dp->dccps_service_list);
369
370 dp->dccps_service_list = sl;
371 release_sock(sk);
372 return 0;
373 }
374
375 /* byte 1 is feature. the rest is the preference list */
376 static int dccp_setsockopt_change(struct sock *sk, int type,
377 struct dccp_so_feat __user *optval)
378 {
379 struct dccp_so_feat opt;
380 u8 *val;
381 int rc;
382
383 if (copy_from_user(&opt, optval, sizeof(opt)))
384 return -EFAULT;
385
386 val = kmalloc(opt.dccpsf_len, GFP_KERNEL);
387 if (!val)
388 return -ENOMEM;
389
390 if (copy_from_user(val, opt.dccpsf_val, opt.dccpsf_len)) {
391 rc = -EFAULT;
392 goto out_free_val;
393 }
394
395 rc = dccp_feat_change(sk, type, opt.dccpsf_feat, val, opt.dccpsf_len,
396 GFP_KERNEL);
397 if (rc)
398 goto out_free_val;
399
400 out:
401 return rc;
402
403 out_free_val:
404 kfree(val);
405 goto out;
406 }
407
408 int dccp_setsockopt(struct sock *sk, int level, int optname,
409 char __user *optval, int optlen)
410 {
411 struct dccp_sock *dp;
412 int err;
413 int val;
414
415 if (level != SOL_DCCP)
416 return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
417 optname, optval,
418 optlen);
419
420 if (optlen < sizeof(int))
421 return -EINVAL;
422
423 if (get_user(val, (int __user *)optval))
424 return -EFAULT;
425
426 if (optname == DCCP_SOCKOPT_SERVICE)
427 return dccp_setsockopt_service(sk, val, optval, optlen);
428
429 lock_sock(sk);
430 dp = dccp_sk(sk);
431 err = 0;
432
433 switch (optname) {
434 case DCCP_SOCKOPT_PACKET_SIZE:
435 dp->dccps_packet_size = val;
436 break;
437
438 case DCCP_SOCKOPT_CHANGE_L:
439 if (optlen != sizeof(struct dccp_so_feat))
440 err = -EINVAL;
441 else
442 err = dccp_setsockopt_change(sk, DCCPO_CHANGE_L,
443 (struct dccp_so_feat *)
444 optval);
445 break;
446
447 case DCCP_SOCKOPT_CHANGE_R:
448 if (optlen != sizeof(struct dccp_so_feat))
449 err = -EINVAL;
450 else
451 err = dccp_setsockopt_change(sk, DCCPO_CHANGE_R,
452 (struct dccp_so_feat *)
453 optval);
454 break;
455
456 default:
457 err = -ENOPROTOOPT;
458 break;
459 }
460
461 release_sock(sk);
462 return err;
463 }
464
465 EXPORT_SYMBOL_GPL(dccp_setsockopt);
466
467 static int dccp_getsockopt_service(struct sock *sk, int len,
468 __be32 __user *optval,
469 int __user *optlen)
470 {
471 const struct dccp_sock *dp = dccp_sk(sk);
472 const struct dccp_service_list *sl;
473 int err = -ENOENT, slen = 0, total_len = sizeof(u32);
474
475 lock_sock(sk);
476 if (dccp_service_not_initialized(sk))
477 goto out;
478
479 if ((sl = dp->dccps_service_list) != NULL) {
480 slen = sl->dccpsl_nr * sizeof(u32);
481 total_len += slen;
482 }
483
484 err = -EINVAL;
485 if (total_len > len)
486 goto out;
487
488 err = 0;
489 if (put_user(total_len, optlen) ||
490 put_user(dp->dccps_service, optval) ||
491 (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
492 err = -EFAULT;
493 out:
494 release_sock(sk);
495 return err;
496 }
497
498 int dccp_getsockopt(struct sock *sk, int level, int optname,
499 char __user *optval, int __user *optlen)
500 {
501 struct dccp_sock *dp;
502 int val, len;
503
504 if (level != SOL_DCCP)
505 return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
506 optname, optval,
507 optlen);
508 if (get_user(len, optlen))
509 return -EFAULT;
510
511 if (len < sizeof(int))
512 return -EINVAL;
513
514 dp = dccp_sk(sk);
515
516 switch (optname) {
517 case DCCP_SOCKOPT_PACKET_SIZE:
518 val = dp->dccps_packet_size;
519 len = sizeof(dp->dccps_packet_size);
520 break;
521 case DCCP_SOCKOPT_SERVICE:
522 return dccp_getsockopt_service(sk, len,
523 (__be32 __user *)optval, optlen);
524 case 128 ... 191:
525 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
526 len, (u32 __user *)optval, optlen);
527 case 192 ... 255:
528 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
529 len, (u32 __user *)optval, optlen);
530 default:
531 return -ENOPROTOOPT;
532 }
533
534 if (put_user(len, optlen) || copy_to_user(optval, &val, len))
535 return -EFAULT;
536
537 return 0;
538 }
539
540 EXPORT_SYMBOL_GPL(dccp_getsockopt);
541
542 int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
543 size_t len)
544 {
545 const struct dccp_sock *dp = dccp_sk(sk);
546 const int flags = msg->msg_flags;
547 const int noblock = flags & MSG_DONTWAIT;
548 struct sk_buff *skb;
549 int rc, size;
550 long timeo;
551
552 if (len > dp->dccps_mss_cache)
553 return -EMSGSIZE;
554
555 lock_sock(sk);
556 timeo = sock_sndtimeo(sk, noblock);
557
558 /*
559 * We have to use sk_stream_wait_connect here to set sk_write_pending,
560 * so that the trick in dccp_rcv_request_sent_state_process.
561 */
562 /* Wait for a connection to finish. */
563 if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN | DCCPF_CLOSING))
564 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
565 goto out_release;
566
567 size = sk->sk_prot->max_header + len;
568 release_sock(sk);
569 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
570 lock_sock(sk);
571 if (skb == NULL)
572 goto out_release;
573
574 skb_reserve(skb, sk->sk_prot->max_header);
575 rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
576 if (rc != 0)
577 goto out_discard;
578
579 rc = dccp_write_xmit(sk, skb, &timeo);
580 /*
581 * XXX we don't use sk_write_queue, so just discard the packet.
582 * Current plan however is to _use_ sk_write_queue with
583 * an algorith similar to tcp_sendmsg, where the main difference
584 * is that in DCCP we have to respect packet boundaries, so
585 * no coalescing of skbs.
586 *
587 * This bug was _quickly_ found & fixed by just looking at an OSTRA
588 * generated callgraph 8) -acme
589 */
590 out_release:
591 release_sock(sk);
592 return rc ? : len;
593 out_discard:
594 kfree_skb(skb);
595 goto out_release;
596 }
597
598 EXPORT_SYMBOL_GPL(dccp_sendmsg);
599
600 int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
601 size_t len, int nonblock, int flags, int *addr_len)
602 {
603 const struct dccp_hdr *dh;
604 long timeo;
605
606 lock_sock(sk);
607
608 if (sk->sk_state == DCCP_LISTEN) {
609 len = -ENOTCONN;
610 goto out;
611 }
612
613 timeo = sock_rcvtimeo(sk, nonblock);
614
615 do {
616 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
617
618 if (skb == NULL)
619 goto verify_sock_status;
620
621 dh = dccp_hdr(skb);
622
623 if (dh->dccph_type == DCCP_PKT_DATA ||
624 dh->dccph_type == DCCP_PKT_DATAACK)
625 goto found_ok_skb;
626
627 if (dh->dccph_type == DCCP_PKT_RESET ||
628 dh->dccph_type == DCCP_PKT_CLOSE) {
629 dccp_pr_debug("found fin ok!\n");
630 len = 0;
631 goto found_fin_ok;
632 }
633 dccp_pr_debug("packet_type=%s\n",
634 dccp_packet_name(dh->dccph_type));
635 sk_eat_skb(sk, skb);
636 verify_sock_status:
637 if (sock_flag(sk, SOCK_DONE)) {
638 len = 0;
639 break;
640 }
641
642 if (sk->sk_err) {
643 len = sock_error(sk);
644 break;
645 }
646
647 if (sk->sk_shutdown & RCV_SHUTDOWN) {
648 len = 0;
649 break;
650 }
651
652 if (sk->sk_state == DCCP_CLOSED) {
653 if (!sock_flag(sk, SOCK_DONE)) {
654 /* This occurs when user tries to read
655 * from never connected socket.
656 */
657 len = -ENOTCONN;
658 break;
659 }
660 len = 0;
661 break;
662 }
663
664 if (!timeo) {
665 len = -EAGAIN;
666 break;
667 }
668
669 if (signal_pending(current)) {
670 len = sock_intr_errno(timeo);
671 break;
672 }
673
674 sk_wait_data(sk, &timeo);
675 continue;
676 found_ok_skb:
677 if (len > skb->len)
678 len = skb->len;
679 else if (len < skb->len)
680 msg->msg_flags |= MSG_TRUNC;
681
682 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) {
683 /* Exception. Bailout! */
684 len = -EFAULT;
685 break;
686 }
687 found_fin_ok:
688 if (!(flags & MSG_PEEK))
689 sk_eat_skb(sk, skb);
690 break;
691 } while (1);
692 out:
693 release_sock(sk);
694 return len;
695 }
696
697 EXPORT_SYMBOL_GPL(dccp_recvmsg);
698
699 int inet_dccp_listen(struct socket *sock, int backlog)
700 {
701 struct sock *sk = sock->sk;
702 unsigned char old_state;
703 int err;
704
705 lock_sock(sk);
706
707 err = -EINVAL;
708 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
709 goto out;
710
711 old_state = sk->sk_state;
712 if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
713 goto out;
714
715 /* Really, if the socket is already in listen state
716 * we can only allow the backlog to be adjusted.
717 */
718 if (old_state != DCCP_LISTEN) {
719 /*
720 * FIXME: here it probably should be sk->sk_prot->listen_start
721 * see tcp_listen_start
722 */
723 err = dccp_listen_start(sk);
724 if (err)
725 goto out;
726 }
727 sk->sk_max_ack_backlog = backlog;
728 err = 0;
729
730 out:
731 release_sock(sk);
732 return err;
733 }
734
735 EXPORT_SYMBOL_GPL(inet_dccp_listen);
736
737 static const unsigned char dccp_new_state[] = {
738 /* current state: new state: action: */
739 [0] = DCCP_CLOSED,
740 [DCCP_OPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
741 [DCCP_REQUESTING] = DCCP_CLOSED,
742 [DCCP_PARTOPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
743 [DCCP_LISTEN] = DCCP_CLOSED,
744 [DCCP_RESPOND] = DCCP_CLOSED,
745 [DCCP_CLOSING] = DCCP_CLOSED,
746 [DCCP_TIME_WAIT] = DCCP_CLOSED,
747 [DCCP_CLOSED] = DCCP_CLOSED,
748 };
749
750 static int dccp_close_state(struct sock *sk)
751 {
752 const int next = dccp_new_state[sk->sk_state];
753 const int ns = next & DCCP_STATE_MASK;
754
755 if (ns != sk->sk_state)
756 dccp_set_state(sk, ns);
757
758 return next & DCCP_ACTION_FIN;
759 }
760
761 void dccp_close(struct sock *sk, long timeout)
762 {
763 struct sk_buff *skb;
764
765 lock_sock(sk);
766
767 sk->sk_shutdown = SHUTDOWN_MASK;
768
769 if (sk->sk_state == DCCP_LISTEN) {
770 dccp_set_state(sk, DCCP_CLOSED);
771
772 /* Special case. */
773 inet_csk_listen_stop(sk);
774
775 goto adjudge_to_death;
776 }
777
778 /*
779 * We need to flush the recv. buffs. We do this only on the
780 * descriptor close, not protocol-sourced closes, because the
781 *reader process may not have drained the data yet!
782 */
783 /* FIXME: check for unread data */
784 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
785 __kfree_skb(skb);
786 }
787
788 if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
789 /* Check zero linger _after_ checking for unread data. */
790 sk->sk_prot->disconnect(sk, 0);
791 } else if (dccp_close_state(sk)) {
792 dccp_send_close(sk, 1);
793 }
794
795 sk_stream_wait_close(sk, timeout);
796
797 adjudge_to_death:
798 /*
799 * It is the last release_sock in its life. It will remove backlog.
800 */
801 release_sock(sk);
802 /*
803 * Now socket is owned by kernel and we acquire BH lock
804 * to finish close. No need to check for user refs.
805 */
806 local_bh_disable();
807 bh_lock_sock(sk);
808 BUG_TRAP(!sock_owned_by_user(sk));
809
810 sock_hold(sk);
811 sock_orphan(sk);
812
813 /*
814 * The last release_sock may have processed the CLOSE or RESET
815 * packet moving sock to CLOSED state, if not we have to fire
816 * the CLOSE/CLOSEREQ retransmission timer, see "8.3. Termination"
817 * in draft-ietf-dccp-spec-11. -acme
818 */
819 if (sk->sk_state == DCCP_CLOSING) {
820 /* FIXME: should start at 2 * RTT */
821 /* Timer for repeating the CLOSE/CLOSEREQ until an answer. */
822 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
823 inet_csk(sk)->icsk_rto,
824 DCCP_RTO_MAX);
825 #if 0
826 /* Yeah, we should use sk->sk_prot->orphan_count, etc */
827 dccp_set_state(sk, DCCP_CLOSED);
828 #endif
829 }
830
831 atomic_inc(sk->sk_prot->orphan_count);
832 if (sk->sk_state == DCCP_CLOSED)
833 inet_csk_destroy_sock(sk);
834
835 /* Otherwise, socket is reprieved until protocol close. */
836
837 bh_unlock_sock(sk);
838 local_bh_enable();
839 sock_put(sk);
840 }
841
842 EXPORT_SYMBOL_GPL(dccp_close);
843
844 void dccp_shutdown(struct sock *sk, int how)
845 {
846 dccp_pr_debug("entry\n");
847 }
848
849 EXPORT_SYMBOL_GPL(dccp_shutdown);
850
851 static int __init dccp_mib_init(void)
852 {
853 int rc = -ENOMEM;
854
855 dccp_statistics[0] = alloc_percpu(struct dccp_mib);
856 if (dccp_statistics[0] == NULL)
857 goto out;
858
859 dccp_statistics[1] = alloc_percpu(struct dccp_mib);
860 if (dccp_statistics[1] == NULL)
861 goto out_free_one;
862
863 rc = 0;
864 out:
865 return rc;
866 out_free_one:
867 free_percpu(dccp_statistics[0]);
868 dccp_statistics[0] = NULL;
869 goto out;
870
871 }
872
873 static void dccp_mib_exit(void)
874 {
875 free_percpu(dccp_statistics[0]);
876 free_percpu(dccp_statistics[1]);
877 dccp_statistics[0] = dccp_statistics[1] = NULL;
878 }
879
880 static int thash_entries;
881 module_param(thash_entries, int, 0444);
882 MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
883
884 #ifdef CONFIG_IP_DCCP_DEBUG
885 int dccp_debug;
886 module_param(dccp_debug, int, 0444);
887 MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
888
889 EXPORT_SYMBOL_GPL(dccp_debug);
890 #endif
891
892 static int __init dccp_init(void)
893 {
894 unsigned long goal;
895 int ehash_order, bhash_order, i;
896 int rc = -ENOBUFS;
897
898 dccp_hashinfo.bind_bucket_cachep =
899 kmem_cache_create("dccp_bind_bucket",
900 sizeof(struct inet_bind_bucket), 0,
901 SLAB_HWCACHE_ALIGN, NULL, NULL);
902 if (!dccp_hashinfo.bind_bucket_cachep)
903 goto out;
904
905 /*
906 * Size and allocate the main established and bind bucket
907 * hash tables.
908 *
909 * The methodology is similar to that of the buffer cache.
910 */
911 if (num_physpages >= (128 * 1024))
912 goal = num_physpages >> (21 - PAGE_SHIFT);
913 else
914 goal = num_physpages >> (23 - PAGE_SHIFT);
915
916 if (thash_entries)
917 goal = (thash_entries *
918 sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
919 for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
920 ;
921 do {
922 dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE /
923 sizeof(struct inet_ehash_bucket);
924 dccp_hashinfo.ehash_size >>= 1;
925 while (dccp_hashinfo.ehash_size &
926 (dccp_hashinfo.ehash_size - 1))
927 dccp_hashinfo.ehash_size--;
928 dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
929 __get_free_pages(GFP_ATOMIC, ehash_order);
930 } while (!dccp_hashinfo.ehash && --ehash_order > 0);
931
932 if (!dccp_hashinfo.ehash) {
933 printk(KERN_CRIT "Failed to allocate DCCP "
934 "established hash table\n");
935 goto out_free_bind_bucket_cachep;
936 }
937
938 for (i = 0; i < (dccp_hashinfo.ehash_size << 1); i++) {
939 rwlock_init(&dccp_hashinfo.ehash[i].lock);
940 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain);
941 }
942
943 bhash_order = ehash_order;
944
945 do {
946 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
947 sizeof(struct inet_bind_hashbucket);
948 if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
949 bhash_order > 0)
950 continue;
951 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
952 __get_free_pages(GFP_ATOMIC, bhash_order);
953 } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
954
955 if (!dccp_hashinfo.bhash) {
956 printk(KERN_CRIT "Failed to allocate DCCP bind hash table\n");
957 goto out_free_dccp_ehash;
958 }
959
960 for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
961 spin_lock_init(&dccp_hashinfo.bhash[i].lock);
962 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
963 }
964
965 rc = dccp_mib_init();
966 if (rc)
967 goto out_free_dccp_bhash;
968
969 rc = dccp_ackvec_init();
970 if (rc)
971 goto out_free_dccp_mib;
972
973 rc = dccp_sysctl_init();
974 if (rc)
975 goto out_ackvec_exit;
976 out:
977 return rc;
978 out_ackvec_exit:
979 dccp_ackvec_exit();
980 out_free_dccp_mib:
981 dccp_mib_exit();
982 out_free_dccp_bhash:
983 free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
984 dccp_hashinfo.bhash = NULL;
985 out_free_dccp_ehash:
986 free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
987 dccp_hashinfo.ehash = NULL;
988 out_free_bind_bucket_cachep:
989 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
990 dccp_hashinfo.bind_bucket_cachep = NULL;
991 goto out;
992 }
993
994 static void __exit dccp_fini(void)
995 {
996 dccp_mib_exit();
997 free_pages((unsigned long)dccp_hashinfo.bhash,
998 get_order(dccp_hashinfo.bhash_size *
999 sizeof(struct inet_bind_hashbucket)));
1000 free_pages((unsigned long)dccp_hashinfo.ehash,
1001 get_order(dccp_hashinfo.ehash_size *
1002 sizeof(struct inet_ehash_bucket)));
1003 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1004 dccp_ackvec_exit();
1005 dccp_sysctl_exit();
1006 }
1007
1008 module_init(dccp_init);
1009 module_exit(dccp_fini);
1010
1011 MODULE_LICENSE("GPL");
1012 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
1013 MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");
Ubuntu Artful kernel mirror