net/dccp/proto.c

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