net/dccp/ipv6.c

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