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