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