kernel/net/dccp/ipv6.c

   1 /*
   2  *      DCCP over IPv6
   3  *      Linux INET6 implementation
   4  *
   5  *      Based on net/dccp6/ipv6.c
   6  *
   7  *      Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
   8  *
   9  *      This program is free software; you can redistribute it and/or
  10  *      modify it under the terms of the GNU General Public License
  11  *      as published by the Free Software Foundation; either version
  12  *      2 of the License, or (at your option) any later version.
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/random.h>
  17 #include <linux/slab.h>
  18 #include <linux/xfrm.h>
  19
  20 #include <net/addrconf.h>
  21 #include <net/inet_common.h>
  22 #include <net/inet_hashtables.h>
  23 #include <net/inet_sock.h>
  24 #include <net/inet6_connection_sock.h>
  25 #include <net/inet6_hashtables.h>
  26 #include <net/ip6_route.h>
  27 #include <net/ipv6.h>
  28 #include <net/protocol.h>
  29 #include <net/transp_v6.h>
  30 #include <net/ip6_checksum.h>
  31 #include <net/xfrm.h>
  32 #include <net/secure_seq.h>
  33
  34 #include "dccp.h"
  35 #include "ipv6.h"
  36 #include "feat.h"
  37
  38 /* The per-net dccp.v6_ctl_sk is used for sending RSTs and ACKs */
  39
  40 static const struct inet_connection_sock_af_ops dccp_ipv6_mapped;
  41 static const struct inet_connection_sock_af_ops dccp_ipv6_af_ops;
  42
  43 /* add pseudo-header to DCCP checksum stored in skb->csum */
  44 static inline __sum16 dccp_v6_csum_finish(struct sk_buff *skb,
  45                                       const struct in6_addr *saddr,
  46                                       const struct in6_addr *daddr)
  47 {
  48         return csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_DCCP, skb->csum);
  49 }
  50
  51 static inline void dccp_v6_send_check(struct sock *sk, struct sk_buff *skb)
  52 {
  53         struct ipv6_pinfo *np = inet6_sk(sk);
  54         struct dccp_hdr *dh = dccp_hdr(skb);
  55
  56         dccp_csum_outgoing(skb);
  57         dh->dccph_checksum = dccp_v6_csum_finish(skb, &np->saddr, &sk->sk_v6_daddr);
  58 }
  59
  60 static inline __u64 dccp_v6_init_sequence(struct sk_buff *skb)
  61 {
  62         return secure_dccpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
  63                                              ipv6_hdr(skb)->saddr.s6_addr32,
  64                                              dccp_hdr(skb)->dccph_dport,
  65                                              dccp_hdr(skb)->dccph_sport     );
  66
  67 }
  68
  69 static void dccp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
  70                         u8 type, u8 code, int offset, __be32 info)
  71 {
  72         const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
  73         const struct dccp_hdr *dh;
  74         struct dccp_sock *dp;
  75         struct ipv6_pinfo *np;
  76         struct sock *sk;
  77         int err;
  78         __u64 seq;
  79         struct net *net = dev_net(skb->dev);
  80
  81         /* Only need dccph_dport & dccph_sport which are the first
  82          * 4 bytes in dccp header.
  83          * Our caller (icmpv6_notify()) already pulled 8 bytes for us.
  84          */
  85         BUILD_BUG_ON(offsetofend(struct dccp_hdr, dccph_sport) > 8);
  86         BUILD_BUG_ON(offsetofend(struct dccp_hdr, dccph_dport) > 8);
  87         dh = (struct dccp_hdr *)(skb->data + offset);
  88
  89         sk = __inet6_lookup_established(net, &dccp_hashinfo,
  90                                         &hdr->daddr, dh->dccph_dport,
  91                                         &hdr->saddr, ntohs(dh->dccph_sport),
  92                                         inet6_iif(skb));
  93
  94         if (!sk) {
  95                 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
  96                                    ICMP6_MIB_INERRORS);
  97                 return;
  98         }
  99
 100         if (sk->sk_state == DCCP_TIME_WAIT) {
 101                 inet_twsk_put(inet_twsk(sk));
 102                 return;
 103         }
 104         seq = dccp_hdr_seq(dh);
 105         if (sk->sk_state == DCCP_NEW_SYN_RECV)
 106                 return dccp_req_err(sk, seq);
 107
 108         bh_lock_sock(sk);
 109         if (sock_owned_by_user(sk))
 110                 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
 111
 112         if (sk->sk_state == DCCP_CLOSED)
 113                 goto out;
 114
 115         dp = dccp_sk(sk);
 116         if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_LISTEN) &&
 117             !between48(seq, dp->dccps_awl, dp->dccps_awh)) {
 118                 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
 119                 goto out;
 120         }
 121
 122         np = inet6_sk(sk);
 123
 124         if (type == NDISC_REDIRECT) {
 125                 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
 126
 127                 if (dst)
 128                         dst->ops->redirect(dst, sk, skb);
 129                 goto out;
 130         }
 131
 132         if (type == ICMPV6_PKT_TOOBIG) {
 133                 struct dst_entry *dst = NULL;
 134
 135                 if (!ip6_sk_accept_pmtu(sk))
 136                         goto out;
 137
 138                 if (sock_owned_by_user(sk))
 139                         goto out;
 140                 if ((1 << sk->sk_state) & (DCCPF_LISTEN | DCCPF_CLOSED))
 141                         goto out;
 142
 143                 dst = inet6_csk_update_pmtu(sk, ntohl(info));
 144                 if (!dst)
 145                         goto out;
 146
 147                 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst))
 148                         dccp_sync_mss(sk, dst_mtu(dst));
 149                 goto out;
 150         }
 151
 152         icmpv6_err_convert(type, code, &err);
 153
 154         /* Might be for an request_sock */
 155         switch (sk->sk_state) {
 156         case DCCP_REQUESTING:
 157         case DCCP_RESPOND:  /* Cannot happen.
 158                                It can, it SYNs are crossed. --ANK */
 159                 if (!sock_owned_by_user(sk)) {
 160                         DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS);
 161                         sk->sk_err = err;
 162                         /*
 163                          * Wake people up to see the error
 164                          * (see connect in sock.c)
 165                          */
 166                         sk->sk_error_report(sk);
 167                         dccp_done(sk);
 168                 } else
 169                         sk->sk_err_soft = err;
 170                 goto out;
 171         }
 172
 173         if (!sock_owned_by_user(sk) && np->recverr) {
 174                 sk->sk_err = err;
 175                 sk->sk_error_report(sk);
 176         } else
 177                 sk->sk_err_soft = err;
 178
 179 out:
 180         bh_unlock_sock(sk);
 181         sock_put(sk);
 182 }
 183
 184
 185 static int dccp_v6_send_response(const struct sock *sk, struct request_sock *req)
 186 {
 187         struct inet_request_sock *ireq = inet_rsk(req);
 188         struct ipv6_pinfo *np = inet6_sk(sk);
 189         struct sk_buff *skb;
 190         struct in6_addr *final_p, final;
 191         struct flowi6 fl6;
 192         int err = -1;
 193         struct dst_entry *dst;
 194
 195         memset(&fl6, 0, sizeof(fl6));
 196         fl6.flowi6_proto = IPPROTO_DCCP;
 197         fl6.daddr = ireq->ir_v6_rmt_addr;
 198         fl6.saddr = ireq->ir_v6_loc_addr;
 199         fl6.flowlabel = 0;
 200         fl6.flowi6_oif = ireq->ir_iif;
 201         fl6.fl6_dport = ireq->ir_rmt_port;
 202         fl6.fl6_sport = htons(ireq->ir_num);
 203         security_req_classify_flow(req, flowi6_to_flowi(&fl6));
 204
 205
 206         rcu_read_lock();
 207         final_p = fl6_update_dst(&fl6, rcu_dereference(np->opt), &final);
 208         rcu_read_unlock();
 209
 210         dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
 211         if (IS_ERR(dst)) {
 212                 err = PTR_ERR(dst);
 213                 dst = NULL;
 214                 goto done;
 215         }
 216
 217         skb = dccp_make_response(sk, dst, req);
 218         if (skb != NULL) {
 219                 struct dccp_hdr *dh = dccp_hdr(skb);
 220
 221                 dh->dccph_checksum = dccp_v6_csum_finish(skb,
 222                                                          &ireq->ir_v6_loc_addr,
 223                                                          &ireq->ir_v6_rmt_addr);
 224                 fl6.daddr = ireq->ir_v6_rmt_addr;
 225                 rcu_read_lock();
 226                 err = ip6_xmit(sk, skb, &fl6, rcu_dereference(np->opt),
 227                                np->tclass);
 228                 rcu_read_unlock();
 229                 err = net_xmit_eval(err);
 230         }
 231
 232 done:
 233         dst_release(dst);
 234         return err;
 235 }
 236
 237 static void dccp_v6_reqsk_destructor(struct request_sock *req)
 238 {
 239         dccp_feat_list_purge(&dccp_rsk(req)->dreq_featneg);
 240         kfree_skb(inet_rsk(req)->pktopts);
 241 }
 242
 243 static void dccp_v6_ctl_send_reset(const struct sock *sk, struct sk_buff *rxskb)
 244 {
 245         const struct ipv6hdr *rxip6h;
 246         struct sk_buff *skb;
 247         struct flowi6 fl6;
 248         struct net *net = dev_net(skb_dst(rxskb)->dev);
 249         struct sock *ctl_sk = net->dccp.v6_ctl_sk;
 250         struct dst_entry *dst;
 251
 252         if (dccp_hdr(rxskb)->dccph_type == DCCP_PKT_RESET)
 253                 return;
 254
 255         if (!ipv6_unicast_destination(rxskb))
 256                 return;
 257
 258         skb = dccp_ctl_make_reset(ctl_sk, rxskb);
 259         if (skb == NULL)
 260                 return;
 261
 262         rxip6h = ipv6_hdr(rxskb);
 263         dccp_hdr(skb)->dccph_checksum = dccp_v6_csum_finish(skb, &rxip6h->saddr,
 264                                                             &rxip6h->daddr);
 265
 266         memset(&fl6, 0, sizeof(fl6));
 267         fl6.daddr = rxip6h->saddr;
 268         fl6.saddr = rxip6h->daddr;
 269
 270         fl6.flowi6_proto = IPPROTO_DCCP;
 271         fl6.flowi6_oif = inet6_iif(rxskb);
 272         fl6.fl6_dport = dccp_hdr(skb)->dccph_dport;
 273         fl6.fl6_sport = dccp_hdr(skb)->dccph_sport;
 274         security_skb_classify_flow(rxskb, flowi6_to_flowi(&fl6));
 275
 276         /* sk = NULL, but it is safe for now. RST socket required. */
 277         dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL);
 278         if (!IS_ERR(dst)) {
 279                 skb_dst_set(skb, dst);
 280                 ip6_xmit(ctl_sk, skb, &fl6, NULL, 0);
 281                 DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS);
 282                 DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS);
 283                 return;
 284         }
 285
 286         kfree_skb(skb);
 287 }
 288
 289 static struct request_sock_ops dccp6_request_sock_ops = {
 290         .family         = AF_INET6,
 291         .obj_size       = sizeof(struct dccp6_request_sock),
 292         .rtx_syn_ack    = dccp_v6_send_response,
 293         .send_ack       = dccp_reqsk_send_ack,
 294         .destructor     = dccp_v6_reqsk_destructor,
 295         .send_reset     = dccp_v6_ctl_send_reset,
 296         .syn_ack_timeout = dccp_syn_ack_timeout,
 297 };
 298
 299 static int dccp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
 300 {
 301         struct request_sock *req;
 302         struct dccp_request_sock *dreq;
 303         struct inet_request_sock *ireq;
 304         struct ipv6_pinfo *np = inet6_sk(sk);
 305         const __be32 service = dccp_hdr_request(skb)->dccph_req_service;
 306         struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
 307
 308         if (skb->protocol == htons(ETH_P_IP))
 309                 return dccp_v4_conn_request(sk, skb);
 310
 311         if (!ipv6_unicast_destination(skb))
 312                 return 0;       /* discard, don't send a reset here */
 313
 314         if (dccp_bad_service_code(sk, service)) {
 315                 dcb->dccpd_reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE;
 316                 goto drop;
 317         }
 318         /*
 319          * There are no SYN attacks on IPv6, yet...
 320          */
 321         dcb->dccpd_reset_code = DCCP_RESET_CODE_TOO_BUSY;
 322         if (inet_csk_reqsk_queue_is_full(sk))
 323                 goto drop;
 324
 325         if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
 326                 goto drop;
 327
 328         req = inet_reqsk_alloc(&dccp6_request_sock_ops, sk, true);
 329         if (req == NULL)
 330                 goto drop;
 331
 332         if (dccp_reqsk_init(req, dccp_sk(sk), skb))
 333                 goto drop_and_free;
 334
 335         dreq = dccp_rsk(req);
 336         if (dccp_parse_options(sk, dreq, skb))
 337                 goto drop_and_free;
 338
 339         if (security_inet_conn_request(sk, skb, req))
 340                 goto drop_and_free;
 341
 342         ireq = inet_rsk(req);
 343         ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
 344         ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
 345         ireq->ireq_family = AF_INET6;
 346
 347         if (ipv6_opt_accepted(sk, skb, IP6CB(skb)) ||
 348             np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
 349             np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
 350                 atomic_inc(&skb->users);
 351                 ireq->pktopts = skb;
 352         }
 353         ireq->ir_iif = sk->sk_bound_dev_if;
 354
 355         /* So that link locals have meaning */
 356         if (!sk->sk_bound_dev_if &&
 357             ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
 358                 ireq->ir_iif = inet6_iif(skb);
 359
 360         /*
 361          * Step 3: Process LISTEN state
 362          *
 363          *   Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
 364          *
 365          * Setting S.SWL/S.SWH to is deferred to dccp_create_openreq_child().
 366          */
 367         dreq->dreq_isr     = dcb->dccpd_seq;
 368         dreq->dreq_gsr     = dreq->dreq_isr;
 369         dreq->dreq_iss     = dccp_v6_init_sequence(skb);
 370         dreq->dreq_gss     = dreq->dreq_iss;
 371         dreq->dreq_service = service;
 372
 373         if (dccp_v6_send_response(sk, req))
 374                 goto drop_and_free;
 375
 376         inet_csk_reqsk_queue_hash_add(sk, req, DCCP_TIMEOUT_INIT);
 377         return 0;
 378
 379 drop_and_free:
 380         reqsk_free(req);
 381 drop:
 382         DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS);
 383         return -1;
 384 }
 385
 386 static struct sock *dccp_v6_request_recv_sock(const struct sock *sk,
 387                                               struct sk_buff *skb,
 388                                               struct request_sock *req,
 389                                               struct dst_entry *dst,
 390                                               struct request_sock *req_unhash,
 391                                               bool *own_req)
 392 {
 393         struct inet_request_sock *ireq = inet_rsk(req);
 394         struct ipv6_pinfo *newnp;
 395         const struct ipv6_pinfo *np = inet6_sk(sk);
 396         struct ipv6_txoptions *opt;
 397         struct inet_sock *newinet;
 398         struct dccp6_sock *newdp6;
 399         struct sock *newsk;
 400
 401         if (skb->protocol == htons(ETH_P_IP)) {
 402                 /*
 403                  *      v6 mapped
 404                  */
 405                 newsk = dccp_v4_request_recv_sock(sk, skb, req, dst,
 406                                                   req_unhash, own_req);
 407                 if (newsk == NULL)
 408                         return NULL;
 409
 410                 newdp6 = (struct dccp6_sock *)newsk;
 411                 newinet = inet_sk(newsk);
 412                 newinet->pinet6 = &newdp6->inet6;
 413                 newnp = inet6_sk(newsk);
 414
 415                 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
 416
 417                 newnp->saddr = newsk->sk_v6_rcv_saddr;
 418
 419                 inet_csk(newsk)->icsk_af_ops = &dccp_ipv6_mapped;
 420                 newsk->sk_backlog_rcv = dccp_v4_do_rcv;
 421                 newnp->pktoptions  = NULL;
 422                 newnp->opt         = NULL;
 423                 newnp->mcast_oif   = inet6_iif(skb);
 424                 newnp->mcast_hops  = ipv6_hdr(skb)->hop_limit;
 425
 426                 /*
 427                  * No need to charge this sock to the relevant IPv6 refcnt debug socks count
 428                  * here, dccp_create_openreq_child now does this for us, see the comment in
 429                  * that function for the gory details. -acme
 430                  */
 431
 432                 /* It is tricky place. Until this moment IPv4 tcp
 433                    worked with IPv6 icsk.icsk_af_ops.
 434                    Sync it now.
 435                  */
 436                 dccp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
 437
 438                 return newsk;
 439         }
 440
 441
 442         if (sk_acceptq_is_full(sk))
 443                 goto out_overflow;
 444
 445         if (!dst) {
 446                 struct flowi6 fl6;
 447
 448                 dst = inet6_csk_route_req(sk, &fl6, req, IPPROTO_DCCP);
 449                 if (!dst)
 450                         goto out;
 451         }
 452
 453         newsk = dccp_create_openreq_child(sk, req, skb);
 454         if (newsk == NULL)
 455                 goto out_nonewsk;
 456
 457         /*
 458          * No need to charge this sock to the relevant IPv6 refcnt debug socks
 459          * count here, dccp_create_openreq_child now does this for us, see the
 460          * comment in that function for the gory details. -acme
 461          */
 462
 463         ip6_dst_store(newsk, dst, NULL, NULL);
 464         newsk->sk_route_caps = dst->dev->features & ~(NETIF_F_IP_CSUM |
 465                                                       NETIF_F_TSO);
 466         newdp6 = (struct dccp6_sock *)newsk;
 467         newinet = inet_sk(newsk);
 468         newinet->pinet6 = &newdp6->inet6;
 469         newnp = inet6_sk(newsk);
 470
 471         memcpy(newnp, np, sizeof(struct ipv6_pinfo));
 472
 473         newsk->sk_v6_daddr      = ireq->ir_v6_rmt_addr;
 474         newnp->saddr            = ireq->ir_v6_loc_addr;
 475         newsk->sk_v6_rcv_saddr  = ireq->ir_v6_loc_addr;
 476         newsk->sk_bound_dev_if  = ireq->ir_iif;
 477
 478         /* Now IPv6 options...
 479
 480            First: no IPv4 options.
 481          */
 482         newinet->inet_opt = NULL;
 483
 484         /* Clone RX bits */
 485         newnp->rxopt.all = np->rxopt.all;
 486
 487         newnp->pktoptions = NULL;
 488         newnp->opt        = NULL;
 489         newnp->mcast_oif  = inet6_iif(skb);
 490         newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
 491
 492         /*
 493          * Clone native IPv6 options from listening socket (if any)
 494          *
 495          * Yes, keeping reference count would be much more clever, but we make
 496          * one more one thing there: reattach optmem to newsk.
 497          */
 498         opt = rcu_dereference(np->opt);
 499         if (opt) {
 500                 opt = ipv6_dup_options(newsk, opt);
 501                 RCU_INIT_POINTER(newnp->opt, opt);
 502         }
 503         inet_csk(newsk)->icsk_ext_hdr_len = 0;
 504         if (opt)
 505                 inet_csk(newsk)->icsk_ext_hdr_len = opt->opt_nflen +
 506                                                     opt->opt_flen;
 507
 508         dccp_sync_mss(newsk, dst_mtu(dst));
 509
 510         newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
 511         newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
 512
 513         if (__inet_inherit_port(sk, newsk) < 0) {
 514                 inet_csk_prepare_forced_close(newsk);
 515                 dccp_done(newsk);
 516                 goto out;
 517         }
 518         *own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash));
 519         /* Clone pktoptions received with SYN, if we own the req */
 520         if (*own_req && ireq->pktopts) {
 521                 newnp->pktoptions = skb_clone(ireq->pktopts, GFP_ATOMIC);
 522                 consume_skb(ireq->pktopts);
 523                 ireq->pktopts = NULL;
 524                 if (newnp->pktoptions)
 525                         skb_set_owner_r(newnp->pktoptions, newsk);
 526         }
 527
 528         return newsk;
 529
 530 out_overflow:
 531         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
 532 out_nonewsk:
 533         dst_release(dst);
 534 out:
 535         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
 536         return NULL;
 537 }
 538
 539 /* The socket must have it's spinlock held when we get
 540  * here.
 541  *
 542  * We have a potential double-lock case here, so even when
 543  * doing backlog processing we use the BH locking scheme.
 544  * This is because we cannot sleep with the original spinlock
 545  * held.
 546  */
 547 static int dccp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
 548 {
 549         struct ipv6_pinfo *np = inet6_sk(sk);
 550         struct sk_buff *opt_skb = NULL;
 551
 552         /* Imagine: socket is IPv6. IPv4 packet arrives,
 553            goes to IPv4 receive handler and backlogged.
 554            From backlog it always goes here. Kerboom...
 555            Fortunately, dccp_rcv_established and rcv_established
 556            handle them correctly, but it is not case with
 557            dccp_v6_hnd_req and dccp_v6_ctl_send_reset().   --ANK
 558          */
 559
 560         if (skb->protocol == htons(ETH_P_IP))
 561                 return dccp_v4_do_rcv(sk, skb);
 562
 563         if (sk_filter(sk, skb))
 564                 goto discard;
 565
 566         /*
 567          * socket locking is here for SMP purposes as backlog rcv is currently
 568          * called with bh processing disabled.
 569          */
 570
 571         /* Do Stevens' IPV6_PKTOPTIONS.
 572
 573            Yes, guys, it is the only place in our code, where we
 574            may make it not affecting IPv4.
 575            The rest of code is protocol independent,
 576            and I do not like idea to uglify IPv4.
 577
 578            Actually, all the idea behind IPV6_PKTOPTIONS
 579            looks not very well thought. For now we latch
 580            options, received in the last packet, enqueued
 581            by tcp. Feel free to propose better solution.
 582                                                --ANK (980728)
 583          */
 584         if (np->rxopt.all)
 585         /*
 586          * FIXME: Add handling of IPV6_PKTOPTIONS skb. See the comments below
 587          *        (wrt ipv6_pktopions) and net/ipv6/tcp_ipv6.c for an example.
 588          */
 589                 opt_skb = skb_clone(skb, GFP_ATOMIC);
 590
 591         if (sk->sk_state == DCCP_OPEN) { /* Fast path */
 592                 if (dccp_rcv_established(sk, skb, dccp_hdr(skb), skb->len))
 593                         goto reset;
 594                 if (opt_skb) {
 595                         /* XXX This is where we would goto ipv6_pktoptions. */
 596                         __kfree_skb(opt_skb);
 597                 }
 598                 return 0;
 599         }
 600
 601         /*
 602          *  Step 3: Process LISTEN state
 603          *     If S.state == LISTEN,
 604          *       If P.type == Request or P contains a valid Init Cookie option,
 605          *            (* Must scan the packet's options to check for Init
 606          *               Cookies.  Only Init Cookies are processed here,
 607          *               however; other options are processed in Step 8.  This
 608          *               scan need only be performed if the endpoint uses Init
 609          *               Cookies *)
 610          *            (* Generate a new socket and switch to that socket *)
 611          *            Set S := new socket for this port pair
 612          *            S.state = RESPOND
 613          *            Choose S.ISS (initial seqno) or set from Init Cookies
 614          *            Initialize S.GAR := S.ISS
 615          *            Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookies
 616          *            Continue with S.state == RESPOND
 617          *            (* A Response packet will be generated in Step 11 *)
 618          *       Otherwise,
 619          *            Generate Reset(No Connection) unless P.type == Reset
 620          *            Drop packet and return
 621          *
 622          * NOTE: the check for the packet types is done in
 623          *       dccp_rcv_state_process
 624          */
 625
 626         if (dccp_rcv_state_process(sk, skb, dccp_hdr(skb), skb->len))
 627                 goto reset;
 628         if (opt_skb) {
 629                 /* XXX This is where we would goto ipv6_pktoptions. */
 630                 __kfree_skb(opt_skb);
 631         }
 632         return 0;
 633
 634 reset:
 635         dccp_v6_ctl_send_reset(sk, skb);
 636 discard:
 637         if (opt_skb != NULL)
 638                 __kfree_skb(opt_skb);
 639         kfree_skb(skb);
 640         return 0;
 641 }
 642
 643 static int dccp_v6_rcv(struct sk_buff *skb)
 644 {
 645         const struct dccp_hdr *dh;
 646         struct sock *sk;
 647         int min_cov;
 648
 649         /* Step 1: Check header basics */
 650
 651         if (dccp_invalid_packet(skb))
 652                 goto discard_it;
 653
 654         /* Step 1: If header checksum is incorrect, drop packet and return. */
 655         if (dccp_v6_csum_finish(skb, &ipv6_hdr(skb)->saddr,
 656                                      &ipv6_hdr(skb)->daddr)) {
 657                 DCCP_WARN("dropped packet with invalid checksum\n");
 658                 goto discard_it;
 659         }
 660
 661         dh = dccp_hdr(skb);
 662
 663         DCCP_SKB_CB(skb)->dccpd_seq  = dccp_hdr_seq(dh);
 664         DCCP_SKB_CB(skb)->dccpd_type = dh->dccph_type;
 665
 666         if (dccp_packet_without_ack(skb))
 667                 DCCP_SKB_CB(skb)->dccpd_ack_seq = DCCP_PKT_WITHOUT_ACK_SEQ;
 668         else
 669                 DCCP_SKB_CB(skb)->dccpd_ack_seq = dccp_hdr_ack_seq(skb);
 670
 671 lookup:
 672         sk = __inet6_lookup_skb(&dccp_hashinfo, skb,
 673                                 dh->dccph_sport, dh->dccph_dport,
 674                                 inet6_iif(skb));
 675         if (!sk) {
 676                 dccp_pr_debug("failed to look up flow ID in table and "
 677                               "get corresponding socket\n");
 678                 goto no_dccp_socket;
 679         }
 680
 681         /*
 682          * Step 2:
 683          *      ... or S.state == TIMEWAIT,
 684          *              Generate Reset(No Connection) unless P.type == Reset
 685          *              Drop packet and return
 686          */
 687         if (sk->sk_state == DCCP_TIME_WAIT) {
 688                 dccp_pr_debug("sk->sk_state == DCCP_TIME_WAIT: do_time_wait\n");
 689                 inet_twsk_put(inet_twsk(sk));
 690                 goto no_dccp_socket;
 691         }
 692
 693         if (sk->sk_state == DCCP_NEW_SYN_RECV) {
 694                 struct request_sock *req = inet_reqsk(sk);
 695                 struct sock *nsk;
 696
 697                 sk = req->rsk_listener;
 698                 if (unlikely(sk->sk_state != DCCP_LISTEN)) {
 699                         inet_csk_reqsk_queue_drop_and_put(sk, req);
 700                         goto lookup;
 701                 }
 702                 sock_hold(sk);
 703                 nsk = dccp_check_req(sk, skb, req);
 704                 if (!nsk) {
 705                         reqsk_put(req);
 706                         goto discard_and_relse;
 707                 }
 708                 if (nsk == sk) {
 709                         reqsk_put(req);
 710                 } else if (dccp_child_process(sk, nsk, skb)) {
 711                         dccp_v6_ctl_send_reset(sk, skb);
 712                         goto discard_and_relse;
 713                 } else {
 714                         sock_put(sk);
 715                         return 0;
 716                 }
 717         }
 718         /*
 719          * RFC 4340, sec. 9.2.1: Minimum Checksum Coverage
 720          *      o if MinCsCov = 0, only packets with CsCov = 0 are accepted
 721          *      o if MinCsCov > 0, also accept packets with CsCov >= MinCsCov
 722          */
 723         min_cov = dccp_sk(sk)->dccps_pcrlen;
 724         if (dh->dccph_cscov  &&  (min_cov == 0 || dh->dccph_cscov < min_cov))  {
 725                 dccp_pr_debug("Packet CsCov %d does not satisfy MinCsCov %d\n",
 726                               dh->dccph_cscov, min_cov);
 727                 /* FIXME: send Data Dropped option (see also dccp_v4_rcv) */
 728                 goto discard_and_relse;
 729         }
 730
 731         if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
 732                 goto discard_and_relse;
 733
 734         return sk_receive_skb(sk, skb, 1) ? -1 : 0;
 735
 736 no_dccp_socket:
 737         if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
 738                 goto discard_it;
 739         /*
 740          * Step 2:
 741          *      If no socket ...
 742          *              Generate Reset(No Connection) unless P.type == Reset
 743          *              Drop packet and return
 744          */
 745         if (dh->dccph_type != DCCP_PKT_RESET) {
 746                 DCCP_SKB_CB(skb)->dccpd_reset_code =
 747                                         DCCP_RESET_CODE_NO_CONNECTION;
 748                 dccp_v6_ctl_send_reset(sk, skb);
 749         }
 750
 751 discard_it:
 752         kfree_skb(skb);
 753         return 0;
 754
 755 discard_and_relse:
 756         sock_put(sk);
 757         goto discard_it;
 758 }
 759
 760 static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
 761                            int addr_len)
 762 {
 763         struct sockaddr_in6 *usin = (struct sockaddr_in6 *)uaddr;
 764         struct inet_connection_sock *icsk = inet_csk(sk);
 765         struct inet_sock *inet = inet_sk(sk);
 766         struct ipv6_pinfo *np = inet6_sk(sk);
 767         struct dccp_sock *dp = dccp_sk(sk);
 768         struct in6_addr *saddr = NULL, *final_p, final;
 769         struct ipv6_txoptions *opt;
 770         struct flowi6 fl6;
 771         struct dst_entry *dst;
 772         int addr_type;
 773         int err;
 774
 775         dp->dccps_role = DCCP_ROLE_CLIENT;
 776
 777         if (addr_len < SIN6_LEN_RFC2133)
 778                 return -EINVAL;
 779
 780         if (usin->sin6_family != AF_INET6)
 781                 return -EAFNOSUPPORT;
 782
 783         memset(&fl6, 0, sizeof(fl6));
 784
 785         if (np->sndflow) {
 786                 fl6.flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK;
 787                 IP6_ECN_flow_init(fl6.flowlabel);
 788                 if (fl6.flowlabel & IPV6_FLOWLABEL_MASK) {
 789                         struct ip6_flowlabel *flowlabel;
 790                         flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
 791                         if (flowlabel == NULL)
 792                                 return -EINVAL;
 793                         fl6_sock_release(flowlabel);
 794                 }
 795         }
 796         /*
 797          * connect() to INADDR_ANY means loopback (BSD'ism).
 798          */
 799         if (ipv6_addr_any(&usin->sin6_addr))
 800                 usin->sin6_addr.s6_addr[15] = 1;
 801
 802         addr_type = ipv6_addr_type(&usin->sin6_addr);
 803
 804         if (addr_type & IPV6_ADDR_MULTICAST)
 805                 return -ENETUNREACH;
 806
 807         if (addr_type & IPV6_ADDR_LINKLOCAL) {
 808                 if (addr_len >= sizeof(struct sockaddr_in6) &&
 809                     usin->sin6_scope_id) {
 810                         /* If interface is set while binding, indices
 811                          * must coincide.
 812                          */
 813                         if (sk->sk_bound_dev_if &&
 814                             sk->sk_bound_dev_if != usin->sin6_scope_id)
 815                                 return -EINVAL;
 816
 817                         sk->sk_bound_dev_if = usin->sin6_scope_id;
 818                 }
 819
 820                 /* Connect to link-local address requires an interface */
 821                 if (!sk->sk_bound_dev_if)
 822                         return -EINVAL;
 823         }
 824
 825         sk->sk_v6_daddr = usin->sin6_addr;
 826         np->flow_label = fl6.flowlabel;
 827
 828         /*
 829          * DCCP over IPv4
 830          */
 831         if (addr_type == IPV6_ADDR_MAPPED) {
 832                 u32 exthdrlen = icsk->icsk_ext_hdr_len;
 833                 struct sockaddr_in sin;
 834
 835                 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
 836
 837                 if (__ipv6_only_sock(sk))
 838                         return -ENETUNREACH;
 839
 840                 sin.sin_family = AF_INET;
 841                 sin.sin_port = usin->sin6_port;
 842                 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
 843
 844                 icsk->icsk_af_ops = &dccp_ipv6_mapped;
 845                 sk->sk_backlog_rcv = dccp_v4_do_rcv;
 846
 847                 err = dccp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
 848                 if (err) {
 849                         icsk->icsk_ext_hdr_len = exthdrlen;
 850                         icsk->icsk_af_ops = &dccp_ipv6_af_ops;
 851                         sk->sk_backlog_rcv = dccp_v6_do_rcv;
 852                         goto failure;
 853                 }
 854                 np->saddr = sk->sk_v6_rcv_saddr;
 855                 return err;
 856         }
 857
 858         if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
 859                 saddr = &sk->sk_v6_rcv_saddr;
 860
 861         fl6.flowi6_proto = IPPROTO_DCCP;
 862         fl6.daddr = sk->sk_v6_daddr;
 863         fl6.saddr = saddr ? *saddr : np->saddr;
 864         fl6.flowi6_oif = sk->sk_bound_dev_if;
 865         fl6.fl6_dport = usin->sin6_port;
 866         fl6.fl6_sport = inet->inet_sport;
 867         security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
 868
 869         opt = rcu_dereference_protected(np->opt, sock_owned_by_user(sk));
 870         final_p = fl6_update_dst(&fl6, opt, &final);
 871
 872         dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
 873         if (IS_ERR(dst)) {
 874                 err = PTR_ERR(dst);
 875                 goto failure;
 876         }
 877
 878         if (saddr == NULL) {
 879                 saddr = &fl6.saddr;
 880                 sk->sk_v6_rcv_saddr = *saddr;
 881         }
 882
 883         /* set the source address */
 884         np->saddr = *saddr;
 885         inet->inet_rcv_saddr = LOOPBACK4_IPV6;
 886
 887         ip6_dst_store(sk, dst, NULL, NULL);
 888
 889         icsk->icsk_ext_hdr_len = 0;
 890         if (opt)
 891                 icsk->icsk_ext_hdr_len = opt->opt_flen + opt->opt_nflen;
 892
 893         inet->inet_dport = usin->sin6_port;
 894
 895         dccp_set_state(sk, DCCP_REQUESTING);
 896         err = inet6_hash_connect(&dccp_death_row, sk);
 897         if (err)
 898                 goto late_failure;
 899
 900         dp->dccps_iss = secure_dccpv6_sequence_number(np->saddr.s6_addr32,
 901                                                       sk->sk_v6_daddr.s6_addr32,
 902                                                       inet->inet_sport,
 903                                                       inet->inet_dport);
 904         err = dccp_connect(sk);
 905         if (err)
 906                 goto late_failure;
 907
 908         return 0;
 909
 910 late_failure:
 911         dccp_set_state(sk, DCCP_CLOSED);
 912         __sk_dst_reset(sk);
 913 failure:
 914         inet->inet_dport = 0;
 915         sk->sk_route_caps = 0;
 916         return err;
 917 }
 918
 919 static const struct inet_connection_sock_af_ops dccp_ipv6_af_ops = {
 920         .queue_xmit        = inet6_csk_xmit,
 921         .send_check        = dccp_v6_send_check,
 922         .rebuild_header    = inet6_sk_rebuild_header,
 923         .conn_request      = dccp_v6_conn_request,
 924         .syn_recv_sock     = dccp_v6_request_recv_sock,
 925         .net_header_len    = sizeof(struct ipv6hdr),
 926         .setsockopt        = ipv6_setsockopt,
 927         .getsockopt        = ipv6_getsockopt,
 928         .addr2sockaddr     = inet6_csk_addr2sockaddr,
 929         .sockaddr_len      = sizeof(struct sockaddr_in6),
 930         .bind_conflict     = inet6_csk_bind_conflict,
 931 #ifdef CONFIG_COMPAT
 932         .compat_setsockopt = compat_ipv6_setsockopt,
 933         .compat_getsockopt = compat_ipv6_getsockopt,
 934 #endif
 935 };
 936
 937 /*
 938  *      DCCP over IPv4 via INET6 API
 939  */
 940 static const struct inet_connection_sock_af_ops dccp_ipv6_mapped = {
 941         .queue_xmit        = ip_queue_xmit,
 942         .send_check        = dccp_v4_send_check,
 943         .rebuild_header    = inet_sk_rebuild_header,
 944         .conn_request      = dccp_v6_conn_request,
 945         .syn_recv_sock     = dccp_v6_request_recv_sock,
 946         .net_header_len    = sizeof(struct iphdr),
 947         .setsockopt        = ipv6_setsockopt,
 948         .getsockopt        = ipv6_getsockopt,
 949         .addr2sockaddr     = inet6_csk_addr2sockaddr,
 950         .sockaddr_len      = sizeof(struct sockaddr_in6),
 951         .bind_conflict     = inet6_csk_bind_conflict,
 952 #ifdef CONFIG_COMPAT
 953         .compat_setsockopt = compat_ipv6_setsockopt,
 954         .compat_getsockopt = compat_ipv6_getsockopt,
 955 #endif
 956 };
 957
 958 /* NOTE: A lot of things set to zero explicitly by call to
 959  *       sk_alloc() so need not be done here.
 960  */
 961 static int dccp_v6_init_sock(struct sock *sk)
 962 {
 963         static __u8 dccp_v6_ctl_sock_initialized;
 964         int err = dccp_init_sock(sk, dccp_v6_ctl_sock_initialized);
 965
 966         if (err == 0) {
 967                 if (unlikely(!dccp_v6_ctl_sock_initialized))
 968                         dccp_v6_ctl_sock_initialized = 1;
 969                 inet_csk(sk)->icsk_af_ops = &dccp_ipv6_af_ops;
 970         }
 971
 972         return err;
 973 }
 974
 975 static void dccp_v6_destroy_sock(struct sock *sk)
 976 {
 977         dccp_destroy_sock(sk);
 978         inet6_destroy_sock(sk);
 979 }
 980
 981 static struct timewait_sock_ops dccp6_timewait_sock_ops = {
 982         .twsk_obj_size  = sizeof(struct dccp6_timewait_sock),
 983 };
 984
 985 static struct proto dccp_v6_prot = {
 986         .name              = "DCCPv6",
 987         .owner             = THIS_MODULE,
 988         .close             = dccp_close,
 989         .connect           = dccp_v6_connect,
 990         .disconnect        = dccp_disconnect,
 991         .ioctl             = dccp_ioctl,
 992         .init              = dccp_v6_init_sock,
 993         .setsockopt        = dccp_setsockopt,
 994         .getsockopt        = dccp_getsockopt,
 995         .sendmsg           = dccp_sendmsg,
 996         .recvmsg           = dccp_recvmsg,
 997         .backlog_rcv       = dccp_v6_do_rcv,
 998         .hash              = inet_hash,
 999         .unhash            = inet_unhash,
1000         .accept            = inet_csk_accept,
1001         .get_port          = inet_csk_get_port,
1002         .shutdown          = dccp_shutdown,
1003         .destroy           = dccp_v6_destroy_sock,
1004         .orphan_count      = &dccp_orphan_count,
1005         .max_header        = MAX_DCCP_HEADER,
1006         .obj_size          = sizeof(struct dccp6_sock),
1007         .slab_flags        = SLAB_DESTROY_BY_RCU,
1008         .rsk_prot          = &dccp6_request_sock_ops,
1009         .twsk_prot         = &dccp6_timewait_sock_ops,
1010         .h.hashinfo        = &dccp_hashinfo,
1011 #ifdef CONFIG_COMPAT
1012         .compat_setsockopt = compat_dccp_setsockopt,
1013         .compat_getsockopt = compat_dccp_getsockopt,
1014 #endif
1015 };
1016
1017 static const struct inet6_protocol dccp_v6_protocol = {
1018         .handler        = dccp_v6_rcv,
1019         .err_handler    = dccp_v6_err,
1020         .flags          = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
1021 };
1022
1023 static const struct proto_ops inet6_dccp_ops = {
1024         .family            = PF_INET6,
1025         .owner             = THIS_MODULE,
1026         .release           = inet6_release,
1027         .bind              = inet6_bind,
1028         .connect           = inet_stream_connect,
1029         .socketpair        = sock_no_socketpair,
1030         .accept            = inet_accept,
1031         .getname           = inet6_getname,
1032         .poll              = dccp_poll,
1033         .ioctl             = inet6_ioctl,
1034         .listen            = inet_dccp_listen,
1035         .shutdown          = inet_shutdown,
1036         .setsockopt        = sock_common_setsockopt,
1037         .getsockopt        = sock_common_getsockopt,
1038         .sendmsg           = inet_sendmsg,
1039         .recvmsg           = sock_common_recvmsg,
1040         .mmap              = sock_no_mmap,
1041         .sendpage          = sock_no_sendpage,
1042 #ifdef CONFIG_COMPAT
1043         .compat_setsockopt = compat_sock_common_setsockopt,
1044         .compat_getsockopt = compat_sock_common_getsockopt,
1045 #endif
1046 };
1047
1048 static struct inet_protosw dccp_v6_protosw = {
1049         .type           = SOCK_DCCP,
1050         .protocol       = IPPROTO_DCCP,
1051         .prot           = &dccp_v6_prot,
1052         .ops            = &inet6_dccp_ops,
1053         .flags          = INET_PROTOSW_ICSK,
1054 };
1055
1056 static int __net_init dccp_v6_init_net(struct net *net)
1057 {
1058         if (dccp_hashinfo.bhash == NULL)
1059                 return -ESOCKTNOSUPPORT;
1060
1061         return inet_ctl_sock_create(&net->dccp.v6_ctl_sk, PF_INET6,
1062                                     SOCK_DCCP, IPPROTO_DCCP, net);
1063 }
1064
1065 static void __net_exit dccp_v6_exit_net(struct net *net)
1066 {
1067         inet_ctl_sock_destroy(net->dccp.v6_ctl_sk);
1068 }
1069
1070 static struct pernet_operations dccp_v6_ops = {
1071         .init   = dccp_v6_init_net,
1072         .exit   = dccp_v6_exit_net,
1073 };
1074
1075 static int __init dccp_v6_init(void)
1076 {
1077         int err = proto_register(&dccp_v6_prot, 1);
1078
1079         if (err != 0)
1080                 goto out;
1081
1082         err = inet6_add_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
1083         if (err != 0)
1084                 goto out_unregister_proto;
1085
1086         inet6_register_protosw(&dccp_v6_protosw);
1087
1088         err = register_pernet_subsys(&dccp_v6_ops);
1089         if (err != 0)
1090                 goto out_destroy_ctl_sock;
1091 out:
1092         return err;
1093
1094 out_destroy_ctl_sock:
1095         inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
1096         inet6_unregister_protosw(&dccp_v6_protosw);
1097 out_unregister_proto:
1098         proto_unregister(&dccp_v6_prot);
1099         goto out;
1100 }
1101
1102 static void __exit dccp_v6_exit(void)
1103 {
1104         unregister_pernet_subsys(&dccp_v6_ops);
1105         inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
1106         inet6_unregister_protosw(&dccp_v6_protosw);
1107         proto_unregister(&dccp_v6_prot);
1108 }
1109
1110 module_init(dccp_v6_init);
1111 module_exit(dccp_v6_exit);
1112
1113 /*
1114  * __stringify doesn't likes enums, so use SOCK_DCCP (6) and IPPROTO_DCCP (33)
1115  * values directly, Also cover the case where the protocol is not specified,
1116  * i.e. net-pf-PF_INET6-proto-0-type-SOCK_DCCP
1117  */
1118 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 33, 6);
1119 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 0, 6);
1120 MODULE_LICENSE("GPL");
1121 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@mandriva.com>");
1122 MODULE_DESCRIPTION("DCCPv6 - Datagram Congestion Controlled Protocol");