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