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