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 if (sk->sk_state == DCCP_CLOSED) { 798 rc = -ENOTCONN; 799 goto out_discard; 800 } 801 802 skb_reserve(skb, sk->sk_prot->max_header); 803 rc = memcpy_from_msg(skb_put(skb, len), msg, len); 804 if (rc != 0) 805 goto out_discard; 806 807 rc = dccp_msghdr_parse(msg, skb); 808 if (rc != 0) 809 goto out_discard; 810 811 dccp_qpolicy_push(sk, skb); 812 /* 813 * The xmit_timer is set if the TX CCID is rate-based and will expire 814 * when congestion control permits to release further packets into the 815 * network. Window-based CCIDs do not use this timer. 816 */ 817 if (!timer_pending(&dp->dccps_xmit_timer)) 818 dccp_write_xmit(sk); 819 out_release: 820 release_sock(sk); 821 return rc ? : len; 822 out_discard: 823 kfree_skb(skb); 824 goto out_release; 825 } 826 827 EXPORT_SYMBOL_GPL(dccp_sendmsg); 828 829 int dccp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock, 830 int flags, int *addr_len) 831 { 832 const struct dccp_hdr *dh; 833 long timeo; 834 835 lock_sock(sk); 836 837 if (sk->sk_state == DCCP_LISTEN) { 838 len = -ENOTCONN; 839 goto out; 840 } 841 842 timeo = sock_rcvtimeo(sk, nonblock); 843 844 do { 845 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue); 846 847 if (skb == NULL) 848 goto verify_sock_status; 849 850 dh = dccp_hdr(skb); 851 852 switch (dh->dccph_type) { 853 case DCCP_PKT_DATA: 854 case DCCP_PKT_DATAACK: 855 goto found_ok_skb; 856 857 case DCCP_PKT_CLOSE: 858 case DCCP_PKT_CLOSEREQ: 859 if (!(flags & MSG_PEEK)) 860 dccp_finish_passive_close(sk); 861 /* fall through */ 862 case DCCP_PKT_RESET: 863 dccp_pr_debug("found fin (%s) ok!\n", 864 dccp_packet_name(dh->dccph_type)); 865 len = 0; 866 goto found_fin_ok; 867 default: 868 dccp_pr_debug("packet_type=%s\n", 869 dccp_packet_name(dh->dccph_type)); 870 sk_eat_skb(sk, skb); 871 } 872 verify_sock_status: 873 if (sock_flag(sk, SOCK_DONE)) { 874 len = 0; 875 break; 876 } 877 878 if (sk->sk_err) { 879 len = sock_error(sk); 880 break; 881 } 882 883 if (sk->sk_shutdown & RCV_SHUTDOWN) { 884 len = 0; 885 break; 886 } 887 888 if (sk->sk_state == DCCP_CLOSED) { 889 if (!sock_flag(sk, SOCK_DONE)) { 890 /* This occurs when user tries to read 891 * from never connected socket. 892 */ 893 len = -ENOTCONN; 894 break; 895 } 896 len = 0; 897 break; 898 } 899 900 if (!timeo) { 901 len = -EAGAIN; 902 break; 903 } 904 905 if (signal_pending(current)) { 906 len = sock_intr_errno(timeo); 907 break; 908 } 909 910 sk_wait_data(sk, &timeo, NULL); 911 continue; 912 found_ok_skb: 913 if (len > skb->len) 914 len = skb->len; 915 else if (len < skb->len) 916 msg->msg_flags |= MSG_TRUNC; 917 918 if (skb_copy_datagram_msg(skb, 0, msg, len)) { 919 /* Exception. Bailout! */ 920 len = -EFAULT; 921 break; 922 } 923 if (flags & MSG_TRUNC) 924 len = skb->len; 925 found_fin_ok: 926 if (!(flags & MSG_PEEK)) 927 sk_eat_skb(sk, skb); 928 break; 929 } while (1); 930 out: 931 release_sock(sk); 932 return len; 933 } 934 935 EXPORT_SYMBOL_GPL(dccp_recvmsg); 936 937 int inet_dccp_listen(struct socket *sock, int backlog) 938 { 939 struct sock *sk = sock->sk; 940 unsigned char old_state; 941 int err; 942 943 lock_sock(sk); 944 945 err = -EINVAL; 946 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP) 947 goto out; 948 949 old_state = sk->sk_state; 950 if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN))) 951 goto out; 952 953 /* Really, if the socket is already in listen state 954 * we can only allow the backlog to be adjusted. 955 */ 956 if (old_state != DCCP_LISTEN) { 957 /* 958 * FIXME: here it probably should be sk->sk_prot->listen_start 959 * see tcp_listen_start 960 */ 961 err = dccp_listen_start(sk, backlog); 962 if (err) 963 goto out; 964 } 965 sk->sk_max_ack_backlog = backlog; 966 err = 0; 967 968 out: 969 release_sock(sk); 970 return err; 971 } 972 973 EXPORT_SYMBOL_GPL(inet_dccp_listen); 974 975 static void dccp_terminate_connection(struct sock *sk) 976 { 977 u8 next_state = DCCP_CLOSED; 978 979 switch (sk->sk_state) { 980 case DCCP_PASSIVE_CLOSE: 981 case DCCP_PASSIVE_CLOSEREQ: 982 dccp_finish_passive_close(sk); 983 break; 984 case DCCP_PARTOPEN: 985 dccp_pr_debug("Stop PARTOPEN timer (%p)\n", sk); 986 inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK); 987 /* fall through */ 988 case DCCP_OPEN: 989 dccp_send_close(sk, 1); 990 991 if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER && 992 !dccp_sk(sk)->dccps_server_timewait) 993 next_state = DCCP_ACTIVE_CLOSEREQ; 994 else 995 next_state = DCCP_CLOSING; 996 /* fall through */ 997 default: 998 dccp_set_state(sk, next_state); 999 } 1000 } 1001 1002 void dccp_close(struct sock *sk, long timeout) 1003 { 1004 struct dccp_sock *dp = dccp_sk(sk); 1005 struct sk_buff *skb; 1006 u32 data_was_unread = 0; 1007 int state; 1008 1009 lock_sock(sk); 1010 1011 sk->sk_shutdown = SHUTDOWN_MASK; 1012 1013 if (sk->sk_state == DCCP_LISTEN) { 1014 dccp_set_state(sk, DCCP_CLOSED); 1015 1016 /* Special case. */ 1017 inet_csk_listen_stop(sk); 1018 1019 goto adjudge_to_death; 1020 } 1021 1022 sk_stop_timer(sk, &dp->dccps_xmit_timer); 1023 1024 /* 1025 * We need to flush the recv. buffs. We do this only on the 1026 * descriptor close, not protocol-sourced closes, because the 1027 *reader process may not have drained the data yet! 1028 */ 1029 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) { 1030 data_was_unread += skb->len; 1031 __kfree_skb(skb); 1032 } 1033 1034 /* If socket has been already reset kill it. */ 1035 if (sk->sk_state == DCCP_CLOSED) 1036 goto adjudge_to_death; 1037 1038 if (data_was_unread) { 1039 /* Unread data was tossed, send an appropriate Reset Code */ 1040 DCCP_WARN("ABORT with %u bytes unread\n", data_was_unread); 1041 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED); 1042 dccp_set_state(sk, DCCP_CLOSED); 1043 } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) { 1044 /* Check zero linger _after_ checking for unread data. */ 1045 sk->sk_prot->disconnect(sk, 0); 1046 } else if (sk->sk_state != DCCP_CLOSED) { 1047 /* 1048 * Normal connection termination. May need to wait if there are 1049 * still packets in the TX queue that are delayed by the CCID. 1050 */ 1051 dccp_flush_write_queue(sk, &timeout); 1052 dccp_terminate_connection(sk); 1053 } 1054 1055 /* 1056 * Flush write queue. This may be necessary in several cases: 1057 * - we have been closed by the peer but still have application data; 1058 * - abortive termination (unread data or zero linger time), 1059 * - normal termination but queue could not be flushed within time limit 1060 */ 1061 __skb_queue_purge(&sk->sk_write_queue); 1062 1063 sk_stream_wait_close(sk, timeout); 1064 1065 adjudge_to_death: 1066 state = sk->sk_state; 1067 sock_hold(sk); 1068 sock_orphan(sk); 1069 1070 /* 1071 * It is the last release_sock in its life. It will remove backlog. 1072 */ 1073 release_sock(sk); 1074 /* 1075 * Now socket is owned by kernel and we acquire BH lock 1076 * to finish close. No need to check for user refs. 1077 */ 1078 local_bh_disable(); 1079 bh_lock_sock(sk); 1080 WARN_ON(sock_owned_by_user(sk)); 1081 1082 percpu_counter_inc(sk->sk_prot->orphan_count); 1083 1084 /* Have we already been destroyed by a softirq or backlog? */ 1085 if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED) 1086 goto out; 1087 1088 if (sk->sk_state == DCCP_CLOSED) 1089 inet_csk_destroy_sock(sk); 1090 1091 /* Otherwise, socket is reprieved until protocol close. */ 1092 1093 out: 1094 bh_unlock_sock(sk); 1095 local_bh_enable(); 1096 sock_put(sk); 1097 } 1098 1099 EXPORT_SYMBOL_GPL(dccp_close); 1100 1101 void dccp_shutdown(struct sock *sk, int how) 1102 { 1103 dccp_pr_debug("called shutdown(%x)\n", how); 1104 } 1105 1106 EXPORT_SYMBOL_GPL(dccp_shutdown); 1107 1108 static inline int __init dccp_mib_init(void) 1109 { 1110 dccp_statistics = alloc_percpu(struct dccp_mib); 1111 if (!dccp_statistics) 1112 return -ENOMEM; 1113 return 0; 1114 } 1115 1116 static inline void dccp_mib_exit(void) 1117 { 1118 free_percpu(dccp_statistics); 1119 } 1120 1121 static int thash_entries; 1122 module_param(thash_entries, int, 0444); 1123 MODULE_PARM_DESC(thash_entries, "Number of ehash buckets"); 1124 1125 #ifdef CONFIG_IP_DCCP_DEBUG 1126 bool dccp_debug; 1127 module_param(dccp_debug, bool, 0644); 1128 MODULE_PARM_DESC(dccp_debug, "Enable debug messages"); 1129 1130 EXPORT_SYMBOL_GPL(dccp_debug); 1131 #endif 1132 1133 static int __init dccp_init(void) 1134 { 1135 unsigned long goal; 1136 int ehash_order, bhash_order, i; 1137 int rc; 1138 1139 BUILD_BUG_ON(sizeof(struct dccp_skb_cb) > 1140 FIELD_SIZEOF(struct sk_buff, cb)); 1141 rc = percpu_counter_init(&dccp_orphan_count, 0, GFP_KERNEL); 1142 if (rc) 1143 goto out_fail; 1144 rc = -ENOBUFS; 1145 inet_hashinfo_init(&dccp_hashinfo); 1146 dccp_hashinfo.bind_bucket_cachep = 1147 kmem_cache_create("dccp_bind_bucket", 1148 sizeof(struct inet_bind_bucket), 0, 1149 SLAB_HWCACHE_ALIGN, NULL); 1150 if (!dccp_hashinfo.bind_bucket_cachep) 1151 goto out_free_percpu; 1152 1153 /* 1154 * Size and allocate the main established and bind bucket 1155 * hash tables. 1156 * 1157 * The methodology is similar to that of the buffer cache. 1158 */ 1159 if (totalram_pages >= (128 * 1024)) 1160 goal = totalram_pages >> (21 - PAGE_SHIFT); 1161 else 1162 goal = totalram_pages >> (23 - PAGE_SHIFT); 1163 1164 if (thash_entries) 1165 goal = (thash_entries * 1166 sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT; 1167 for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++) 1168 ; 1169 do { 1170 unsigned long hash_size = (1UL << ehash_order) * PAGE_SIZE / 1171 sizeof(struct inet_ehash_bucket); 1172 1173 while (hash_size & (hash_size - 1)) 1174 hash_size--; 1175 dccp_hashinfo.ehash_mask = hash_size - 1; 1176 dccp_hashinfo.ehash = (struct inet_ehash_bucket *) 1177 __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, ehash_order); 1178 } while (!dccp_hashinfo.ehash && --ehash_order > 0); 1179 1180 if (!dccp_hashinfo.ehash) { 1181 DCCP_CRIT("Failed to allocate DCCP established hash table"); 1182 goto out_free_bind_bucket_cachep; 1183 } 1184 1185 for (i = 0; i <= dccp_hashinfo.ehash_mask; i++) 1186 INIT_HLIST_NULLS_HEAD(&dccp_hashinfo.ehash[i].chain, i); 1187 1188 if (inet_ehash_locks_alloc(&dccp_hashinfo)) 1189 goto out_free_dccp_ehash; 1190 1191 bhash_order = ehash_order; 1192 1193 do { 1194 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE / 1195 sizeof(struct inet_bind_hashbucket); 1196 if ((dccp_hashinfo.bhash_size > (64 * 1024)) && 1197 bhash_order > 0) 1198 continue; 1199 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *) 1200 __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, bhash_order); 1201 } while (!dccp_hashinfo.bhash && --bhash_order >= 0); 1202 1203 if (!dccp_hashinfo.bhash) { 1204 DCCP_CRIT("Failed to allocate DCCP bind hash table"); 1205 goto out_free_dccp_locks; 1206 } 1207 1208 for (i = 0; i < dccp_hashinfo.bhash_size; i++) { 1209 spin_lock_init(&dccp_hashinfo.bhash[i].lock); 1210 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain); 1211 } 1212 1213 rc = dccp_mib_init(); 1214 if (rc) 1215 goto out_free_dccp_bhash; 1216 1217 rc = dccp_ackvec_init(); 1218 if (rc) 1219 goto out_free_dccp_mib; 1220 1221 rc = dccp_sysctl_init(); 1222 if (rc) 1223 goto out_ackvec_exit; 1224 1225 rc = ccid_initialize_builtins(); 1226 if (rc) 1227 goto out_sysctl_exit; 1228 1229 dccp_timestamping_init(); 1230 1231 return 0; 1232 1233 out_sysctl_exit: 1234 dccp_sysctl_exit(); 1235 out_ackvec_exit: 1236 dccp_ackvec_exit(); 1237 out_free_dccp_mib: 1238 dccp_mib_exit(); 1239 out_free_dccp_bhash: 1240 free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order); 1241 out_free_dccp_locks: 1242 inet_ehash_locks_free(&dccp_hashinfo); 1243 out_free_dccp_ehash: 1244 free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order); 1245 out_free_bind_bucket_cachep: 1246 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep); 1247 out_free_percpu: 1248 percpu_counter_destroy(&dccp_orphan_count); 1249 out_fail: 1250 dccp_hashinfo.bhash = NULL; 1251 dccp_hashinfo.ehash = NULL; 1252 dccp_hashinfo.bind_bucket_cachep = NULL; 1253 return rc; 1254 } 1255 1256 static void __exit dccp_fini(void) 1257 { 1258 ccid_cleanup_builtins(); 1259 dccp_mib_exit(); 1260 free_pages((unsigned long)dccp_hashinfo.bhash, 1261 get_order(dccp_hashinfo.bhash_size * 1262 sizeof(struct inet_bind_hashbucket))); 1263 free_pages((unsigned long)dccp_hashinfo.ehash, 1264 get_order((dccp_hashinfo.ehash_mask + 1) * 1265 sizeof(struct inet_ehash_bucket))); 1266 inet_ehash_locks_free(&dccp_hashinfo); 1267 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep); 1268 dccp_ackvec_exit(); 1269 dccp_sysctl_exit(); 1270 percpu_counter_destroy(&dccp_orphan_count); 1271 } 1272 1273 module_init(dccp_init); 1274 module_exit(dccp_fini); 1275 1276 MODULE_LICENSE("GPL"); 1277 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>"); 1278 MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol"); 1279