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 */ 37 static struct socket *dccp_v6_ctl_socket; 38 39 static struct inet_connection_sock_af_ops dccp_ipv6_mapped; 40 static struct inet_connection_sock_af_ops dccp_ipv6_af_ops; 41 42 static 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 48 static 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 */ 62 static 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 69 static 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 79 static 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 85 static 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 94 static 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 227 out: 228 bh_unlock_sock(sk); 229 sock_put(sk); 230 } 231 232 233 static 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 300 done: 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 307 static 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 313 static 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 383 static 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 392 static 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 423 static 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 501 drop_and_free: 502 reqsk_free(req); 503 drop: 504 DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS); 505 dcb->dccpd_reset_code = reset_code; 506 return -1; 507 } 508 509 static 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 686 out_overflow: 687 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS); 688 out: 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 */ 704 static 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 /* 743 * FIXME: Add handling of IPV6_PKTOPTIONS skb. See the comments below 744 * (wrt ipv6_pktopions) and net/ipv6/tcp_ipv6.c for an example. 745 */ 746 opt_skb = skb_clone(skb, GFP_ATOMIC); 747 748 if (sk->sk_state == DCCP_OPEN) { /* Fast path */ 749 if (dccp_rcv_established(sk, skb, dccp_hdr(skb), skb->len)) 750 goto reset; 751 if (opt_skb) { 752 /* XXX This is where we would goto ipv6_pktoptions. */ 753 __kfree_skb(opt_skb); 754 } 755 return 0; 756 } 757 758 /* 759 * Step 3: Process LISTEN state 760 * If S.state == LISTEN, 761 * If P.type == Request or P contains a valid Init Cookie option, 762 * (* Must scan the packet's options to check for Init 763 * Cookies. Only Init Cookies are processed here, 764 * however; other options are processed in Step 8. This 765 * scan need only be performed if the endpoint uses Init 766 * Cookies *) 767 * (* Generate a new socket and switch to that socket *) 768 * Set S := new socket for this port pair 769 * S.state = RESPOND 770 * Choose S.ISS (initial seqno) or set from Init Cookies 771 * Initialize S.GAR := S.ISS 772 * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookies 773 * Continue with S.state == RESPOND 774 * (* A Response packet will be generated in Step 11 *) 775 * Otherwise, 776 * Generate Reset(No Connection) unless P.type == Reset 777 * Drop packet and return 778 * 779 * NOTE: the check for the packet types is done in 780 * dccp_rcv_state_process 781 */ 782 if (sk->sk_state == DCCP_LISTEN) { 783 struct sock *nsk = dccp_v6_hnd_req(sk, skb); 784 785 if (nsk == NULL) 786 goto discard; 787 /* 788 * Queue it on the new socket if the new socket is active, 789 * otherwise we just shortcircuit this and continue with 790 * the new socket.. 791 */ 792 if (nsk != sk) { 793 if (dccp_child_process(sk, nsk, skb)) 794 goto reset; 795 if (opt_skb != NULL) 796 __kfree_skb(opt_skb); 797 return 0; 798 } 799 } 800 801 if (dccp_rcv_state_process(sk, skb, dccp_hdr(skb), skb->len)) 802 goto reset; 803 if (opt_skb) { 804 /* XXX This is where we would goto ipv6_pktoptions. */ 805 __kfree_skb(opt_skb); 806 } 807 return 0; 808 809 reset: 810 dccp_v6_ctl_send_reset(sk, skb); 811 discard: 812 if (opt_skb != NULL) 813 __kfree_skb(opt_skb); 814 kfree_skb(skb); 815 return 0; 816 } 817 818 static int dccp_v6_rcv(struct sk_buff **pskb) 819 { 820 const struct dccp_hdr *dh; 821 struct sk_buff *skb = *pskb; 822 struct sock *sk; 823 int min_cov; 824 825 /* Step 1: Check header basics */ 826 827 if (dccp_invalid_packet(skb)) 828 goto discard_it; 829 830 /* Step 1: If header checksum is incorrect, drop packet and return. */ 831 if (dccp_v6_csum_finish(skb, &ipv6_hdr(skb)->saddr, 832 &ipv6_hdr(skb)->daddr)) { 833 DCCP_WARN("dropped packet with invalid checksum\n"); 834 goto discard_it; 835 } 836 837 dh = dccp_hdr(skb); 838 839 DCCP_SKB_CB(skb)->dccpd_seq = dccp_hdr_seq(skb); 840 DCCP_SKB_CB(skb)->dccpd_type = dh->dccph_type; 841 842 if (dccp_packet_without_ack(skb)) 843 DCCP_SKB_CB(skb)->dccpd_ack_seq = DCCP_PKT_WITHOUT_ACK_SEQ; 844 else 845 DCCP_SKB_CB(skb)->dccpd_ack_seq = dccp_hdr_ack_seq(skb); 846 847 /* Step 2: 848 * Look up flow ID in table and get corresponding socket */ 849 sk = __inet6_lookup(&dccp_hashinfo, &ipv6_hdr(skb)->saddr, 850 dh->dccph_sport, 851 &ipv6_hdr(skb)->daddr, ntohs(dh->dccph_dport), 852 inet6_iif(skb)); 853 /* 854 * Step 2: 855 * If no socket ... 856 */ 857 if (sk == NULL) { 858 dccp_pr_debug("failed to look up flow ID in table and " 859 "get corresponding socket\n"); 860 goto no_dccp_socket; 861 } 862 863 /* 864 * Step 2: 865 * ... or S.state == TIMEWAIT, 866 * Generate Reset(No Connection) unless P.type == Reset 867 * Drop packet and return 868 */ 869 if (sk->sk_state == DCCP_TIME_WAIT) { 870 dccp_pr_debug("sk->sk_state == DCCP_TIME_WAIT: do_time_wait\n"); 871 inet_twsk_put(inet_twsk(sk)); 872 goto no_dccp_socket; 873 } 874 875 /* 876 * RFC 4340, sec. 9.2.1: Minimum Checksum Coverage 877 * o if MinCsCov = 0, only packets with CsCov = 0 are accepted 878 * o if MinCsCov > 0, also accept packets with CsCov >= MinCsCov 879 */ 880 min_cov = dccp_sk(sk)->dccps_pcrlen; 881 if (dh->dccph_cscov && (min_cov == 0 || dh->dccph_cscov < min_cov)) { 882 dccp_pr_debug("Packet CsCov %d does not satisfy MinCsCov %d\n", 883 dh->dccph_cscov, min_cov); 884 /* FIXME: send Data Dropped option (see also dccp_v4_rcv) */ 885 goto discard_and_relse; 886 } 887 888 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) 889 goto discard_and_relse; 890 891 return sk_receive_skb(sk, skb, 1) ? -1 : 0; 892 893 no_dccp_socket: 894 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) 895 goto discard_it; 896 /* 897 * Step 2: 898 * If no socket ... 899 * Generate Reset(No Connection) unless P.type == Reset 900 * Drop packet and return 901 */ 902 if (dh->dccph_type != DCCP_PKT_RESET) { 903 DCCP_SKB_CB(skb)->dccpd_reset_code = 904 DCCP_RESET_CODE_NO_CONNECTION; 905 dccp_v6_ctl_send_reset(sk, skb); 906 } 907 908 discard_it: 909 kfree_skb(skb); 910 return 0; 911 912 discard_and_relse: 913 sock_put(sk); 914 goto discard_it; 915 } 916 917 static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr, 918 int addr_len) 919 { 920 struct sockaddr_in6 *usin = (struct sockaddr_in6 *)uaddr; 921 struct inet_connection_sock *icsk = inet_csk(sk); 922 struct inet_sock *inet = inet_sk(sk); 923 struct ipv6_pinfo *np = inet6_sk(sk); 924 struct dccp_sock *dp = dccp_sk(sk); 925 struct in6_addr *saddr = NULL, *final_p = NULL, final; 926 struct flowi fl; 927 struct dst_entry *dst; 928 int addr_type; 929 int err; 930 931 dp->dccps_role = DCCP_ROLE_CLIENT; 932 933 if (addr_len < SIN6_LEN_RFC2133) 934 return -EINVAL; 935 936 if (usin->sin6_family != AF_INET6) 937 return -EAFNOSUPPORT; 938 939 memset(&fl, 0, sizeof(fl)); 940 941 if (np->sndflow) { 942 fl.fl6_flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK; 943 IP6_ECN_flow_init(fl.fl6_flowlabel); 944 if (fl.fl6_flowlabel & IPV6_FLOWLABEL_MASK) { 945 struct ip6_flowlabel *flowlabel; 946 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel); 947 if (flowlabel == NULL) 948 return -EINVAL; 949 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst); 950 fl6_sock_release(flowlabel); 951 } 952 } 953 /* 954 * connect() to INADDR_ANY means loopback (BSD'ism). 955 */ 956 if (ipv6_addr_any(&usin->sin6_addr)) 957 usin->sin6_addr.s6_addr[15] = 1; 958 959 addr_type = ipv6_addr_type(&usin->sin6_addr); 960 961 if (addr_type & IPV6_ADDR_MULTICAST) 962 return -ENETUNREACH; 963 964 if (addr_type & IPV6_ADDR_LINKLOCAL) { 965 if (addr_len >= sizeof(struct sockaddr_in6) && 966 usin->sin6_scope_id) { 967 /* If interface is set while binding, indices 968 * must coincide. 969 */ 970 if (sk->sk_bound_dev_if && 971 sk->sk_bound_dev_if != usin->sin6_scope_id) 972 return -EINVAL; 973 974 sk->sk_bound_dev_if = usin->sin6_scope_id; 975 } 976 977 /* Connect to link-local address requires an interface */ 978 if (!sk->sk_bound_dev_if) 979 return -EINVAL; 980 } 981 982 ipv6_addr_copy(&np->daddr, &usin->sin6_addr); 983 np->flow_label = fl.fl6_flowlabel; 984 985 /* 986 * DCCP over IPv4 987 */ 988 if (addr_type == IPV6_ADDR_MAPPED) { 989 u32 exthdrlen = icsk->icsk_ext_hdr_len; 990 struct sockaddr_in sin; 991 992 SOCK_DEBUG(sk, "connect: ipv4 mapped\n"); 993 994 if (__ipv6_only_sock(sk)) 995 return -ENETUNREACH; 996 997 sin.sin_family = AF_INET; 998 sin.sin_port = usin->sin6_port; 999 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3]; 1000 1001 icsk->icsk_af_ops = &dccp_ipv6_mapped; 1002 sk->sk_backlog_rcv = dccp_v4_do_rcv; 1003 1004 err = dccp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin)); 1005 if (err) { 1006 icsk->icsk_ext_hdr_len = exthdrlen; 1007 icsk->icsk_af_ops = &dccp_ipv6_af_ops; 1008 sk->sk_backlog_rcv = dccp_v6_do_rcv; 1009 goto failure; 1010 } else { 1011 ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF), 1012 inet->saddr); 1013 ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF), 1014 inet->rcv_saddr); 1015 } 1016 1017 return err; 1018 } 1019 1020 if (!ipv6_addr_any(&np->rcv_saddr)) 1021 saddr = &np->rcv_saddr; 1022 1023 fl.proto = IPPROTO_DCCP; 1024 ipv6_addr_copy(&fl.fl6_dst, &np->daddr); 1025 ipv6_addr_copy(&fl.fl6_src, saddr ? saddr : &np->saddr); 1026 fl.oif = sk->sk_bound_dev_if; 1027 fl.fl_ip_dport = usin->sin6_port; 1028 fl.fl_ip_sport = inet->sport; 1029 security_sk_classify_flow(sk, &fl); 1030 1031 if (np->opt != NULL && np->opt->srcrt != NULL) { 1032 const struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt; 1033 1034 ipv6_addr_copy(&final, &fl.fl6_dst); 1035 ipv6_addr_copy(&fl.fl6_dst, rt0->addr); 1036 final_p = &final; 1037 } 1038 1039 err = ip6_dst_lookup(sk, &dst, &fl); 1040 if (err) 1041 goto failure; 1042 1043 if (final_p) 1044 ipv6_addr_copy(&fl.fl6_dst, final_p); 1045 1046 err = xfrm_lookup(&dst, &fl, sk, 1); 1047 if (err < 0) 1048 goto failure; 1049 1050 if (saddr == NULL) { 1051 saddr = &fl.fl6_src; 1052 ipv6_addr_copy(&np->rcv_saddr, saddr); 1053 } 1054 1055 /* set the source address */ 1056 ipv6_addr_copy(&np->saddr, saddr); 1057 inet->rcv_saddr = LOOPBACK4_IPV6; 1058 1059 __ip6_dst_store(sk, dst, NULL, NULL); 1060 1061 icsk->icsk_ext_hdr_len = 0; 1062 if (np->opt != NULL) 1063 icsk->icsk_ext_hdr_len = (np->opt->opt_flen + 1064 np->opt->opt_nflen); 1065 1066 inet->dport = usin->sin6_port; 1067 1068 dccp_set_state(sk, DCCP_REQUESTING); 1069 err = inet6_hash_connect(&dccp_death_row, sk); 1070 if (err) 1071 goto late_failure; 1072 1073 dp->dccps_iss = secure_dccpv6_sequence_number(np->saddr.s6_addr32, 1074 np->daddr.s6_addr32, 1075 inet->sport, inet->dport); 1076 err = dccp_connect(sk); 1077 if (err) 1078 goto late_failure; 1079 1080 return 0; 1081 1082 late_failure: 1083 dccp_set_state(sk, DCCP_CLOSED); 1084 __sk_dst_reset(sk); 1085 failure: 1086 inet->dport = 0; 1087 sk->sk_route_caps = 0; 1088 return err; 1089 } 1090 1091 static struct inet_connection_sock_af_ops dccp_ipv6_af_ops = { 1092 .queue_xmit = inet6_csk_xmit, 1093 .send_check = dccp_v6_send_check, 1094 .rebuild_header = inet6_sk_rebuild_header, 1095 .conn_request = dccp_v6_conn_request, 1096 .syn_recv_sock = dccp_v6_request_recv_sock, 1097 .net_header_len = sizeof(struct ipv6hdr), 1098 .setsockopt = ipv6_setsockopt, 1099 .getsockopt = ipv6_getsockopt, 1100 .addr2sockaddr = inet6_csk_addr2sockaddr, 1101 .sockaddr_len = sizeof(struct sockaddr_in6), 1102 #ifdef CONFIG_COMPAT 1103 .compat_setsockopt = compat_ipv6_setsockopt, 1104 .compat_getsockopt = compat_ipv6_getsockopt, 1105 #endif 1106 }; 1107 1108 /* 1109 * DCCP over IPv4 via INET6 API 1110 */ 1111 static struct inet_connection_sock_af_ops dccp_ipv6_mapped = { 1112 .queue_xmit = ip_queue_xmit, 1113 .send_check = dccp_v4_send_check, 1114 .rebuild_header = inet_sk_rebuild_header, 1115 .conn_request = dccp_v6_conn_request, 1116 .syn_recv_sock = dccp_v6_request_recv_sock, 1117 .net_header_len = sizeof(struct iphdr), 1118 .setsockopt = ipv6_setsockopt, 1119 .getsockopt = ipv6_getsockopt, 1120 .addr2sockaddr = inet6_csk_addr2sockaddr, 1121 .sockaddr_len = sizeof(struct sockaddr_in6), 1122 #ifdef CONFIG_COMPAT 1123 .compat_setsockopt = compat_ipv6_setsockopt, 1124 .compat_getsockopt = compat_ipv6_getsockopt, 1125 #endif 1126 }; 1127 1128 /* NOTE: A lot of things set to zero explicitly by call to 1129 * sk_alloc() so need not be done here. 1130 */ 1131 static int dccp_v6_init_sock(struct sock *sk) 1132 { 1133 static __u8 dccp_v6_ctl_sock_initialized; 1134 int err = dccp_init_sock(sk, dccp_v6_ctl_sock_initialized); 1135 1136 if (err == 0) { 1137 if (unlikely(!dccp_v6_ctl_sock_initialized)) 1138 dccp_v6_ctl_sock_initialized = 1; 1139 inet_csk(sk)->icsk_af_ops = &dccp_ipv6_af_ops; 1140 } 1141 1142 return err; 1143 } 1144 1145 static int dccp_v6_destroy_sock(struct sock *sk) 1146 { 1147 dccp_destroy_sock(sk); 1148 return inet6_destroy_sock(sk); 1149 } 1150 1151 static struct timewait_sock_ops dccp6_timewait_sock_ops = { 1152 .twsk_obj_size = sizeof(struct dccp6_timewait_sock), 1153 }; 1154 1155 static struct proto dccp_v6_prot = { 1156 .name = "DCCPv6", 1157 .owner = THIS_MODULE, 1158 .close = dccp_close, 1159 .connect = dccp_v6_connect, 1160 .disconnect = dccp_disconnect, 1161 .ioctl = dccp_ioctl, 1162 .init = dccp_v6_init_sock, 1163 .setsockopt = dccp_setsockopt, 1164 .getsockopt = dccp_getsockopt, 1165 .sendmsg = dccp_sendmsg, 1166 .recvmsg = dccp_recvmsg, 1167 .backlog_rcv = dccp_v6_do_rcv, 1168 .hash = dccp_v6_hash, 1169 .unhash = dccp_unhash, 1170 .accept = inet_csk_accept, 1171 .get_port = dccp_v6_get_port, 1172 .shutdown = dccp_shutdown, 1173 .destroy = dccp_v6_destroy_sock, 1174 .orphan_count = &dccp_orphan_count, 1175 .max_header = MAX_DCCP_HEADER, 1176 .obj_size = sizeof(struct dccp6_sock), 1177 .rsk_prot = &dccp6_request_sock_ops, 1178 .twsk_prot = &dccp6_timewait_sock_ops, 1179 #ifdef CONFIG_COMPAT 1180 .compat_setsockopt = compat_dccp_setsockopt, 1181 .compat_getsockopt = compat_dccp_getsockopt, 1182 #endif 1183 }; 1184 1185 static struct inet6_protocol dccp_v6_protocol = { 1186 .handler = dccp_v6_rcv, 1187 .err_handler = dccp_v6_err, 1188 .flags = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL, 1189 }; 1190 1191 static struct proto_ops inet6_dccp_ops = { 1192 .family = PF_INET6, 1193 .owner = THIS_MODULE, 1194 .release = inet6_release, 1195 .bind = inet6_bind, 1196 .connect = inet_stream_connect, 1197 .socketpair = sock_no_socketpair, 1198 .accept = inet_accept, 1199 .getname = inet6_getname, 1200 .poll = dccp_poll, 1201 .ioctl = inet6_ioctl, 1202 .listen = inet_dccp_listen, 1203 .shutdown = inet_shutdown, 1204 .setsockopt = sock_common_setsockopt, 1205 .getsockopt = sock_common_getsockopt, 1206 .sendmsg = inet_sendmsg, 1207 .recvmsg = sock_common_recvmsg, 1208 .mmap = sock_no_mmap, 1209 .sendpage = sock_no_sendpage, 1210 #ifdef CONFIG_COMPAT 1211 .compat_setsockopt = compat_sock_common_setsockopt, 1212 .compat_getsockopt = compat_sock_common_getsockopt, 1213 #endif 1214 }; 1215 1216 static struct inet_protosw dccp_v6_protosw = { 1217 .type = SOCK_DCCP, 1218 .protocol = IPPROTO_DCCP, 1219 .prot = &dccp_v6_prot, 1220 .ops = &inet6_dccp_ops, 1221 .capability = -1, 1222 .flags = INET_PROTOSW_ICSK, 1223 }; 1224 1225 static int __init dccp_v6_init(void) 1226 { 1227 int err = proto_register(&dccp_v6_prot, 1); 1228 1229 if (err != 0) 1230 goto out; 1231 1232 err = inet6_add_protocol(&dccp_v6_protocol, IPPROTO_DCCP); 1233 if (err != 0) 1234 goto out_unregister_proto; 1235 1236 inet6_register_protosw(&dccp_v6_protosw); 1237 1238 err = inet_csk_ctl_sock_create(&dccp_v6_ctl_socket, PF_INET6, 1239 SOCK_DCCP, IPPROTO_DCCP); 1240 if (err != 0) 1241 goto out_unregister_protosw; 1242 out: 1243 return err; 1244 out_unregister_protosw: 1245 inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP); 1246 inet6_unregister_protosw(&dccp_v6_protosw); 1247 out_unregister_proto: 1248 proto_unregister(&dccp_v6_prot); 1249 goto out; 1250 } 1251 1252 static void __exit dccp_v6_exit(void) 1253 { 1254 inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP); 1255 inet6_unregister_protosw(&dccp_v6_protosw); 1256 proto_unregister(&dccp_v6_prot); 1257 } 1258 1259 module_init(dccp_v6_init); 1260 module_exit(dccp_v6_exit); 1261 1262 /* 1263 * __stringify doesn't likes enums, so use SOCK_DCCP (6) and IPPROTO_DCCP (33) 1264 * values directly, Also cover the case where the protocol is not specified, 1265 * i.e. net-pf-PF_INET6-proto-0-type-SOCK_DCCP 1266 */ 1267 MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-33-type-6"); 1268 MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-0-type-6"); 1269 MODULE_LICENSE("GPL"); 1270 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@mandriva.com>"); 1271 MODULE_DESCRIPTION("DCCPv6 - Datagram Congestion Controlled Protocol"); 1272