?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dccp: Refine the wait-for-ccid mechanism
[firewire-audio.git] / net / dccp / proto.c
blob8c125ffab1c58cbc62d2dd038c7a24f26d744271
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/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
25 #include <net/inet_sock.h>
26 #include <net/sock.h>
27 #include <net/xfrm.h>
28
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>
34
35 #include "ccid.h"
36 #include "dccp.h"
37 #include "feat.h"
38
39 DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
40
41 EXPORT_SYMBOL_GPL(dccp_statistics);
42
43 atomic_t dccp_orphan_count = ATOMIC_INIT(0);
44
45 EXPORT_SYMBOL_GPL(dccp_orphan_count);
46
47 struct 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
53 EXPORT_SYMBOL_GPL(dccp_hashinfo);
54
55 /* the maximum queue length for tx in packets. 0 is no limit */
56 int sysctl_dccp_tx_qlen __read_mostly = 5;
57
58 void dccp_set_state(struct sock *sk, const int state)
59 {
60 const int oldstate = sk->sk_state;
61
62 dccp_pr_debug("%s(%p) %s --> %s\n", dccp_role(sk), sk,
63 dccp_state_name(oldstate), dccp_state_name(state));
64 WARN_ON(state == oldstate);
65
66 switch (state) {
67 case DCCP_OPEN:
68 if (oldstate != DCCP_OPEN)
69 DCCP_INC_STATS(DCCP_MIB_CURRESTAB);
70 /* Client retransmits all Confirm options until entering OPEN */
71 if (oldstate == DCCP_PARTOPEN)
72 dccp_feat_list_purge(&dccp_sk(sk)->dccps_featneg);
73 break;
74
75 case DCCP_CLOSED:
76 if (oldstate == DCCP_OPEN || oldstate == DCCP_ACTIVE_CLOSEREQ ||
77 oldstate == DCCP_CLOSING)
78 DCCP_INC_STATS(DCCP_MIB_ESTABRESETS);
79
80 sk->sk_prot->unhash(sk);
81 if (inet_csk(sk)->icsk_bind_hash != NULL &&
82 !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
83 inet_put_port(sk);
84 /* fall through */
85 default:
86 if (oldstate == DCCP_OPEN)
87 DCCP_DEC_STATS(DCCP_MIB_CURRESTAB);
88 }
89
90 /* Change state AFTER socket is unhashed to avoid closed
91 * socket sitting in hash tables.
92 */
93 sk->sk_state = state;
94 }
95
96 EXPORT_SYMBOL_GPL(dccp_set_state);
97
98 static void dccp_finish_passive_close(struct sock *sk)
99 {
100 switch (sk->sk_state) {
101 case DCCP_PASSIVE_CLOSE:
102 /* Node (client or server) has received Close packet. */
103 dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED);
104 dccp_set_state(sk, DCCP_CLOSED);
105 break;
106 case DCCP_PASSIVE_CLOSEREQ:
107 /*
108 * Client received CloseReq. We set the `active' flag so that
109 * dccp_send_close() retransmits the Close as per RFC 4340, 8.3.
110 */
111 dccp_send_close(sk, 1);
112 dccp_set_state(sk, DCCP_CLOSING);
113 }
114 }
115
116 void dccp_done(struct sock *sk)
117 {
118 dccp_set_state(sk, DCCP_CLOSED);
119 dccp_clear_xmit_timers(sk);
120
121 sk->sk_shutdown = SHUTDOWN_MASK;
122
123 if (!sock_flag(sk, SOCK_DEAD))
124 sk->sk_state_change(sk);
125 else
126 inet_csk_destroy_sock(sk);
127 }
128
129 EXPORT_SYMBOL_GPL(dccp_done);
130
131 const char *dccp_packet_name(const int type)
132 {
133 static const char *dccp_packet_names[] = {
134 [DCCP_PKT_REQUEST] = "REQUEST",
135 [DCCP_PKT_RESPONSE] = "RESPONSE",
136 [DCCP_PKT_DATA] = "DATA",
137 [DCCP_PKT_ACK] = "ACK",
138 [DCCP_PKT_DATAACK] = "DATAACK",
139 [DCCP_PKT_CLOSEREQ] = "CLOSEREQ",
140 [DCCP_PKT_CLOSE] = "CLOSE",
141 [DCCP_PKT_RESET] = "RESET",
142 [DCCP_PKT_SYNC] = "SYNC",
143 [DCCP_PKT_SYNCACK] = "SYNCACK",
144 };
145
146 if (type >= DCCP_NR_PKT_TYPES)
147 return "INVALID";
148 else
149 return dccp_packet_names[type];
150 }
151
152 EXPORT_SYMBOL_GPL(dccp_packet_name);
153
154 const char *dccp_state_name(const int state)
155 {
156 static char *dccp_state_names[] = {
157 [DCCP_OPEN] = "OPEN",
158 [DCCP_REQUESTING] = "REQUESTING",
159 [DCCP_PARTOPEN] = "PARTOPEN",
160 [DCCP_LISTEN] = "LISTEN",
161 [DCCP_RESPOND] = "RESPOND",
162 [DCCP_CLOSING] = "CLOSING",
163 [DCCP_ACTIVE_CLOSEREQ] = "CLOSEREQ",
164 [DCCP_PASSIVE_CLOSE] = "PASSIVE_CLOSE",
165 [DCCP_PASSIVE_CLOSEREQ] = "PASSIVE_CLOSEREQ",
166 [DCCP_TIME_WAIT] = "TIME_WAIT",
167 [DCCP_CLOSED] = "CLOSED",
168 };
169
170 if (state >= DCCP_MAX_STATES)
171 return "INVALID STATE!";
172 else
173 return dccp_state_names[state];
174 }
175
176 EXPORT_SYMBOL_GPL(dccp_state_name);
177
178 int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
179 {
180 struct dccp_sock *dp = dccp_sk(sk);
181 struct inet_connection_sock *icsk = inet_csk(sk);
182
183 icsk->icsk_rto = DCCP_TIMEOUT_INIT;
184 icsk->icsk_syn_retries = sysctl_dccp_request_retries;
185 sk->sk_state = DCCP_CLOSED;
186 sk->sk_write_space = dccp_write_space;
187 icsk->icsk_sync_mss = dccp_sync_mss;
188 dp->dccps_mss_cache = 536;
189 dp->dccps_rate_last = jiffies;
190 dp->dccps_role = DCCP_ROLE_UNDEFINED;
191 dp->dccps_service = DCCP_SERVICE_CODE_IS_ABSENT;
192
193 dccp_init_xmit_timers(sk);
194
195 INIT_LIST_HEAD(&dp->dccps_featneg);
196 /* control socket doesn't need feat nego */
197 if (likely(ctl_sock_initialized))
198 return dccp_feat_init(sk);
199 return 0;
200 }
201
202 EXPORT_SYMBOL_GPL(dccp_init_sock);
203
204 void dccp_destroy_sock(struct sock *sk)
205 {
206 struct dccp_sock *dp = dccp_sk(sk);
207
208 /*
209 * DCCP doesn't use sk_write_queue, just sk_send_head
210 * for retransmissions
211 */
212 if (sk->sk_send_head != NULL) {
213 kfree_skb(sk->sk_send_head);
214 sk->sk_send_head = NULL;
215 }
216
217 /* Clean up a referenced DCCP bind bucket. */
218 if (inet_csk(sk)->icsk_bind_hash != NULL)
219 inet_put_port(sk);
220
221 kfree(dp->dccps_service_list);
222 dp->dccps_service_list = NULL;
223
224 if (dp->dccps_hc_rx_ackvec != NULL) {
225 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
226 dp->dccps_hc_rx_ackvec = NULL;
227 }
228 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
229 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
230 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
231
232 /* clean up feature negotiation state */
233 dccp_feat_list_purge(&dp->dccps_featneg);
234 }
235
236 EXPORT_SYMBOL_GPL(dccp_destroy_sock);
237
238 static inline int dccp_listen_start(struct sock *sk, int backlog)
239 {
240 struct dccp_sock *dp = dccp_sk(sk);
241
242 dp->dccps_role = DCCP_ROLE_LISTEN;
243 /* do not start to listen if feature negotiation setup fails */
244 if (dccp_feat_finalise_settings(dp))
245 return -EPROTO;
246 return inet_csk_listen_start(sk, backlog);
247 }
248
249 static inline int dccp_need_reset(int state)
250 {
251 return state != DCCP_CLOSED && state != DCCP_LISTEN &&
252 state != DCCP_REQUESTING;
253 }
254
255 int dccp_disconnect(struct sock *sk, int flags)
256 {
257 struct inet_connection_sock *icsk = inet_csk(sk);
258 struct inet_sock *inet = inet_sk(sk);
259 int err = 0;
260 const int old_state = sk->sk_state;
261
262 if (old_state != DCCP_CLOSED)
263 dccp_set_state(sk, DCCP_CLOSED);
264
265 /*
266 * This corresponds to the ABORT function of RFC793, sec. 3.8
267 * TCP uses a RST segment, DCCP a Reset packet with Code 2, "Aborted".
268 */
269 if (old_state == DCCP_LISTEN) {
270 inet_csk_listen_stop(sk);
271 } else if (dccp_need_reset(old_state)) {
272 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
273 sk->sk_err = ECONNRESET;
274 } else if (old_state == DCCP_REQUESTING)
275 sk->sk_err = ECONNRESET;
276
277 dccp_clear_xmit_timers(sk);
278
279 __skb_queue_purge(&sk->sk_receive_queue);
280 __skb_queue_purge(&sk->sk_write_queue);
281 if (sk->sk_send_head != NULL) {
282 __kfree_skb(sk->sk_send_head);
283 sk->sk_send_head = NULL;
284 }
285
286 inet->dport = 0;
287
288 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
289 inet_reset_saddr(sk);
290
291 sk->sk_shutdown = 0;
292 sock_reset_flag(sk, SOCK_DONE);
293
294 icsk->icsk_backoff = 0;
295 inet_csk_delack_init(sk);
296 __sk_dst_reset(sk);
297
298 WARN_ON(inet->num && !icsk->icsk_bind_hash);
299
300 sk->sk_error_report(sk);
301 return err;
302 }
303
304 EXPORT_SYMBOL_GPL(dccp_disconnect);
305
306 /*
307 * Wait for a DCCP event.
308 *
309 * Note that we don't need to lock the socket, as the upper poll layers
310 * take care of normal races (between the test and the event) and we don't
311 * go look at any of the socket buffers directly.
312 */
313 unsigned int dccp_poll(struct file *file, struct socket *sock,
314 poll_table *wait)
315 {
316 unsigned int mask;
317 struct sock *sk = sock->sk;
318
319 poll_wait(file, sk->sk_sleep, wait);
320 if (sk->sk_state == DCCP_LISTEN)
321 return inet_csk_listen_poll(sk);
322
323 /* Socket is not locked. We are protected from async events
324 by poll logic and correct handling of state changes
325 made by another threads is impossible in any case.
326 */
327
328 mask = 0;
329 if (sk->sk_err)
330 mask = POLLERR;
331
332 if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
333 mask |= POLLHUP;
334 if (sk->sk_shutdown & RCV_SHUTDOWN)
335 mask |= POLLIN | POLLRDNORM | POLLRDHUP;
336
337 /* Connected? */
338 if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
339 if (atomic_read(&sk->sk_rmem_alloc) > 0)
340 mask |= POLLIN | POLLRDNORM;
341
342 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
343 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
344 mask |= POLLOUT | POLLWRNORM;
345 } else { /* send SIGIO later */
346 set_bit(SOCK_ASYNC_NOSPACE,
347 &sk->sk_socket->flags);
348 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
349
350 /* Race breaker. If space is freed after
351 * wspace test but before the flags are set,
352 * IO signal will be lost.
353 */
354 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
355 mask |= POLLOUT | POLLWRNORM;
356 }
357 }
358 }
359 return mask;
360 }
361
362 EXPORT_SYMBOL_GPL(dccp_poll);
363
364 int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
365 {
366 int rc = -ENOTCONN;
367
368 lock_sock(sk);
369
370 if (sk->sk_state == DCCP_LISTEN)
371 goto out;
372
373 switch (cmd) {
374 case SIOCINQ: {
375 struct sk_buff *skb;
376 unsigned long amount = 0;
377
378 skb = skb_peek(&sk->sk_receive_queue);
379 if (skb != NULL) {
380 /*
381 * We will only return the amount of this packet since
382 * that is all that will be read.
383 */
384 amount = skb->len;
385 }
386 rc = put_user(amount, (int __user *)arg);
387 }
388 break;
389 default:
390 rc = -ENOIOCTLCMD;
391 break;
392 }
393 out:
394 release_sock(sk);
395 return rc;
396 }
397
398 EXPORT_SYMBOL_GPL(dccp_ioctl);
399
400 static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
401 char __user *optval, int optlen)
402 {
403 struct dccp_sock *dp = dccp_sk(sk);
404 struct dccp_service_list *sl = NULL;
405
406 if (service == DCCP_SERVICE_INVALID_VALUE ||
407 optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
408 return -EINVAL;
409
410 if (optlen > sizeof(service)) {
411 sl = kmalloc(optlen, GFP_KERNEL);
412 if (sl == NULL)
413 return -ENOMEM;
414
415 sl->dccpsl_nr = optlen / sizeof(u32) - 1;
416 if (copy_from_user(sl->dccpsl_list,
417 optval + sizeof(service),
418 optlen - sizeof(service)) ||
419 dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
420 kfree(sl);
421 return -EFAULT;
422 }
423 }
424
425 lock_sock(sk);
426 dp->dccps_service = service;
427
428 kfree(dp->dccps_service_list);
429
430 dp->dccps_service_list = sl;
431 release_sock(sk);
432 return 0;
433 }
434
435 static int dccp_setsockopt_cscov(struct sock *sk, int cscov, bool rx)
436 {
437 u8 *list, len;
438 int i, rc;
439
440 if (cscov < 0 || cscov > 15)
441 return -EINVAL;
442 /*
443 * Populate a list of permissible values, in the range cscov...15. This
444 * is necessary since feature negotiation of single values only works if
445 * both sides incidentally choose the same value. Since the list starts
446 * lowest-value first, negotiation will pick the smallest shared value.
447 */
448 if (cscov == 0)
449 return 0;
450 len = 16 - cscov;
451
452 list = kmalloc(len, GFP_KERNEL);
453 if (list == NULL)
454 return -ENOBUFS;
455
456 for (i = 0; i < len; i++)
457 list[i] = cscov++;
458
459 rc = dccp_feat_register_sp(sk, DCCPF_MIN_CSUM_COVER, rx, list, len);
460
461 if (rc == 0) {
462 if (rx)
463 dccp_sk(sk)->dccps_pcrlen = cscov;
464 else
465 dccp_sk(sk)->dccps_pcslen = cscov;
466 }
467 kfree(list);
468 return rc;
469 }
470
471 static int dccp_setsockopt_ccid(struct sock *sk, int type,
472 char __user *optval, int optlen)
473 {
474 u8 *val;
475 int rc = 0;
476
477 if (optlen < 1 || optlen > DCCP_FEAT_MAX_SP_VALS)
478 return -EINVAL;
479
480 val = kmalloc(optlen, GFP_KERNEL);
481 if (val == NULL)
482 return -ENOMEM;
483
484 if (copy_from_user(val, optval, optlen)) {
485 kfree(val);
486 return -EFAULT;
487 }
488
489 lock_sock(sk);
490 if (type == DCCP_SOCKOPT_TX_CCID || type == DCCP_SOCKOPT_CCID)
491 rc = dccp_feat_register_sp(sk, DCCPF_CCID, 1, val, optlen);
492
493 if (!rc && (type == DCCP_SOCKOPT_RX_CCID || type == DCCP_SOCKOPT_CCID))
494 rc = dccp_feat_register_sp(sk, DCCPF_CCID, 0, val, optlen);
495 release_sock(sk);
496
497 kfree(val);
498 return rc;
499 }
500
501 static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
502 char __user *optval, int optlen)
503 {
504 struct dccp_sock *dp = dccp_sk(sk);
505 int val, err = 0;
506
507 switch (optname) {
508 case DCCP_SOCKOPT_PACKET_SIZE:
509 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
510 return 0;
511 case DCCP_SOCKOPT_CHANGE_L:
512 case DCCP_SOCKOPT_CHANGE_R:
513 DCCP_WARN("sockopt(CHANGE_L/R) is deprecated: fix your app\n");
514 return 0;
515 case DCCP_SOCKOPT_CCID:
516 case DCCP_SOCKOPT_RX_CCID:
517 case DCCP_SOCKOPT_TX_CCID:
518 return dccp_setsockopt_ccid(sk, optname, optval, optlen);
519 }
520
521 if (optlen < (int)sizeof(int))
522 return -EINVAL;
523
524 if (get_user(val, (int __user *)optval))
525 return -EFAULT;
526
527 if (optname == DCCP_SOCKOPT_SERVICE)
528 return dccp_setsockopt_service(sk, val, optval, optlen);
529
530 lock_sock(sk);
531 switch (optname) {
532 case DCCP_SOCKOPT_SERVER_TIMEWAIT:
533 if (dp->dccps_role != DCCP_ROLE_SERVER)
534 err = -EOPNOTSUPP;
535 else
536 dp->dccps_server_timewait = (val != 0);
537 break;
538 case DCCP_SOCKOPT_SEND_CSCOV:
539 err = dccp_setsockopt_cscov(sk, val, false);
540 break;
541 case DCCP_SOCKOPT_RECV_CSCOV:
542 err = dccp_setsockopt_cscov(sk, val, true);
543 break;
544 default:
545 err = -ENOPROTOOPT;
546 break;
547 }
548 release_sock(sk);
549
550 return err;
551 }
552
553 int dccp_setsockopt(struct sock *sk, int level, int optname,
554 char __user *optval, int optlen)
555 {
556 if (level != SOL_DCCP)
557 return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
558 optname, optval,
559 optlen);
560 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
561 }
562
563 EXPORT_SYMBOL_GPL(dccp_setsockopt);
564
565 #ifdef CONFIG_COMPAT
566 int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
567 char __user *optval, int optlen)
568 {
569 if (level != SOL_DCCP)
570 return inet_csk_compat_setsockopt(sk, level, optname,
571 optval, optlen);
572 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
573 }
574
575 EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
576 #endif
577
578 static int dccp_getsockopt_service(struct sock *sk, int len,
579 __be32 __user *optval,
580 int __user *optlen)
581 {
582 const struct dccp_sock *dp = dccp_sk(sk);
583 const struct dccp_service_list *sl;
584 int err = -ENOENT, slen = 0, total_len = sizeof(u32);
585
586 lock_sock(sk);
587 if ((sl = dp->dccps_service_list) != NULL) {
588 slen = sl->dccpsl_nr * sizeof(u32);
589 total_len += slen;
590 }
591
592 err = -EINVAL;
593 if (total_len > len)
594 goto out;
595
596 err = 0;
597 if (put_user(total_len, optlen) ||
598 put_user(dp->dccps_service, optval) ||
599 (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
600 err = -EFAULT;
601 out:
602 release_sock(sk);
603 return err;
604 }
605
606 static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
607 char __user *optval, int __user *optlen)
608 {
609 struct dccp_sock *dp;
610 int val, len;
611
612 if (get_user(len, optlen))
613 return -EFAULT;
614
615 if (len < (int)sizeof(int))
616 return -EINVAL;
617
618 dp = dccp_sk(sk);
619
620 switch (optname) {
621 case DCCP_SOCKOPT_PACKET_SIZE:
622 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
623 return 0;
624 case DCCP_SOCKOPT_SERVICE:
625 return dccp_getsockopt_service(sk, len,
626 (__be32 __user *)optval, optlen);
627 case DCCP_SOCKOPT_GET_CUR_MPS:
628 val = dp->dccps_mss_cache;
629 break;
630 case DCCP_SOCKOPT_AVAILABLE_CCIDS:
631 return ccid_getsockopt_builtin_ccids(sk, len, optval, optlen);
632 case DCCP_SOCKOPT_TX_CCID:
633 val = ccid_get_current_tx_ccid(dp);
634 if (val < 0)
635 return -ENOPROTOOPT;
636 break;
637 case DCCP_SOCKOPT_RX_CCID:
638 val = ccid_get_current_rx_ccid(dp);
639 if (val < 0)
640 return -ENOPROTOOPT;
641 break;
642 case DCCP_SOCKOPT_SERVER_TIMEWAIT:
643 val = dp->dccps_server_timewait;
644 break;
645 case DCCP_SOCKOPT_SEND_CSCOV:
646 val = dp->dccps_pcslen;
647 break;
648 case DCCP_SOCKOPT_RECV_CSCOV:
649 val = dp->dccps_pcrlen;
650 break;
651 case 128 ... 191:
652 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
653 len, (u32 __user *)optval, optlen);
654 case 192 ... 255:
655 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
656 len, (u32 __user *)optval, optlen);
657 default:
658 return -ENOPROTOOPT;
659 }
660
661 len = sizeof(val);
662 if (put_user(len, optlen) || copy_to_user(optval, &val, len))
663 return -EFAULT;
664
665 return 0;
666 }
667
668 int dccp_getsockopt(struct sock *sk, int level, int optname,
669 char __user *optval, int __user *optlen)
670 {
671 if (level != SOL_DCCP)
672 return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
673 optname, optval,
674 optlen);
675 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
676 }
677
678 EXPORT_SYMBOL_GPL(dccp_getsockopt);
679
680 #ifdef CONFIG_COMPAT
681 int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
682 char __user *optval, int __user *optlen)
683 {
684 if (level != SOL_DCCP)
685 return inet_csk_compat_getsockopt(sk, level, optname,
686 optval, optlen);
687 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
688 }
689
690 EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
691 #endif
692
693 int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
694 size_t len)
695 {
696 const struct dccp_sock *dp = dccp_sk(sk);
697 const int flags = msg->msg_flags;
698 const int noblock = flags & MSG_DONTWAIT;
699 struct sk_buff *skb;
700 int rc, size;
701 long timeo;
702
703 if (len > dp->dccps_mss_cache)
704 return -EMSGSIZE;
705
706 lock_sock(sk);
707
708 if (sysctl_dccp_tx_qlen &&
709 (sk->sk_write_queue.qlen >= sysctl_dccp_tx_qlen)) {
710 rc = -EAGAIN;
711 goto out_release;
712 }
713
714 timeo = sock_sndtimeo(sk, noblock);
715
716 /*
717 * We have to use sk_stream_wait_connect here to set sk_write_pending,
718 * so that the trick in dccp_rcv_request_sent_state_process.
719 */
720 /* Wait for a connection to finish. */
721 if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
722 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
723 goto out_release;
724
725 size = sk->sk_prot->max_header + len;
726 release_sock(sk);
727 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
728 lock_sock(sk);
729 if (skb == NULL)
730 goto out_release;
731
732 skb_reserve(skb, sk->sk_prot->max_header);
733 rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
734 if (rc != 0)
735 goto out_discard;
736
737 skb_queue_tail(&sk->sk_write_queue, skb);
738 dccp_write_xmit(sk);
739 out_release:
740 release_sock(sk);
741 return rc ? : len;
742 out_discard:
743 kfree_skb(skb);
744 goto out_release;
745 }
746
747 EXPORT_SYMBOL_GPL(dccp_sendmsg);
748
749 int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
750 size_t len, int nonblock, int flags, int *addr_len)
751 {
752 const struct dccp_hdr *dh;
753 long timeo;
754
755 lock_sock(sk);
756
757 if (sk->sk_state == DCCP_LISTEN) {
758 len = -ENOTCONN;
759 goto out;
760 }
761
762 timeo = sock_rcvtimeo(sk, nonblock);
763
764 do {
765 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
766
767 if (skb == NULL)
768 goto verify_sock_status;
769
770 dh = dccp_hdr(skb);
771
772 switch (dh->dccph_type) {
773 case DCCP_PKT_DATA:
774 case DCCP_PKT_DATAACK:
775 goto found_ok_skb;
776
777 case DCCP_PKT_CLOSE:
778 case DCCP_PKT_CLOSEREQ:
779 if (!(flags & MSG_PEEK))
780 dccp_finish_passive_close(sk);
781 /* fall through */
782 case DCCP_PKT_RESET:
783 dccp_pr_debug("found fin (%s) ok!\n",
784 dccp_packet_name(dh->dccph_type));
785 len = 0;
786 goto found_fin_ok;
787 default:
788 dccp_pr_debug("packet_type=%s\n",
789 dccp_packet_name(dh->dccph_type));
790 sk_eat_skb(sk, skb, 0);
791 }
792 verify_sock_status:
793 if (sock_flag(sk, SOCK_DONE)) {
794 len = 0;
795 break;
796 }
797
798 if (sk->sk_err) {
799 len = sock_error(sk);
800 break;
801 }
802
803 if (sk->sk_shutdown & RCV_SHUTDOWN) {
804 len = 0;
805 break;
806 }
807
808 if (sk->sk_state == DCCP_CLOSED) {
809 if (!sock_flag(sk, SOCK_DONE)) {
810 /* This occurs when user tries to read
811 * from never connected socket.
812 */
813 len = -ENOTCONN;
814 break;
815 }
816 len = 0;
817 break;
818 }
819
820 if (!timeo) {
821 len = -EAGAIN;
822 break;
823 }
824
825 if (signal_pending(current)) {
826 len = sock_intr_errno(timeo);
827 break;
828 }
829
830 sk_wait_data(sk, &timeo);
831 continue;
832 found_ok_skb:
833 if (len > skb->len)
834 len = skb->len;
835 else if (len < skb->len)
836 msg->msg_flags |= MSG_TRUNC;
837
838 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) {
839 /* Exception. Bailout! */
840 len = -EFAULT;
841 break;
842 }
843 found_fin_ok:
844 if (!(flags & MSG_PEEK))
845 sk_eat_skb(sk, skb, 0);
846 break;
847 } while (1);
848 out:
849 release_sock(sk);
850 return len;
851 }
852
853 EXPORT_SYMBOL_GPL(dccp_recvmsg);
854
855 int inet_dccp_listen(struct socket *sock, int backlog)
856 {
857 struct sock *sk = sock->sk;
858 unsigned char old_state;
859 int err;
860
861 lock_sock(sk);
862
863 err = -EINVAL;
864 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
865 goto out;
866
867 old_state = sk->sk_state;
868 if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
869 goto out;
870
871 /* Really, if the socket is already in listen state
872 * we can only allow the backlog to be adjusted.
873 */
874 if (old_state != DCCP_LISTEN) {
875 /*
876 * FIXME: here it probably should be sk->sk_prot->listen_start
877 * see tcp_listen_start
878 */
879 err = dccp_listen_start(sk, backlog);
880 if (err)
881 goto out;
882 }
883 sk->sk_max_ack_backlog = backlog;
884 err = 0;
885
886 out:
887 release_sock(sk);
888 return err;
889 }
890
891 EXPORT_SYMBOL_GPL(inet_dccp_listen);
892
893 static void dccp_terminate_connection(struct sock *sk)
894 {
895 u8 next_state = DCCP_CLOSED;
896
897 switch (sk->sk_state) {
898 case DCCP_PASSIVE_CLOSE:
899 case DCCP_PASSIVE_CLOSEREQ:
900 dccp_finish_passive_close(sk);
901 break;
902 case DCCP_PARTOPEN:
903 dccp_pr_debug("Stop PARTOPEN timer (%p)\n", sk);
904 inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
905 /* fall through */
906 case DCCP_OPEN:
907 dccp_send_close(sk, 1);
908
909 if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER &&
910 !dccp_sk(sk)->dccps_server_timewait)
911 next_state = DCCP_ACTIVE_CLOSEREQ;
912 else
913 next_state = DCCP_CLOSING;
914 /* fall through */
915 default:
916 dccp_set_state(sk, next_state);
917 }
918 }
919
920 void dccp_close(struct sock *sk, long timeout)
921 {
922 struct dccp_sock *dp = dccp_sk(sk);
923 struct sk_buff *skb;
924 u32 data_was_unread = 0;
925 int state;
926
927 lock_sock(sk);
928
929 sk->sk_shutdown = SHUTDOWN_MASK;
930
931 if (sk->sk_state == DCCP_LISTEN) {
932 dccp_set_state(sk, DCCP_CLOSED);
933
934 /* Special case. */
935 inet_csk_listen_stop(sk);
936
937 goto adjudge_to_death;
938 }
939
940 sk_stop_timer(sk, &dp->dccps_xmit_timer);
941
942 /*
943 * We need to flush the recv. buffs. We do this only on the
944 * descriptor close, not protocol-sourced closes, because the
945 *reader process may not have drained the data yet!
946 */
947 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
948 data_was_unread += skb->len;
949 __kfree_skb(skb);
950 }
951
952 if (data_was_unread) {
953 /* Unread data was tossed, send an appropriate Reset Code */
954 DCCP_WARN("DCCP: ABORT -- %u bytes unread\n", data_was_unread);
955 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
956 dccp_set_state(sk, DCCP_CLOSED);
957 } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
958 /* Check zero linger _after_ checking for unread data. */
959 sk->sk_prot->disconnect(sk, 0);
960 } else if (sk->sk_state != DCCP_CLOSED) {
961 /*
962 * Normal connection termination. May need to wait if there are
963 * still packets in the TX queue that are delayed by the CCID.
964 */
965 dccp_flush_write_queue(sk, &timeout);
966 dccp_terminate_connection(sk);
967 }
968
969 /*
970 * Flush write queue. This may be necessary in several cases:
971 * - we have been closed by the peer but still have application data;
972 * - abortive termination (unread data or zero linger time),
973 * - normal termination but queue could not be flushed within time limit
974 */
975 __skb_queue_purge(&sk->sk_write_queue);
976
977 sk_stream_wait_close(sk, timeout);
978
979 adjudge_to_death:
980 state = sk->sk_state;
981 sock_hold(sk);
982 sock_orphan(sk);
983 atomic_inc(sk->sk_prot->orphan_count);
984
985 /*
986 * It is the last release_sock in its life. It will remove backlog.
987 */
988 release_sock(sk);
989 /*
990 * Now socket is owned by kernel and we acquire BH lock
991 * to finish close. No need to check for user refs.
992 */
993 local_bh_disable();
994 bh_lock_sock(sk);
995 WARN_ON(sock_owned_by_user(sk));
996
997 /* Have we already been destroyed by a softirq or backlog? */
998 if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
999 goto out;
1000
1001 if (sk->sk_state == DCCP_CLOSED)
1002 inet_csk_destroy_sock(sk);
1003
1004 /* Otherwise, socket is reprieved until protocol close. */
1005
1006 out:
1007 bh_unlock_sock(sk);
1008 local_bh_enable();
1009 sock_put(sk);
1010 }
1011
1012 EXPORT_SYMBOL_GPL(dccp_close);
1013
1014 void dccp_shutdown(struct sock *sk, int how)
1015 {
1016 dccp_pr_debug("called shutdown(%x)\n", how);
1017 }
1018
1019 EXPORT_SYMBOL_GPL(dccp_shutdown);
1020
1021 static inline int dccp_mib_init(void)
1022 {
1023 return snmp_mib_init((void**)dccp_statistics, sizeof(struct dccp_mib));
1024 }
1025
1026 static inline void dccp_mib_exit(void)
1027 {
1028 snmp_mib_free((void**)dccp_statistics);
1029 }
1030
1031 static int thash_entries;
1032 module_param(thash_entries, int, 0444);
1033 MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
1034
1035 #ifdef CONFIG_IP_DCCP_DEBUG
1036 int dccp_debug;
1037 module_param(dccp_debug, bool, 0644);
1038 MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
1039
1040 EXPORT_SYMBOL_GPL(dccp_debug);
1041 #endif
1042
1043 static int __init dccp_init(void)
1044 {
1045 unsigned long goal;
1046 int ehash_order, bhash_order, i;
1047 int rc = -ENOBUFS;
1048
1049 BUILD_BUG_ON(sizeof(struct dccp_skb_cb) >
1050 FIELD_SIZEOF(struct sk_buff, cb));
1051
1052 dccp_hashinfo.bind_bucket_cachep =
1053 kmem_cache_create("dccp_bind_bucket",
1054 sizeof(struct inet_bind_bucket), 0,
1055 SLAB_HWCACHE_ALIGN, NULL);
1056 if (!dccp_hashinfo.bind_bucket_cachep)
1057 goto out;
1058
1059 /*
1060 * Size and allocate the main established and bind bucket
1061 * hash tables.
1062 *
1063 * The methodology is similar to that of the buffer cache.
1064 */
1065 if (num_physpages >= (128 * 1024))
1066 goal = num_physpages >> (21 - PAGE_SHIFT);
1067 else
1068 goal = num_physpages >> (23 - PAGE_SHIFT);
1069
1070 if (thash_entries)
1071 goal = (thash_entries *
1072 sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
1073 for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
1074 ;
1075 do {
1076 dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE /
1077 sizeof(struct inet_ehash_bucket);
1078 while (dccp_hashinfo.ehash_size &
1079 (dccp_hashinfo.ehash_size - 1))
1080 dccp_hashinfo.ehash_size--;
1081 dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
1082 __get_free_pages(GFP_ATOMIC, ehash_order);
1083 } while (!dccp_hashinfo.ehash && --ehash_order > 0);
1084
1085 if (!dccp_hashinfo.ehash) {
1086 DCCP_CRIT("Failed to allocate DCCP established hash table");
1087 goto out_free_bind_bucket_cachep;
1088 }
1089
1090 for (i = 0; i < dccp_hashinfo.ehash_size; i++) {
1091 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain);
1092 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].twchain);
1093 }
1094
1095 if (inet_ehash_locks_alloc(&dccp_hashinfo))
1096 goto out_free_dccp_ehash;
1097
1098 bhash_order = ehash_order;
1099
1100 do {
1101 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
1102 sizeof(struct inet_bind_hashbucket);
1103 if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
1104 bhash_order > 0)
1105 continue;
1106 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
1107 __get_free_pages(GFP_ATOMIC, bhash_order);
1108 } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
1109
1110 if (!dccp_hashinfo.bhash) {
1111 DCCP_CRIT("Failed to allocate DCCP bind hash table");
1112 goto out_free_dccp_locks;
1113 }
1114
1115 for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
1116 spin_lock_init(&dccp_hashinfo.bhash[i].lock);
1117 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
1118 }
1119
1120 rc = dccp_mib_init();
1121 if (rc)
1122 goto out_free_dccp_bhash;
1123
1124 rc = dccp_ackvec_init();
1125 if (rc)
1126 goto out_free_dccp_mib;
1127
1128 rc = dccp_sysctl_init();
1129 if (rc)
1130 goto out_ackvec_exit;
1131
1132 dccp_timestamping_init();
1133 out:
1134 return rc;
1135 out_ackvec_exit:
1136 dccp_ackvec_exit();
1137 out_free_dccp_mib:
1138 dccp_mib_exit();
1139 out_free_dccp_bhash:
1140 free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
1141 dccp_hashinfo.bhash = NULL;
1142 out_free_dccp_locks:
1143 inet_ehash_locks_free(&dccp_hashinfo);
1144 out_free_dccp_ehash:
1145 free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
1146 dccp_hashinfo.ehash = NULL;
1147 out_free_bind_bucket_cachep:
1148 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1149 dccp_hashinfo.bind_bucket_cachep = NULL;
1150 goto out;
1151 }
1152
1153 static void __exit dccp_fini(void)
1154 {
1155 dccp_mib_exit();
1156 free_pages((unsigned long)dccp_hashinfo.bhash,
1157 get_order(dccp_hashinfo.bhash_size *
1158 sizeof(struct inet_bind_hashbucket)));
1159 free_pages((unsigned long)dccp_hashinfo.ehash,
1160 get_order(dccp_hashinfo.ehash_size *
1161 sizeof(struct inet_ehash_bucket)));
1162 inet_ehash_locks_free(&dccp_hashinfo);
1163 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1164 dccp_ackvec_exit();
1165 dccp_sysctl_exit();
1166 }
1167
1168 module_init(dccp_init);
1169 module_exit(dccp_fini);
1170
1171 MODULE_LICENSE("GPL");
1172 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
1173 MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");
AMDTP streaming driver for the Linux FireWire stack (Juju)