1 /* 2 * Copyright (c) 2003, 2004 Jeffrey M. Hsu. All rights reserved. 3 * Copyright (c) 2003, 2004 The DragonFly Project. All rights reserved. 4 * 5 * This code is derived from software contributed to The DragonFly Project 6 * by Jeffrey M. Hsu. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of The DragonFly Project nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific, prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 24 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 30 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 /* 35 * Copyright (c) 1982, 1986, 1988, 1993 36 * The Regents of the University of California. All rights reserved. 37 * 38 * Redistribution and use in source and binary forms, with or without 39 * modification, are permitted provided that the following conditions 40 * are met: 41 * 1. Redistributions of source code must retain the above copyright 42 * notice, this list of conditions and the following disclaimer. 43 * 2. Redistributions in binary form must reproduce the above copyright 44 * notice, this list of conditions and the following disclaimer in the 45 * documentation and/or other materials provided with the distribution. 46 * 3. Neither the name of the University nor the names of its contributors 47 * may be used to endorse or promote products derived from this software 48 * without specific prior written permission. 49 * 50 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 51 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 52 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 53 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 54 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 55 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 56 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 57 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 58 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 59 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 60 * SUCH DAMAGE. 61 * 62 * From: @(#)tcp_usrreq.c 8.2 (Berkeley) 1/3/94 63 * $FreeBSD: src/sys/netinet/tcp_usrreq.c,v 1.51.2.17 2002/10/11 11:46:44 ume Exp $ 64 */ 65 66 #include "opt_ipsec.h" 67 #include "opt_inet.h" 68 #include "opt_inet6.h" 69 #include "opt_tcpdebug.h" 70 71 #include <sys/param.h> 72 #include <sys/systm.h> 73 #include <sys/kernel.h> 74 #include <sys/malloc.h> 75 #include <sys/sysctl.h> 76 #include <sys/globaldata.h> 77 #include <sys/thread.h> 78 79 #include <sys/mbuf.h> 80 #ifdef INET6 81 #include <sys/domain.h> 82 #endif /* INET6 */ 83 #include <sys/socket.h> 84 #include <sys/socketvar.h> 85 #include <sys/socketops.h> 86 #include <sys/protosw.h> 87 88 #include <sys/thread2.h> 89 #include <sys/msgport2.h> 90 #include <sys/socketvar2.h> 91 92 #include <net/if.h> 93 #include <net/netisr.h> 94 #include <net/route.h> 95 96 #include <net/netmsg2.h> 97 #include <net/netisr2.h> 98 99 #include <netinet/in.h> 100 #include <netinet/in_systm.h> 101 #ifdef INET6 102 #include <netinet/ip6.h> 103 #endif 104 #include <netinet/in_pcb.h> 105 #ifdef INET6 106 #include <netinet6/in6_pcb.h> 107 #endif 108 #include <netinet/in_var.h> 109 #include <netinet/ip_var.h> 110 #ifdef INET6 111 #include <netinet6/ip6_var.h> 112 #include <netinet6/tcp6_var.h> 113 #endif 114 #include <netinet/tcp.h> 115 #include <netinet/tcp_fsm.h> 116 #include <netinet/tcp_seq.h> 117 #include <netinet/tcp_timer.h> 118 #include <netinet/tcp_timer2.h> 119 #include <netinet/tcp_var.h> 120 #include <netinet/tcpip.h> 121 #ifdef TCPDEBUG 122 #include <netinet/tcp_debug.h> 123 #endif 124 125 #ifdef IPSEC 126 #include <netinet6/ipsec.h> 127 #endif /*IPSEC*/ 128 129 /* 130 * TCP protocol interface to socket abstraction. 131 */ 132 extern char *tcpstates[]; /* XXX ??? */ 133 134 static int tcp_attach (struct socket *, struct pru_attach_info *); 135 static void tcp_connect (netmsg_t msg); 136 #ifdef INET6 137 static void tcp6_connect (netmsg_t msg); 138 static int tcp6_connect_oncpu(struct tcpcb *tp, int flags, 139 struct mbuf **mp, 140 struct sockaddr_in6 *sin6, 141 struct in6_addr *addr6); 142 #endif /* INET6 */ 143 static struct tcpcb * 144 tcp_disconnect (struct tcpcb *); 145 static struct tcpcb * 146 tcp_usrclosed (struct tcpcb *); 147 148 #ifdef TCPDEBUG 149 #define TCPDEBUG0 int ostate = 0 150 #define TCPDEBUG1() ostate = tp ? tp->t_state : 0 151 #define TCPDEBUG2(req) if (tp && (so->so_options & SO_DEBUG)) \ 152 tcp_trace(TA_USER, ostate, tp, 0, 0, req) 153 #else 154 #define TCPDEBUG0 155 #define TCPDEBUG1() 156 #define TCPDEBUG2(req) 157 #endif 158 159 static int tcp_lport_extension = 1; 160 SYSCTL_INT(_net_inet_tcp, OID_AUTO, lportext, CTLFLAG_RW, 161 &tcp_lport_extension, 0, ""); 162 163 /* 164 * For some ill optimized programs, which try to use TCP_NOPUSH 165 * to improve performance, will have small amount of data sits 166 * in the sending buffer. These small amount of data will _not_ 167 * be pushed into the network until more data are written into 168 * the socket or the socket write side is shutdown. 169 */ 170 static int tcp_disable_nopush = 1; 171 SYSCTL_INT(_net_inet_tcp, OID_AUTO, disable_nopush, CTLFLAG_RW, 172 &tcp_disable_nopush, 0, "TCP_NOPUSH socket option will have no effect"); 173 174 /* 175 * Allocate socket buffer space. 176 */ 177 static int 178 tcp_usr_preattach(struct socket *so, int proto __unused, 179 struct pru_attach_info *ai) 180 { 181 int error; 182 183 if (so->so_snd.ssb_hiwat == 0 || so->so_rcv.ssb_hiwat == 0) { 184 error = soreserve(so, tcp_sendspace, tcp_recvspace, 185 ai->sb_rlimit); 186 if (error) 187 return (error); 188 } 189 atomic_set_int(&so->so_rcv.ssb_flags, SSB_AUTOSIZE | SSB_PREALLOC); 190 atomic_set_int(&so->so_snd.ssb_flags, SSB_AUTOSIZE | SSB_PREALLOC); 191 192 return 0; 193 } 194 195 /* 196 * TCP attaches to socket via pru_attach(), reserving space, 197 * and an internet control block. This socket may move to 198 * other CPU later when we bind/connect. 199 */ 200 static void 201 tcp_usr_attach(netmsg_t msg) 202 { 203 struct socket *so = msg->base.nm_so; 204 struct pru_attach_info *ai = msg->attach.nm_ai; 205 int error; 206 struct inpcb *inp; 207 struct tcpcb *tp = NULL; 208 TCPDEBUG0; 209 210 inp = so->so_pcb; 211 KASSERT(inp == NULL, ("tcp socket attached")); 212 TCPDEBUG1(); 213 214 error = tcp_attach(so, ai); 215 if (error) 216 goto out; 217 218 if ((so->so_options & SO_LINGER) && so->so_linger == 0) 219 so->so_linger = TCP_LINGERTIME; 220 tp = sototcpcb(so); 221 out: 222 TCPDEBUG2(PRU_ATTACH); 223 lwkt_replymsg(&msg->lmsg, error); 224 } 225 226 /* 227 * pru_detach() detaches the TCP protocol from the socket. 228 * If the protocol state is non-embryonic, then can't 229 * do this directly: have to initiate a pru_disconnect(), 230 * which may finish later; embryonic TCB's can just 231 * be discarded here. 232 */ 233 static void 234 tcp_usr_detach(netmsg_t msg) 235 { 236 struct socket *so = msg->base.nm_so; 237 int error = 0; 238 struct inpcb *inp; 239 struct tcpcb *tp; 240 TCPDEBUG0; 241 242 inp = so->so_pcb; 243 244 /* 245 * If the inp is already detached or never attached, it may have 246 * been due to an async close or async attach failure. Just return 247 * as if no error occured. 248 */ 249 if (inp) { 250 tp = intotcpcb(inp); 251 KASSERT(tp != NULL, ("tcp_usr_detach: tp is NULL")); 252 TCPDEBUG1(); 253 tp = tcp_disconnect(tp); 254 TCPDEBUG2(PRU_DETACH); 255 } 256 lwkt_replymsg(&msg->lmsg, error); 257 } 258 259 /* 260 * NOTE: ignore_error is non-zero for certain disconnection races 261 * which we want to silently allow, otherwise close() may return 262 * an unexpected error. 263 * 264 * NOTE: The variables (msg) and (tp) are assumed. 265 */ 266 #define COMMON_START(so, inp, ignore_error) \ 267 TCPDEBUG0; \ 268 \ 269 inp = so->so_pcb; \ 270 do { \ 271 if (inp == NULL) { \ 272 error = ignore_error ? 0 : EINVAL; \ 273 tp = NULL; \ 274 goto out; \ 275 } \ 276 tp = intotcpcb(inp); \ 277 TCPDEBUG1(); \ 278 } while(0) 279 280 #define COMMON_END1(req, noreply) \ 281 out: do { \ 282 TCPDEBUG2(req); \ 283 if (!(noreply)) \ 284 lwkt_replymsg(&msg->lmsg, error); \ 285 return; \ 286 } while(0) 287 288 #define COMMON_END(req) COMMON_END1((req), 0) 289 290 static void 291 tcp_sosetport(struct lwkt_msg *msg, lwkt_port_t port) 292 { 293 sosetport(((struct netmsg_base *)msg)->nm_so, port); 294 } 295 296 /* 297 * Give the socket an address. 298 */ 299 static void 300 tcp_usr_bind(netmsg_t msg) 301 { 302 struct socket *so = msg->bind.base.nm_so; 303 struct sockaddr *nam = msg->bind.nm_nam; 304 struct thread *td = msg->bind.nm_td; 305 int error = 0; 306 struct inpcb *inp; 307 struct tcpcb *tp; 308 struct sockaddr_in *sinp; 309 lwkt_port_t port0 = netisr_cpuport(0); 310 311 COMMON_START(so, inp, 0); 312 313 /* 314 * Must check for multicast addresses and disallow binding 315 * to them. 316 */ 317 sinp = (struct sockaddr_in *)nam; 318 if (sinp->sin_family == AF_INET && 319 IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) { 320 error = EAFNOSUPPORT; 321 goto out; 322 } 323 324 /* 325 * Check "already bound" here (in_pcbbind() does the same check 326 * though), so we don't forward a connected socket to netisr0, 327 * which would panic in the following in_pcbunlink(). 328 */ 329 if (inp->inp_lport != 0 || inp->inp_laddr.s_addr != INADDR_ANY) { 330 error = EINVAL; /* already bound */ 331 goto out; 332 } 333 334 /* 335 * Use netisr0 to serialize in_pcbbind(), so that pru_detach and 336 * pru_bind for different sockets on the same local port could be 337 * properly ordered. The original race is illustrated here for 338 * reference. 339 * 340 * s1 = socket(); 341 * bind(s1, *.PORT); 342 * close(s1); <----- asynchronous 343 * s2 = socket(); 344 * bind(s2, *.PORT); 345 * 346 * All will expect bind(s2, *.PORT) to succeed. However, it will 347 * fail, if following sequence happens due to random socket initial 348 * msgport and asynchronous close(2): 349 * 350 * netisrN netisrM 351 * : : 352 * : pru_bind(s2) [*.PORT is used by s1] 353 * pru_detach(s1) : 354 */ 355 if (&curthread->td_msgport != port0) { 356 lwkt_msg_t lmsg = &msg->bind.base.lmsg; 357 358 KASSERT((msg->bind.nm_flags & PRUB_RELINK) == 0, 359 ("already asked to relink")); 360 361 in_pcbunlink(so->so_pcb, &tcbinfo[mycpuid]); 362 msg->bind.nm_flags |= PRUB_RELINK; 363 364 /* See the related comment in tcp_connect() */ 365 lwkt_setmsg_receipt(lmsg, tcp_sosetport); 366 lwkt_forwardmsg(port0, lmsg); 367 /* msg invalid now */ 368 return; 369 } 370 KASSERT(so->so_port == port0, ("so_port is not netisr0")); 371 372 if (msg->bind.nm_flags & PRUB_RELINK) { 373 msg->bind.nm_flags &= ~PRUB_RELINK; 374 in_pcblink(so->so_pcb, &tcbinfo[mycpuid]); 375 } 376 KASSERT(inp->inp_pcbinfo == &tcbinfo[0], ("pcbinfo is not tcbinfo0")); 377 378 error = in_pcbbind(inp, nam, td); 379 if (error) 380 goto out; 381 382 COMMON_END(PRU_BIND); 383 } 384 385 #ifdef INET6 386 387 static void 388 tcp6_usr_bind(netmsg_t msg) 389 { 390 struct socket *so = msg->bind.base.nm_so; 391 struct sockaddr *nam = msg->bind.nm_nam; 392 struct thread *td = msg->bind.nm_td; 393 int error = 0; 394 struct inpcb *inp; 395 struct tcpcb *tp; 396 struct sockaddr_in6 *sin6p; 397 398 COMMON_START(so, inp, 0); 399 400 /* 401 * Must check for multicast addresses and disallow binding 402 * to them. 403 */ 404 sin6p = (struct sockaddr_in6 *)nam; 405 if (sin6p->sin6_family == AF_INET6 && 406 IN6_IS_ADDR_MULTICAST(&sin6p->sin6_addr)) { 407 error = EAFNOSUPPORT; 408 goto out; 409 } 410 error = in6_pcbbind(inp, nam, td); 411 if (error) 412 goto out; 413 COMMON_END(PRU_BIND); 414 } 415 #endif /* INET6 */ 416 417 struct netmsg_inswildcard { 418 struct netmsg_base base; 419 struct inpcb *nm_inp; 420 }; 421 422 static void 423 in_pcbinswildcardhash_handler(netmsg_t msg) 424 { 425 struct netmsg_inswildcard *nm = (struct netmsg_inswildcard *)msg; 426 int cpu = mycpuid, nextcpu; 427 428 in_pcbinswildcardhash_oncpu(nm->nm_inp, &tcbinfo[cpu]); 429 430 nextcpu = cpu + 1; 431 if (nextcpu < ncpus2) 432 lwkt_forwardmsg(netisr_cpuport(nextcpu), &nm->base.lmsg); 433 else 434 lwkt_replymsg(&nm->base.lmsg, 0); 435 } 436 437 /* 438 * Prepare to accept connections. 439 */ 440 static void 441 tcp_usr_listen(netmsg_t msg) 442 { 443 struct socket *so = msg->listen.base.nm_so; 444 struct thread *td = msg->listen.nm_td; 445 int error = 0; 446 struct inpcb *inp; 447 struct tcpcb *tp; 448 struct netmsg_inswildcard nm; 449 lwkt_port_t port0 = netisr_cpuport(0); 450 451 COMMON_START(so, inp, 0); 452 453 if (&curthread->td_msgport != port0) { 454 lwkt_msg_t lmsg = &msg->listen.base.lmsg; 455 456 KASSERT((msg->listen.nm_flags & PRUL_RELINK) == 0, 457 ("already asked to relink")); 458 459 in_pcbunlink(so->so_pcb, &tcbinfo[mycpuid]); 460 msg->listen.nm_flags |= PRUL_RELINK; 461 462 /* See the related comment in tcp_connect() */ 463 lwkt_setmsg_receipt(lmsg, tcp_sosetport); 464 lwkt_forwardmsg(port0, lmsg); 465 /* msg invalid now */ 466 return; 467 } 468 KASSERT(so->so_port == port0, ("so_port is not netisr0")); 469 470 if (msg->listen.nm_flags & PRUL_RELINK) { 471 msg->listen.nm_flags &= ~PRUL_RELINK; 472 in_pcblink(so->so_pcb, &tcbinfo[mycpuid]); 473 } 474 KASSERT(inp->inp_pcbinfo == &tcbinfo[0], ("pcbinfo is not tcbinfo0")); 475 476 if (tp->t_flags & TF_LISTEN) 477 goto out; 478 479 if (inp->inp_lport == 0) { 480 error = in_pcbbind(inp, NULL, td); 481 if (error) 482 goto out; 483 } 484 485 tp->t_state = TCPS_LISTEN; 486 tp->t_flags |= TF_LISTEN; 487 tp->tt_msg = NULL; /* Catch any invalid timer usage */ 488 489 if (ncpus2 > 1) { 490 /* 491 * Put this inpcb into wildcard hash on other cpus. 492 */ 493 ASSERT_INP_NOTINHASH(inp); 494 netmsg_init(&nm.base, NULL, &curthread->td_msgport, 495 MSGF_PRIORITY, in_pcbinswildcardhash_handler); 496 nm.nm_inp = inp; 497 lwkt_domsg(netisr_cpuport(1), &nm.base.lmsg, 0); 498 } 499 in_pcbinswildcardhash(inp); 500 COMMON_END(PRU_LISTEN); 501 } 502 503 #ifdef INET6 504 505 static void 506 tcp6_usr_listen(netmsg_t msg) 507 { 508 struct socket *so = msg->listen.base.nm_so; 509 struct thread *td = msg->listen.nm_td; 510 int error = 0; 511 struct inpcb *inp; 512 struct tcpcb *tp; 513 struct netmsg_inswildcard nm; 514 515 COMMON_START(so, inp, 0); 516 517 if (tp->t_flags & TF_LISTEN) 518 goto out; 519 520 if (inp->inp_lport == 0) { 521 error = in6_pcbbind(inp, NULL, td); 522 if (error) 523 goto out; 524 } 525 526 tp->t_state = TCPS_LISTEN; 527 tp->t_flags |= TF_LISTEN; 528 tp->tt_msg = NULL; /* Catch any invalid timer usage */ 529 530 if (ncpus2 > 1) { 531 /* 532 * Put this inpcb into wildcard hash on other cpus. 533 */ 534 KKASSERT(so->so_port == netisr_cpuport(0)); 535 ASSERT_IN_NETISR(0); 536 KKASSERT(inp->inp_pcbinfo == &tcbinfo[0]); 537 ASSERT_INP_NOTINHASH(inp); 538 539 netmsg_init(&nm.base, NULL, &curthread->td_msgport, 540 MSGF_PRIORITY, in_pcbinswildcardhash_handler); 541 nm.nm_inp = inp; 542 lwkt_domsg(netisr_cpuport(1), &nm.base.lmsg, 0); 543 } 544 in_pcbinswildcardhash(inp); 545 COMMON_END(PRU_LISTEN); 546 } 547 #endif /* INET6 */ 548 549 /* 550 * Initiate connection to peer. 551 * Create a template for use in transmissions on this connection. 552 * Enter SYN_SENT state, and mark socket as connecting. 553 * Start keep-alive timer, and seed output sequence space. 554 * Send initial segment on connection. 555 */ 556 static void 557 tcp_usr_connect(netmsg_t msg) 558 { 559 struct socket *so = msg->connect.base.nm_so; 560 struct sockaddr *nam = msg->connect.nm_nam; 561 struct thread *td = msg->connect.nm_td; 562 int error = 0; 563 struct inpcb *inp; 564 struct tcpcb *tp; 565 struct sockaddr_in *sinp; 566 567 COMMON_START(so, inp, 0); 568 569 /* 570 * Must disallow TCP ``connections'' to multicast addresses. 571 */ 572 sinp = (struct sockaddr_in *)nam; 573 if (sinp->sin_family == AF_INET 574 && IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) { 575 error = EAFNOSUPPORT; 576 goto out; 577 } 578 579 if (!prison_remote_ip(td, (struct sockaddr*)sinp)) { 580 error = EAFNOSUPPORT; /* IPv6 only jail */ 581 goto out; 582 } 583 584 tcp_connect(msg); 585 /* msg is invalid now */ 586 return; 587 out: 588 if (msg->connect.nm_m) { 589 m_freem(msg->connect.nm_m); 590 msg->connect.nm_m = NULL; 591 } 592 if (msg->connect.nm_flags & PRUC_HELDTD) 593 lwkt_rele(td); 594 if (error && (msg->connect.nm_flags & PRUC_ASYNC)) { 595 so->so_error = error; 596 soisdisconnected(so); 597 } 598 lwkt_replymsg(&msg->lmsg, error); 599 } 600 601 #ifdef INET6 602 603 static void 604 tcp6_usr_connect(netmsg_t msg) 605 { 606 struct socket *so = msg->connect.base.nm_so; 607 struct sockaddr *nam = msg->connect.nm_nam; 608 struct thread *td = msg->connect.nm_td; 609 int error = 0; 610 struct inpcb *inp; 611 struct tcpcb *tp; 612 struct sockaddr_in6 *sin6p; 613 614 COMMON_START(so, inp, 0); 615 616 /* 617 * Must disallow TCP ``connections'' to multicast addresses. 618 */ 619 sin6p = (struct sockaddr_in6 *)nam; 620 if (sin6p->sin6_family == AF_INET6 621 && IN6_IS_ADDR_MULTICAST(&sin6p->sin6_addr)) { 622 error = EAFNOSUPPORT; 623 goto out; 624 } 625 626 if (!prison_remote_ip(td, nam)) { 627 error = EAFNOSUPPORT; /* IPv4 only jail */ 628 goto out; 629 } 630 631 /* Reject v4-mapped address */ 632 if (IN6_IS_ADDR_V4MAPPED(&sin6p->sin6_addr)) { 633 error = EADDRNOTAVAIL; 634 goto out; 635 } 636 637 inp->inp_inc.inc_isipv6 = 1; 638 tcp6_connect(msg); 639 /* msg is invalid now */ 640 return; 641 out: 642 if (msg->connect.nm_m) { 643 m_freem(msg->connect.nm_m); 644 msg->connect.nm_m = NULL; 645 } 646 lwkt_replymsg(&msg->lmsg, error); 647 } 648 649 #endif /* INET6 */ 650 651 /* 652 * Initiate disconnect from peer. 653 * If connection never passed embryonic stage, just drop; 654 * else if don't need to let data drain, then can just drop anyways, 655 * else have to begin TCP shutdown process: mark socket disconnecting, 656 * drain unread data, state switch to reflect user close, and 657 * send segment (e.g. FIN) to peer. Socket will be really disconnected 658 * when peer sends FIN and acks ours. 659 * 660 * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB. 661 */ 662 static void 663 tcp_usr_disconnect(netmsg_t msg) 664 { 665 struct socket *so = msg->disconnect.base.nm_so; 666 int error = 0; 667 struct inpcb *inp; 668 struct tcpcb *tp; 669 670 COMMON_START(so, inp, 1); 671 tp = tcp_disconnect(tp); 672 COMMON_END(PRU_DISCONNECT); 673 } 674 675 /* 676 * Accept a connection. Essentially all the work is 677 * done at higher levels; just return the address 678 * of the peer, storing through addr. 679 */ 680 static void 681 tcp_usr_accept(netmsg_t msg) 682 { 683 struct socket *so = msg->accept.base.nm_so; 684 struct sockaddr **nam = msg->accept.nm_nam; 685 int error = 0; 686 struct inpcb *inp; 687 struct tcpcb *tp = NULL; 688 TCPDEBUG0; 689 690 inp = so->so_pcb; 691 if (so->so_state & SS_ISDISCONNECTED) { 692 error = ECONNABORTED; 693 goto out; 694 } 695 if (inp == NULL) { 696 error = EINVAL; 697 goto out; 698 } 699 700 tp = intotcpcb(inp); 701 TCPDEBUG1(); 702 in_setpeeraddr(so, nam); 703 COMMON_END(PRU_ACCEPT); 704 } 705 706 #ifdef INET6 707 static void 708 tcp6_usr_accept(netmsg_t msg) 709 { 710 struct socket *so = msg->accept.base.nm_so; 711 struct sockaddr **nam = msg->accept.nm_nam; 712 int error = 0; 713 struct inpcb *inp; 714 struct tcpcb *tp = NULL; 715 TCPDEBUG0; 716 717 inp = so->so_pcb; 718 719 if (so->so_state & SS_ISDISCONNECTED) { 720 error = ECONNABORTED; 721 goto out; 722 } 723 if (inp == NULL) { 724 error = EINVAL; 725 goto out; 726 } 727 tp = intotcpcb(inp); 728 TCPDEBUG1(); 729 in6_setpeeraddr(so, nam); 730 COMMON_END(PRU_ACCEPT); 731 } 732 #endif /* INET6 */ 733 734 /* 735 * Mark the connection as being incapable of further output. 736 */ 737 static void 738 tcp_usr_shutdown(netmsg_t msg) 739 { 740 struct socket *so = msg->shutdown.base.nm_so; 741 int error = 0; 742 struct inpcb *inp; 743 struct tcpcb *tp; 744 745 COMMON_START(so, inp, 0); 746 socantsendmore(so); 747 tp = tcp_usrclosed(tp); 748 if (tp) 749 error = tcp_output(tp); 750 COMMON_END(PRU_SHUTDOWN); 751 } 752 753 /* 754 * After a receive, possibly send window update to peer. 755 */ 756 static void 757 tcp_usr_rcvd(netmsg_t msg) 758 { 759 struct socket *so = msg->rcvd.base.nm_so; 760 int error = 0, noreply = 0; 761 struct inpcb *inp; 762 struct tcpcb *tp; 763 764 COMMON_START(so, inp, 0); 765 766 if (msg->rcvd.nm_pru_flags & PRUR_ASYNC) { 767 noreply = 1; 768 so_async_rcvd_reply(so); 769 } 770 tcp_output(tp); 771 772 COMMON_END1(PRU_RCVD, noreply); 773 } 774 775 /* 776 * Do a send by putting data in output queue and updating urgent 777 * marker if URG set. Possibly send more data. Unlike the other 778 * pru_*() routines, the mbuf chains are our responsibility. We 779 * must either enqueue them or free them. The other pru_* routines 780 * generally are caller-frees. 781 */ 782 static void 783 tcp_usr_send(netmsg_t msg) 784 { 785 struct socket *so = msg->send.base.nm_so; 786 int flags = msg->send.nm_flags; 787 struct mbuf *m = msg->send.nm_m; 788 int error = 0; 789 struct inpcb *inp; 790 struct tcpcb *tp; 791 TCPDEBUG0; 792 793 KKASSERT(msg->send.nm_control == NULL); 794 KKASSERT(msg->send.nm_addr == NULL); 795 KKASSERT((flags & PRUS_FREEADDR) == 0); 796 797 inp = so->so_pcb; 798 799 if (inp == NULL) { 800 /* 801 * OOPS! we lost a race, the TCP session got reset after 802 * we checked SS_CANTSENDMORE, eg: while doing uiomove or a 803 * network interrupt in the non-critical section of sosend(). 804 */ 805 m_freem(m); 806 error = ECONNRESET; /* XXX EPIPE? */ 807 tp = NULL; 808 TCPDEBUG1(); 809 goto out; 810 } 811 tp = intotcpcb(inp); 812 TCPDEBUG1(); 813 814 #ifdef foo 815 /* 816 * This is no longer necessary, since: 817 * - sosendtcp() has already checked it for us 818 * - It does not work with asynchronized send 819 */ 820 821 /* 822 * Don't let too much OOB data build up 823 */ 824 if (flags & PRUS_OOB) { 825 if (ssb_space(&so->so_snd) < -512) { 826 m_freem(m); 827 error = ENOBUFS; 828 goto out; 829 } 830 } 831 #endif 832 833 /* 834 * Pump the data into the socket. 835 */ 836 if (m) { 837 ssb_appendstream(&so->so_snd, m); 838 sowwakeup(so); 839 } 840 if (flags & PRUS_OOB) { 841 /* 842 * According to RFC961 (Assigned Protocols), 843 * the urgent pointer points to the last octet 844 * of urgent data. We continue, however, 845 * to consider it to indicate the first octet 846 * of data past the urgent section. 847 * Otherwise, snd_up should be one lower. 848 */ 849 tp->snd_up = tp->snd_una + so->so_snd.ssb_cc; 850 tp->t_flags |= TF_FORCE; 851 error = tcp_output(tp); 852 tp->t_flags &= ~TF_FORCE; 853 } else { 854 if (flags & PRUS_EOF) { 855 /* 856 * Close the send side of the connection after 857 * the data is sent. 858 */ 859 socantsendmore(so); 860 tp = tcp_usrclosed(tp); 861 } 862 if (tp != NULL && !tcp_output_pending(tp)) { 863 if (flags & PRUS_MORETOCOME) 864 tp->t_flags |= TF_MORETOCOME; 865 error = tcp_output_fair(tp); 866 if (flags & PRUS_MORETOCOME) 867 tp->t_flags &= ~TF_MORETOCOME; 868 } 869 } 870 COMMON_END1((flags & PRUS_OOB) ? PRU_SENDOOB : 871 ((flags & PRUS_EOF) ? PRU_SEND_EOF : PRU_SEND), 872 (flags & PRUS_NOREPLY)); 873 } 874 875 /* 876 * NOTE: (so) is referenced from soabort*() and netmsg_pru_abort() 877 * will sofree() it when we return. 878 */ 879 static void 880 tcp_usr_abort(netmsg_t msg) 881 { 882 struct socket *so = msg->abort.base.nm_so; 883 int error = 0; 884 struct inpcb *inp; 885 struct tcpcb *tp; 886 887 COMMON_START(so, inp, 1); 888 tp = tcp_drop(tp, ECONNABORTED); 889 COMMON_END(PRU_ABORT); 890 } 891 892 /* 893 * Receive out-of-band data. 894 */ 895 static void 896 tcp_usr_rcvoob(netmsg_t msg) 897 { 898 struct socket *so = msg->rcvoob.base.nm_so; 899 struct mbuf *m = msg->rcvoob.nm_m; 900 int flags = msg->rcvoob.nm_flags; 901 int error = 0; 902 struct inpcb *inp; 903 struct tcpcb *tp; 904 905 COMMON_START(so, inp, 0); 906 if ((so->so_oobmark == 0 && 907 (so->so_state & SS_RCVATMARK) == 0) || 908 so->so_options & SO_OOBINLINE || 909 tp->t_oobflags & TCPOOB_HADDATA) { 910 error = EINVAL; 911 goto out; 912 } 913 if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) { 914 error = EWOULDBLOCK; 915 goto out; 916 } 917 m->m_len = 1; 918 *mtod(m, caddr_t) = tp->t_iobc; 919 if ((flags & MSG_PEEK) == 0) 920 tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA); 921 COMMON_END(PRU_RCVOOB); 922 } 923 924 static void 925 tcp_usr_savefaddr(struct socket *so, const struct sockaddr *faddr) 926 { 927 in_savefaddr(so, faddr); 928 } 929 930 #ifdef INET6 931 static void 932 tcp6_usr_savefaddr(struct socket *so, const struct sockaddr *faddr) 933 { 934 in6_savefaddr(so, faddr); 935 } 936 #endif 937 938 static int 939 tcp_usr_preconnect(struct socket *so, const struct sockaddr *nam, 940 struct thread *td __unused) 941 { 942 const struct sockaddr_in *sinp; 943 944 sinp = (const struct sockaddr_in *)nam; 945 if (sinp->sin_family == AF_INET && 946 IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) 947 return EAFNOSUPPORT; 948 949 soisconnecting(so); 950 return 0; 951 } 952 953 /* xxx - should be const */ 954 struct pr_usrreqs tcp_usrreqs = { 955 .pru_abort = tcp_usr_abort, 956 .pru_accept = tcp_usr_accept, 957 .pru_attach = tcp_usr_attach, 958 .pru_bind = tcp_usr_bind, 959 .pru_connect = tcp_usr_connect, 960 .pru_connect2 = pr_generic_notsupp, 961 .pru_control = in_control_dispatch, 962 .pru_detach = tcp_usr_detach, 963 .pru_disconnect = tcp_usr_disconnect, 964 .pru_listen = tcp_usr_listen, 965 .pru_peeraddr = in_setpeeraddr_dispatch, 966 .pru_rcvd = tcp_usr_rcvd, 967 .pru_rcvoob = tcp_usr_rcvoob, 968 .pru_send = tcp_usr_send, 969 .pru_sense = pru_sense_null, 970 .pru_shutdown = tcp_usr_shutdown, 971 .pru_sockaddr = in_setsockaddr_dispatch, 972 .pru_sosend = sosendtcp, 973 .pru_soreceive = sorecvtcp, 974 .pru_savefaddr = tcp_usr_savefaddr, 975 .pru_preconnect = tcp_usr_preconnect, 976 .pru_preattach = tcp_usr_preattach 977 }; 978 979 #ifdef INET6 980 struct pr_usrreqs tcp6_usrreqs = { 981 .pru_abort = tcp_usr_abort, 982 .pru_accept = tcp6_usr_accept, 983 .pru_attach = tcp_usr_attach, 984 .pru_bind = tcp6_usr_bind, 985 .pru_connect = tcp6_usr_connect, 986 .pru_connect2 = pr_generic_notsupp, 987 .pru_control = in6_control_dispatch, 988 .pru_detach = tcp_usr_detach, 989 .pru_disconnect = tcp_usr_disconnect, 990 .pru_listen = tcp6_usr_listen, 991 .pru_peeraddr = in6_setpeeraddr_dispatch, 992 .pru_rcvd = tcp_usr_rcvd, 993 .pru_rcvoob = tcp_usr_rcvoob, 994 .pru_send = tcp_usr_send, 995 .pru_sense = pru_sense_null, 996 .pru_shutdown = tcp_usr_shutdown, 997 .pru_sockaddr = in6_setsockaddr_dispatch, 998 .pru_sosend = sosendtcp, 999 .pru_soreceive = sorecvtcp, 1000 .pru_savefaddr = tcp6_usr_savefaddr 1001 }; 1002 #endif /* INET6 */ 1003 1004 static int 1005 tcp_connect_oncpu(struct tcpcb *tp, int flags, struct mbuf *m, 1006 struct sockaddr_in *sin, struct sockaddr_in *if_sin) 1007 { 1008 struct inpcb *inp = tp->t_inpcb, *oinp; 1009 struct socket *so = inp->inp_socket; 1010 struct route *ro = &inp->inp_route; 1011 1012 KASSERT(inp->inp_pcbinfo == &tcbinfo[mycpu->gd_cpuid], 1013 ("pcbinfo mismatch")); 1014 1015 oinp = in_pcblookup_hash(inp->inp_pcbinfo, 1016 sin->sin_addr, sin->sin_port, 1017 (inp->inp_laddr.s_addr != INADDR_ANY ? 1018 inp->inp_laddr : if_sin->sin_addr), 1019 inp->inp_lport, 0, NULL); 1020 if (oinp != NULL) { 1021 m_freem(m); 1022 return (EADDRINUSE); 1023 } 1024 if (inp->inp_laddr.s_addr == INADDR_ANY) 1025 inp->inp_laddr = if_sin->sin_addr; 1026 inp->inp_faddr = sin->sin_addr; 1027 inp->inp_fport = sin->sin_port; 1028 in_pcbinsconnhash(inp); 1029 1030 /* 1031 * We are now on the inpcb's owner CPU, if the cached route was 1032 * freed because the rtentry's owner CPU is not the current CPU 1033 * (e.g. in tcp_connect()), then we try to reallocate it here with 1034 * the hope that a rtentry may be cloned from a RTF_PRCLONING 1035 * rtentry. 1036 */ 1037 if (!(inp->inp_socket->so_options & SO_DONTROUTE) && /*XXX*/ 1038 ro->ro_rt == NULL) { 1039 bzero(&ro->ro_dst, sizeof(struct sockaddr_in)); 1040 ro->ro_dst.sa_family = AF_INET; 1041 ro->ro_dst.sa_len = sizeof(struct sockaddr_in); 1042 ((struct sockaddr_in *)&ro->ro_dst)->sin_addr = 1043 sin->sin_addr; 1044 rtalloc(ro); 1045 } 1046 1047 /* 1048 * Now that no more errors can occur, change the protocol processing 1049 * port to the current thread (which is the correct thread). 1050 * 1051 * Create TCP timer message now; we are on the tcpcb's owner 1052 * CPU/thread. 1053 */ 1054 tcp_create_timermsg(tp, &curthread->td_msgport); 1055 1056 /* 1057 * Compute window scaling to request. Use a larger scaling then 1058 * needed for the initial receive buffer in case the receive buffer 1059 * gets expanded. 1060 */ 1061 if (tp->request_r_scale < TCP_MIN_WINSHIFT) 1062 tp->request_r_scale = TCP_MIN_WINSHIFT; 1063 while (tp->request_r_scale < TCP_MAX_WINSHIFT && 1064 (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.ssb_hiwat 1065 ) { 1066 tp->request_r_scale++; 1067 } 1068 1069 soisconnecting(so); 1070 tcpstat.tcps_connattempt++; 1071 tp->t_state = TCPS_SYN_SENT; 1072 tcp_callout_reset(tp, tp->tt_keep, tp->t_keepinit, tcp_timer_keep); 1073 tp->iss = tcp_new_isn(tp); 1074 tcp_sendseqinit(tp); 1075 if (m) { 1076 ssb_appendstream(&so->so_snd, m); 1077 m = NULL; 1078 if (flags & PRUS_OOB) 1079 tp->snd_up = tp->snd_una + so->so_snd.ssb_cc; 1080 } 1081 1082 /* 1083 * Close the send side of the connection after 1084 * the data is sent if flagged. 1085 */ 1086 if ((flags & (PRUS_OOB|PRUS_EOF)) == PRUS_EOF) { 1087 socantsendmore(so); 1088 tp = tcp_usrclosed(tp); 1089 } 1090 return (tcp_output(tp)); 1091 } 1092 1093 /* 1094 * Common subroutine to open a TCP connection to remote host specified 1095 * by struct sockaddr_in in mbuf *nam. Call in_pcbbind to assign a local 1096 * port number if needed. Call in_pcbladdr to do the routing and to choose 1097 * a local host address (interface). 1098 * Initialize connection parameters and enter SYN-SENT state. 1099 */ 1100 static void 1101 tcp_connect(netmsg_t msg) 1102 { 1103 struct socket *so = msg->connect.base.nm_so; 1104 struct sockaddr *nam = msg->connect.nm_nam; 1105 struct thread *td = msg->connect.nm_td; 1106 struct sockaddr_in *sin = (struct sockaddr_in *)nam; 1107 struct sockaddr_in *if_sin = NULL; 1108 struct inpcb *inp; 1109 struct tcpcb *tp; 1110 int error; 1111 lwkt_port_t port; 1112 1113 COMMON_START(so, inp, 0); 1114 1115 /* 1116 * Reconnect our pcb if we have to 1117 */ 1118 if (msg->connect.nm_flags & PRUC_RECONNECT) { 1119 msg->connect.nm_flags &= ~PRUC_RECONNECT; 1120 in_pcblink(so->so_pcb, &tcbinfo[mycpu->gd_cpuid]); 1121 } 1122 1123 /* 1124 * Bind if we have to 1125 */ 1126 if (inp->inp_lport == 0) { 1127 if (tcp_lport_extension) { 1128 KKASSERT(inp->inp_laddr.s_addr == INADDR_ANY); 1129 1130 error = in_pcbladdr(inp, nam, &if_sin, td); 1131 if (error) 1132 goto out; 1133 inp->inp_laddr.s_addr = if_sin->sin_addr.s_addr; 1134 1135 error = in_pcbbind_remote(inp, nam, td); 1136 if (error) 1137 goto out; 1138 1139 msg->connect.nm_flags |= PRUC_HASLADDR; 1140 } else { 1141 error = in_pcbbind(inp, NULL, td); 1142 if (error) 1143 goto out; 1144 } 1145 } 1146 1147 if ((msg->connect.nm_flags & PRUC_HASLADDR) == 0) { 1148 /* 1149 * Calculate the correct protocol processing thread. The 1150 * connect operation must run there. Set the forwarding 1151 * port before we forward the message or it will get bounced 1152 * right back to us. 1153 */ 1154 error = in_pcbladdr(inp, nam, &if_sin, td); 1155 if (error) 1156 goto out; 1157 } 1158 KKASSERT(inp->inp_socket == so); 1159 1160 port = tcp_addrport(sin->sin_addr.s_addr, sin->sin_port, 1161 (inp->inp_laddr.s_addr != INADDR_ANY ? 1162 inp->inp_laddr.s_addr : if_sin->sin_addr.s_addr), 1163 inp->inp_lport); 1164 1165 if (port != &curthread->td_msgport) { 1166 lwkt_msg_t lmsg = &msg->connect.base.lmsg; 1167 1168 /* 1169 * in_pcbladdr() may have allocated a route entry for us 1170 * on the current CPU, but we need a route entry on the 1171 * inpcb's owner CPU, so free it here. 1172 */ 1173 in_pcbresetroute(inp); 1174 1175 /* 1176 * We are moving the protocol processing port the socket 1177 * is on, we have to unlink here and re-link on the 1178 * target cpu. 1179 */ 1180 in_pcbunlink(so->so_pcb, &tcbinfo[mycpu->gd_cpuid]); 1181 msg->connect.nm_flags |= PRUC_RECONNECT; 1182 msg->connect.base.nm_dispatch = tcp_connect; 1183 1184 /* 1185 * Use message put done receipt to change this socket's 1186 * so_port, i.e. _after_ this message was put onto the 1187 * target netisr's msgport but _before_ the message could 1188 * be pulled from the target netisr's msgport, so that: 1189 * - The upper half (socket code) will not see the new 1190 * msgport before this message reaches the new msgport 1191 * and messages for this socket will be ordered. 1192 * - This message will see the new msgport, when its 1193 * handler is called in the target netisr. 1194 * 1195 * NOTE: 1196 * We MUST use messege put done receipt to change this 1197 * socket's so_port: 1198 * If we changed the so_port in this netisr after the 1199 * lwkt_forwardmsg (so messages for this socket will be 1200 * ordered) and changed the so_port in the target netisr 1201 * at the very beginning of this message's handler, we 1202 * would suffer so_port overwritten race, given this 1203 * message might be forwarded again. 1204 * 1205 * NOTE: 1206 * This mechanism depends on that the netisr's msgport 1207 * is spin msgport (currently it is :). 1208 * 1209 * If the upper half saw the new msgport before this 1210 * message reached the target netisr's msgport, the 1211 * messages sent from the upper half could reach the new 1212 * msgport before this message, thus there would be 1213 * message reordering. The worst case could be soclose() 1214 * saw the new msgport and the detach message could reach 1215 * the new msgport before this message, i.e. the inpcb 1216 * could have been destroyed when this message was still 1217 * pending on or on its way to the new msgport. Other 1218 * weird cases could also happen, e.g. inpcb->inp_pcbinfo, 1219 * since we have unlinked this inpcb from the current 1220 * pcbinfo first. 1221 */ 1222 lwkt_setmsg_receipt(lmsg, tcp_sosetport); 1223 lwkt_forwardmsg(port, lmsg); 1224 /* msg invalid now */ 1225 return; 1226 } else if (msg->connect.nm_flags & PRUC_HELDTD) { 1227 /* 1228 * The original thread is no longer needed; release it. 1229 */ 1230 lwkt_rele(td); 1231 msg->connect.nm_flags &= ~PRUC_HELDTD; 1232 } 1233 error = tcp_connect_oncpu(tp, msg->connect.nm_sndflags, 1234 msg->connect.nm_m, sin, if_sin); 1235 msg->connect.nm_m = NULL; 1236 out: 1237 if (msg->connect.nm_m) { 1238 m_freem(msg->connect.nm_m); 1239 msg->connect.nm_m = NULL; 1240 } 1241 if (msg->connect.nm_flags & PRUC_HELDTD) 1242 lwkt_rele(td); 1243 if (error && (msg->connect.nm_flags & PRUC_ASYNC)) { 1244 so->so_error = error; 1245 soisdisconnected(so); 1246 } 1247 lwkt_replymsg(&msg->connect.base.lmsg, error); 1248 /* msg invalid now */ 1249 } 1250 1251 #ifdef INET6 1252 1253 static void 1254 tcp6_connect(netmsg_t msg) 1255 { 1256 struct tcpcb *tp; 1257 struct socket *so = msg->connect.base.nm_so; 1258 struct sockaddr *nam = msg->connect.nm_nam; 1259 struct thread *td = msg->connect.nm_td; 1260 struct inpcb *inp; 1261 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)nam; 1262 struct in6_addr *addr6; 1263 lwkt_port_t port; 1264 int error; 1265 1266 COMMON_START(so, inp, 0); 1267 1268 /* 1269 * Reconnect our pcb if we have to 1270 */ 1271 if (msg->connect.nm_flags & PRUC_RECONNECT) { 1272 msg->connect.nm_flags &= ~PRUC_RECONNECT; 1273 in_pcblink(so->so_pcb, &tcbinfo[mycpu->gd_cpuid]); 1274 } 1275 1276 /* 1277 * Bind if we have to 1278 */ 1279 if (inp->inp_lport == 0) { 1280 error = in6_pcbbind(inp, NULL, td); 1281 if (error) 1282 goto out; 1283 } 1284 1285 /* 1286 * Cannot simply call in_pcbconnect, because there might be an 1287 * earlier incarnation of this same connection still in 1288 * TIME_WAIT state, creating an ADDRINUSE error. 1289 */ 1290 error = in6_pcbladdr(inp, nam, &addr6, td); 1291 if (error) 1292 goto out; 1293 1294 port = tcp6_addrport(); /* XXX hack for now, always cpu0 */ 1295 1296 if (port != &curthread->td_msgport) { 1297 lwkt_msg_t lmsg = &msg->connect.base.lmsg; 1298 1299 /* 1300 * in_pcbladdr() may have allocated a route entry for us 1301 * on the current CPU, but we need a route entry on the 1302 * inpcb's owner CPU, so free it here. 1303 */ 1304 in_pcbresetroute(inp); 1305 1306 in_pcbunlink(so->so_pcb, &tcbinfo[mycpu->gd_cpuid]); 1307 msg->connect.nm_flags |= PRUC_RECONNECT; 1308 msg->connect.base.nm_dispatch = tcp6_connect; 1309 1310 /* See the related comment in tcp_connect() */ 1311 lwkt_setmsg_receipt(lmsg, tcp_sosetport); 1312 lwkt_forwardmsg(port, lmsg); 1313 /* msg invalid now */ 1314 return; 1315 } 1316 error = tcp6_connect_oncpu(tp, msg->connect.nm_sndflags, 1317 &msg->connect.nm_m, sin6, addr6); 1318 /* nm_m may still be intact */ 1319 out: 1320 if (msg->connect.nm_m) { 1321 m_freem(msg->connect.nm_m); 1322 msg->connect.nm_m = NULL; 1323 } 1324 lwkt_replymsg(&msg->connect.base.lmsg, error); 1325 /* msg invalid now */ 1326 } 1327 1328 static int 1329 tcp6_connect_oncpu(struct tcpcb *tp, int flags, struct mbuf **mp, 1330 struct sockaddr_in6 *sin6, struct in6_addr *addr6) 1331 { 1332 struct mbuf *m = *mp; 1333 struct inpcb *inp = tp->t_inpcb; 1334 struct socket *so = inp->inp_socket; 1335 struct inpcb *oinp; 1336 1337 /* 1338 * Cannot simply call in_pcbconnect, because there might be an 1339 * earlier incarnation of this same connection still in 1340 * TIME_WAIT state, creating an ADDRINUSE error. 1341 */ 1342 oinp = in6_pcblookup_hash(inp->inp_pcbinfo, 1343 &sin6->sin6_addr, sin6->sin6_port, 1344 (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr) ? 1345 addr6 : &inp->in6p_laddr), 1346 inp->inp_lport, 0, NULL); 1347 if (oinp) 1348 return (EADDRINUSE); 1349 1350 if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) 1351 inp->in6p_laddr = *addr6; 1352 inp->in6p_faddr = sin6->sin6_addr; 1353 inp->inp_fport = sin6->sin6_port; 1354 if ((sin6->sin6_flowinfo & IPV6_FLOWINFO_MASK) != 0) 1355 inp->in6p_flowinfo = sin6->sin6_flowinfo; 1356 in_pcbinsconnhash(inp); 1357 1358 /* 1359 * Now that no more errors can occur, change the protocol processing 1360 * port to the current thread (which is the correct thread). 1361 * 1362 * Create TCP timer message now; we are on the tcpcb's owner 1363 * CPU/thread. 1364 */ 1365 tcp_create_timermsg(tp, &curthread->td_msgport); 1366 1367 /* Compute window scaling to request. */ 1368 if (tp->request_r_scale < TCP_MIN_WINSHIFT) 1369 tp->request_r_scale = TCP_MIN_WINSHIFT; 1370 while (tp->request_r_scale < TCP_MAX_WINSHIFT && 1371 (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.ssb_hiwat) { 1372 tp->request_r_scale++; 1373 } 1374 1375 soisconnecting(so); 1376 tcpstat.tcps_connattempt++; 1377 tp->t_state = TCPS_SYN_SENT; 1378 tcp_callout_reset(tp, tp->tt_keep, tp->t_keepinit, tcp_timer_keep); 1379 tp->iss = tcp_new_isn(tp); 1380 tcp_sendseqinit(tp); 1381 if (m) { 1382 ssb_appendstream(&so->so_snd, m); 1383 *mp = NULL; 1384 if (flags & PRUS_OOB) 1385 tp->snd_up = tp->snd_una + so->so_snd.ssb_cc; 1386 } 1387 1388 /* 1389 * Close the send side of the connection after 1390 * the data is sent if flagged. 1391 */ 1392 if ((flags & (PRUS_OOB|PRUS_EOF)) == PRUS_EOF) { 1393 socantsendmore(so); 1394 tp = tcp_usrclosed(tp); 1395 } 1396 return (tcp_output(tp)); 1397 } 1398 1399 #endif /* INET6 */ 1400 1401 /* 1402 * The new sockopt interface makes it possible for us to block in the 1403 * copyin/out step (if we take a page fault). Taking a page fault while 1404 * in a critical section is probably a Bad Thing. (Since sockets and pcbs 1405 * both now use TSM, there probably isn't any need for this function to 1406 * run in a critical section any more. This needs more examination.) 1407 */ 1408 void 1409 tcp_ctloutput(netmsg_t msg) 1410 { 1411 struct socket *so = msg->base.nm_so; 1412 struct sockopt *sopt = msg->ctloutput.nm_sopt; 1413 int error, opt, optval, opthz; 1414 struct inpcb *inp; 1415 struct tcpcb *tp; 1416 1417 error = 0; 1418 inp = so->so_pcb; 1419 if (inp == NULL) { 1420 error = ECONNRESET; 1421 goto done; 1422 } 1423 tp = intotcpcb(inp); 1424 1425 /* Get socket's owner cpuid hint */ 1426 if (sopt->sopt_level == SOL_SOCKET && 1427 sopt->sopt_dir == SOPT_GET && 1428 sopt->sopt_name == SO_CPUHINT) { 1429 if (tp->t_flags & TF_LISTEN) { 1430 /* 1431 * Listen sockets owner cpuid is always 0, 1432 * which does not make sense if SO_REUSEPORT 1433 * is not set. 1434 */ 1435 if (so->so_options & SO_REUSEPORT) 1436 optval = (inp->inp_lgrpindex & ncpus2_mask); 1437 else 1438 optval = -1; /* no hint */ 1439 } else { 1440 optval = mycpuid; 1441 } 1442 soopt_from_kbuf(sopt, &optval, sizeof(optval)); 1443 goto done; 1444 } 1445 1446 if (sopt->sopt_level != IPPROTO_TCP) { 1447 if (sopt->sopt_level == IPPROTO_IP) { 1448 switch (sopt->sopt_name) { 1449 case IP_MULTICAST_IF: 1450 case IP_MULTICAST_VIF: 1451 case IP_MULTICAST_TTL: 1452 case IP_MULTICAST_LOOP: 1453 case IP_ADD_MEMBERSHIP: 1454 case IP_DROP_MEMBERSHIP: 1455 /* 1456 * Multicast does not make sense on 1457 * TCP sockets. 1458 */ 1459 error = EOPNOTSUPP; 1460 goto done; 1461 } 1462 } 1463 #ifdef INET6 1464 if (INP_CHECK_SOCKAF(so, AF_INET6)) 1465 ip6_ctloutput_dispatch(msg); 1466 else 1467 #endif /* INET6 */ 1468 ip_ctloutput(msg); 1469 /* msg invalid now */ 1470 return; 1471 } 1472 1473 switch (sopt->sopt_dir) { 1474 case SOPT_SET: 1475 error = soopt_to_kbuf(sopt, &optval, sizeof optval, 1476 sizeof optval); 1477 if (error) 1478 break; 1479 switch (sopt->sopt_name) { 1480 case TCP_FASTKEEP: 1481 if (optval > 0) 1482 tp->t_keepidle = tp->t_keepintvl; 1483 else 1484 tp->t_keepidle = tcp_keepidle; 1485 tcp_timer_keep_activity(tp, 0); 1486 break; 1487 #ifdef TCP_SIGNATURE 1488 case TCP_SIGNATURE_ENABLE: 1489 if (tp->t_state == TCPS_CLOSED) { 1490 /* 1491 * This is the only safe state that this 1492 * option could be changed. Some segments 1493 * could already have been sent in other 1494 * states. 1495 */ 1496 if (optval > 0) 1497 tp->t_flags |= TF_SIGNATURE; 1498 else 1499 tp->t_flags &= ~TF_SIGNATURE; 1500 } else { 1501 error = EOPNOTSUPP; 1502 } 1503 break; 1504 #endif /* TCP_SIGNATURE */ 1505 case TCP_NODELAY: 1506 case TCP_NOOPT: 1507 switch (sopt->sopt_name) { 1508 case TCP_NODELAY: 1509 opt = TF_NODELAY; 1510 break; 1511 case TCP_NOOPT: 1512 opt = TF_NOOPT; 1513 break; 1514 default: 1515 opt = 0; /* dead code to fool gcc */ 1516 break; 1517 } 1518 1519 if (optval) 1520 tp->t_flags |= opt; 1521 else 1522 tp->t_flags &= ~opt; 1523 break; 1524 1525 case TCP_NOPUSH: 1526 if (tcp_disable_nopush) 1527 break; 1528 if (optval) 1529 tp->t_flags |= TF_NOPUSH; 1530 else { 1531 tp->t_flags &= ~TF_NOPUSH; 1532 error = tcp_output(tp); 1533 } 1534 break; 1535 1536 case TCP_MAXSEG: 1537 /* 1538 * Must be between 0 and maxseg. If the requested 1539 * maxseg is too small to satisfy the desired minmss, 1540 * pump it up (silently so sysctl modifications of 1541 * minmss do not create unexpected program failures). 1542 * Handle degenerate cases. 1543 */ 1544 if (optval > 0 && optval <= tp->t_maxseg) { 1545 if (optval + 40 < tcp_minmss) { 1546 optval = tcp_minmss - 40; 1547 if (optval < 0) 1548 optval = 1; 1549 } 1550 tp->t_maxseg = optval; 1551 } else { 1552 error = EINVAL; 1553 } 1554 break; 1555 1556 case TCP_KEEPINIT: 1557 opthz = ((int64_t)optval * hz) / 1000; 1558 if (opthz >= 1) 1559 tp->t_keepinit = opthz; 1560 else 1561 error = EINVAL; 1562 break; 1563 1564 case TCP_KEEPIDLE: 1565 opthz = ((int64_t)optval * hz) / 1000; 1566 if (opthz >= 1) { 1567 tp->t_keepidle = opthz; 1568 tcp_timer_keep_activity(tp, 0); 1569 } else { 1570 error = EINVAL; 1571 } 1572 break; 1573 1574 case TCP_KEEPINTVL: 1575 opthz = ((int64_t)optval * hz) / 1000; 1576 if (opthz >= 1) { 1577 tp->t_keepintvl = opthz; 1578 tp->t_maxidle = tp->t_keepintvl * tp->t_keepcnt; 1579 } else { 1580 error = EINVAL; 1581 } 1582 break; 1583 1584 case TCP_KEEPCNT: 1585 if (optval > 0) { 1586 tp->t_keepcnt = optval; 1587 tp->t_maxidle = tp->t_keepintvl * tp->t_keepcnt; 1588 } else { 1589 error = EINVAL; 1590 } 1591 break; 1592 1593 default: 1594 error = ENOPROTOOPT; 1595 break; 1596 } 1597 break; 1598 1599 case SOPT_GET: 1600 switch (sopt->sopt_name) { 1601 #ifdef TCP_SIGNATURE 1602 case TCP_SIGNATURE_ENABLE: 1603 optval = (tp->t_flags & TF_SIGNATURE) ? 1 : 0; 1604 break; 1605 #endif /* TCP_SIGNATURE */ 1606 case TCP_NODELAY: 1607 optval = tp->t_flags & TF_NODELAY; 1608 break; 1609 case TCP_MAXSEG: 1610 optval = tp->t_maxseg; 1611 break; 1612 case TCP_NOOPT: 1613 optval = tp->t_flags & TF_NOOPT; 1614 break; 1615 case TCP_NOPUSH: 1616 optval = tp->t_flags & TF_NOPUSH; 1617 break; 1618 case TCP_KEEPINIT: 1619 optval = ((int64_t)tp->t_keepinit * 1000) / hz; 1620 break; 1621 case TCP_KEEPIDLE: 1622 optval = ((int64_t)tp->t_keepidle * 1000) / hz; 1623 break; 1624 case TCP_KEEPINTVL: 1625 optval = ((int64_t)tp->t_keepintvl * 1000) / hz; 1626 break; 1627 case TCP_KEEPCNT: 1628 optval = tp->t_keepcnt; 1629 break; 1630 default: 1631 error = ENOPROTOOPT; 1632 break; 1633 } 1634 if (error == 0) 1635 soopt_from_kbuf(sopt, &optval, sizeof optval); 1636 break; 1637 } 1638 done: 1639 lwkt_replymsg(&msg->lmsg, error); 1640 } 1641 1642 /* 1643 * tcp_sendspace and tcp_recvspace are the default send and receive window 1644 * sizes, respectively. These are obsolescent (this information should 1645 * be set by the route). 1646 * 1647 * Use a default that does not require tcp window scaling to be turned 1648 * on. Individual programs or the administrator can increase the default. 1649 */ 1650 u_long tcp_sendspace = 57344; /* largest multiple of PAGE_SIZE < 64k */ 1651 SYSCTL_INT(_net_inet_tcp, TCPCTL_SENDSPACE, sendspace, CTLFLAG_RW, 1652 &tcp_sendspace , 0, "Maximum outgoing TCP datagram size"); 1653 u_long tcp_recvspace = 57344; /* largest multiple of PAGE_SIZE < 64k */ 1654 SYSCTL_INT(_net_inet_tcp, TCPCTL_RECVSPACE, recvspace, CTLFLAG_RW, 1655 &tcp_recvspace , 0, "Maximum incoming TCP datagram size"); 1656 1657 /* 1658 * Attach TCP protocol to socket, allocating internet protocol control 1659 * block, tcp control block, buffer space, and entering CLOSED state. 1660 */ 1661 static int 1662 tcp_attach(struct socket *so, struct pru_attach_info *ai) 1663 { 1664 struct tcpcb *tp; 1665 struct inpcb *inp; 1666 int error; 1667 int cpu; 1668 #ifdef INET6 1669 boolean_t isipv6 = INP_CHECK_SOCKAF(so, AF_INET6); 1670 #endif 1671 1672 if (ai != NULL) { 1673 error = tcp_usr_preattach(so, 0 /* don't care */, ai); 1674 if (error) 1675 return (error); 1676 } else { 1677 /* Post attach; do nothing */ 1678 } 1679 1680 cpu = mycpu->gd_cpuid; 1681 1682 /* 1683 * Set the default pcbinfo. This will likely change when we 1684 * bind/connect. 1685 */ 1686 error = in_pcballoc(so, &tcbinfo[cpu]); 1687 if (error) 1688 return (error); 1689 inp = so->so_pcb; 1690 #ifdef INET6 1691 if (isipv6) 1692 inp->in6p_hops = -1; /* use kernel default */ 1693 #endif 1694 tp = tcp_newtcpcb(inp); 1695 KASSERT(tp != NULL, ("tcp_newtcpcb failed")); 1696 tp->t_state = TCPS_CLOSED; 1697 /* Keep a reference for asynchronized pru_rcvd */ 1698 soreference(so); 1699 return (0); 1700 } 1701 1702 /* 1703 * Initiate (or continue) disconnect. 1704 * If embryonic state, just send reset (once). 1705 * If in ``let data drain'' option and linger null, just drop. 1706 * Otherwise (hard), mark socket disconnecting and drop 1707 * current input data; switch states based on user close, and 1708 * send segment to peer (with FIN). 1709 */ 1710 static struct tcpcb * 1711 tcp_disconnect(struct tcpcb *tp) 1712 { 1713 struct socket *so = tp->t_inpcb->inp_socket; 1714 1715 if (tp->t_state < TCPS_ESTABLISHED) { 1716 tp = tcp_close(tp); 1717 } else if ((so->so_options & SO_LINGER) && so->so_linger == 0) { 1718 tp = tcp_drop(tp, 0); 1719 } else { 1720 lwkt_gettoken(&so->so_rcv.ssb_token); 1721 soisdisconnecting(so); 1722 sbflush(&so->so_rcv.sb); 1723 tp = tcp_usrclosed(tp); 1724 if (tp) 1725 tcp_output(tp); 1726 lwkt_reltoken(&so->so_rcv.ssb_token); 1727 } 1728 return (tp); 1729 } 1730 1731 /* 1732 * User issued close, and wish to trail through shutdown states: 1733 * if never received SYN, just forget it. If got a SYN from peer, 1734 * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN. 1735 * If already got a FIN from peer, then almost done; go to LAST_ACK 1736 * state. In all other cases, have already sent FIN to peer (e.g. 1737 * after PRU_SHUTDOWN), and just have to play tedious game waiting 1738 * for peer to send FIN or not respond to keep-alives, etc. 1739 * We can let the user exit from the close as soon as the FIN is acked. 1740 */ 1741 static struct tcpcb * 1742 tcp_usrclosed(struct tcpcb *tp) 1743 { 1744 1745 switch (tp->t_state) { 1746 1747 case TCPS_CLOSED: 1748 case TCPS_LISTEN: 1749 tp->t_state = TCPS_CLOSED; 1750 tp = tcp_close(tp); 1751 break; 1752 1753 case TCPS_SYN_SENT: 1754 case TCPS_SYN_RECEIVED: 1755 tp->t_flags |= TF_NEEDFIN; 1756 break; 1757 1758 case TCPS_ESTABLISHED: 1759 tp->t_state = TCPS_FIN_WAIT_1; 1760 break; 1761 1762 case TCPS_CLOSE_WAIT: 1763 tp->t_state = TCPS_LAST_ACK; 1764 break; 1765 } 1766 if (tp && tp->t_state >= TCPS_FIN_WAIT_2) { 1767 soisdisconnected(tp->t_inpcb->inp_socket); 1768 /* To prevent the connection hanging in FIN_WAIT_2 forever. */ 1769 if (tp->t_state == TCPS_FIN_WAIT_2) { 1770 tcp_callout_reset(tp, tp->tt_2msl, tp->t_maxidle, 1771 tcp_timer_2msl); 1772 } 1773 } 1774 return (tp); 1775 } 1776