net/dccp/ipv6.c

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