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