sys/netinet/tcp_usrreq.c

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