linux/net/dccp/ipv4.c
<<
>>
Prefs
   1/*
   2 *  net/dccp/ipv4.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
   8 *      modify it under the terms of the GNU General Public License
   9 *      as published by the Free Software Foundation; either version
  10 *      2 of the License, or (at your option) any later version.
  11 */
  12
  13#include <linux/dccp.h>
  14#include <linux/icmp.h>
  15#include <linux/slab.h>
  16#include <linux/module.h>
  17#include <linux/skbuff.h>
  18#include <linux/random.h>
  19
  20#include <net/icmp.h>
  21#include <net/inet_common.h>
  22#include <net/inet_hashtables.h>
  23#include <net/inet_sock.h>
  24#include <net/protocol.h>
  25#include <net/sock.h>
  26#include <net/timewait_sock.h>
  27#include <net/tcp_states.h>
  28#include <net/xfrm.h>
  29#include <net/secure_seq.h>
  30
  31#include "ackvec.h"
  32#include "ccid.h"
  33#include "dccp.h"
  34#include "feat.h"
  35
  36/*
  37 * The per-net dccp.v4_ctl_sk socket is used for responding to
  38 * the Out-of-the-blue (OOTB) packets. A control sock will be created
  39 * for this socket at the initialization time.
  40 */
  41
  42int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
  43{
  44        const struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
  45        struct inet_sock *inet = inet_sk(sk);
  46        struct dccp_sock *dp = dccp_sk(sk);
  47        __be16 orig_sport, orig_dport;
  48        __be32 daddr, nexthop;
  49        struct flowi4 *fl4;
  50        struct rtable *rt;
  51        int err;
  52        struct ip_options_rcu *inet_opt;
  53
  54        dp->dccps_role = DCCP_ROLE_CLIENT;
  55
  56        if (addr_len < sizeof(struct sockaddr_in))
  57                return -EINVAL;
  58
  59        if (usin->sin_family != AF_INET)
  60                return -EAFNOSUPPORT;
  61
  62        nexthop = daddr = usin->sin_addr.s_addr;
  63
  64        inet_opt = rcu_dereference_protected(inet->inet_opt,
  65                                             sock_owned_by_user(sk));
  66        if (inet_opt != NULL && inet_opt->opt.srr) {
  67                if (daddr == 0)
  68                        return -EINVAL;
  69                nexthop = inet_opt->opt.faddr;
  70        }
  71
  72        orig_sport = inet->inet_sport;
  73        orig_dport = usin->sin_port;
  74        fl4 = &inet->cork.fl.u.ip4;
  75        rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
  76                              RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
  77                              IPPROTO_DCCP,
  78                              orig_sport, orig_dport, sk, true);
  79        if (IS_ERR(rt))
  80                return PTR_ERR(rt);
  81
  82        if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
  83                ip_rt_put(rt);
  84                return -ENETUNREACH;
  85        }
  86
  87        if (inet_opt == NULL || !inet_opt->opt.srr)
  88                daddr = fl4->daddr;
  89
  90        if (inet->inet_saddr == 0)
  91                inet->inet_saddr = fl4->saddr;
  92        inet->inet_rcv_saddr = inet->inet_saddr;
  93
  94        inet->inet_dport = usin->sin_port;
  95        inet->inet_daddr = daddr;
  96
  97        inet_csk(sk)->icsk_ext_hdr_len = 0;
  98        if (inet_opt)
  99                inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
 100        /*
 101         * Socket identity is still unknown (sport may be zero).
 102         * However we set state to DCCP_REQUESTING and not releasing socket
 103         * lock select source port, enter ourselves into the hash tables and
 104         * complete initialization after this.
 105         */
 106        dccp_set_state(sk, DCCP_REQUESTING);
 107        err = inet_hash_connect(&dccp_death_row, sk);
 108        if (err != 0)
 109                goto failure;
 110
 111        rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
 112                               inet->inet_sport, inet->inet_dport, sk);
 113        if (IS_ERR(rt)) {
 114                err = PTR_ERR(rt);
 115                rt = NULL;
 116                goto failure;
 117        }
 118        /* OK, now commit destination to socket.  */
 119        sk_setup_caps(sk, &rt->dst);
 120
 121        dp->dccps_iss = secure_dccp_sequence_number(inet->inet_saddr,
 122                                                    inet->inet_daddr,
 123                                                    inet->inet_sport,
 124                                                    inet->inet_dport);
 125        inet->inet_id = dp->dccps_iss ^ jiffies;
 126
 127        err = dccp_connect(sk);
 128        rt = NULL;
 129        if (err != 0)
 130                goto failure;
 131out:
 132        return err;
 133failure:
 134        /*
 135         * This unhashes the socket and releases the local port, if necessary.
 136         */
 137        dccp_set_state(sk, DCCP_CLOSED);
 138        ip_rt_put(rt);
 139        sk->sk_route_caps = 0;
 140        inet->inet_dport = 0;
 141        goto out;
 142}
 143
 144EXPORT_SYMBOL_GPL(dccp_v4_connect);
 145
 146/*
 147 * This routine does path mtu discovery as defined in RFC1191.
 148 */
 149static inline void dccp_do_pmtu_discovery(struct sock *sk,
 150                                          const struct iphdr *iph,
 151                                          u32 mtu)
 152{
 153        struct dst_entry *dst;
 154        const struct inet_sock *inet = inet_sk(sk);
 155        const struct dccp_sock *dp = dccp_sk(sk);
 156
 157        /* We are not interested in DCCP_LISTEN and request_socks (RESPONSEs
 158         * send out by Linux are always < 576bytes so they should go through
 159         * unfragmented).
 160         */
 161        if (sk->sk_state == DCCP_LISTEN)
 162                return;
 163
 164        dst = inet_csk_update_pmtu(sk, mtu);
 165        if (!dst)
 166                return;
 167
 168        /* Something is about to be wrong... Remember soft error
 169         * for the case, if this connection will not able to recover.
 170         */
 171        if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
 172                sk->sk_err_soft = EMSGSIZE;
 173
 174        mtu = dst_mtu(dst);
 175
 176        if (inet->pmtudisc != IP_PMTUDISC_DONT &&
 177            inet_csk(sk)->icsk_pmtu_cookie > mtu) {
 178                dccp_sync_mss(sk, mtu);
 179
 180                /*
 181                 * From RFC 4340, sec. 14.1:
 182                 *
 183                 *      DCCP-Sync packets are the best choice for upward
 184                 *      probing, since DCCP-Sync probes do not risk application
 185                 *      data loss.
 186                 */
 187                dccp_send_sync(sk, dp->dccps_gsr, DCCP_PKT_SYNC);
 188        } /* else let the usual retransmit timer handle it */
 189}
 190
 191static void dccp_do_redirect(struct sk_buff *skb, struct sock *sk)
 192{
 193        struct dst_entry *dst = __sk_dst_check(sk, 0);
 194
 195        if (dst)
 196                dst->ops->redirect(dst, sk, skb);
 197}
 198
 199/*
 200 * This routine is called by the ICMP module when it gets some sort of error
 201 * condition. If err < 0 then the socket should be closed and the error
 202 * returned to the user. If err > 0 it's just the icmp type << 8 | icmp code.
 203 * After adjustment header points to the first 8 bytes of the tcp header. We
 204 * need to find the appropriate port.
 205 *
 206 * The locking strategy used here is very "optimistic". When someone else
 207 * accesses the socket the ICMP is just dropped and for some paths there is no
 208 * check at all. A more general error queue to queue errors for later handling
 209 * is probably better.
 210 */
 211static void dccp_v4_err(struct sk_buff *skb, u32 info)
 212{
 213        const struct iphdr *iph = (struct iphdr *)skb->data;
 214        const u8 offset = iph->ihl << 2;
 215        const struct dccp_hdr *dh = (struct dccp_hdr *)(skb->data + offset);
 216        struct dccp_sock *dp;
 217        struct inet_sock *inet;
 218        const int type = icmp_hdr(skb)->type;
 219        const int code = icmp_hdr(skb)->code;
 220        struct sock *sk;
 221        __u64 seq;
 222        int err;
 223        struct net *net = dev_net(skb->dev);
 224
 225        if (skb->len < offset + sizeof(*dh) ||
 226            skb->len < offset + __dccp_basic_hdr_len(dh)) {
 227                ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
 228                return;
 229        }
 230
 231        sk = inet_lookup(net, &dccp_hashinfo,
 232                        iph->daddr, dh->dccph_dport,
 233                        iph->saddr, dh->dccph_sport, inet_iif(skb));
 234        if (sk == NULL) {
 235                ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
 236                return;
 237        }
 238
 239        if (sk->sk_state == DCCP_TIME_WAIT) {
 240                inet_twsk_put(inet_twsk(sk));
 241                return;
 242        }
 243
 244        bh_lock_sock(sk);
 245        /* If too many ICMPs get dropped on busy
 246         * servers this needs to be solved differently.
 247         */
 248        if (sock_owned_by_user(sk))
 249                NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
 250
 251        if (sk->sk_state == DCCP_CLOSED)
 252                goto out;
 253
 254        dp = dccp_sk(sk);
 255        seq = dccp_hdr_seq(dh);
 256        if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_LISTEN) &&
 257            !between48(seq, dp->dccps_awl, dp->dccps_awh)) {
 258                NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
 259                goto out;
 260        }
 261
 262        switch (type) {
 263        case ICMP_REDIRECT:
 264                dccp_do_redirect(skb, sk);
 265                goto out;
 266        case ICMP_SOURCE_QUENCH:
 267                /* Just silently ignore these. */
 268                goto out;
 269        case ICMP_PARAMETERPROB:
 270                err = EPROTO;
 271                break;
 272        case ICMP_DEST_UNREACH:
 273                if (code > NR_ICMP_UNREACH)
 274                        goto out;
 275
 276                if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
 277                        if (!sock_owned_by_user(sk))
 278                                dccp_do_pmtu_discovery(sk, iph, info);
 279                        goto out;
 280                }
 281
 282                err = icmp_err_convert[code].errno;
 283                break;
 284        case ICMP_TIME_EXCEEDED:
 285                err = EHOSTUNREACH;
 286                break;
 287        default:
 288                goto out;
 289        }
 290
 291        switch (sk->sk_state) {
 292                struct request_sock *req , **prev;
 293        case DCCP_LISTEN:
 294                if (sock_owned_by_user(sk))
 295                        goto out;
 296                req = inet_csk_search_req(sk, &prev, dh->dccph_dport,
 297                                          iph->daddr, iph->saddr);
 298                if (!req)
 299                        goto out;
 300
 301                /*
 302                 * ICMPs are not backlogged, hence we cannot get an established
 303                 * socket here.
 304                 */
 305                WARN_ON(req->sk);
 306
 307                if (!between48(seq, dccp_rsk(req)->dreq_iss,
 308                                    dccp_rsk(req)->dreq_gss)) {
 309                        NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
 310                        goto out;
 311                }
 312                /*
 313                 * Still in RESPOND, just remove it silently.
 314                 * There is no good way to pass the error to the newly
 315                 * created socket, and POSIX does not want network
 316                 * errors returned from accept().
 317                 */
 318                inet_csk_reqsk_queue_drop(sk, req, prev);
 319                goto out;
 320
 321        case DCCP_REQUESTING:
 322        case DCCP_RESPOND:
 323                if (!sock_owned_by_user(sk)) {
 324                        DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS);
 325                        sk->sk_err = err;
 326
 327                        sk->sk_error_report(sk);
 328
 329                        dccp_done(sk);
 330                } else
 331                        sk->sk_err_soft = err;
 332                goto out;
 333        }
 334
 335        /* If we've already connected we will keep trying
 336         * until we time out, or the user gives up.
 337         *
 338         * rfc1122 4.2.3.9 allows to consider as hard errors
 339         * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
 340         * but it is obsoleted by pmtu discovery).
 341         *
 342         * Note, that in modern internet, where routing is unreliable
 343         * and in each dark corner broken firewalls sit, sending random
 344         * errors ordered by their masters even this two messages finally lose
 345         * their original sense (even Linux sends invalid PORT_UNREACHs)
 346         *
 347         * Now we are in compliance with RFCs.
 348         *                                                      --ANK (980905)
 349         */
 350
 351        inet = inet_sk(sk);
 352        if (!sock_owned_by_user(sk) && inet->recverr) {
 353                sk->sk_err = err;
 354                sk->sk_error_report(sk);
 355        } else /* Only an error on timeout */
 356                sk->sk_err_soft = err;
 357out:
 358        bh_unlock_sock(sk);
 359        sock_put(sk);
 360}
 361
 362static inline __sum16 dccp_v4_csum_finish(struct sk_buff *skb,
 363                                      __be32 src, __be32 dst)
 364{
 365        return csum_tcpudp_magic(src, dst, skb->len, IPPROTO_DCCP, skb->csum);
 366}
 367
 368void dccp_v4_send_check(struct sock *sk, struct sk_buff *skb)
 369{
 370        const struct inet_sock *inet = inet_sk(sk);
 371        struct dccp_hdr *dh = dccp_hdr(skb);
 372
 373        dccp_csum_outgoing(skb);
 374        dh->dccph_checksum = dccp_v4_csum_finish(skb,
 375                                                 inet->inet_saddr,
 376                                                 inet->inet_daddr);
 377}
 378
 379EXPORT_SYMBOL_GPL(dccp_v4_send_check);
 380
 381static inline u64 dccp_v4_init_sequence(const struct sk_buff *skb)
 382{
 383        return secure_dccp_sequence_number(ip_hdr(skb)->daddr,
 384                                           ip_hdr(skb)->saddr,
 385                                           dccp_hdr(skb)->dccph_dport,
 386                                           dccp_hdr(skb)->dccph_sport);
 387}
 388
 389/*
 390 * The three way handshake has completed - we got a valid ACK or DATAACK -
 391 * now create the new socket.
 392 *
 393 * This is the equivalent of TCP's tcp_v4_syn_recv_sock
 394 */
 395struct sock *dccp_v4_request_recv_sock(struct sock *sk, struct sk_buff *skb,
 396                                       struct request_sock *req,
 397                                       struct dst_entry *dst)
 398{
 399        struct inet_request_sock *ireq;
 400        struct inet_sock *newinet;
 401        struct sock *newsk;
 402
 403        if (sk_acceptq_is_full(sk))
 404                goto exit_overflow;
 405
 406        newsk = dccp_create_openreq_child(sk, req, skb);
 407        if (newsk == NULL)
 408                goto exit_nonewsk;
 409
 410        newinet            = inet_sk(newsk);
 411        ireq               = inet_rsk(req);
 412        newinet->inet_daddr     = ireq->rmt_addr;
 413        newinet->inet_rcv_saddr = ireq->loc_addr;
 414        newinet->inet_saddr     = ireq->loc_addr;
 415        newinet->inet_opt       = ireq->opt;
 416        ireq->opt          = NULL;
 417        newinet->mc_index  = inet_iif(skb);
 418        newinet->mc_ttl    = ip_hdr(skb)->ttl;
 419        newinet->inet_id   = jiffies;
 420
 421        if (dst == NULL && (dst = inet_csk_route_child_sock(sk, newsk, req)) == NULL)
 422                goto put_and_exit;
 423
 424        sk_setup_caps(newsk, dst);
 425
 426        dccp_sync_mss(newsk, dst_mtu(dst));
 427
 428        if (__inet_inherit_port(sk, newsk) < 0)
 429                goto put_and_exit;
 430        __inet_hash_nolisten(newsk, NULL);
 431
 432        return newsk;
 433
 434exit_overflow:
 435        NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
 436exit_nonewsk:
 437        dst_release(dst);
 438exit:
 439        NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
 440        return NULL;
 441put_and_exit:
 442        bh_unlock_sock(newsk);
 443        sock_put(newsk);
 444        goto exit;
 445}
 446
 447EXPORT_SYMBOL_GPL(dccp_v4_request_recv_sock);
 448
 449static struct sock *dccp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
 450{
 451        const struct dccp_hdr *dh = dccp_hdr(skb);
 452        const struct iphdr *iph = ip_hdr(skb);
 453        struct sock *nsk;
 454        struct request_sock **prev;
 455        /* Find possible connection requests. */
 456        struct request_sock *req = inet_csk_search_req(sk, &prev,
 457                                                       dh->dccph_sport,
 458                                                       iph->saddr, iph->daddr);
 459        if (req != NULL)
 460                return dccp_check_req(sk, skb, req, prev);
 461
 462        nsk = inet_lookup_established(sock_net(sk), &dccp_hashinfo,
 463                                      iph->saddr, dh->dccph_sport,
 464                                      iph->daddr, dh->dccph_dport,
 465                                      inet_iif(skb));
 466        if (nsk != NULL) {
 467                if (nsk->sk_state != DCCP_TIME_WAIT) {
 468                        bh_lock_sock(nsk);
 469                        return nsk;
 470                }
 471                inet_twsk_put(inet_twsk(nsk));
 472                return NULL;
 473        }
 474
 475        return sk;
 476}
 477
 478static struct dst_entry* dccp_v4_route_skb(struct net *net, struct sock *sk,
 479                                           struct sk_buff *skb)
 480{
 481        struct rtable *rt;
 482        const struct iphdr *iph = ip_hdr(skb);
 483        struct flowi4 fl4 = {
 484                .flowi4_oif = inet_iif(skb),
 485                .daddr = iph->saddr,
 486                .saddr = iph->daddr,
 487                .flowi4_tos = RT_CONN_FLAGS(sk),
 488                .flowi4_proto = sk->sk_protocol,
 489                .fl4_sport = dccp_hdr(skb)->dccph_dport,
 490                .fl4_dport = dccp_hdr(skb)->dccph_sport,
 491        };
 492
 493        security_skb_classify_flow(skb, flowi4_to_flowi(&fl4));
 494        rt = ip_route_output_flow(net, &fl4, sk);
 495        if (IS_ERR(rt)) {
 496                IP_INC_STATS_BH(net, IPSTATS_MIB_OUTNOROUTES);
 497                return NULL;
 498        }
 499
 500        return &rt->dst;
 501}
 502
 503static int dccp_v4_send_response(struct sock *sk, struct request_sock *req,
 504                                 struct request_values *rv_unused)
 505{
 506        int err = -1;
 507        struct sk_buff *skb;
 508        struct dst_entry *dst;
 509        struct flowi4 fl4;
 510
 511        dst = inet_csk_route_req(sk, &fl4, req);
 512        if (dst == NULL)
 513                goto out;
 514
 515        skb = dccp_make_response(sk, dst, req);
 516        if (skb != NULL) {
 517                const struct inet_request_sock *ireq = inet_rsk(req);
 518                struct dccp_hdr *dh = dccp_hdr(skb);
 519
 520                dh->dccph_checksum = dccp_v4_csum_finish(skb, ireq->loc_addr,
 521                                                              ireq->rmt_addr);
 522                err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
 523                                            ireq->rmt_addr,
 524                                            ireq->opt);
 525                err = net_xmit_eval(err);
 526        }
 527
 528out:
 529        dst_release(dst);
 530        return err;
 531}
 532
 533static void dccp_v4_ctl_send_reset(struct sock *sk, struct sk_buff *rxskb)
 534{
 535        int err;
 536        const struct iphdr *rxiph;
 537        struct sk_buff *skb;
 538        struct dst_entry *dst;
 539        struct net *net = dev_net(skb_dst(rxskb)->dev);
 540        struct sock *ctl_sk = net->dccp.v4_ctl_sk;
 541
 542        /* Never send a reset in response to a reset. */
 543        if (dccp_hdr(rxskb)->dccph_type == DCCP_PKT_RESET)
 544                return;
 545
 546        if (skb_rtable(rxskb)->rt_type != RTN_LOCAL)
 547                return;
 548
 549        dst = dccp_v4_route_skb(net, ctl_sk, rxskb);
 550        if (dst == NULL)
 551                return;
 552
 553        skb = dccp_ctl_make_reset(ctl_sk, rxskb);
 554        if (skb == NULL)
 555                goto out;
 556
 557        rxiph = ip_hdr(rxskb);
 558        dccp_hdr(skb)->dccph_checksum = dccp_v4_csum_finish(skb, rxiph->saddr,
 559                                                                 rxiph->daddr);
 560        skb_dst_set(skb, dst_clone(dst));
 561
 562        bh_lock_sock(ctl_sk);
 563        err = ip_build_and_send_pkt(skb, ctl_sk,
 564                                    rxiph->daddr, rxiph->saddr, NULL);
 565        bh_unlock_sock(ctl_sk);
 566
 567        if (net_xmit_eval(err) == 0) {
 568                DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS);
 569                DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS);
 570        }
 571out:
 572         dst_release(dst);
 573}
 574
 575static void dccp_v4_reqsk_destructor(struct request_sock *req)
 576{
 577        dccp_feat_list_purge(&dccp_rsk(req)->dreq_featneg);
 578        kfree(inet_rsk(req)->opt);
 579}
 580
 581void dccp_syn_ack_timeout(struct sock *sk, struct request_sock *req)
 582{
 583}
 584EXPORT_SYMBOL(dccp_syn_ack_timeout);
 585
 586static struct request_sock_ops dccp_request_sock_ops __read_mostly = {
 587        .family         = PF_INET,
 588        .obj_size       = sizeof(struct dccp_request_sock),
 589        .rtx_syn_ack    = dccp_v4_send_response,
 590        .send_ack       = dccp_reqsk_send_ack,
 591        .destructor     = dccp_v4_reqsk_destructor,
 592        .send_reset     = dccp_v4_ctl_send_reset,
 593        .syn_ack_timeout = dccp_syn_ack_timeout,
 594};
 595
 596int dccp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
 597{
 598        struct inet_request_sock *ireq;
 599        struct request_sock *req;
 600        struct dccp_request_sock *dreq;
 601        const __be32 service = dccp_hdr_request(skb)->dccph_req_service;
 602        struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
 603
 604        /* Never answer to DCCP_PKT_REQUESTs send to broadcast or multicast */
 605        if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
 606                return 0;       /* discard, don't send a reset here */
 607
 608        if (dccp_bad_service_code(sk, service)) {
 609                dcb->dccpd_reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE;
 610                goto drop;
 611        }
 612        /*
 613         * TW buckets are converted to open requests without
 614         * limitations, they conserve resources and peer is
 615         * evidently real one.
 616         */
 617        dcb->dccpd_reset_code = DCCP_RESET_CODE_TOO_BUSY;
 618        if (inet_csk_reqsk_queue_is_full(sk))
 619                goto drop;
 620
 621        /*
 622         * Accept backlog is full. If we have already queued enough
 623         * of warm entries in syn queue, drop request. It is better than
 624         * clogging syn queue with openreqs with exponentially increasing
 625         * timeout.
 626         */
 627        if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
 628                goto drop;
 629
 630        req = inet_reqsk_alloc(&dccp_request_sock_ops);
 631        if (req == NULL)
 632                goto drop;
 633
 634        if (dccp_reqsk_init(req, dccp_sk(sk), skb))
 635                goto drop_and_free;
 636
 637        dreq = dccp_rsk(req);
 638        if (dccp_parse_options(sk, dreq, skb))
 639                goto drop_and_free;
 640
 641        if (security_inet_conn_request(sk, skb, req))
 642                goto drop_and_free;
 643
 644        ireq = inet_rsk(req);
 645        ireq->loc_addr = ip_hdr(skb)->daddr;
 646        ireq->rmt_addr = ip_hdr(skb)->saddr;
 647
 648        /*
 649         * Step 3: Process LISTEN state
 650         *
 651         * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
 652         *
 653         * Setting S.SWL/S.SWH to is deferred to dccp_create_openreq_child().
 654         */
 655        dreq->dreq_isr     = dcb->dccpd_seq;
 656        dreq->dreq_gsr     = dreq->dreq_isr;
 657        dreq->dreq_iss     = dccp_v4_init_sequence(skb);
 658        dreq->dreq_gss     = dreq->dreq_iss;
 659        dreq->dreq_service = service;
 660
 661        if (dccp_v4_send_response(sk, req, NULL))
 662                goto drop_and_free;
 663
 664        inet_csk_reqsk_queue_hash_add(sk, req, DCCP_TIMEOUT_INIT);
 665        return 0;
 666
 667drop_and_free:
 668        reqsk_free(req);
 669drop:
 670        DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS);
 671        return -1;
 672}
 673
 674EXPORT_SYMBOL_GPL(dccp_v4_conn_request);
 675
 676int dccp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
 677{
 678        struct dccp_hdr *dh = dccp_hdr(skb);
 679
 680        if (sk->sk_state == DCCP_OPEN) { /* Fast path */
 681                if (dccp_rcv_established(sk, skb, dh, skb->len))
 682                        goto reset;
 683                return 0;
 684        }
 685
 686        /*
 687         *  Step 3: Process LISTEN state
 688         *       If P.type == Request or P contains a valid Init Cookie option,
 689         *            (* Must scan the packet's options to check for Init
 690         *               Cookies.  Only Init Cookies are processed here,
 691         *               however; other options are processed in Step 8.  This
 692         *               scan need only be performed if the endpoint uses Init
 693         *               Cookies *)
 694         *            (* Generate a new socket and switch to that socket *)
 695         *            Set S := new socket for this port pair
 696         *            S.state = RESPOND
 697         *            Choose S.ISS (initial seqno) or set from Init Cookies
 698         *            Initialize S.GAR := S.ISS
 699         *            Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookies
 700         *            Continue with S.state == RESPOND
 701         *            (* A Response packet will be generated in Step 11 *)
 702         *       Otherwise,
 703         *            Generate Reset(No Connection) unless P.type == Reset
 704         *            Drop packet and return
 705         *
 706         * NOTE: the check for the packet types is done in
 707         *       dccp_rcv_state_process
 708         */
 709        if (sk->sk_state == DCCP_LISTEN) {
 710                struct sock *nsk = dccp_v4_hnd_req(sk, skb);
 711
 712                if (nsk == NULL)
 713                        goto discard;
 714
 715                if (nsk != sk) {
 716                        if (dccp_child_process(sk, nsk, skb))
 717                                goto reset;
 718                        return 0;
 719                }
 720        }
 721
 722        if (dccp_rcv_state_process(sk, skb, dh, skb->len))
 723                goto reset;
 724        return 0;
 725
 726reset:
 727        dccp_v4_ctl_send_reset(sk, skb);
 728discard:
 729        kfree_skb(skb);
 730        return 0;
 731}
 732
 733EXPORT_SYMBOL_GPL(dccp_v4_do_rcv);
 734
 735/**
 736 *      dccp_invalid_packet  -  check for malformed packets
 737 *      Implements RFC 4340, 8.5:  Step 1: Check header basics
 738 *      Packets that fail these checks are ignored and do not receive Resets.
 739 */
 740int dccp_invalid_packet(struct sk_buff *skb)
 741{
 742        const struct dccp_hdr *dh;
 743        unsigned int cscov;
 744
 745        if (skb->pkt_type != PACKET_HOST)
 746                return 1;
 747
 748        /* If the packet is shorter than 12 bytes, drop packet and return */
 749        if (!pskb_may_pull(skb, sizeof(struct dccp_hdr))) {
 750                DCCP_WARN("pskb_may_pull failed\n");
 751                return 1;
 752        }
 753
 754        dh = dccp_hdr(skb);
 755
 756        /* If P.type is not understood, drop packet and return */
 757        if (dh->dccph_type >= DCCP_PKT_INVALID) {
 758                DCCP_WARN("invalid packet type\n");
 759                return 1;
 760        }
 761
 762        /*
 763         * If P.Data Offset is too small for packet type, drop packet and return
 764         */
 765        if (dh->dccph_doff < dccp_hdr_len(skb) / sizeof(u32)) {
 766                DCCP_WARN("P.Data Offset(%u) too small\n", dh->dccph_doff);
 767                return 1;
 768        }
 769        /*
 770         * If P.Data Offset is too too large for packet, drop packet and return
 771         */
 772        if (!pskb_may_pull(skb, dh->dccph_doff * sizeof(u32))) {
 773                DCCP_WARN("P.Data Offset(%u) too large\n", dh->dccph_doff);
 774                return 1;
 775        }
 776
 777        /*
 778         * If P.type is not Data, Ack, or DataAck and P.X == 0 (the packet
 779         * has short sequence numbers), drop packet and return
 780         */
 781        if ((dh->dccph_type < DCCP_PKT_DATA    ||
 782            dh->dccph_type > DCCP_PKT_DATAACK) && dh->dccph_x == 0)  {
 783                DCCP_WARN("P.type (%s) not Data || [Data]Ack, while P.X == 0\n",
 784                          dccp_packet_name(dh->dccph_type));
 785                return 1;
 786        }
 787
 788        /*
 789         * If P.CsCov is too large for the packet size, drop packet and return.
 790         * This must come _before_ checksumming (not as RFC 4340 suggests).
 791         */
 792        cscov = dccp_csum_coverage(skb);
 793        if (cscov > skb->len) {
 794                DCCP_WARN("P.CsCov %u exceeds packet length %d\n",
 795                          dh->dccph_cscov, skb->len);
 796                return 1;
 797        }
 798
 799        /* If header checksum is incorrect, drop packet and return.
 800         * (This step is completed in the AF-dependent functions.) */
 801        skb->csum = skb_checksum(skb, 0, cscov, 0);
 802
 803        return 0;
 804}
 805
 806EXPORT_SYMBOL_GPL(dccp_invalid_packet);
 807
 808/* this is called when real data arrives */
 809static int dccp_v4_rcv(struct sk_buff *skb)
 810{
 811        const struct dccp_hdr *dh;
 812        const struct iphdr *iph;
 813        struct sock *sk;
 814        int min_cov;
 815
 816        /* Step 1: Check header basics */
 817
 818        if (dccp_invalid_packet(skb))
 819                goto discard_it;
 820
 821        iph = ip_hdr(skb);
 822        /* Step 1: If header checksum is incorrect, drop packet and return */
 823        if (dccp_v4_csum_finish(skb, iph->saddr, iph->daddr)) {
 824                DCCP_WARN("dropped packet with invalid checksum\n");
 825                goto discard_it;
 826        }
 827
 828        dh = dccp_hdr(skb);
 829
 830        DCCP_SKB_CB(skb)->dccpd_seq  = dccp_hdr_seq(dh);
 831        DCCP_SKB_CB(skb)->dccpd_type = dh->dccph_type;
 832
 833        dccp_pr_debug("%8.8s src=%pI4@%-5d dst=%pI4@%-5d seq=%llu",
 834                      dccp_packet_name(dh->dccph_type),
 835                      &iph->saddr, ntohs(dh->dccph_sport),
 836                      &iph->daddr, ntohs(dh->dccph_dport),
 837                      (unsigned long long) DCCP_SKB_CB(skb)->dccpd_seq);
 838
 839        if (dccp_packet_without_ack(skb)) {
 840                DCCP_SKB_CB(skb)->dccpd_ack_seq = DCCP_PKT_WITHOUT_ACK_SEQ;
 841                dccp_pr_debug_cat("\n");
 842        } else {
 843                DCCP_SKB_CB(skb)->dccpd_ack_seq = dccp_hdr_ack_seq(skb);
 844                dccp_pr_debug_cat(", ack=%llu\n", (unsigned long long)
 845                                  DCCP_SKB_CB(skb)->dccpd_ack_seq);
 846        }
 847
 848        /* Step 2:
 849         *      Look up flow ID in table and get corresponding socket */
 850        sk = __inet_lookup_skb(&dccp_hashinfo, skb,
 851                               dh->dccph_sport, dh->dccph_dport);
 852        /*
 853         * Step 2:
 854         *      If no socket ...
 855         */
 856        if (sk == NULL) {
 857                dccp_pr_debug("failed to look up flow ID in table and "
 858                              "get corresponding socket\n");
 859                goto no_dccp_socket;
 860        }
 861
 862        /*
 863         * Step 2:
 864         *      ... or S.state == TIMEWAIT,
 865         *              Generate Reset(No Connection) unless P.type == Reset
 866         *              Drop packet and return
 867         */
 868        if (sk->sk_state == DCCP_TIME_WAIT) {
 869                dccp_pr_debug("sk->sk_state == DCCP_TIME_WAIT: do_time_wait\n");
 870                inet_twsk_put(inet_twsk(sk));
 871                goto no_dccp_socket;
 872        }
 873
 874        /*
 875         * RFC 4340, sec. 9.2.1: Minimum Checksum Coverage
 876         *      o if MinCsCov = 0, only packets with CsCov = 0 are accepted
 877         *      o if MinCsCov > 0, also accept packets with CsCov >= MinCsCov
 878         */
 879        min_cov = dccp_sk(sk)->dccps_pcrlen;
 880        if (dh->dccph_cscov && (min_cov == 0 || dh->dccph_cscov < min_cov))  {
 881                dccp_pr_debug("Packet CsCov %d does not satisfy MinCsCov %d\n",
 882                              dh->dccph_cscov, min_cov);
 883                /* FIXME: "Such packets SHOULD be reported using Data Dropped
 884                 *         options (Section 11.7) with Drop Code 0, Protocol
 885                 *         Constraints."                                     */
 886                goto discard_and_relse;
 887        }
 888
 889        if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
 890                goto discard_and_relse;
 891        nf_reset(skb);
 892
 893        return sk_receive_skb(sk, skb, 1);
 894
 895no_dccp_socket:
 896        if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
 897                goto discard_it;
 898        /*
 899         * Step 2:
 900         *      If no socket ...
 901         *              Generate Reset(No Connection) unless P.type == Reset
 902         *              Drop packet and return
 903         */
 904        if (dh->dccph_type != DCCP_PKT_RESET) {
 905                DCCP_SKB_CB(skb)->dccpd_reset_code =
 906                                        DCCP_RESET_CODE_NO_CONNECTION;
 907                dccp_v4_ctl_send_reset(sk, skb);
 908        }
 909
 910discard_it:
 911        kfree_skb(skb);
 912        return 0;
 913
 914discard_and_relse:
 915        sock_put(sk);
 916        goto discard_it;
 917}
 918
 919static const struct inet_connection_sock_af_ops dccp_ipv4_af_ops = {
 920        .queue_xmit        = ip_queue_xmit,
 921        .send_check        = dccp_v4_send_check,
 922        .rebuild_header    = inet_sk_rebuild_header,
 923        .conn_request      = dccp_v4_conn_request,
 924        .syn_recv_sock     = dccp_v4_request_recv_sock,
 925        .net_header_len    = sizeof(struct iphdr),
 926        .setsockopt        = ip_setsockopt,
 927        .getsockopt        = ip_getsockopt,
 928        .addr2sockaddr     = inet_csk_addr2sockaddr,
 929        .sockaddr_len      = sizeof(struct sockaddr_in),
 930        .bind_conflict     = inet_csk_bind_conflict,
 931#ifdef CONFIG_COMPAT
 932        .compat_setsockopt = compat_ip_setsockopt,
 933        .compat_getsockopt = compat_ip_getsockopt,
 934#endif
 935};
 936
 937static int dccp_v4_init_sock(struct sock *sk)
 938{
 939        static __u8 dccp_v4_ctl_sock_initialized;
 940        int err = dccp_init_sock(sk, dccp_v4_ctl_sock_initialized);
 941
 942        if (err == 0) {
 943                if (unlikely(!dccp_v4_ctl_sock_initialized))
 944                        dccp_v4_ctl_sock_initialized = 1;
 945                inet_csk(sk)->icsk_af_ops = &dccp_ipv4_af_ops;
 946        }
 947
 948        return err;
 949}
 950
 951static struct timewait_sock_ops dccp_timewait_sock_ops = {
 952        .twsk_obj_size  = sizeof(struct inet_timewait_sock),
 953};
 954
 955static struct proto dccp_v4_prot = {
 956        .name                   = "DCCP",
 957        .owner                  = THIS_MODULE,
 958        .close                  = dccp_close,
 959        .connect                = dccp_v4_connect,
 960        .disconnect             = dccp_disconnect,
 961        .ioctl                  = dccp_ioctl,
 962        .init                   = dccp_v4_init_sock,
 963        .setsockopt             = dccp_setsockopt,
 964        .getsockopt             = dccp_getsockopt,
 965        .sendmsg                = dccp_sendmsg,
 966        .recvmsg                = dccp_recvmsg,
 967        .backlog_rcv            = dccp_v4_do_rcv,
 968        .hash                   = inet_hash,
 969        .unhash                 = inet_unhash,
 970        .accept                 = inet_csk_accept,
 971        .get_port               = inet_csk_get_port,
 972        .shutdown               = dccp_shutdown,
 973        .destroy                = dccp_destroy_sock,
 974        .orphan_count           = &dccp_orphan_count,
 975        .max_header             = MAX_DCCP_HEADER,
 976        .obj_size               = sizeof(struct dccp_sock),
 977        .slab_flags             = SLAB_DESTROY_BY_RCU,
 978        .rsk_prot               = &dccp_request_sock_ops,
 979        .twsk_prot              = &dccp_timewait_sock_ops,
 980        .h.hashinfo             = &dccp_hashinfo,
 981#ifdef CONFIG_COMPAT
 982        .compat_setsockopt      = compat_dccp_setsockopt,
 983        .compat_getsockopt      = compat_dccp_getsockopt,
 984#endif
 985};
 986
 987static const struct net_protocol dccp_v4_protocol = {
 988        .handler        = dccp_v4_rcv,
 989        .err_handler    = dccp_v4_err,
 990        .no_policy      = 1,
 991        .netns_ok       = 1,
 992};
 993
 994static const struct proto_ops inet_dccp_ops = {
 995        .family            = PF_INET,
 996        .owner             = THIS_MODULE,
 997        .release           = inet_release,
 998        .bind              = inet_bind,
 999        .connect           = inet_stream_connect,
1000        .socketpair        = sock_no_socketpair,
1001        .accept            = inet_accept,
1002        .getname           = inet_getname,
1003        /* FIXME: work on tcp_poll to rename it to inet_csk_poll */
1004        .poll              = dccp_poll,
1005        .ioctl             = inet_ioctl,
1006        /* FIXME: work on inet_listen to rename it to sock_common_listen */
1007        .listen            = inet_dccp_listen,
1008        .shutdown          = inet_shutdown,
1009        .setsockopt        = sock_common_setsockopt,
1010        .getsockopt        = sock_common_getsockopt,
1011        .sendmsg           = inet_sendmsg,
1012        .recvmsg           = sock_common_recvmsg,
1013        .mmap              = sock_no_mmap,
1014        .sendpage          = sock_no_sendpage,
1015#ifdef CONFIG_COMPAT
1016        .compat_setsockopt = compat_sock_common_setsockopt,
1017        .compat_getsockopt = compat_sock_common_getsockopt,
1018#endif
1019};
1020
1021static struct inet_protosw dccp_v4_protosw = {
1022        .type           = SOCK_DCCP,
1023        .protocol       = IPPROTO_DCCP,
1024        .prot           = &dccp_v4_prot,
1025        .ops            = &inet_dccp_ops,
1026        .no_check       = 0,
1027        .flags          = INET_PROTOSW_ICSK,
1028};
1029
1030static int __net_init dccp_v4_init_net(struct net *net)
1031{
1032        if (dccp_hashinfo.bhash == NULL)
1033                return -ESOCKTNOSUPPORT;
1034
1035        return inet_ctl_sock_create(&net->dccp.v4_ctl_sk, PF_INET,
1036                                    SOCK_DCCP, IPPROTO_DCCP, net);
1037}
1038
1039static void __net_exit dccp_v4_exit_net(struct net *net)
1040{
1041        inet_ctl_sock_destroy(net->dccp.v4_ctl_sk);
1042}
1043
1044static struct pernet_operations dccp_v4_ops = {
1045        .init   = dccp_v4_init_net,
1046        .exit   = dccp_v4_exit_net,
1047};
1048
1049static int __init dccp_v4_init(void)
1050{
1051        int err = proto_register(&dccp_v4_prot, 1);
1052
1053        if (err != 0)
1054                goto out;
1055
1056        err = inet_add_protocol(&dccp_v4_protocol, IPPROTO_DCCP);
1057        if (err != 0)
1058                goto out_proto_unregister;
1059
1060        inet_register_protosw(&dccp_v4_protosw);
1061
1062        err = register_pernet_subsys(&dccp_v4_ops);
1063        if (err)
1064                goto out_destroy_ctl_sock;
1065out:
1066        return err;
1067out_destroy_ctl_sock:
1068        inet_unregister_protosw(&dccp_v4_protosw);
1069        inet_del_protocol(&dccp_v4_protocol, IPPROTO_DCCP);
1070out_proto_unregister:
1071        proto_unregister(&dccp_v4_prot);
1072        goto out;
1073}
1074
1075static void __exit dccp_v4_exit(void)
1076{
1077        unregister_pernet_subsys(&dccp_v4_ops);
1078        inet_unregister_protosw(&dccp_v4_protosw);
1079        inet_del_protocol(&dccp_v4_protocol, IPPROTO_DCCP);
1080        proto_unregister(&dccp_v4_prot);
1081}
1082
1083module_init(dccp_v4_init);
1084module_exit(dccp_v4_exit);
1085
1086/*
1087 * __stringify doesn't likes enums, so use SOCK_DCCP (6) and IPPROTO_DCCP (33)
1088 * values directly, Also cover the case where the protocol is not specified,
1089 * i.e. net-pf-PF_INET-proto-0-type-SOCK_DCCP
1090 */
1091MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET, 33, 6);
1092MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET, 0, 6);
1093MODULE_LICENSE("GPL");
1094MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@mandriva.com>");
1095MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");
1096
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.