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