git.oblomov.eu Git - linux-2.6/blob - net/dccp/ipv6.c

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