third_party/tcplp/bsdtcp/tcp_usrreq.c - third_party/openthread - Git at Google

 /*-
  * Copyright (c) 1982, 1986, 1988, 1993
  *	The Regents of the University of California.
  * Copyright (c) 2006-2007 Robert N. M. Watson
  * Copyright (c) 2010-2011 Juniper Networks, Inc.
  * All rights reserved.
  *
  * Portions of this software were developed by Robert N. M. Watson under
  * contract to Juniper Networks, Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  *	From: @(#)tcp_usrreq.c	8.2 (Berkeley) 1/3/94
  */

 #include <errno.h>
 #include <string.h>
 #include "../tcplp.h"
 #include "../lib/cbuf.h"
 #include "tcp.h"
 #include "tcp_fsm.h"
 #include "tcp_seq.h"
 #include "tcp_var.h"
 #include "tcp_timer.h"
 //#include <sys/socket.h>
 #include "ip6.h"

 #include "tcp_const.h"

 #include <openthread/tcp.h>

 //static void	tcp_disconnect(struct tcpcb *);
 static void	tcp_usrclosed(struct tcpcb *);

 /*
  * samkumar: Removed tcp6_usr_bind, since checking if an address/port is free
  * needs to be done at the host system (along with other socket management
  * duties). TCPlp doesn't know what other sockets are in the system, or which
  * other addresses/ports are busy.
  */

 /* samkumar: This is based on a function in in6_pcb.c. */
 static int in6_pcbconnect(struct tcpcb* tp, struct sockaddr_in6* nam) {
 	register struct sockaddr_in6 *sin6 = nam;
 	tp->faddr = sin6->sin6_addr;
 	tp->fport = sin6->sin6_port;
 	return 0;
 }

 /*
  * Initiate connection to peer.
  * Create a template for use in transmissions on this connection.
  * Enter SYN_SENT state, and mark socket as connecting.
  * Start keep-alive timer, and seed output sequence space.
  * Send initial segment on connection.
  */
 /*
  * samkumar: I removed locking, statistics, and inpcb management. The signature
  * used to be
  *
  * static int
  * tcp6_connect(struct tcpcb *tp, struct sockaddr *nam, struct thread *td)
  */
 static int
 tcp6_connect(struct tcpcb *tp, struct sockaddr_in6 *nam)
 {
 	int error;

 	int sb_max = cbuf_free_space(&tp->recvbuf); // same as sendbuf

 	/*
 	 * samkumar: For autobind, the original BSD code assigned the port first
 	 * (with logic that also looked at the address) and then the address. This
 	 * was done by calling into other parts of the FreeBSD network stack,
 	 * outside of the TCP stack. Here, we just use the tcplp_sys_autobind
 	 * function to do all of that work.
 	 */
 	bool autobind_addr = IN6_IS_ADDR_UNSPECIFIED(&tp->laddr);
 	bool autobind_port = (tp->lport == 0);
 	if (autobind_addr || autobind_port) {
 		otSockAddr foreign;
 		otSockAddr local;

 		memcpy(&foreign.mAddress, &nam->sin6_addr, sizeof(foreign.mAddress));
 		foreign.mPort = ntohs(nam->sin6_port);

 		if (!autobind_addr) {
 			memcpy(&local.mAddress, &tp->laddr, sizeof(local.mAddress));
 		}

 		if (!autobind_port) {
 			local.mPort = ntohs(tp->lport);
 		}

 		if (!tcplp_sys_autobind(tp->instance, &foreign, &local, autobind_addr, autobind_port)) {
 			// Autobind failed
 			error = EINVAL;
 			goto out;
 		}

 		if (autobind_addr) {
 			memcpy(&tp->laddr, &local.mAddress, sizeof(tp->laddr));
 		}

 		if (autobind_port) {
 			tp->lport = htons(local.mPort);
 		}
 	}
 	error = in6_pcbconnect(tp, nam);
 	if (error != 0)
 		goto out;

 	/* Compute window scaling to request.  */
 	while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
 	    (TCP_MAXWIN << tp->request_r_scale) < sb_max)
 		tp->request_r_scale++;

 	tcp_state_change(tp, TCPS_SYN_SENT);
 	tp->iss = tcp_new_isn(tp);
 	tcp_sendseqinit(tp);

 	return 0;

 out:
 	return error;
 }

 /*
  * samkumar: I removed locking, statistics, inpcb management, and debug probes.
  * I also remove codepaths that check for IPv6, since the address is assumed to
  * be IPv6. The signature used to be
  *
  * static int
  * tcp6_usr_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
  */
 int
 tcp6_usr_connect(struct tcpcb* tp, struct sockaddr_in6* sin6p)
 {
 	int error = 0;

 	if (tp->t_state != TCPS_CLOSED) { // samkumar: This is a check that I added
 		return (EISCONN);
 	}

 	/* samkumar: I removed the following error check since we receive sin6p
 	 * in the function argument and don't need to convert a struct sockaddr to
 	 * a struct sockaddr_in6 anymore.
 	 *
 	 * if (nam->sa_len != sizeof (*sin6p))
 	 * 	return (EINVAL);
 	 */

 	/*
 	 * Must disallow TCP ``connections'' to multicast addresses.
 	 */
 	/* samkumar: I commented out the check on sin6p->sin6_family. */
 	if (/*sin6p->sin6_family == AF_INET6
 	    && */IN6_IS_ADDR_MULTICAST(&sin6p->sin6_addr))
 		return (EAFNOSUPPORT);

 	/*
 	 * samkumar: There was some code here that obtained the TCB (struct tcpcb*)
 	 * by getting the inpcb from the socket and the TCB from the inpcb. I
 	 * removed that code.
 	 */

 	/*
 	 * XXXRW: Some confusion: V4/V6 flags relate to binding, and
 	 * therefore probably require the hash lock, which isn't held here.
 	 * Is this a significant problem?
 	 */
 	if (IN6_IS_ADDR_V4MAPPED(&sin6p->sin6_addr)) {
 		tcplp_sys_log("V4-Mapped Address!");

 		/*
 		 * samkumar: There used to be code that woulf handle the case of
 		 * v4-mapped addresses. It would call in6_sin6_2_sin to convert the
 		 * struct sockaddr_in6 to a struct sockaddr_in, set the INP_IPV4 flag
 		 * and clear the INP_IPV6 flag on inp->inp_vflag, do some other
 		 * processing, and finally call tcp_connect and tcp_output. However,
 		 * it would first check if the IN6P_IPV6_V6ONLY flag was set in
 		 * inp->inp_flags, and if so, it would return with EINVAL. In TCPlp, we
 		 * support IPv6 only, so I removed the check for IN6P_IPV6_V6ONLY and
 		 * always act as if that flag is set. I kept the code in that if
 		 * statement making the check, and removed the other code that actually
 		 * handled this case.
 		 */
 		error = EINVAL;
 		goto out;
 	}

 	/*
 	 * samkumar: I removed some code here that set/cleared some flags in the`
 	 * inpcb and called prison_remote_ip6.
 	 */

 	/*
 	 * samkumar: Originally, the struct thread *td was passed along to
 	 * tcp6_connect.
 	 */
 	if ((error = tcp6_connect(tp, sin6p)) != 0)
 		goto out;

 	tcp_timer_activate(tp, TT_KEEP, TP_KEEPINIT(tp));
 	error = tcp_output(tp);

 out:
 	return (error);
 }

 /*
  * Do a send by putting data in output queue and updating urgent
  * marker if URG set.  Possibly send more data.  Unlike the other
  * pru_*() routines, the mbuf chains are our responsibility.  We
  * must either enqueue them or free them.  The other pru_* routines
  * generally are caller-frees.
  */
 /*
  * samkumar: I removed locking, statistics, inpcb management, and debug probes.
  * I also removed support for the urgent pointer.
  *
  * I changed the signature of this function. It used to be
  * static int
  * tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
  *     struct sockaddr *nam, struct mbuf *control, struct thread *td)
  *
  * The new function signature works as follows. DATA is a new linked buffer to
  * add to the end of the send buffer. EXTENDBY is the number of bytes by which
  * to extend the final linked buffer of the send buffer. Either DATA should be
  * NULL, or EXTENDBY should be 0.
  */
 int tcp_usr_send(struct tcpcb* tp, int moretocome, otLinkedBuffer* data, size_t extendby)
 {
 	int error = 0;

 	/*
 	 * samkumar: This if statement and the next are checks that I added
 	 */
 	if (tp->t_state < TCPS_ESTABLISHED) {
 		error = ENOTCONN;
 		goto out;
 	}

 	if (tpiscantsend(tp)) {
 		error = EPIPE;
 		goto out;
 	}

 	/*
 	 * samkumar: There used to be logic here that acquired locks, dealt with
 	 * INP_TIMEWAIT and INP_DROPPED flags on inp->inp_flags, and handled the
 	 * control mbuf passed as an argument (which would result in an error since
 	 * TCP doesn't support control information). I've deleted that code, but
 	 * left the following if block.
 	 */
 	 if ((tp->t_state == TCPS_TIME_WAIT) || (tp->t_state == TCPS_CLOSED)) {
 		error = ECONNRESET;
 		goto out;
 	}

 	/*
 	 * The following code used to be wrapped in an if statement:
 	 * "if (!(flags & PRUS_OOB))", that only executed it if the "out of band"
 	 * flag was not set. In TCB, "out of band" data is conveyed via the urgent
 	 * pointer, and TCPlp does not support the urgent pointer. Therefore, I
 	 * removed the "if" check and put its body below.
 	 */

 	/*
 	 * samkumar; The FreeBSD code calls sbappendstream(&so->so_snd, m, flags);
 	 * I've replaced it with the following logic, which appends to the
 	 * send buffer according to TCPlp's data structures.
 	 */
 	if (data == NULL) {
 		if (extendby == 0) {
 			goto out;
 		}
 		lbuf_extend(&tp->sendbuf, extendby);
 	} else {
 		if (data->mLength == 0) {
 			goto out;
 		}
 		lbuf_append(&tp->sendbuf, data);
 	}

 	/*
 	 * samkumar: There used to be code here to handle "implied connect,"
 	 * which initiates the TCP handshake if sending data on a socket that
 	 * isn't yet connected. TCPlp doesn't support this at the moment, but
 	 * it might be worth revisiting  when implementing TCP Fast Open.
 	 */

 	/*
 	 * samkumar: There used to be code here handling the PRUS_EOF flag in
 	 * the former flags parameter. I've removed this code.
 	 */

 	/*
 	 * samkumar: The code below was previously wrapped in an if statement
 	 * that checked that the INP_DROPPED flag in inp->inp_flags and the
 	 * PRUS_NOTREADY flag in the former flags parameter were both clear.
 	 * If either one was set, then tcp_output would not be called.
 	 *
 	 * The "more to come" functionality was previously triggered via the
 	 * PRUS_MORETOCOME flag in the flags parameter to this function. Since
 	 * that's the only flag that TCPlp uses here, I replaced the flags
 	 * parameter with a "moretocome" parameter, which we check instead.
 	 */
 	if (moretocome)
 		tp->t_flags |= TF_MORETOCOME;
 	error = tcp_output(tp);
 	if (moretocome)
 		tp->t_flags &= ~TF_MORETOCOME;

 	/*
 	 * samkumar: This is where the "if (!(flags & PRUS_OOB))" block would end.
 	 * There used to be a large "else" block handling out-of-band data, but I
 	 * removed that entire block since we do not support the urgent pointer in
 	 * TCPlp.
 	 */
 out:
 	return (error);
 }

 /*
  * After a receive, possibly send window update to peer.
  */
 int
 tcp_usr_rcvd(struct tcpcb* tp)
 {
 	int error = 0;

 	/*
 	 * samkumar: There used to be logic here that acquired locks, dealt with
 	 * INP_TIMEWAIT and INP_DROPPED flags on inp->inp_flags, and added debug
 	 * probes I've deleted that code, but left the following if block.
 	 */
 	if ((tp->t_state == TCPS_TIME_WAIT) || (tp->t_state == TCPS_CLOSED)) {
 		error = ECONNRESET;
 		goto out;
 	}

 	tcp_output(tp);

 out:
 	return (error);
 }

 /*
  * samkumar: Removed the tcp_disconnect function. It is meant to be a
  * "friendly" disconnect to complement the unceremonious "abort" functionality
  * that is also provbided. The FreeBSD implementation called it from
  * tcp_usr_close, which we removed (see the comment below for the reason why).
  * It's not called from anywhere else, so I'm removing this function entirely.
  */

 /*
  * Mark the connection as being incapable of further output.
  */
 /*
  * samkumar: Modified to remove locking, socket/inpcb handling, and debug
  * probes.
  */
 int
 tcp_usr_shutdown(struct tcpcb* tp)
 {
 	int error = 0;

 	/*
 	 * samkumar: replaced checks on the INP_TIMEWAIT and INP_DROPPED flags on
 	 * inp->inp_flags with these checks on tp->t_state.
 	 */
 	if ((tp->t_state == TCPS_TIME_WAIT) || (tp->t_state == TCPS_CLOSED)) {
 		error = ECONNRESET;
 		goto out;
 	}

 	/* samkumar: replaced socantsendmore with tpcantsendmore */
 	tpcantsendmore(tp);
 	tcp_usrclosed(tp);

 	/*
 	 * samkumar: replaced check on INP_DROPPED flag in inp->inp_flags with
 	 * this check on tp->t_state.
 	 */
 	if (tp->t_state != TCPS_CLOSED)
 		error = tcp_output(tp);

 out:
 	return (error);
 }


 /*
  * User issued close, and wish to trail through shutdown states:
  * if never received SYN, just forget it.  If got a SYN from peer,
  * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
  * If already got a FIN from peer, then almost done; go to LAST_ACK
  * state.  In all other cases, have already sent FIN to peer (e.g.
  * after PRU_SHUTDOWN), and just have to play tedious game waiting
  * for peer to send FIN or not respond to keep-alives, etc.
  * We can let the user exit from the close as soon as the FIN is acked.
  */
 /*
  * Removed locking, TCP Offload, and socket/inpcb handling.
  */
 static void
 tcp_usrclosed(struct tcpcb *tp)
 {
 	switch (tp->t_state) {
 	case TCPS_LISTEN:
 		tcp_state_change(tp, TCPS_CLOSED);
 		/* FALLTHROUGH */
 	case TCPS_CLOSED:
 		tp = tcp_close(tp);
 		tcplp_sys_connection_lost(tp, CONN_LOST_NORMAL);
 		/*
 		 * tcp_close() should never return NULL here as the socket is
 		 * still open.
 		 */
 		KASSERT(tp != NULL,
 		    ("tcp_usrclosed: tcp_close() returned NULL"));
 		break;

 	case TCPS_SYN_SENT:
 	case TCPS_SYN_RECEIVED:
 		tp->t_flags |= TF_NEEDFIN;
 		break;

 	case TCPS_ESTABLISHED:
 		tcp_state_change(tp, TCPS_FIN_WAIT_1);
 		break;

 	case TCPS_CLOSE_WAIT:
 		tcp_state_change(tp, TCPS_LAST_ACK);
 		break;
 	}
 	if (tp->t_state >= TCPS_FIN_WAIT_2) {
 		/* samkumar: commented out the following "soisdisconnected" line. */
 		// soisdisconnected(tp->t_inpcb->inp_socket);
 		/* Prevent the connection hanging in FIN_WAIT_2 forever. */
 		if (tp->t_state == TCPS_FIN_WAIT_2) {
 			int timeout;

 			timeout = (tcp_fast_finwait2_recycle) ?
 			    tcp_finwait2_timeout : TP_MAXIDLE(tp);
 			tcp_timer_activate(tp, TT_2MSL, timeout);
 		}
 	}
 }

 /*
  * samkumar: I removed the tcp_usr_close function. It was meant to be called in
  * case the socket is closed. It calls tcp_disconnect if the underlying TCP
  * connection is still alive when the socket is closed ("full TCP state").
  * In TCPlp, we can't handle this because we want to free up the underlying
  * memory immediately when the user deallocates a TCP connection, making it
  * unavailable for the somewhat more ceremonious closing that tcp_disconnect
  * would allow. The host system is expected to simply abort the connection if
  * the application deallocates it.
  */

 /*
  * Abort the TCP.  Drop the connection abruptly.
  */
 /*
  * samkumar: Modified to remove locking, socket/inpcb handling, and debug
  * probes.
  */
 void
 tcp_usr_abort(struct tcpcb* tp)
 {
 	/*
 	 * If we still have full TCP state, and we're not dropped, drop.
 	 */
 	/*
 	 * I replaced the checks on inp->inp_flags (which tested for the absence of
 	 * INP_TIMEWAIT and INP_DROPPED flags), with the following checks on
 	 * tp->t_state.
 	 */
 	if (tp->t_state != TCP6S_TIME_WAIT &&
 		tp->t_state != TCP6S_CLOSED) {
 		tcp_drop(tp, ECONNABORTED);
 	} else if (tp->t_state == TCPS_TIME_WAIT) { // samkumar: I added this clause
 		tp = tcp_close(tp);
 		tcplp_sys_connection_lost(tp, CONN_LOST_NORMAL);
 	}
 }
	/*-
	* Copyright (c) 1982, 1986, 1988, 1993
	* The Regents of the University of California.
	* Copyright (c) 2006-2007 Robert N. M. Watson
	* Copyright (c) 2010-2011 Juniper Networks, Inc.
	* All rights reserved.
	*
	* Portions of this software were developed by Robert N. M. Watson under
	* contract to Juniper Networks, Inc.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* 4. Neither the name of the University nor the names of its contributors
	* may be used to endorse or promote products derived from this software
	* without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	*
	* From: @(#)tcp_usrreq.c 8.2 (Berkeley) 1/3/94
	*/

	#include <errno.h>
	#include <string.h>
	#include "../tcplp.h"
	#include "../lib/cbuf.h"
	#include "tcp.h"
	#include "tcp_fsm.h"
	#include "tcp_seq.h"
	#include "tcp_var.h"
	#include "tcp_timer.h"
	//#include <sys/socket.h>
	#include "ip6.h"

	#include "tcp_const.h"

	#include <openthread/tcp.h>

	//static void tcp_disconnect(struct tcpcb *);
	static void tcp_usrclosed(struct tcpcb *);

	/*
	* samkumar: Removed tcp6_usr_bind, since checking if an address/port is free
	* needs to be done at the host system (along with other socket management
	* duties). TCPlp doesn't know what other sockets are in the system, or which
	* other addresses/ports are busy.
	*/

	/* samkumar: This is based on a function in in6_pcb.c. */
	static int in6_pcbconnect(struct tcpcb* tp, struct sockaddr_in6* nam) {
	register struct sockaddr_in6 *sin6 = nam;
	tp->faddr = sin6->sin6_addr;
	tp->fport = sin6->sin6_port;
	return 0;
	}

	/*
	* Initiate connection to peer.
	* Create a template for use in transmissions on this connection.
	* Enter SYN_SENT state, and mark socket as connecting.
	* Start keep-alive timer, and seed output sequence space.
	* Send initial segment on connection.
	*/
	/*
	* samkumar: I removed locking, statistics, and inpcb management. The signature
	* used to be
	*
	* static int
	* tcp6_connect(struct tcpcb tp, struct sockaddr nam, struct thread *td)
	*/
	static int
	tcp6_connect(struct tcpcb tp, struct sockaddr_in6 nam)
	{
	int error;

	int sb_max = cbuf_free_space(&tp->recvbuf); // same as sendbuf

	/*
	* samkumar: For autobind, the original BSD code assigned the port first
	* (with logic that also looked at the address) and then the address. This
	* was done by calling into other parts of the FreeBSD network stack,
	* outside of the TCP stack. Here, we just use the tcplp_sys_autobind
	* function to do all of that work.
	*/
	bool autobind_addr = IN6_IS_ADDR_UNSPECIFIED(&tp->laddr);
	bool autobind_port = (tp->lport == 0);
	if (autobind_addr \|\| autobind_port) {
	otSockAddr foreign;
	otSockAddr local;

	memcpy(&foreign.mAddress, &nam->sin6_addr, sizeof(foreign.mAddress));
	foreign.mPort = ntohs(nam->sin6_port);

	if (!autobind_addr) {
	memcpy(&local.mAddress, &tp->laddr, sizeof(local.mAddress));
	}

	if (!autobind_port) {
	local.mPort = ntohs(tp->lport);
	}

	if (!tcplp_sys_autobind(tp->instance, &foreign, &local, autobind_addr, autobind_port)) {
	// Autobind failed
	error = EINVAL;
	goto out;
	}

	if (autobind_addr) {
	memcpy(&tp->laddr, &local.mAddress, sizeof(tp->laddr));
	}

	if (autobind_port) {
	tp->lport = htons(local.mPort);
	}
	}
	error = in6_pcbconnect(tp, nam);
	if (error != 0)
	goto out;

	/* Compute window scaling to request. */
	while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
	(TCP_MAXWIN << tp->request_r_scale) < sb_max)
	tp->request_r_scale++;

	tcp_state_change(tp, TCPS_SYN_SENT);
	tp->iss = tcp_new_isn(tp);
	tcp_sendseqinit(tp);

	return 0;

	out:
	return error;
	}

	/*
	* samkumar: I removed locking, statistics, inpcb management, and debug probes.
	* I also remove codepaths that check for IPv6, since the address is assumed to
	* be IPv6. The signature used to be
	*
	* static int
	* tcp6_usr_connect(struct socket so, struct sockaddr nam, struct thread *td)
	*/
	int
	tcp6_usr_connect(struct tcpcb* tp, struct sockaddr_in6* sin6p)
	{
	int error = 0;

	if (tp->t_state != TCPS_CLOSED) { // samkumar: This is a check that I added
	return (EISCONN);
	}

	/* samkumar: I removed the following error check since we receive sin6p
	* in the function argument and don't need to convert a struct sockaddr to
	* a struct sockaddr_in6 anymore.
	*
	* if (nam->sa_len != sizeof (*sin6p))
	* return (EINVAL);
	*/

	/*
	* Must disallow TCP ``connections'' to multicast addresses.
	*/
	/* samkumar: I commented out the check on sin6p->sin6_family. */
	if (/*sin6p->sin6_family == AF_INET6
	&& */IN6_IS_ADDR_MULTICAST(&sin6p->sin6_addr))
	return (EAFNOSUPPORT);

	/*
	* samkumar: There was some code here that obtained the TCB (struct tcpcb*)
	* by getting the inpcb from the socket and the TCB from the inpcb. I
	* removed that code.
	*/

	/*
	* XXXRW: Some confusion: V4/V6 flags relate to binding, and
	* therefore probably require the hash lock, which isn't held here.
	* Is this a significant problem?
	*/
	if (IN6_IS_ADDR_V4MAPPED(&sin6p->sin6_addr)) {
	tcplp_sys_log("V4-Mapped Address!");

	/*
	* samkumar: There used to be code that woulf handle the case of
	* v4-mapped addresses. It would call in6_sin6_2_sin to convert the
	* struct sockaddr_in6 to a struct sockaddr_in, set the INP_IPV4 flag
	* and clear the INP_IPV6 flag on inp->inp_vflag, do some other
	* processing, and finally call tcp_connect and tcp_output. However,
	* it would first check if the IN6P_IPV6_V6ONLY flag was set in
	* inp->inp_flags, and if so, it would return with EINVAL. In TCPlp, we
	* support IPv6 only, so I removed the check for IN6P_IPV6_V6ONLY and
	* always act as if that flag is set. I kept the code in that if
	* statement making the check, and removed the other code that actually
	* handled this case.
	*/
	error = EINVAL;
	goto out;
	}

	/*
	* samkumar: I removed some code here that set/cleared some flags in the`
	* inpcb and called prison_remote_ip6.
	*/

	/*
	* samkumar: Originally, the struct thread *td was passed along to
	* tcp6_connect.
	*/
	if ((error = tcp6_connect(tp, sin6p)) != 0)
	goto out;

	tcp_timer_activate(tp, TT_KEEP, TP_KEEPINIT(tp));
	error = tcp_output(tp);

	out:
	return (error);
	}

	/*
	* Do a send by putting data in output queue and updating urgent
	* marker if URG set. Possibly send more data. Unlike the other
	* pru_*() routines, the mbuf chains are our responsibility. We
	* must either enqueue them or free them. The other pru_* routines
	* generally are caller-frees.
	*/
	/*
	* samkumar: I removed locking, statistics, inpcb management, and debug probes.
	* I also removed support for the urgent pointer.
	*
	* I changed the signature of this function. It used to be
	* static int
	* tcp_usr_send(struct socket so, int flags, struct mbuf m,
	* struct sockaddr nam, struct mbuf control, struct thread *td)
	*
	* The new function signature works as follows. DATA is a new linked buffer to
	* add to the end of the send buffer. EXTENDBY is the number of bytes by which
	* to extend the final linked buffer of the send buffer. Either DATA should be
	* NULL, or EXTENDBY should be 0.
	*/
	int tcp_usr_send(struct tcpcb* tp, int moretocome, otLinkedBuffer* data, size_t extendby)
	{
	int error = 0;

	/*
	* samkumar: This if statement and the next are checks that I added
	*/
	if (tp->t_state < TCPS_ESTABLISHED) {
	error = ENOTCONN;
	goto out;
	}

	if (tpiscantsend(tp)) {
	error = EPIPE;
	goto out;
	}

	/*
	* samkumar: There used to be logic here that acquired locks, dealt with
	* INP_TIMEWAIT and INP_DROPPED flags on inp->inp_flags, and handled the
	* control mbuf passed as an argument (which would result in an error since
	* TCP doesn't support control information). I've deleted that code, but
	* left the following if block.
	*/
	if ((tp->t_state == TCPS_TIME_WAIT) \|\| (tp->t_state == TCPS_CLOSED)) {
	error = ECONNRESET;
	goto out;
	}

	/*
	* The following code used to be wrapped in an if statement:
	* "if (!(flags & PRUS_OOB))", that only executed it if the "out of band"
	* flag was not set. In TCB, "out of band" data is conveyed via the urgent
	* pointer, and TCPlp does not support the urgent pointer. Therefore, I
	* removed the "if" check and put its body below.
	*/

	/*
	* samkumar; The FreeBSD code calls sbappendstream(&so->so_snd, m, flags);
	* I've replaced it with the following logic, which appends to the
	* send buffer according to TCPlp's data structures.
	*/
	if (data == NULL) {
	if (extendby == 0) {
	goto out;
	}
	lbuf_extend(&tp->sendbuf, extendby);
	} else {
	if (data->mLength == 0) {
	goto out;
	}
	lbuf_append(&tp->sendbuf, data);
	}

	/*
	* samkumar: There used to be code here to handle "implied connect,"
	* which initiates the TCP handshake if sending data on a socket that
	* isn't yet connected. TCPlp doesn't support this at the moment, but
	* it might be worth revisiting when implementing TCP Fast Open.
	*/

	/*
	* samkumar: There used to be code here handling the PRUS_EOF flag in
	* the former flags parameter. I've removed this code.
	*/

	/*
	* samkumar: The code below was previously wrapped in an if statement
	* that checked that the INP_DROPPED flag in inp->inp_flags and the
	* PRUS_NOTREADY flag in the former flags parameter were both clear.
	* If either one was set, then tcp_output would not be called.
	*
	* The "more to come" functionality was previously triggered via the
	* PRUS_MORETOCOME flag in the flags parameter to this function. Since
	* that's the only flag that TCPlp uses here, I replaced the flags
	* parameter with a "moretocome" parameter, which we check instead.
	*/
	if (moretocome)
	tp->t_flags \|= TF_MORETOCOME;
	error = tcp_output(tp);
	if (moretocome)
	tp->t_flags &= ~TF_MORETOCOME;

	/*
	* samkumar: This is where the "if (!(flags & PRUS_OOB))" block would end.
	* There used to be a large "else" block handling out-of-band data, but I
	* removed that entire block since we do not support the urgent pointer in
	* TCPlp.
	*/
	out:
	return (error);
	}

	/*
	* After a receive, possibly send window update to peer.
	*/
	int
	tcp_usr_rcvd(struct tcpcb* tp)
	{
	int error = 0;

	/*
	* samkumar: There used to be logic here that acquired locks, dealt with
	* INP_TIMEWAIT and INP_DROPPED flags on inp->inp_flags, and added debug
	* probes I've deleted that code, but left the following if block.
	*/
	if ((tp->t_state == TCPS_TIME_WAIT) \|\| (tp->t_state == TCPS_CLOSED)) {
	error = ECONNRESET;
	goto out;
	}

	tcp_output(tp);

	out:
	return (error);
	}

	/*
	* samkumar: Removed the tcp_disconnect function. It is meant to be a
	* "friendly" disconnect to complement the unceremonious "abort" functionality
	* that is also provbided. The FreeBSD implementation called it from
	* tcp_usr_close, which we removed (see the comment below for the reason why).
	* It's not called from anywhere else, so I'm removing this function entirely.
	*/

	/*
	* Mark the connection as being incapable of further output.
	*/
	/*
	* samkumar: Modified to remove locking, socket/inpcb handling, and debug
	* probes.
	*/
	int
	tcp_usr_shutdown(struct tcpcb* tp)
	{
	int error = 0;

	/*
	* samkumar: replaced checks on the INP_TIMEWAIT and INP_DROPPED flags on
	* inp->inp_flags with these checks on tp->t_state.
	*/
	if ((tp->t_state == TCPS_TIME_WAIT) \|\| (tp->t_state == TCPS_CLOSED)) {
	error = ECONNRESET;
	goto out;
	}

	/* samkumar: replaced socantsendmore with tpcantsendmore */
	tpcantsendmore(tp);
	tcp_usrclosed(tp);

	/*
	* samkumar: replaced check on INP_DROPPED flag in inp->inp_flags with
	* this check on tp->t_state.
	*/
	if (tp->t_state != TCPS_CLOSED)
	error = tcp_output(tp);

	out:
	return (error);
	}


	/*
	* User issued close, and wish to trail through shutdown states:
	* if never received SYN, just forget it. If got a SYN from peer,
	* but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
	* If already got a FIN from peer, then almost done; go to LAST_ACK
	* state. In all other cases, have already sent FIN to peer (e.g.
	* after PRU_SHUTDOWN), and just have to play tedious game waiting
	* for peer to send FIN or not respond to keep-alives, etc.
	* We can let the user exit from the close as soon as the FIN is acked.
	*/
	/*
	* Removed locking, TCP Offload, and socket/inpcb handling.
	*/
	static void
	tcp_usrclosed(struct tcpcb *tp)
	{
	switch (tp->t_state) {
	case TCPS_LISTEN:
	tcp_state_change(tp, TCPS_CLOSED);
	/* FALLTHROUGH */
	case TCPS_CLOSED:
	tp = tcp_close(tp);
	tcplp_sys_connection_lost(tp, CONN_LOST_NORMAL);
	/*
	* tcp_close() should never return NULL here as the socket is
	* still open.
	*/
	KASSERT(tp != NULL,
	("tcp_usrclosed: tcp_close() returned NULL"));
	break;

	case TCPS_SYN_SENT:
	case TCPS_SYN_RECEIVED:
	tp->t_flags \|= TF_NEEDFIN;
	break;

	case TCPS_ESTABLISHED:
	tcp_state_change(tp, TCPS_FIN_WAIT_1);
	break;

	case TCPS_CLOSE_WAIT:
	tcp_state_change(tp, TCPS_LAST_ACK);
	break;
	}
	if (tp->t_state >= TCPS_FIN_WAIT_2) {
	/* samkumar: commented out the following "soisdisconnected" line. */
	// soisdisconnected(tp->t_inpcb->inp_socket);
	/* Prevent the connection hanging in FIN_WAIT_2 forever. */
	if (tp->t_state == TCPS_FIN_WAIT_2) {
	int timeout;

	timeout = (tcp_fast_finwait2_recycle) ?
	tcp_finwait2_timeout : TP_MAXIDLE(tp);
	tcp_timer_activate(tp, TT_2MSL, timeout);
	}
	}
	}

	/*
	* samkumar: I removed the tcp_usr_close function. It was meant to be called in
	* case the socket is closed. It calls tcp_disconnect if the underlying TCP
	* connection is still alive when the socket is closed ("full TCP state").
	* In TCPlp, we can't handle this because we want to free up the underlying
	* memory immediately when the user deallocates a TCP connection, making it
	* unavailable for the somewhat more ceremonious closing that tcp_disconnect
	* would allow. The host system is expected to simply abort the connection if
	* the application deallocates it.
	*/

	/*
	* Abort the TCP. Drop the connection abruptly.
	*/
	/*
	* samkumar: Modified to remove locking, socket/inpcb handling, and debug
	* probes.
	*/
	void
	tcp_usr_abort(struct tcpcb* tp)
	{
	/*
	* If we still have full TCP state, and we're not dropped, drop.
	*/
	/*
	* I replaced the checks on inp->inp_flags (which tested for the absence of
	* INP_TIMEWAIT and INP_DROPPED flags), with the following checks on
	* tp->t_state.
	*/
	if (tp->t_state != TCP6S_TIME_WAIT &&
	tp->t_state != TCP6S_CLOSED) {
	tcp_drop(tp, ECONNABORTED);
	} else if (tp->t_state == TCPS_TIME_WAIT) { // samkumar: I added this clause
	tp = tcp_close(tp);
	tcplp_sys_connection_lost(tp, CONN_LOST_NORMAL);
	}
	}