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