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