git.oblomov.eu Git - linux-2.6/blob - 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
 313         __skb_queue_purge(&sk->sk_receive_queue);
 314         __skb_queue_purge(&sk->sk_write_queue);
 315         if (sk->sk_send_head != NULL) {
 316                 __kfree_skb(sk->sk_send_head);
 317                 sk->sk_send_head = NULL;
 318         }
 319
 320         inet->dport = 0;
 321
 322         if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
 323                 inet_reset_saddr(sk);
 324
 325         sk->sk_shutdown = 0;
 326         sock_reset_flag(sk, SOCK_DONE);
 327
 328         icsk->icsk_backoff = 0;
 329         inet_csk_delack_init(sk);
 330         __sk_dst_reset(sk);
 331
 332         WARN_ON(inet->num && !icsk->icsk_bind_hash);
 333
 334         sk->sk_error_report(sk);
 335         return err;
 336 }
 337
 338 EXPORT_SYMBOL_GPL(dccp_disconnect);
 339
 340 /*
 341  *      Wait for a DCCP event.
 342  *
 343  *      Note that we don't need to lock the socket, as the upper poll layers
 344  *      take care of normal races (between the test and the event) and we don't
 345  *      go look at any of the socket buffers directly.
 346  */
 347 unsigned int dccp_poll(struct file *file, struct socket *sock,
 348                        poll_table *wait)
 349 {
 350         unsigned int mask;
 351         struct sock *sk = sock->sk;
 352
 353         poll_wait(file, sk->sk_sleep, wait);
 354         if (sk->sk_state == DCCP_LISTEN)
 355                 return inet_csk_listen_poll(sk);
 356
 357         /* Socket is not locked. We are protected from async events
 358            by poll logic and correct handling of state changes
 359            made by another threads is impossible in any case.
 360          */
 361
 362         mask = 0;
 363         if (sk->sk_err)
 364                 mask = POLLERR;
 365
 366         if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
 367                 mask |= POLLHUP;
 368         if (sk->sk_shutdown & RCV_SHUTDOWN)
 369                 mask |= POLLIN | POLLRDNORM | POLLRDHUP;
 370
 371         /* Connected? */
 372         if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
 373                 if (atomic_read(&sk->sk_rmem_alloc) > 0)
 374                         mask |= POLLIN | POLLRDNORM;
 375
 376                 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
 377                         if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
 378                                 mask |= POLLOUT | POLLWRNORM;
 379                         } else {  /* send SIGIO later */
 380                                 set_bit(SOCK_ASYNC_NOSPACE,
 381                                         &sk->sk_socket->flags);
 382                                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
 383
 384                                 /* Race breaker. If space is freed after
 385                                  * wspace test but before the flags are set,
 386                                  * IO signal will be lost.
 387                                  */
 388                                 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
 389                                         mask |= POLLOUT | POLLWRNORM;
 390                         }
 391                 }
 392         }
 393         return mask;
 394 }
 395
 396 EXPORT_SYMBOL_GPL(dccp_poll);
 397
 398 int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
 399 {
 400         int rc = -ENOTCONN;
 401
 402         lock_sock(sk);
 403
 404         if (sk->sk_state == DCCP_LISTEN)
 405                 goto out;
 406
 407         switch (cmd) {
 408         case SIOCINQ: {
 409                 struct sk_buff *skb;
 410                 unsigned long amount = 0;
 411
 412                 skb = skb_peek(&sk->sk_receive_queue);
 413                 if (skb != NULL) {
 414                         /*
 415                          * We will only return the amount of this packet since
 416                          * that is all that will be read.
 417                          */
 418                         amount = skb->len;
 419                 }
 420                 rc = put_user(amount, (int __user *)arg);
 421         }
 422                 break;
 423         default:
 424                 rc = -ENOIOCTLCMD;
 425                 break;
 426         }
 427 out:
 428         release_sock(sk);
 429         return rc;
 430 }
 431
 432 EXPORT_SYMBOL_GPL(dccp_ioctl);
 433
 434 static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
 435                                    char __user *optval, int optlen)
 436 {
 437         struct dccp_sock *dp = dccp_sk(sk);
 438         struct dccp_service_list *sl = NULL;
 439
 440         if (service == DCCP_SERVICE_INVALID_VALUE ||
 441             optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
 442                 return -EINVAL;
 443
 444         if (optlen > sizeof(service)) {
 445                 sl = kmalloc(optlen, GFP_KERNEL);
 446                 if (sl == NULL)
 447                         return -ENOMEM;
 448
 449                 sl->dccpsl_nr = optlen / sizeof(u32) - 1;
 450                 if (copy_from_user(sl->dccpsl_list,
 451                                    optval + sizeof(service),
 452                                    optlen - sizeof(service)) ||
 453                     dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
 454                         kfree(sl);
 455                         return -EFAULT;
 456                 }
 457         }
 458
 459         lock_sock(sk);
 460         dp->dccps_service = service;
 461
 462         kfree(dp->dccps_service_list);
 463
 464         dp->dccps_service_list = sl;
 465         release_sock(sk);
 466         return 0;
 467 }
 468
 469 /* byte 1 is feature.  the rest is the preference list */
 470 static int dccp_setsockopt_change(struct sock *sk, int type,
 471                                   struct dccp_so_feat __user *optval)
 472 {
 473         struct dccp_so_feat opt;
 474         u8 *val;
 475         int rc;
 476
 477         if (copy_from_user(&opt, optval, sizeof(opt)))
 478                 return -EFAULT;
 479         /*
 480          * rfc4340: 6.1. Change Options
 481          */
 482         if (opt.dccpsf_len < 1)
 483                 return -EINVAL;
 484
 485         val = kmalloc(opt.dccpsf_len, GFP_KERNEL);
 486         if (!val)
 487                 return -ENOMEM;
 488
 489         if (copy_from_user(val, opt.dccpsf_val, opt.dccpsf_len)) {
 490                 rc = -EFAULT;
 491                 goto out_free_val;
 492         }
 493
 494         rc = dccp_feat_change(dccp_msk(sk), type, opt.dccpsf_feat,
 495                               val, opt.dccpsf_len, GFP_KERNEL);
 496         if (rc)
 497                 goto out_free_val;
 498
 499 out:
 500         return rc;
 501
 502 out_free_val:
 503         kfree(val);
 504         goto out;
 505 }
 506
 507 static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
 508                 char __user *optval, int optlen)
 509 {
 510         struct dccp_sock *dp = dccp_sk(sk);
 511         int val, err = 0;
 512
 513         if (optlen < sizeof(int))
 514                 return -EINVAL;
 515
 516         if (get_user(val, (int __user *)optval))
 517                 return -EFAULT;
 518
 519         if (optname == DCCP_SOCKOPT_SERVICE)
 520                 return dccp_setsockopt_service(sk, val, optval, optlen);
 521
 522         lock_sock(sk);
 523         switch (optname) {
 524         case DCCP_SOCKOPT_PACKET_SIZE:
 525                 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
 526                 err = 0;
 527                 break;
 528         case DCCP_SOCKOPT_CHANGE_L:
 529                 if (optlen != sizeof(struct dccp_so_feat))
 530                         err = -EINVAL;
 531                 else
 532                         err = dccp_setsockopt_change(sk, DCCPO_CHANGE_L,
 533                                                      (struct dccp_so_feat __user *)
 534                                                      optval);
 535                 break;
 536         case DCCP_SOCKOPT_CHANGE_R:
 537                 if (optlen != sizeof(struct dccp_so_feat))
 538                         err = -EINVAL;
 539                 else
 540                         err = dccp_setsockopt_change(sk, DCCPO_CHANGE_R,
 541                                                      (struct dccp_so_feat __user *)
 542                                                      optval);
 543                 break;
 544         case DCCP_SOCKOPT_SERVER_TIMEWAIT:
 545                 if (dp->dccps_role != DCCP_ROLE_SERVER)
 546                         err = -EOPNOTSUPP;
 547                 else
 548                         dp->dccps_server_timewait = (val != 0);
 549                 break;
 550         case DCCP_SOCKOPT_SEND_CSCOV:   /* sender side, RFC 4340, sec. 9.2 */
 551                 if (val < 0 || val > 15)
 552                         err = -EINVAL;
 553                 else
 554                         dp->dccps_pcslen = val;
 555                 break;
 556         case DCCP_SOCKOPT_RECV_CSCOV:   /* receiver side, RFC 4340 sec. 9.2.1 */
 557                 if (val < 0 || val > 15)
 558                         err = -EINVAL;
 559                 else {
 560                         dp->dccps_pcrlen = val;
 561                         /* FIXME: add feature negotiation,
 562                          * ChangeL(MinimumChecksumCoverage, val) */
 563                 }
 564                 break;
 565         default:
 566                 err = -ENOPROTOOPT;
 567                 break;
 568         }
 569
 570         release_sock(sk);
 571         return err;
 572 }
 573
 574 int dccp_setsockopt(struct sock *sk, int level, int optname,
 575                     char __user *optval, int optlen)
 576 {
 577         if (level != SOL_DCCP)
 578                 return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
 579                                                              optname, optval,
 580                                                              optlen);
 581         return do_dccp_setsockopt(sk, level, optname, optval, optlen);
 582 }
 583
 584 EXPORT_SYMBOL_GPL(dccp_setsockopt);
 585
 586 #ifdef CONFIG_COMPAT
 587 int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
 588                            char __user *optval, int optlen)
 589 {
 590         if (level != SOL_DCCP)
 591                 return inet_csk_compat_setsockopt(sk, level, optname,
 592                                                   optval, optlen);
 593         return do_dccp_setsockopt(sk, level, optname, optval, optlen);
 594 }
 595
 596 EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
 597 #endif
 598
 599 static int dccp_getsockopt_service(struct sock *sk, int len,
 600                                    __be32 __user *optval,
 601                                    int __user *optlen)
 602 {
 603         const struct dccp_sock *dp = dccp_sk(sk);
 604         const struct dccp_service_list *sl;
 605         int err = -ENOENT, slen = 0, total_len = sizeof(u32);
 606
 607         lock_sock(sk);
 608         if ((sl = dp->dccps_service_list) != NULL) {
 609                 slen = sl->dccpsl_nr * sizeof(u32);
 610                 total_len += slen;
 611         }
 612
 613         err = -EINVAL;
 614         if (total_len > len)
 615                 goto out;
 616
 617         err = 0;
 618         if (put_user(total_len, optlen) ||
 619             put_user(dp->dccps_service, optval) ||
 620             (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
 621                 err = -EFAULT;
 622 out:
 623         release_sock(sk);
 624         return err;
 625 }
 626
 627 static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
 628                     char __user *optval, int __user *optlen)
 629 {
 630         struct dccp_sock *dp;
 631         int val, len;
 632
 633         if (get_user(len, optlen))
 634                 return -EFAULT;
 635
 636         if (len < (int)sizeof(int))
 637                 return -EINVAL;
 638
 639         dp = dccp_sk(sk);
 640
 641         switch (optname) {
 642         case DCCP_SOCKOPT_PACKET_SIZE:
 643                 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
 644                 return 0;
 645         case DCCP_SOCKOPT_SERVICE:
 646                 return dccp_getsockopt_service(sk, len,
 647                                                (__be32 __user *)optval, optlen);
 648         case DCCP_SOCKOPT_GET_CUR_MPS:
 649                 val = dp->dccps_mss_cache;
 650                 break;
 651         case DCCP_SOCKOPT_SERVER_TIMEWAIT:
 652                 val = dp->dccps_server_timewait;
 653                 break;
 654         case DCCP_SOCKOPT_SEND_CSCOV:
 655                 val = dp->dccps_pcslen;
 656                 break;
 657         case DCCP_SOCKOPT_RECV_CSCOV:
 658                 val = dp->dccps_pcrlen;
 659                 break;
 660         case 128 ... 191:
 661                 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
 662                                              len, (u32 __user *)optval, optlen);
 663         case 192 ... 255:
 664                 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
 665                                              len, (u32 __user *)optval, optlen);
 666         default:
 667                 return -ENOPROTOOPT;
 668         }
 669
 670         len = sizeof(val);
 671         if (put_user(len, optlen) || copy_to_user(optval, &val, len))
 672                 return -EFAULT;
 673
 674         return 0;
 675 }
 676
 677 int dccp_getsockopt(struct sock *sk, int level, int optname,
 678                     char __user *optval, int __user *optlen)
 679 {
 680         if (level != SOL_DCCP)
 681                 return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
 682                                                              optname, optval,
 683                                                              optlen);
 684         return do_dccp_getsockopt(sk, level, optname, optval, optlen);
 685 }
 686
 687 EXPORT_SYMBOL_GPL(dccp_getsockopt);
 688
 689 #ifdef CONFIG_COMPAT
 690 int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
 691                            char __user *optval, int __user *optlen)
 692 {
 693         if (level != SOL_DCCP)
 694                 return inet_csk_compat_getsockopt(sk, level, optname,
 695                                                   optval, optlen);
 696         return do_dccp_getsockopt(sk, level, optname, optval, optlen);
 697 }
 698
 699 EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
 700 #endif
 701
 702 int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
 703                  size_t len)
 704 {
 705         const struct dccp_sock *dp = dccp_sk(sk);
 706         const int flags = msg->msg_flags;
 707         const int noblock = flags & MSG_DONTWAIT;
 708         struct sk_buff *skb;
 709         int rc, size;
 710         long timeo;
 711
 712         if (len > dp->dccps_mss_cache)
 713                 return -EMSGSIZE;
 714
 715         lock_sock(sk);
 716
 717         if (sysctl_dccp_tx_qlen &&
 718             (sk->sk_write_queue.qlen >= sysctl_dccp_tx_qlen)) {
 719                 rc = -EAGAIN;
 720                 goto out_release;
 721         }
 722
 723         timeo = sock_sndtimeo(sk, noblock);
 724
 725         /*
 726          * We have to use sk_stream_wait_connect here to set sk_write_pending,
 727          * so that the trick in dccp_rcv_request_sent_state_process.
 728          */
 729         /* Wait for a connection to finish. */
 730         if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
 731                 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
 732                         goto out_release;
 733
 734         size = sk->sk_prot->max_header + len;
 735         release_sock(sk);
 736         skb = sock_alloc_send_skb(sk, size, noblock, &rc);
 737         lock_sock(sk);
 738         if (skb == NULL)
 739                 goto out_release;
 740
 741         skb_reserve(skb, sk->sk_prot->max_header);
 742         rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
 743         if (rc != 0)
 744                 goto out_discard;
 745
 746         skb_queue_tail(&sk->sk_write_queue, skb);
 747         dccp_write_xmit(sk,0);
 748 out_release:
 749         release_sock(sk);
 750         return rc ? : len;
 751 out_discard:
 752         kfree_skb(skb);
 753         goto out_release;
 754 }
 755
 756 EXPORT_SYMBOL_GPL(dccp_sendmsg);
 757
 758 int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
 759                  size_t len, int nonblock, int flags, int *addr_len)
 760 {
 761         const struct dccp_hdr *dh;
 762         long timeo;
 763
 764         lock_sock(sk);
 765
 766         if (sk->sk_state == DCCP_LISTEN) {
 767                 len = -ENOTCONN;
 768                 goto out;
 769         }
 770
 771         timeo = sock_rcvtimeo(sk, nonblock);
 772
 773         do {
 774                 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
 775
 776                 if (skb == NULL)
 777                         goto verify_sock_status;
 778
 779                 dh = dccp_hdr(skb);
 780
 781                 switch (dh->dccph_type) {
 782                 case DCCP_PKT_DATA:
 783                 case DCCP_PKT_DATAACK:
 784                         goto found_ok_skb;
 785
 786                 case DCCP_PKT_CLOSE:
 787                 case DCCP_PKT_CLOSEREQ:
 788                         if (!(flags & MSG_PEEK))
 789                                 dccp_finish_passive_close(sk);
 790                         /* fall through */
 791                 case DCCP_PKT_RESET:
 792                         dccp_pr_debug("found fin (%s) ok!\n",
 793                                       dccp_packet_name(dh->dccph_type));
 794                         len = 0;
 795                         goto found_fin_ok;
 796                 default:
 797                         dccp_pr_debug("packet_type=%s\n",
 798                                       dccp_packet_name(dh->dccph_type));
 799                         sk_eat_skb(sk, skb, 0);
 800                 }
 801 verify_sock_status:
 802                 if (sock_flag(sk, SOCK_DONE)) {
 803                         len = 0;
 804                         break;
 805                 }
 806
 807                 if (sk->sk_err) {
 808                         len = sock_error(sk);
 809                         break;
 810                 }
 811
 812                 if (sk->sk_shutdown & RCV_SHUTDOWN) {
 813                         len = 0;
 814                         break;
 815                 }
 816
 817                 if (sk->sk_state == DCCP_CLOSED) {
 818                         if (!sock_flag(sk, SOCK_DONE)) {
 819                                 /* This occurs when user tries to read
 820                                  * from never connected socket.
 821                                  */
 822                                 len = -ENOTCONN;
 823                                 break;
 824                         }
 825                         len = 0;
 826                         break;
 827                 }
 828
 829                 if (!timeo) {
 830                         len = -EAGAIN;
 831                         break;
 832                 }
 833
 834                 if (signal_pending(current)) {
 835                         len = sock_intr_errno(timeo);
 836                         break;
 837                 }
 838
 839                 sk_wait_data(sk, &timeo);
 840                 continue;
 841         found_ok_skb:
 842                 if (len > skb->len)
 843                         len = skb->len;
 844                 else if (len < skb->len)
 845                         msg->msg_flags |= MSG_TRUNC;
 846
 847                 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) {
 848                         /* Exception. Bailout! */
 849                         len = -EFAULT;
 850                         break;
 851                 }
 852         found_fin_ok:
 853                 if (!(flags & MSG_PEEK))
 854                         sk_eat_skb(sk, skb, 0);
 855                 break;
 856         } while (1);
 857 out:
 858         release_sock(sk);
 859         return len;
 860 }
 861
 862 EXPORT_SYMBOL_GPL(dccp_recvmsg);
 863
 864 int inet_dccp_listen(struct socket *sock, int backlog)
 865 {
 866         struct sock *sk = sock->sk;
 867         unsigned char old_state;
 868         int err;
 869
 870         lock_sock(sk);
 871
 872         err = -EINVAL;
 873         if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
 874                 goto out;
 875
 876         old_state = sk->sk_state;
 877         if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
 878                 goto out;
 879
 880         /* Really, if the socket is already in listen state
 881          * we can only allow the backlog to be adjusted.
 882          */
 883         if (old_state != DCCP_LISTEN) {
 884                 /*
 885                  * FIXME: here it probably should be sk->sk_prot->listen_start
 886                  * see tcp_listen_start
 887                  */
 888                 err = dccp_listen_start(sk, backlog);
 889                 if (err)
 890                         goto out;
 891         }
 892         sk->sk_max_ack_backlog = backlog;
 893         err = 0;
 894
 895 out:
 896         release_sock(sk);
 897         return err;
 898 }
 899
 900 EXPORT_SYMBOL_GPL(inet_dccp_listen);
 901
 902 static void dccp_terminate_connection(struct sock *sk)
 903 {
 904         u8 next_state = DCCP_CLOSED;
 905
 906         switch (sk->sk_state) {
 907         case DCCP_PASSIVE_CLOSE:
 908         case DCCP_PASSIVE_CLOSEREQ:
 909                 dccp_finish_passive_close(sk);
 910                 break;
 911         case DCCP_PARTOPEN:
 912                 dccp_pr_debug("Stop PARTOPEN timer (%p)\n", sk);
 913                 inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
 914                 /* fall through */
 915         case DCCP_OPEN:
 916                 dccp_send_close(sk, 1);
 917
 918                 if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER &&
 919                     !dccp_sk(sk)->dccps_server_timewait)
 920                         next_state = DCCP_ACTIVE_CLOSEREQ;
 921                 else
 922                         next_state = DCCP_CLOSING;
 923                 /* fall through */
 924         default:
 925                 dccp_set_state(sk, next_state);
 926         }
 927 }
 928
 929 void dccp_close(struct sock *sk, long timeout)
 930 {
 931         struct dccp_sock *dp = dccp_sk(sk);
 932         struct sk_buff *skb;
 933         u32 data_was_unread = 0;
 934         int state;
 935
 936         lock_sock(sk);
 937
 938         sk->sk_shutdown = SHUTDOWN_MASK;
 939
 940         if (sk->sk_state == DCCP_LISTEN) {
 941                 dccp_set_state(sk, DCCP_CLOSED);
 942
 943                 /* Special case. */
 944                 inet_csk_listen_stop(sk);
 945
 946                 goto adjudge_to_death;
 947         }
 948
 949         sk_stop_timer(sk, &dp->dccps_xmit_timer);
 950
 951         /*
 952          * We need to flush the recv. buffs.  We do this only on the
 953          * descriptor close, not protocol-sourced closes, because the
 954           *reader process may not have drained the data yet!
 955          */
 956         while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
 957                 data_was_unread += skb->len;
 958                 __kfree_skb(skb);
 959         }
 960
 961         if (data_was_unread) {
 962                 /* Unread data was tossed, send an appropriate Reset Code */
 963                 DCCP_WARN("DCCP: ABORT -- %u bytes unread\n", data_was_unread);
 964                 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
 965                 dccp_set_state(sk, DCCP_CLOSED);
 966         } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
 967                 /* Check zero linger _after_ checking for unread data. */
 968                 sk->sk_prot->disconnect(sk, 0);
 969         } else if (sk->sk_state != DCCP_CLOSED) {
 970                 dccp_terminate_connection(sk);
 971         }
 972
 973         sk_stream_wait_close(sk, timeout);
 974
 975 adjudge_to_death:
 976         state = sk->sk_state;
 977         sock_hold(sk);
 978         sock_orphan(sk);
 979         atomic_inc(sk->sk_prot->orphan_count);
 980
 981         /*
 982          * It is the last release_sock in its life. It will remove backlog.
 983          */
 984         release_sock(sk);
 985         /*
 986          * Now socket is owned by kernel and we acquire BH lock
 987          * to finish close. No need to check for user refs.
 988          */
 989         local_bh_disable();
 990         bh_lock_sock(sk);
 991         WARN_ON(sock_owned_by_user(sk));
 992
 993         /* Have we already been destroyed by a softirq or backlog? */
 994         if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
 995                 goto out;
 996
 997         if (sk->sk_state == DCCP_CLOSED)
 998                 inet_csk_destroy_sock(sk);
 999
