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