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