linux/net/ipv4/inet_connection_sock.c
<<
>>
Prefs
   1/*
   2 * INET         An implementation of the TCP/IP protocol suite for the LINUX
   3 *              operating system.  INET is implemented using the  BSD Socket
   4 *              interface as the means of communication with the user level.
   5 *
   6 *              Support for INET connection oriented protocols.
   7 *
   8 * Authors:     See the TCP sources
   9 *
  10 *              This program is free software; you can redistribute it and/or
  11 *              modify it under the terms of the GNU General Public License
  12 *              as published by the Free Software Foundation; either version
  13 *              2 of the License, or(at your option) any later version.
  14 */
  15
  16#include <linux/module.h>
  17#include <linux/jhash.h>
  18
  19#include <net/inet_connection_sock.h>
  20#include <net/inet_hashtables.h>
  21#include <net/inet_timewait_sock.h>
  22#include <net/ip.h>
  23#include <net/route.h>
  24#include <net/tcp_states.h>
  25#include <net/xfrm.h>
  26
  27#ifdef INET_CSK_DEBUG
  28const char inet_csk_timer_bug_msg[] = "inet_csk BUG: unknown timer value\n";
  29EXPORT_SYMBOL(inet_csk_timer_bug_msg);
  30#endif
  31
  32/*
  33 * This struct holds the first and last local port number.
  34 */
  35struct local_ports sysctl_local_ports __read_mostly = {
  36        .lock = SEQLOCK_UNLOCKED,
  37        .range = { 32768, 61000 },
  38};
  39
  40void inet_get_local_port_range(int *low, int *high)
  41{
  42        unsigned seq;
  43        do {
  44                seq = read_seqbegin(&sysctl_local_ports.lock);
  45
  46                *low = sysctl_local_ports.range[0];
  47                *high = sysctl_local_ports.range[1];
  48        } while (read_seqretry(&sysctl_local_ports.lock, seq));
  49}
  50EXPORT_SYMBOL(inet_get_local_port_range);
  51
  52int inet_csk_bind_conflict(const struct sock *sk,
  53                           const struct inet_bind_bucket *tb)
  54{
  55        const __be32 sk_rcv_saddr = inet_rcv_saddr(sk);
  56        struct sock *sk2;
  57        struct hlist_node *node;
  58        int reuse = sk->sk_reuse;
  59
  60        /*
  61         * Unlike other sk lookup places we do not check
  62         * for sk_net here, since _all_ the socks listed
  63         * in tb->owners list belong to the same net - the
  64         * one this bucket belongs to.
  65         */
  66
  67        sk_for_each_bound(sk2, node, &tb->owners) {
  68                if (sk != sk2 &&
  69                    !inet_v6_ipv6only(sk2) &&
  70                    (!sk->sk_bound_dev_if ||
  71                     !sk2->sk_bound_dev_if ||
  72                     sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {
  73                        if (!reuse || !sk2->sk_reuse ||
  74                            sk2->sk_state == TCP_LISTEN) {
  75                                const __be32 sk2_rcv_saddr = inet_rcv_saddr(sk2);
  76                                if (!sk2_rcv_saddr || !sk_rcv_saddr ||
  77                                    sk2_rcv_saddr == sk_rcv_saddr)
  78                                        break;
  79                        }
  80                }
  81        }
  82        return node != NULL;
  83}
  84
  85EXPORT_SYMBOL_GPL(inet_csk_bind_conflict);
  86
  87/* Obtain a reference to a local port for the given sock,
  88 * if snum is zero it means select any available local port.
  89 */
  90int inet_csk_get_port(struct sock *sk, unsigned short snum)
  91{
  92        struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo;
  93        struct inet_bind_hashbucket *head;
  94        struct hlist_node *node;
  95        struct inet_bind_bucket *tb;
  96        int ret, attempts = 5;
  97        struct net *net = sock_net(sk);
  98        int smallest_size = -1, smallest_rover;
  99
 100        local_bh_disable();
 101        if (!snum) {
 102                int remaining, rover, low, high;
 103
 104again:
 105                inet_get_local_port_range(&low, &high);
 106                remaining = (high - low) + 1;
 107                smallest_rover = rover = net_random() % remaining + low;
 108
 109                smallest_size = -1;
 110                do {
 111                        head = &hashinfo->bhash[inet_bhashfn(net, rover,
 112                                        hashinfo->bhash_size)];
 113                        spin_lock(&head->lock);
 114                        inet_bind_bucket_for_each(tb, node, &head->chain)
 115                                if (ib_net(tb) == net && tb->port == rover) {
 116                                        if (tb->fastreuse > 0 &&
 117                                            sk->sk_reuse &&
 118                                            sk->sk_state != TCP_LISTEN &&
 119                                            (tb->num_owners < smallest_size || smallest_size == -1)) {
 120                                                smallest_size = tb->num_owners;
 121                                                smallest_rover = rover;
 122                                                if (atomic_read(&hashinfo->bsockets) > (high - low) + 1) {
 123                                                        spin_unlock(&head->lock);
 124                                                        snum = smallest_rover;
 125                                                        goto have_snum;
 126                                                }
 127                                        }
 128                                        goto next;
 129                                }
 130                        break;
 131                next:
 132                        spin_unlock(&head->lock);
 133                        if (++rover > high)
 134                                rover = low;
 135                } while (--remaining > 0);
 136
 137                /* Exhausted local port range during search?  It is not
 138                 * possible for us to be holding one of the bind hash
 139                 * locks if this test triggers, because if 'remaining'
 140                 * drops to zero, we broke out of the do/while loop at
 141                 * the top level, not from the 'break;' statement.
 142                 */
 143                ret = 1;
 144                if (remaining <= 0) {
 145                        if (smallest_size != -1) {
 146                                snum = smallest_rover;
 147                                goto have_snum;
 148                        }
 149                        goto fail;
 150                }
 151                /* OK, here is the one we will use.  HEAD is
 152                 * non-NULL and we hold it's mutex.
 153                 */
 154                snum = rover;
 155        } else {
 156have_snum:
 157                head = &hashinfo->bhash[inet_bhashfn(net, snum,
 158                                hashinfo->bhash_size)];
 159                spin_lock(&head->lock);
 160                inet_bind_bucket_for_each(tb, node, &head->chain)
 161                        if (ib_net(tb) == net && tb->port == snum)
 162                                goto tb_found;
 163        }
 164        tb = NULL;
 165        goto tb_not_found;
 166tb_found:
 167        if (!hlist_empty(&tb->owners)) {
 168                if (tb->fastreuse > 0 &&
 169                    sk->sk_reuse && sk->sk_state != TCP_LISTEN &&
 170                    smallest_size == -1) {
 171                        goto success;
 172                } else {
 173                        ret = 1;
 174                        if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb)) {
 175                                if (sk->sk_reuse && sk->sk_state != TCP_LISTEN &&
 176                                    smallest_size != -1 && --attempts >= 0) {
 177                                        spin_unlock(&head->lock);
 178                                        goto again;
 179                                }
 180                                goto fail_unlock;
 181                        }
 182                }
 183        }
 184tb_not_found:
 185        ret = 1;
 186        if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep,
 187                                        net, head, snum)) == NULL)
 188                goto fail_unlock;
 189        if (hlist_empty(&tb->owners)) {
 190                if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
 191                        tb->fastreuse = 1;
 192                else
 193                        tb->fastreuse = 0;
 194        } else if (tb->fastreuse &&
 195                   (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
 196                tb->fastreuse = 0;
 197success:
 198        if (!inet_csk(sk)->icsk_bind_hash)
 199                inet_bind_hash(sk, tb, snum);
 200        WARN_ON(inet_csk(sk)->icsk_bind_hash != tb);
 201        ret = 0;
 202
 203fail_unlock:
 204        spin_unlock(&head->lock);
 205fail:
 206        local_bh_enable();
 207        return ret;
 208}
 209
 210EXPORT_SYMBOL_GPL(inet_csk_get_port);
 211
 212/*
 213 * Wait for an incoming connection, avoid race conditions. This must be called
 214 * with the socket locked.
 215 */
 216static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
 217{
 218        struct inet_connection_sock *icsk = inet_csk(sk);
 219        DEFINE_WAIT(wait);
 220        int err;
 221
 222        /*
 223         * True wake-one mechanism for incoming connections: only
 224         * one process gets woken up, not the 'whole herd'.
 225         * Since we do not 'race & poll' for established sockets
 226         * anymore, the common case will execute the loop only once.
 227         *
 228         * Subtle issue: "add_wait_queue_exclusive()" will be added
 229         * after any current non-exclusive waiters, and we know that
 230         * it will always _stay_ after any new non-exclusive waiters
 231         * because all non-exclusive waiters are added at the
 232         * beginning of the wait-queue. As such, it's ok to "drop"
 233         * our exclusiveness temporarily when we get woken up without
 234         * having to remove and re-insert us on the wait queue.
 235         */
 236        for (;;) {
 237                prepare_to_wait_exclusive(sk->sk_sleep, &wait,
 238                                          TASK_INTERRUPTIBLE);
 239                release_sock(sk);
 240                if (reqsk_queue_empty(&icsk->icsk_accept_queue))
 241                        timeo = schedule_timeout(timeo);
 242                lock_sock(sk);
 243                err = 0;
 244                if (!reqsk_queue_empty(&icsk->icsk_accept_queue))
 245                        break;
 246                err = -EINVAL;
 247                if (sk->sk_state != TCP_LISTEN)
 248                        break;
 249                err = sock_intr_errno(timeo);
 250                if (signal_pending(current))
 251                        break;
 252                err = -EAGAIN;
 253                if (!timeo)
 254                        break;
 255        }
 256        finish_wait(sk->sk_sleep, &wait);
 257        return err;
 258}
 259
 260/*
 261 * This will accept the next outstanding connection.
 262 */
 263struct sock *inet_csk_accept(struct sock *sk, int flags, int *err)
 264{
 265        struct inet_connection_sock *icsk = inet_csk(sk);
 266        struct sock *newsk;
 267        int error;
 268
 269        lock_sock(sk);
 270
 271        /* We need to make sure that this socket is listening,
 272         * and that it has something pending.
 273         */
 274        error = -EINVAL;
 275        if (sk->sk_state != TCP_LISTEN)
 276                goto out_err;
 277
 278        /* Find already established connection */
 279        if (reqsk_queue_empty(&icsk->icsk_accept_queue)) {
 280                long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 281
 282                /* If this is a non blocking socket don't sleep */
 283                error = -EAGAIN;
 284                if (!timeo)
 285                        goto out_err;
 286
 287                error = inet_csk_wait_for_connect(sk, timeo);
 288                if (error)
 289                        goto out_err;
 290        }
 291
 292        newsk = reqsk_queue_get_child(&icsk->icsk_accept_queue, sk);
 293        WARN_ON(newsk->sk_state == TCP_SYN_RECV);
 294out:
 295        release_sock(sk);
 296        return newsk;
 297out_err:
 298        newsk = NULL;
 299        *err = error;
 300        goto out;
 301}
 302
 303EXPORT_SYMBOL(inet_csk_accept);
 304
 305/*
 306 * Using different timers for retransmit, delayed acks and probes
 307 * We may wish use just one timer maintaining a list of expire jiffies
 308 * to optimize.
 309 */
 310void inet_csk_init_xmit_timers(struct sock *sk,
 311                               void (*retransmit_handler)(unsigned long),
 312                               void (*delack_handler)(unsigned long),
 313                               void (*keepalive_handler)(unsigned long))
 314{
 315        struct inet_connection_sock *icsk = inet_csk(sk);
 316
 317        setup_timer(&icsk->icsk_retransmit_timer, retransmit_handler,
 318                        (unsigned long)sk);
 319        setup_timer(&icsk->icsk_delack_timer, delack_handler,
 320                        (unsigned long)sk);
 321        setup_timer(&sk->sk_timer, keepalive_handler, (unsigned long)sk);
 322        icsk->icsk_pending = icsk->icsk_ack.pending = 0;
 323}
 324
 325EXPORT_SYMBOL(inet_csk_init_xmit_timers);
 326
 327void inet_csk_clear_xmit_timers(struct sock *sk)
 328{
 329        struct inet_connection_sock *icsk = inet_csk(sk);
 330
 331        icsk->icsk_pending = icsk->icsk_ack.pending = icsk->icsk_ack.blocked = 0;
 332
 333        sk_stop_timer(sk, &icsk->icsk_retransmit_timer);
 334        sk_stop_timer(sk, &icsk->icsk_delack_timer);
 335        sk_stop_timer(sk, &sk->sk_timer);
 336}
 337
 338EXPORT_SYMBOL(inet_csk_clear_xmit_timers);
 339
 340void inet_csk_delete_keepalive_timer(struct sock *sk)
 341{
 342        sk_stop_timer(sk, &sk->sk_timer);
 343}
 344
 345EXPORT_SYMBOL(inet_csk_delete_keepalive_timer);
 346
 347void inet_csk_reset_keepalive_timer(struct sock *sk, unsigned long len)
 348{
 349        sk_reset_timer(sk, &sk->sk_timer, jiffies + len);
 350}
 351
 352EXPORT_SYMBOL(inet_csk_reset_keepalive_timer);
 353
 354struct dst_entry *inet_csk_route_req(struct sock *sk,
 355                                     const struct request_sock *req)
 356{
 357        struct rtable *rt;
 358        const struct inet_request_sock *ireq = inet_rsk(req);
 359        struct ip_options *opt = inet_rsk(req)->opt;
 360        struct flowi fl = { .oif = sk->sk_bound_dev_if,
 361                            .nl_u = { .ip4_u =
 362                                      { .daddr = ((opt && opt->srr) ?
 363                                                  opt->faddr :
 364                                                  ireq->rmt_addr),
 365                                        .saddr = ireq->loc_addr,
 366                                        .tos = RT_CONN_FLAGS(sk) } },
 367                            .proto = sk->sk_protocol,
 368                            .flags = inet_sk_flowi_flags(sk),
 369                            .uli_u = { .ports =
 370                                       { .sport = inet_sk(sk)->sport,
 371                                         .dport = ireq->rmt_port } } };
 372        struct net *net = sock_net(sk);
 373
 374        security_req_classify_flow(req, &fl);
 375        if (ip_route_output_flow(net, &rt, &fl, sk, 0))
 376                goto no_route;
 377        if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway)
 378                goto route_err;
 379        return &rt->u.dst;
 380
 381route_err:
 382        ip_rt_put(rt);
 383no_route:
 384        IP_INC_STATS_BH(net, IPSTATS_MIB_OUTNOROUTES);
 385        return NULL;
 386}
 387
 388EXPORT_SYMBOL_GPL(inet_csk_route_req);
 389
 390static inline u32 inet_synq_hash(const __be32 raddr, const __be16 rport,
 391                                 const u32 rnd, const u32 synq_hsize)
 392{
 393        return jhash_2words((__force u32)raddr, (__force u32)rport, rnd) & (synq_hsize - 1);
 394}
 395
 396#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 397#define AF_INET_FAMILY(fam) ((fam) == AF_INET)
 398#else
 399#define AF_INET_FAMILY(fam) 1
 400#endif
 401
 402struct request_sock *inet_csk_search_req(const struct sock *sk,
 403                                         struct request_sock ***prevp,
 404                                         const __be16 rport, const __be32 raddr,
 405                                         const __be32 laddr)
 406{
 407        const struct inet_connection_sock *icsk = inet_csk(sk);
 408        struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt;
 409        struct request_sock *req, **prev;
 410
 411        for (prev = &lopt->syn_table[inet_synq_hash(raddr, rport, lopt->hash_rnd,
 412                                                    lopt->nr_table_entries)];
 413             (req = *prev) != NULL;
 414             prev = &req->dl_next) {
 415                const struct inet_request_sock *ireq = inet_rsk(req);
 416
 417                if (ireq->rmt_port == rport &&
 418                    ireq->rmt_addr == raddr &&
 419                    ireq->loc_addr == laddr &&
 420                    AF_INET_FAMILY(req->rsk_ops->family)) {
 421                        WARN_ON(req->sk);
 422                        *prevp = prev;
 423                        break;
 424                }
 425        }
 426
 427        return req;
 428}
 429
 430EXPORT_SYMBOL_GPL(inet_csk_search_req);
 431
 432void inet_csk_reqsk_queue_hash_add(struct sock *sk, struct request_sock *req,
 433                                   unsigned long timeout)
 434{
 435        struct inet_connection_sock *icsk = inet_csk(sk);
 436        struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt;
 437        const u32 h = inet_synq_hash(inet_rsk(req)->rmt_addr, inet_rsk(req)->rmt_port,
 438                                     lopt->hash_rnd, lopt->nr_table_entries);
 439
 440        reqsk_queue_hash_req(&icsk->icsk_accept_queue, h, req, timeout);
 441        inet_csk_reqsk_queue_added(sk, timeout);
 442}
 443
 444/* Only thing we need from tcp.h */
 445extern int sysctl_tcp_synack_retries;
 446
 447EXPORT_SYMBOL_GPL(inet_csk_reqsk_queue_hash_add);
 448
 449void inet_csk_reqsk_queue_prune(struct sock *parent,
 450                                const unsigned long interval,
 451                                const unsigned long timeout,
 452                                const unsigned long max_rto)
 453{
 454        struct inet_connection_sock *icsk = inet_csk(parent);
 455        struct request_sock_queue *queue = &icsk->icsk_accept_queue;
 456        struct listen_sock *lopt = queue->listen_opt;
 457        int max_retries = icsk->icsk_syn_retries ? : sysctl_tcp_synack_retries;
 458        int thresh = max_retries;
 459        unsigned long now = jiffies;
 460        struct request_sock **reqp, *req;
 461        int i, budget;
 462
 463        if (lopt == NULL || lopt->qlen == 0)
 464                return;
 465
 466        /* Normally all the openreqs are young and become mature
 467         * (i.e. converted to established socket) for first timeout.
 468         * If synack was not acknowledged for 3 seconds, it means
 469         * one of the following things: synack was lost, ack was lost,
 470         * rtt is high or nobody planned to ack (i.e. synflood).
 471         * When server is a bit loaded, queue is populated with old
 472         * open requests, reducing effective size of queue.
 473         * When server is well loaded, queue size reduces to zero
 474         * after several minutes of work. It is not synflood,
 475         * it is normal operation. The solution is pruning
 476         * too old entries overriding normal timeout, when
 477         * situation becomes dangerous.
 478         *
 479         * Essentially, we reserve half of room for young
 480         * embrions; and abort old ones without pity, if old
 481         * ones are about to clog our table.
 482         */
 483        if (lopt->qlen>>(lopt->max_qlen_log-1)) {
 484                int young = (lopt->qlen_young<<1);
 485
 486                while (thresh > 2) {
 487                        if (lopt->qlen < young)
 488                                break;
 489                        thresh--;
 490                        young <<= 1;
 491                }
 492        }
 493
 494        if (queue->rskq_defer_accept)
 495                max_retries = queue->rskq_defer_accept;
 496
 497        budget = 2 * (lopt->nr_table_entries / (timeout / interval));
 498        i = lopt->clock_hand;
 499
 500        do {
 501                reqp=&lopt->syn_table[i];
 502                while ((req = *reqp) != NULL) {
 503                        if (time_after_eq(now, req->expires)) {
 504                                if ((req->retrans < thresh ||
 505                                     (inet_rsk(req)->acked && req->retrans < max_retries))
 506                                    && !req->rsk_ops->rtx_syn_ack(parent, req)) {
 507                                        unsigned long timeo;
 508
 509                                        if (req->retrans++ == 0)
 510                                                lopt->qlen_young--;
 511                                        timeo = min((timeout << req->retrans), max_rto);
 512                                        req->expires = now + timeo;
 513                                        reqp = &req->dl_next;
 514                                        continue;
 515                                }
 516
 517                                /* Drop this request */
 518                                inet_csk_reqsk_queue_unlink(parent, req, reqp);
 519                                reqsk_queue_removed(queue, req);
 520                                reqsk_free(req);
 521                                continue;
 522                        }
 523                        reqp = &req->dl_next;
 524                }
 525
 526                i = (i + 1) & (lopt->nr_table_entries - 1);
 527
 528        } while (--budget > 0);
 529
 530        lopt->clock_hand = i;
 531
 532        if (lopt->qlen)
 533                inet_csk_reset_keepalive_timer(parent, interval);
 534}
 535
 536EXPORT_SYMBOL_GPL(inet_csk_reqsk_queue_prune);
 537
 538struct sock *inet_csk_clone(struct sock *sk, const struct request_sock *req,
 539                            const gfp_t priority)
 540{
 541        struct sock *newsk = sk_clone(sk, priority);
 542
 543        if (newsk != NULL) {
 544                struct inet_connection_sock *newicsk = inet_csk(newsk);
 545
 546                newsk->sk_state = TCP_SYN_RECV;
 547                newicsk->icsk_bind_hash = NULL;
 548
 549                inet_sk(newsk)->dport = inet_rsk(req)->rmt_port;
 550                inet_sk(newsk)->num = ntohs(inet_rsk(req)->loc_port);
 551                inet_sk(newsk)->sport = inet_rsk(req)->loc_port;
 552                newsk->sk_write_space = sk_stream_write_space;
 553
 554                newicsk->icsk_retransmits = 0;
 555                newicsk->icsk_backoff     = 0;
 556                newicsk->icsk_probes_out  = 0;
 557
 558                /* Deinitialize accept_queue to trap illegal accesses. */
 559                memset(&newicsk->icsk_accept_queue, 0, sizeof(newicsk->icsk_accept_queue));
 560
 561                security_inet_csk_clone(newsk, req);
 562        }
 563        return newsk;
 564}
 565
 566EXPORT_SYMBOL_GPL(inet_csk_clone);
 567
 568/*
 569 * At this point, there should be no process reference to this
 570 * socket, and thus no user references at all.  Therefore we
 571 * can assume the socket waitqueue is inactive and nobody will
 572 * try to jump onto it.
 573 */
 574void inet_csk_destroy_sock(struct sock *sk)
 575{
 576        WARN_ON(sk->sk_state != TCP_CLOSE);
 577        WARN_ON(!sock_flag(sk, SOCK_DEAD));
 578
 579        /* It cannot be in hash table! */
 580        WARN_ON(!sk_unhashed(sk));
 581
 582        /* If it has not 0 inet_sk(sk)->num, it must be bound */
 583        WARN_ON(inet_sk(sk)->num && !inet_csk(sk)->icsk_bind_hash);
 584
 585        sk->sk_prot->destroy(sk);
 586
 587        sk_stream_kill_queues(sk);
 588
 589        xfrm_sk_free_policy(sk);
 590
 591        sk_refcnt_debug_release(sk);
 592
 593        percpu_counter_dec(sk->sk_prot->orphan_count);
 594        sock_put(sk);
 595}
 596
 597EXPORT_SYMBOL(inet_csk_destroy_sock);
 598
 599int inet_csk_listen_start(struct sock *sk, const int nr_table_entries)
 600{
 601        struct inet_sock *inet = inet_sk(sk);
 602        struct inet_connection_sock *icsk = inet_csk(sk);
 603        int rc = reqsk_queue_alloc(&icsk->icsk_accept_queue, nr_table_entries);
 604
 605        if (rc != 0)
 606                return rc;
 607
 608        sk->sk_max_ack_backlog = 0;
 609        sk->sk_ack_backlog = 0;
 610        inet_csk_delack_init(sk);
 611
 612        /* There is race window here: we announce ourselves listening,
 613         * but this transition is still not validated by get_port().
 614         * It is OK, because this socket enters to hash table only
 615         * after validation is complete.
 616         */
 617        sk->sk_state = TCP_LISTEN;
 618        if (!sk->sk_prot->get_port(sk, inet->num)) {
 619                inet->sport = htons(inet->num);
 620
 621                sk_dst_reset(sk);
 622                sk->sk_prot->hash(sk);
 623
 624                return 0;
 625        }
 626
 627        sk->sk_state = TCP_CLOSE;
 628        __reqsk_queue_destroy(&icsk->icsk_accept_queue);
 629        return -EADDRINUSE;
 630}
 631
 632EXPORT_SYMBOL_GPL(inet_csk_listen_start);
 633
 634/*
 635 *      This routine closes sockets which have been at least partially
 636 *      opened, but not yet accepted.
 637 */
 638void inet_csk_listen_stop(struct sock *sk)
 639{
 640        struct inet_connection_sock *icsk = inet_csk(sk);
 641        struct request_sock *acc_req;
 642        struct request_sock *req;
 643
 644        inet_csk_delete_keepalive_timer(sk);
 645
 646        /* make all the listen_opt local to us */
 647        acc_req = reqsk_queue_yank_acceptq(&icsk->icsk_accept_queue);
 648
 649        /* Following specs, it would be better either to send FIN
 650         * (and enter FIN-WAIT-1, it is normal close)
 651         * or to send active reset (abort).
 652         * Certainly, it is pretty dangerous while synflood, but it is
 653         * bad justification for our negligence 8)
 654         * To be honest, we are not able to make either
 655         * of the variants now.                 --ANK
 656         */
 657        reqsk_queue_destroy(&icsk->icsk_accept_queue);
 658
 659        while ((req = acc_req) != NULL) {
 660                struct sock *child = req->sk;
 661
 662                acc_req = req->dl_next;
 663
 664                local_bh_disable();
 665                bh_lock_sock(child);
 666                WARN_ON(sock_owned_by_user(child));
 667                sock_hold(child);
 668
 669                sk->sk_prot->disconnect(child, O_NONBLOCK);
 670
 671                sock_orphan(child);
 672
 673                percpu_counter_inc(sk->sk_prot->orphan_count);
 674
 675                inet_csk_destroy_sock(child);
 676
 677                bh_unlock_sock(child);
 678                local_bh_enable();
 679                sock_put(child);
 680
 681                sk_acceptq_removed(sk);
 682                __reqsk_free(req);
 683        }
 684        WARN_ON(sk->sk_ack_backlog);
 685}
 686
 687EXPORT_SYMBOL_GPL(inet_csk_listen_stop);
 688
 689void inet_csk_addr2sockaddr(struct sock *sk, struct sockaddr *uaddr)
 690{
 691        struct sockaddr_in *sin = (struct sockaddr_in *)uaddr;
 692        const struct inet_sock *inet = inet_sk(sk);
 693
 694        sin->sin_family         = AF_INET;
 695        sin->sin_addr.s_addr    = inet->daddr;
 696        sin->sin_port           = inet->dport;
 697}
 698
 699EXPORT_SYMBOL_GPL(inet_csk_addr2sockaddr);
 700
 701#ifdef CONFIG_COMPAT
 702int inet_csk_compat_getsockopt(struct sock *sk, int level, int optname,
 703                               char __user *optval, int __user *optlen)
 704{
 705        const struct inet_connection_sock *icsk = inet_csk(sk);
 706
 707        if (icsk->icsk_af_ops->compat_getsockopt != NULL)
 708                return icsk->icsk_af_ops->compat_getsockopt(sk, level, optname,
 709                                                            optval, optlen);
 710        return icsk->icsk_af_ops->getsockopt(sk, level, optname,
 711                                             optval, optlen);
 712}
 713
 714EXPORT_SYMBOL_GPL(inet_csk_compat_getsockopt);
 715
 716int inet_csk_compat_setsockopt(struct sock *sk, int level, int optname,
 717                               char __user *optval, int optlen)
 718{
 719        const struct inet_connection_sock *icsk = inet_csk(sk);
 720
 721        if (icsk->icsk_af_ops->compat_setsockopt != NULL)
 722                return icsk->icsk_af_ops->compat_setsockopt(sk, level, optname,
 723                                                            optval, optlen);
 724        return icsk->icsk_af_ops->setsockopt(sk, level, optname,
 725                                             optval, optlen);
 726}
 727
 728EXPORT_SYMBOL_GPL(inet_csk_compat_setsockopt);
 729#endif
 730