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