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