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