net/dccp/ipv6.c

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