1000         /* Otherwise, socket is reprieved until protocol close. */
1001
1002 out:
1003         bh_unlock_sock(sk);
1004         local_bh_enable();
1005         sock_put(sk);
1006 }
1007
1008 EXPORT_SYMBOL_GPL(dccp_close);
1009
1010 void dccp_shutdown(struct sock *sk, int how)
1011 {
1012         dccp_pr_debug("called shutdown(%x)\n", how);
1013 }
1014
1015 EXPORT_SYMBOL_GPL(dccp_shutdown);
1016
1017 static inline int dccp_mib_init(void)
1018 {
1019         return snmp_mib_init((void**)dccp_statistics, sizeof(struct dccp_mib));
1020 }
1021
1022 static inline void dccp_mib_exit(void)
1023 {
1024         snmp_mib_free((void**)dccp_statistics);
1025 }
1026
1027 static int thash_entries;
1028 module_param(thash_entries, int, 0444);
1029 MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
1030
1031 #ifdef CONFIG_IP_DCCP_DEBUG
1032 int dccp_debug;
1033 module_param(dccp_debug, bool, 0444);
1034 MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
1035
1036 EXPORT_SYMBOL_GPL(dccp_debug);
1037 #endif
1038
1039 static int __init dccp_init(void)
1040 {
1041         unsigned long goal;
1042         int ehash_order, bhash_order, i;
1043         int rc = -ENOBUFS;
1044
1045         BUILD_BUG_ON(sizeof(struct dccp_skb_cb) >
1046                      FIELD_SIZEOF(struct sk_buff, cb));
1047
1048         dccp_hashinfo.bind_bucket_cachep =
1049                 kmem_cache_create("dccp_bind_bucket",
1050                                   sizeof(struct inet_bind_bucket), 0,
1051                                   SLAB_HWCACHE_ALIGN, NULL);
1052         if (!dccp_hashinfo.bind_bucket_cachep)
1053                 goto out;
1054
1055         /*
1056          * Size and allocate the main established and bind bucket
1057          * hash tables.
1058          *
1059          * The methodology is similar to that of the buffer cache.
1060          */
1061         if (num_physpages >= (128 * 1024))
1062                 goal = num_physpages >> (21 - PAGE_SHIFT);
1063         else
1064                 goal = num_physpages >> (23 - PAGE_SHIFT);
1065
1066         if (thash_entries)
1067                 goal = (thash_entries *
1068                         sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
1069         for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
1070                 ;
1071         do {
1072                 dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE /
1073                                         sizeof(struct inet_ehash_bucket);
1074                 while (dccp_hashinfo.ehash_size &
1075                        (dccp_hashinfo.ehash_size - 1))
1076                         dccp_hashinfo.ehash_size--;
1077                 dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
1078                         __get_free_pages(GFP_ATOMIC, ehash_order);
1079         } while (!dccp_hashinfo.ehash && --ehash_order > 0);
1080
1081         if (!dccp_hashinfo.ehash) {
1082                 DCCP_CRIT("Failed to allocate DCCP established hash table");
1083                 goto out_free_bind_bucket_cachep;
1084         }
1085
1086         for (i = 0; i < dccp_hashinfo.ehash_size; i++) {
1087                 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain);
1088                 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].twchain);
1089         }
1090
1091         if (inet_ehash_locks_alloc(&dccp_hashinfo))
1092                         goto out_free_dccp_ehash;
1093
1094         bhash_order = ehash_order;
1095
1096         do {
1097                 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
1098                                         sizeof(struct inet_bind_hashbucket);
1099                 if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
1100                     bhash_order > 0)
1101                         continue;
1102                 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
1103                         __get_free_pages(GFP_ATOMIC, bhash_order);
1104         } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
1105
1106         if (!dccp_hashinfo.bhash) {
1107                 DCCP_CRIT("Failed to allocate DCCP bind hash table");
1108                 goto out_free_dccp_locks;
1109         }
1110
1111         for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
1112                 spin_lock_init(&dccp_hashinfo.bhash[i].lock);
1113                 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
1114         }
1115
1116         rc = dccp_mib_init();
1117         if (rc)
1118                 goto out_free_dccp_bhash;
1119
1120         rc = dccp_ackvec_init();
1121         if (rc)
1122                 goto out_free_dccp_mib;
1123
1124         rc = dccp_sysctl_init();
1125         if (rc)
1126                 goto out_ackvec_exit;
1127
1128         dccp_timestamping_init();
1129 out:
1130         return rc;
1131 out_ackvec_exit:
1132         dccp_ackvec_exit();
1133 out_free_dccp_mib:
1134         dccp_mib_exit();
1135 out_free_dccp_bhash:
1136         free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
1137         dccp_hashinfo.bhash = NULL;
1138 out_free_dccp_locks:
1139         inet_ehash_locks_free(&dccp_hashinfo);
1140 out_free_dccp_ehash:
1141         free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
1142         dccp_hashinfo.ehash = NULL;
1143 out_free_bind_bucket_cachep:
1144         kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1145         dccp_hashinfo.bind_bucket_cachep = NULL;
1146         goto out;
1147 }
1148
1149 static void __exit dccp_fini(void)
1150 {
1151         dccp_mib_exit();
1152         free_pages((unsigned long)dccp_hashinfo.bhash,
1153                    get_order(dccp_hashinfo.bhash_size *
1154                              sizeof(struct inet_bind_hashbucket)));
1155         free_pages((unsigned long)dccp_hashinfo.ehash,
1156                    get_order(dccp_hashinfo.ehash_size *
1157                              sizeof(struct inet_ehash_bucket)));
1158         inet_ehash_locks_free(&dccp_hashinfo);
1159         kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1160         dccp_ackvec_exit();
1161         dccp_sysctl_exit();
1162 }
1163
1164 module_init(dccp_init);
1165 module_exit(dccp_fini);
1166
1167 MODULE_LICENSE("GPL");
1168 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
1169 MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");