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