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