Merge changes from mcb-tcp-fixes branch.

src/drivers/scsi/iscsidev.c

  * @v iscsidev		iSCSI device
  */
 void fini_iscsidev ( struct iscsi_device *iscsidev ) {
-	async_wait ( iscsi_shutdown ( &iscsidev->iscsi ) );
+	iscsi_shutdown ( &iscsidev->iscsi );
 }

src/include/gpxe/ftp.h

  *
  */
 struct ftp_request {
-	/** TCP connection for this request */
-	struct tcp_connection tcp;
+	/** Server address */
+	struct sockaddr_tcpip server;
 	/** File to download */
 	const char *filename;
 	/** Callback function
 	 * remote server.
 	 */
 	void ( *callback ) ( char *data, size_t len );
-	/** Eventual return status */
-	int rc;
-	/** Asynchronous operation for this FTP operation */
-	struct async_operation aop;
 
 	/** Current state */
 	enum ftp_state state;
 	/** Passive-mode parameters, as text */
 	char passive_text[24]; /* "aaa,bbb,ccc,ddd,eee,fff" */
 
-	/** TCP connection for the data channel */
-	struct tcp_connection tcp_data;
+	/** TCP application for the control channel */
+	struct tcp_application tcp;
+	/** TCP application for the data channel */
+	struct tcp_application tcp_data;
+
+	/** Asynchronous operation for this FTP operation */
+	struct async_operation aop;
 };
 
 struct async_operation * ftp_get ( struct ftp_request *ftp );

src/include/gpxe/hello.h

  *
  */
 struct hello_request {
-	/** TCP connection for this request */
-	struct tcp_connection tcp;
-	/** Current state */
-	enum hello_state state;
+	/** Server to connect to */
+	struct sockaddr_tcpip server;
 	/** Message to be transmitted */
 	const char *message;
-	/** Amount of message remaining to be transmitted */
-	size_t remaining;
 	/** Callback function
 	 *
 	 * @v data	Received data
 	 * remote server.
 	 */
 	void ( *callback ) ( char *data, size_t len );
+
+	/** Current state */
+	enum hello_state state;
+	/** Amount of message remaining to be transmitted */
+	size_t remaining;
+
+	/** TCP application for this request */
+	struct tcp_application tcp;
+
 	/** Asynchronous operation */
 	struct async_operation aop;
 };

src/include/gpxe/http.h

 struct http_request;
 
 struct http_request {
-	/** TCP connection for this request */
-	struct tcp_connection tcp;
+	/** Server address */
+	struct sockaddr_tcpip server;
+	/** TCP application for this request */
+	struct tcp_application tcp;
 	/** Current state */
 	enum http_state state;
         /** File to download */

src/include/gpxe/iscsi.h

 
 /** An iSCSI session */
 struct iscsi_session {
-	/** TCP connection for this session */
-	struct tcp_connection tcp;
+	/** Initiator IQN */
+	const char *initiator_iqn;
+	/** Target address */
+	struct sockaddr_tcpip target;
+	/** Target IQN */
+	const char *target_iqn;
+	/** Logical Unit Number (LUN) */
+	uint64_t lun;
+	/** Username */
+	const char *username;
+	/** Password */
+	const char *password;
+
+	/** TCP application for this session */
+	struct tcp_application tcp;
 	/** Session status
 	 *
 	 * This is the bitwise-OR of zero or more ISCSI_STATUS_XXX
 	 * constants.
 	 */
 	int status;
-	/** Asynchronous operation for the current iSCSI operation */
-	struct async_operation aop;
 	/** Retry count
 	 *
 	 * Number of times that the connection has been retried.
 	 * Reset upon a successful connection.
 	 */
 	int retry_count;
-
-	/** Initiator IQN */
-	const char *initiator_iqn;
-	/** Target address
-	 *
-	 * Kept separate from the TCP connection structure because we
-	 * may need to handle login redirection.
-	 */
-	struct sockaddr_tcpip target;
-	/** Target IQN */
-	const char *target_iqn;
-	/** Logical Unit Number (LUN) */
-	uint64_t lun;
-
-	/** Username */
-	const char *username;
-	/** Password */
-	const char *password;
 	/** CHAP challenge/response */
 	struct chap_challenge chap;
 
 	 * Set to NULL when command is complete.
 	 */
 	struct scsi_command *command;
+	/** Asynchronous operation for the current iSCSI operation */
+	struct async_operation aop;
 };
 
 /** iSCSI session is currently in the security negotiation phase */
 /** Mask for all iSCSI "needs to send" flags */
 #define ISCSI_STATUS_STRINGS_MASK 0xff00
 
-/** iSCSI session is closing down */
-#define ISCSI_STATUS_CLOSING 0x00010000
-
 /** Maximum number of retries at connecting */
 #define ISCSI_MAX_RETRIES 2
 
 extern struct async_operation * iscsi_issue ( struct iscsi_session *iscsi,
 					      struct scsi_command *command );
-extern struct async_operation * iscsi_shutdown ( struct iscsi_session *iscsi );
+extern void iscsi_shutdown ( struct iscsi_session *iscsi );
 
 /** An iSCSI device */
 struct iscsi_device {

src/include/gpxe/tcp.h

  *
  */
 
-#include <stddef.h>
-#include <gpxe/list.h>
+#include "latch.h"
 #include <gpxe/tcpip.h>
-#include <gpxe/pkbuff.h>
-#include <gpxe/retry.h>
 
-struct tcp_connection;
+/**
+ * A TCP header
+ */
+struct tcp_header {
+	uint16_t src;		/* Source port */
+	uint16_t dest;		/* Destination port */
+	uint32_t seq;		/* Sequence number */
+	uint32_t ack;		/* Acknowledgement number */
+	uint8_t hlen;		/* Header length (4), Reserved (4) */
+	uint8_t flags;		/* Reserved (2), Flags (6) */
+	uint16_t win;		/* Advertised window */
+	uint16_t csum;		/* Checksum */
+	uint16_t urg;		/* Urgent pointer */
+};
+
+/*
+ * TCP flags
+ */
+#define TCP_CWR		0x80
+#define TCP_ECE		0x40
+#define TCP_URG		0x20
+#define TCP_ACK		0x10
+#define TCP_PSH		0x08
+#define TCP_RST		0x04
+#define TCP_SYN		0x02
+#define TCP_FIN		0x01
+
+/**
+* @defgroup tcpstates TCP states
+*
+* The TCP state is defined by a combination of the flags that are
+* currently being sent in outgoing packets, the flags that have been
+* sent and acknowledged by the peer, and the flags that have been
+* received from the peer.
+*
+* @{
+*/
+
+/** TCP flags that are currently being sent in outgoing packets */
+#define TCP_STATE_SENDING(flags) ( (flags) << 0 )
+#define TCP_FLAGS_SENDING(state) ( ( (state) >> 0 ) & 0xff )
+
+/** TCP flags that have been acknowledged by the peer
+ *
+ * Note that this applies only to SYN and FIN.
+ */
+#define TCP_STATE_ACKED(flags) ( (flags) << 8 )
+#define TCP_FLAGS_ACKED(state) ( ( (state) >> 8 ) & 0x03 )
+
+/** TCP flags that have been received from the peer
+ *
+ * Note that this applies only to SYN and FIN, and that once SYN has
+ * been received, we should always be sending ACK.
+ */
+#define TCP_STATE_RCVD(flags) ( (flags) << 12 )
+#define TCP_FLAGS_RCVD(state) ( ( (state) >> 12 ) & 0x03 )
+
+/** CLOSED
+ *
+ * The connection has not yet been used for anything.
+ */
+#define TCP_CLOSED TCP_RST
+
+/** LISTEN
+ *
+ * Not currently used as a state; we have no support for listening
+ * connections.  Given a unique value to avoid compiler warnings.
+ */
+#define TCP_LISTEN 0
+
+/** SYN_SENT
+ *
+ * SYN has been sent, nothing has yet been received or acknowledged.
+ */
+#define TCP_SYN_SENT	( TCP_STATE_SENDING ( TCP_SYN ) )
+
+/** SYN_RCVD
+ *
+ * SYN has been sent but not acknowledged, SYN has been received.
+ */
+#define TCP_SYN_RCVD	( TCP_STATE_SENDING ( TCP_SYN | TCP_ACK ) |	\
+			  TCP_STATE_RCVD ( TCP_SYN ) )
+
+/** ESTABLISHED
+ *
+ * SYN has been sent and acknowledged, SYN has been received.
+ */
+#define TCP_ESTABLISHED	( TCP_STATE_SENDING ( TCP_ACK ) |		\
+			  TCP_STATE_ACKED ( TCP_SYN ) |			\
+			  TCP_STATE_RCVD ( TCP_SYN ) )
+
+/** FIN_WAIT_1
+ *
+ * SYN has been sent and acknowledged, SYN has been received, FIN has
+ * been sent but not acknowledged, FIN has not been received.
+ *
+ * RFC 793 shows that we can enter FIN_WAIT_1 without have had SYN
+ * acknowledged, i.e. if the application closes the connection after
+ * sending and receiving SYN, but before having had SYN acknowledged.
+ * However, we have to *pretend* that SYN has been acknowledged
+ * anyway, otherwise we end up sending SYN and FIN in the same
+ * sequence number slot.  Therefore, when we transition from SYN_RCVD
+ * to FIN_WAIT_1, we have to remember to set TCP_STATE_ACKED(TCP_SYN)
+ * and increment our sequence number.
+ */
+#define TCP_FIN_WAIT_1	( TCP_STATE_SENDING ( TCP_ACK | TCP_FIN ) |	\
+			  TCP_STATE_ACKED ( TCP_SYN ) |			\
+			  TCP_STATE_RCVD ( TCP_SYN ) )
+
+/** FIN_WAIT_2
+ *
+ * SYN has been sent and acknowledged, SYN has been received, FIN has
+ * been sent and acknowledged, FIN ha not been received.
+ */
+#define TCP_FIN_WAIT_2	( TCP_STATE_SENDING ( TCP_ACK ) |		\
+			  TCP_STATE_ACKED ( TCP_SYN | TCP_FIN ) |	\
+			  TCP_STATE_RCVD ( TCP_SYN ) )
+
+/** CLOSING / LAST_ACK
+ *
+ * SYN has been sent and acknowledged, SYN has been received, FIN has
+ * been sent but not acknowledged, FIN has been received.
+ *
+ * This state actually encompasses both CLOSING and LAST_ACK; they are
+ * identical with the definition of state that we use.  I don't
+ * *believe* that they need to be distinguished.
+ */
+#define TCP_CLOSING_OR_LAST_ACK					\
+			( TCP_STATE_SENDING ( TCP_ACK | TCP_FIN ) |	\
+			  TCP_STATE_ACKED ( TCP_SYN ) |			\
+			  TCP_STATE_RCVD ( TCP_SYN | TCP_FIN ) )
+
+/** TIME_WAIT
+ *
+ * SYN has been sent and acknowledged, SYN has been received, FIN has
+ * been sent and acknowledged, FIN has been received.
+ */
+#define TCP_TIME_WAIT	( TCP_STATE_SENDING ( TCP_ACK ) |		\
+			  TCP_STATE_ACKED ( TCP_SYN | TCP_FIN ) |	\
+			  TCP_STATE_RCVD ( TCP_SYN | TCP_FIN ) )
+
+/** CLOSE_WAIT
+ *
+ * SYN has been sent and acknowledged, SYN has been received, FIN has
+ * been received.
+ */
+#define TCP_CLOSE_WAIT	( TCP_STATE_SENDING ( TCP_ACK ) |		\
+			  TCP_STATE_ACKED ( TCP_SYN ) |			\
+			  TCP_STATE_RCVD ( TCP_SYN | TCP_FIN ) )
+
+/** Can send data in current state
+ *
+ * We can send data if and only if we have had our SYN acked and we
+ * have not yet sent our FIN.
+ */
+#define TCP_CAN_SEND_DATA(state)					\
+	( ( (state) & ( TCP_STATE_ACKED ( TCP_SYN | TCP_FIN ) |		\
+		      TCP_STATE_SENDING ( TCP_FIN ) ) )			\
+	  == TCP_STATE_ACKED ( TCP_SYN ) )
+
+/** Have closed gracefully
+ *
+ * We have closed gracefully if we have both received a FIN and had
+ * our own FIN acked.
+ */
+#define TCP_CLOSED_GRACEFULLY(state)					\
+	( ( (state) & ( TCP_STATE_ACKED ( TCP_FIN ) |			\
+			TCP_STATE_RCVD ( TCP_FIN ) ) )			\
+	  == ( TCP_STATE_ACKED ( TCP_FIN ) | TCP_STATE_RCVD ( TCP_FIN ) ) )
+
+/** @} */
+
+/** Mask for TCP header length field */
+#define TCP_MASK_HLEN	0xf0
+
+/** Smallest port number on which a TCP connection can listen */
+#define TCP_MIN_PORT 1
+
+/* Some PKB constants */
+#define MAX_HDR_LEN	100
+#define MAX_PKB_LEN	1500
+#define MIN_PKB_LEN	MAX_HDR_LEN + 100 /* To account for padding by LL */
+
+/**
+ * Advertised TCP window size
+ *
+ * Our TCP window is actually limited by the amount of space available
+ * for RX packets in the NIC's RX ring; we tend to populate the rings
+ * with far fewer descriptors than a typical driver.  Since we have no
+ * way of knowing how much of this RX ring space will be available for
+ * received TCP packets (consider, for example, that they may all be
+ * consumed by a series of unrelated ARP requests between other
+ * machines on the network), it is actually not even theoretically
+ * possible for us to specify an accurate window size.  We therefore
+ * guess an arbitrary number that is empirically as large as possible
+ * while avoiding retransmissions due to dropped packets.
+ */
+#define TCP_WINDOW_SIZE	2048
+
+/** TCP maximum segment lifetime
+ *
+ * Currently set to 2 minutes, as per RFC 793.
+ */
+#define TCP_MSL ( 2 * 60 * TICKS_PER_SEC )
+
+struct tcp_application;
 
 /**
  * TCP operations
 	/*
 	 * Connection closed
 	 *
-	 * @v conn	TCP connection
+	 * @v app	TCP application
 	 * @v status	Error code, if any
 	 *
 	 * This is called when the connection is closed for any
 	 * contains the negative error number, if the closure is due
 	 * to an error.
 	 *
-	 * Note that acked() and newdata() may be called after
-	 * closed(), if the packet containing the FIN also
-	 * acknowledged data or contained new data.  Note also that
-	 * connected() may not have been called before closed(), if
-	 * the close is due to an error.
+	 * When closed() is called, the application no longer has a
+	 * valid TCP connection.  Note that connected() may not have
+	 * been called before closed(), if the close is due to an
+	 * error during connection setup.
 	 */
-	void ( * closed ) ( struct tcp_connection *conn, int status );
+	void ( * closed ) ( struct tcp_application *app, int status );
 	/**
-	 * Connection established (SYNACK received)
+	 * Connection established
 	 *
-	 * @v conn	TCP connection
+	 * @v app	TCP application
 	 */
-	void ( * connected ) ( struct tcp_connection *conn );
+	void ( * connected ) ( struct tcp_application *app );
 	/**
 	 * Data acknowledged
 	 *
-	 * @v conn	TCP connection
+	 * @v app	TCP application
 	 * @v len	Length of acknowledged data
 	 *
 	 * @c len is guaranteed to not exceed the outstanding amount
 	 * of unacknowledged data.
 	 */
-	void ( * acked ) ( struct tcp_connection *conn, size_t len );
+	void ( * acked ) ( struct tcp_application *app, size_t len );
 	/**
 	 * New data received
 	 *
-	 * @v conn	TCP connection
+	 * @v app	TCP application
 	 * @v data	Data
 	 * @v len	Length of data
 	 */
-	void ( * newdata ) ( struct tcp_connection *conn,
+	void ( * newdata ) ( struct tcp_application *app,
 			     void *data, size_t len );
 	/**
 	 * Transmit data
 	 *
-	 * @v conn	TCP connection
+	 * @v app	TCP application
 	 * @v buf	Temporary data buffer
 	 * @v len	Length of temporary data buffer
 	 *
 	 * the buffer is not compulsory; the application may call
 	 * tcp_send() on any block of data.
 	 */
-	void ( * senddata ) ( struct tcp_connection *conn, void *buf,
+	void ( * senddata ) ( struct tcp_application *app, void *buf,
 			      size_t len );
 };
 
-#if USE_UIP
+struct tcp_connection;
 
 /**
- * A TCP connection
+ * A TCP application
  *
+ * This data structure represents an application with a TCP connection.
  */
-struct tcp_connection {
-	/** Address of the remote end of the connection */
-	struct sockaddr_in sin;
-	/** Operations table for this connection */
+struct tcp_application {
+	/** TCP connection data
+	 *
+	 * This is filled in by TCP calls that initiate a connection,
+	 * and reset to NULL when the connection is closed.
+	 */
+	struct tcp_connection *conn;
+	/** TCP connection operations table */
 	struct tcp_operations *tcp_op;
 };
 
-extern void tcp_connect ( struct tcp_connection *conn );
-extern void tcp_send ( struct tcp_connection *conn, const void *data,
-		       size_t len );
-extern void tcp_kick ( struct tcp_connection *conn );
-extern void tcp_close ( struct tcp_connection *conn );
-
-#else
-
-#define TCP_NOMSG ""
-#define TCP_NOMSG_LEN 0
-
-/* Smallest port number on which a TCP connection can listen */
-#define TCP_MIN_PORT 1
-
-/* Some PKB constants */
-#define MAX_HDR_LEN	100
-#define MAX_PKB_LEN	1500
-#define MIN_PKB_LEN	MAX_HDR_LEN + 100 /* To account for padding by LL */
-
-/**
- * TCP states
- */
-#define TCP_CLOSED	0
-#define TCP_LISTEN	1
-#define TCP_SYN_SENT	2
-#define TCP_SYN_RCVD	3
-#define TCP_ESTABLISHED	4
-#define TCP_FIN_WAIT_1	5
-#define TCP_FIN_WAIT_2	6
-#define TCP_CLOSING	7
-#define TCP_TIME_WAIT	8
-#define TCP_CLOSE_WAIT	9
-#define TCP_LAST_ACK	10
-
-#define TCP_INVALID	11
-
-/**
- * A TCP connection
- */
-struct tcp_connection {
-	struct sockaddr_tcpip peer;	/* Remote socket address */
-	uint16_t local_port;		/* Local port, in network byte order */
-	int tcp_state;			/* TCP state */
-	int tcp_lstate;			/* Last TCP state */
-	uint32_t snd_una;		/* Lowest unacked byte on snd stream */
-	uint32_t snd_win;		/* Offered by remote end */
-	uint32_t rcv_nxt;		/* Next expected byte on rcv stream */
-	uint32_t rcv_win;		/* Advertised to receiver */
-	uint8_t tcp_flags;		/* TCP header flags */
-	struct list_head list;		/* List of TCP connections */
-	struct pk_buff *tx_pkb;		/* Transmit packet buffer */
-	struct retry_timer timer;	/* Retransmission timer */
-	struct tcp_operations *tcp_op;	/* Operations table for connection */
-};
-
-/** Retry timer values */
-#define MAX_RETRANSMITS	3
-
-/**
- * Connection closed status codes
- */
-#define CONN_SNDCLOSE	0
-#define CONN_RESTART	1
-#define CONN_TIMEOUT	2
-#define CONN_RCVCLOSE	3
-
-/**
- * A TCP header
- */
-struct tcp_header {
-	uint16_t src;		/* Source port */
-	uint16_t dest;		/* Destination port */
-	uint32_t seq;		/* Sequence number */
-	uint32_t ack;		/* Acknowledgement number */
-	uint8_t hlen;		/* Header length (4), Reserved (4) */
-	uint8_t flags;		/* Reserved (2), Flags (6) */
-	uint16_t win;		/* Advertised window */
-	uint16_t csum;		/* Checksum */
-	uint16_t urg;		/* Urgent pointer */
-};
-
-/**
- * TCP masks
- */
-#define TCP_MASK_HLEN	0xf0
-#define TCP_MASK_FLAGS	0x3f
-
-/**
- * TCP flags
- */
-#define TCP_URG		0x20
-#define TCP_ACK		0x10
-#define TCP_PSH		0x08
-#define TCP_RST		0x04
-#define TCP_SYN		0x02
-#define TCP_FIN		0x01
-
-extern struct tcpip_protocol tcp_protocol;
-
-static inline int tcp_closed ( struct tcp_connection *conn ) {
-	return ( conn->tcp_state == TCP_CLOSED );
-}
-
-extern void tcp_init_conn ( struct tcp_connection *conn );
-extern int tcp_connect ( struct tcp_connection *conn );
-extern int tcp_connectto ( struct tcp_connection *conn,
-			   struct sockaddr_tcpip *peer );
-extern int tcp_listen ( struct tcp_connection *conn, uint16_t port );
-extern int tcp_senddata ( struct tcp_connection *conn );
-extern int tcp_close ( struct tcp_connection *conn );
-
-extern int tcp_send ( struct tcp_connection *conn, const void *data, 
+extern int tcp_connect ( struct tcp_application *app,
+			 struct sockaddr_tcpip *peer,
+			 uint16_t local_port );
+extern void tcp_close ( struct tcp_application *app );
+extern int tcp_senddata ( struct tcp_application *app );
+extern int tcp_send ( struct tcp_application *app, const void *data, 
 		      size_t len );
 
-#endif /* USE_UIP */
+extern struct tcpip_protocol tcp_protocol;
 
 #endif /* _GPXE_TCP_H */

src/net/tcp/ftp.c

 }
 
 /**
- * Get FTP request from control TCP connection
+ * Get FTP request from control TCP application
  *
- * @v conn		TCP connection
+ * @v app		TCP application
  * @ret ftp		FTP request
  */
-static inline struct ftp_request * tcp_to_ftp ( struct tcp_connection *conn ) {
-	return container_of ( conn, struct ftp_request, tcp );
+static inline struct ftp_request * tcp_to_ftp ( struct tcp_application *app ) {
+	return container_of ( app, struct ftp_request, tcp );
 }
 
 /**
- * Set overall FTP operation status
+ * Mark FTP operation as complete
  *
  * @v ftp		FTP request
  * @v rc		Return status code
- *
- * Set the return status that will eventually be returned via
- * ftp_done().  If multiple errors are flagged, only the first will be
- * returned.
  */
-static void ftp_set_status ( struct ftp_request *ftp, int rc ) {
-	if ( ! ftp->rc )
-		ftp->rc = rc;
-}
+static void ftp_done ( struct ftp_request *ftp, int rc ) {
 
-/**
- * Clear overall FTP operation status
- *
- * @v ftp		FTP request
- */
-static void ftp_clear_status ( struct ftp_request *ftp ) {
-	ftp->rc = 0;
-}
+	DBG ( "FTP %p completed with status %d\n", ftp, rc );
 
-/**
- * Mark FTP operation as complete
- *
- * @v ftp		FTP request
- */
-static void ftp_done ( struct ftp_request *ftp ) {
-
-	DBG ( "FTP %p completed with status %d\n", ftp, ftp->rc );
+	/* Close both TCP connections */
+	tcp_close ( &ftp->tcp );
+	tcp_close ( &ftp->tcp_data );
 
-	async_done ( &ftp->aop, ftp->rc );
+	/* Mark asynchronous operation as complete */
+	async_done ( &ftp->aop, rc );
 }
 
 /**
  *
  * @v ftp	FTP request
  *
- * This is called once we have received a complete repsonse line.
+ * This is called once we have received a complete response line.
  */
 static void ftp_reply ( struct ftp_request *ftp ) {
 	char status_major = ftp->status_text[0];
 	 * fatal error.
 	 */
 	if ( ! ( ( status_major == '2' ) ||
-		 ( ( status_major == '3' ) && ( ftp->state == FTP_USER ) ) ) )
-		goto err;
+		 ( ( status_major == '3' ) && ( ftp->state == FTP_USER ) ) ) ){
+		/* Flag protocol error and close connections */
+		ftp_done ( ftp, -EPROTO );
+	}
 
 	/* Open passive connection when we get "PASV" response */
 	if ( ftp->state == FTP_PASV ) {
 		char *ptr = ftp->passive_text;
-		struct sockaddr_in *sin =
-			( struct sockaddr_in * ) &ftp->tcp_data.peer;
-
-		sin->sin_family = AF_INET;
-		ftp_parse_value ( &ptr, ( uint8_t * ) &sin->sin_addr,
-				  sizeof ( sin->sin_addr ) );
-		ftp_parse_value ( &ptr, ( uint8_t * ) &sin->sin_port,
-				  sizeof ( sin->sin_port ) );
-		tcp_connect ( &ftp->tcp_data );
+		union {
+			struct sockaddr_in sin;
+			struct sockaddr_tcpip st;
+		} sa;
+		int rc;
+
+		sa.sin.sin_family = AF_INET;
+		ftp_parse_value ( &ptr, ( uint8_t * ) &sa.sin.sin_addr,
+				  sizeof ( sa.sin.sin_addr ) );
+		ftp_parse_value ( &ptr, ( uint8_t * ) &sa.sin.sin_port,
+				  sizeof ( sa.sin.sin_port ) );
+		if ( ( rc = tcp_connect ( &ftp->tcp_data, &sa.st, 0 ) ) != 0 ){
+			DBG ( "FTP %p could not create data connection\n",
+			      ftp );
+			ftp_done ( ftp, rc );
+			return;
+		}
 	}
 
 	/* Move to next state */
 	}
 
 	return;
-
- err:
-	/* Flag protocol error and close connections */
-	ftp_set_status ( ftp, -EPROTO );
-	tcp_close ( &ftp->tcp );
 }
 
 /**
  * Handle new data arriving on FTP control channel
  *
- * @v conn	TCP connection
+ * @v app	TCP application
  * @v data	New data
  * @v len	Length of new data
  *
  * Data is collected until a complete line is received, at which point
  * its information is passed to ftp_reply().
  */
-static void ftp_newdata ( struct tcp_connection *conn,
+static void ftp_newdata ( struct tcp_application *app,
 			  void *data, size_t len ) {
-	struct ftp_request *ftp = tcp_to_ftp ( conn );
+	struct ftp_request *ftp = tcp_to_ftp ( app );
 	char *recvbuf = ftp->recvbuf;
 	size_t recvsize = ftp->recvsize;
 	char c;
 /**
  * Handle acknowledgement of data sent on FTP control channel
  *
- * @v conn	TCP connection
+ * @v app	TCP application
  */
-static void ftp_acked ( struct tcp_connection *conn, size_t len ) {
-	struct ftp_request *ftp = tcp_to_ftp ( conn );
+static void ftp_acked ( struct tcp_application *app, size_t len ) {
+	struct ftp_request *ftp = tcp_to_ftp ( app );
 	
 	/* Mark off ACKed portion of the currently-transmitted data */
 	ftp->already_sent += len;
 /**
  * Construct data to send on FTP control channel
  *
- * @v conn	TCP connection
+ * @v app	TCP application
  * @v buf	Temporary data buffer
  * @v len	Length of temporary data buffer
  */
-static void ftp_senddata ( struct tcp_connection *conn,
+static void ftp_senddata ( struct tcp_application *app,
 			   void *buf, size_t len ) {
-	struct ftp_request *ftp = tcp_to_ftp ( conn );
+	struct ftp_request *ftp = tcp_to_ftp ( app );
 	const struct ftp_string *string;
 
 	/* Send the as-yet-unACKed portion of the string for the
 	string = &ftp_strings[ftp->state];
 	len = snprintf ( buf, len, string->format,
 			 ftp_string_data ( ftp, string->data_offset ) );
-	tcp_send ( conn, buf + ftp->already_sent, len - ftp->already_sent );
+	tcp_send ( app, buf + ftp->already_sent, len - ftp->already_sent );
 }
 
 /**
  * Handle control channel being closed
  *
- * @v conn		TCP connection
+ * @v app		TCP application
  *
  * When the control channel is closed, the data channel must also be
  * closed, if it is currently open.
  */
-static void ftp_closed ( struct tcp_connection *conn, int status ) {
-	struct ftp_request *ftp = tcp_to_ftp ( conn );
+static void ftp_closed ( struct tcp_application *app, int status ) {
+	struct ftp_request *ftp = tcp_to_ftp ( app );
 
 	DBG ( "FTP %p control connection closed (status %d)\n", ftp, status );
 
-	/* Close data channel and record status */
-	ftp_set_status ( ftp, status );
-	tcp_close ( &ftp->tcp_data );
-
-	/* Mark FTP operation as complete if we are the last
-	 * connection to close
-	 */
-	if ( tcp_closed ( &ftp->tcp_data ) )
-		ftp_done ( ftp );
+	/* Complete FTP operation */
+	ftp_done ( ftp, status );
 }
 
 /** FTP control channel operations */
  */
 
 /**
- * Get FTP request from data TCP connection
+ * Get FTP request from data TCP application
  *
- * @v conn		TCP connection
+ * @v app		TCP application
  * @ret ftp		FTP request
  */
 static inline struct ftp_request *
-tcp_to_ftp_data ( struct tcp_connection *conn ) {
-	return container_of ( conn, struct ftp_request, tcp_data );
+tcp_to_ftp_data ( struct tcp_application *app ) {
+	return container_of ( app, struct ftp_request, tcp_data );
 }
 
 /**
  * Handle data channel being closed
  *
- * @v conn		TCP connection
+ * @v app		TCP application
  *
  * When the data channel is closed, the control channel should be left
  * alone; the server will send a completion message via the control
  *
  * If the data channel is closed due to an error, we abort the request.
  */
-static void ftp_data_closed ( struct tcp_connection *conn, int status ) {
-	struct ftp_request *ftp = tcp_to_ftp_data ( conn );
+static void ftp_data_closed ( struct tcp_application *app, int status ) {
+	struct ftp_request *ftp = tcp_to_ftp_data ( app );
 
 	DBG ( "FTP %p data connection closed (status %d)\n", ftp, status );
 	
 	/* If there was an error, close control channel and record status */
-	if ( status ) {
-		ftp_set_status ( ftp, status );
-		tcp_close ( &ftp->tcp );
-	}
-
-	/* Mark FTP operation as complete if we are the last
-	 * connection to close
-	 */
-	if ( tcp_closed ( &ftp->tcp ) )
-		ftp_done ( ftp );
+	if ( status )
+		ftp_done ( ftp, status );
 }
 
 /**
  * Handle new data arriving on the FTP data channel
  *
- * @v conn	TCP connection
+ * @v app	TCP application
  * @v data	New data
  * @v len	Length of new data
  *
  * Data is handed off to the callback registered in the FTP request.
  */
-static void ftp_data_newdata ( struct tcp_connection *conn,
+static void ftp_data_newdata ( struct tcp_application *app,
 			       void *data, size_t len ) {
-	struct ftp_request *ftp = tcp_to_ftp_data ( conn );
+	struct ftp_request *ftp = tcp_to_ftp_data ( app );
 
 	ftp->callback ( data, len );
 }
  * @v ftp	FTP request
  */
 struct async_operation * ftp_get ( struct ftp_request *ftp ) {
-	
+	int rc;
+
 	DBG ( "FTP %p fetching %s\n", ftp, ftp->filename );
 
 	ftp->tcp.tcp_op = &ftp_tcp_operations;
 	ftp->tcp_data.tcp_op = &ftp_data_tcp_operations;
 	ftp->recvbuf = ftp->status_text;
 	ftp->recvsize = sizeof ( ftp->status_text ) - 1;
-	ftp_clear_status ( ftp );
-	tcp_connect ( &ftp->tcp );
+	if ( ( rc = tcp_connect ( &ftp->tcp, &ftp->server, 0 ) ) != 0 )
+		ftp_done ( ftp, rc );
+
 	return &ftp->aop;
 }

src/net/tcp/hello.c

  * "Hello world" TCP protocol
  *
  * This file implements a trivial TCP-based protocol.  It connects to
- * the server specified in hello_request::tcp and transmits a single
- * message (hello_request::message).  Any data received from the
- * server will be passed to the callback function,
+ * the server specified in hello_request::server and transmits a
+ * single message (hello_request::message).  Any data received from
+ * the server will be passed to the callback function,
  * hello_request::callback(), and once the connection has been closed,
  * the asynchronous operation associated with the request will be
  * marked as complete.
  *   }
  *
  *   struct hello_request hello = {
+ *     .server = {
+ *       ...
+ *     },
  *     .message = "hello world!",
  *     .callback = my_callback,
  *   };
  *
- *   hello.sin.sin_addr.s_addr = ... server IP address ...
- *   hello.sin.sin_port = ... server port ...
- *
  *   rc = async_wait ( say_hello ( &hello ) );
  *
  * @endcode
  */
 
 static inline struct hello_request *
-tcp_to_hello ( struct tcp_connection *conn ) {
-	return container_of ( conn, struct hello_request, tcp );
+tcp_to_hello ( struct tcp_application *app ) {
+	return container_of ( app, struct hello_request, tcp );
 }
 
-static void hello_closed ( struct tcp_connection *conn, int status ) {
-	struct hello_request *hello = tcp_to_hello ( conn );
+static void hello_closed ( struct tcp_application *app, int status ) {
+	struct hello_request *hello = tcp_to_hello ( app );
 
 	async_done ( &hello->aop, status );
 }
 
-static void hello_connected ( struct tcp_connection *conn ) {
-	struct hello_request *hello = tcp_to_hello ( conn );
+static void hello_connected ( struct tcp_application *app ) {
+	struct hello_request *hello = tcp_to_hello ( app );
 
 	hello->remaining = strlen ( hello->message );
 	hello->state = HELLO_SENDING_MESSAGE;
 }
 
-static void hello_acked ( struct tcp_connection *conn, size_t len ) {
-	struct hello_request *hello = tcp_to_hello ( conn );
+static void hello_acked ( struct tcp_application *app, size_t len ) {
+	struct hello_request *hello = tcp_to_hello ( app );
 	
 	hello->message += len;
 	hello->remaining -= len;
 	}
 }
 
-static void hello_newdata ( struct tcp_connection *conn, void *data,
+static void hello_newdata ( struct tcp_application *app, void *data,
 			    size_t len ) {
-	struct hello_request *hello = tcp_to_hello ( conn );
+	struct hello_request *hello = tcp_to_hello ( app );
 
 	hello->callback ( data, len );
 }
 
-static void hello_senddata ( struct tcp_connection *conn,
+static void hello_senddata ( struct tcp_application *app,
 			     void *buf __unused, size_t len __unused ) {
-	struct hello_request *hello = tcp_to_hello ( conn );
+	struct hello_request *hello = tcp_to_hello ( app );
 
-	tcp_send ( conn, hello->message, hello->remaining );
+	tcp_send ( app, hello->message, hello->remaining );
 }
 
 static struct tcp_operations hello_tcp_operations = {
  * @v hello	"Hello world" request
  */
 struct async_operation * say_hello ( struct hello_request *hello ) {
+	int rc;
+
 	hello->tcp.tcp_op = &hello_tcp_operations;
-	tcp_connect ( &hello->tcp );
+	if ( ( rc = tcp_connect ( &hello->tcp, &hello->server, 0 ) ) != 0 )
+		async_done ( &hello->aop, rc );
+
 	return &hello->aop;
 }

src/net/tcp/http.c

  */
 
 static inline struct http_request *
-tcp_to_http ( struct tcp_connection *conn ) {
-	return container_of ( conn, struct http_request, tcp );
+tcp_to_http ( struct tcp_application *app ) {
+	return container_of ( app, struct http_request, tcp );
 }
 
 /**
  * Close an HTTP connection
  *
- * @v conn	a TCP Connection
+ * @v app	a TCP Application
  * @v status	connection status at close
  */
-static void http_closed ( struct tcp_connection *conn, int status ) {
-	struct http_request *http = tcp_to_http ( conn );
+static void http_closed ( struct tcp_application *app, int status ) {
+	struct http_request *http = tcp_to_http ( app );
 	async_done ( &http->aop, status );
 }
 
 /**
  * Callback after a TCP connection is established
  *
- * @v conn	a TCP Connection
+ * @v app	a TCP Application
  */
-static void http_connected ( struct tcp_connection *conn ) {
-	struct http_request *http = tcp_to_http ( conn );
+static void http_connected ( struct tcp_application *app ) {
+	struct http_request *http = tcp_to_http ( app );
 
 	http->state = HTTP_REQUEST_FILE;
 }
 /**
  * Callback for when TCP data is acknowledged
  *
- * @v conn	a TCP Connection
+ * @v app	a TCP Application
  * @v len	the length of data acked
  */
-static void http_acked ( struct tcp_connection *conn, size_t len __attribute__ ((unused)) ) {
-	struct http_request *http = tcp_to_http ( conn );
+static void http_acked ( struct tcp_application *app, size_t len __attribute__ ((unused)) ) {
+	struct http_request *http = tcp_to_http ( app );
 
 	// assume that the whole GET request was sent in on epacket
 
 	case HTTP_RECV_FILE:
 		break;
 	case HTTP_DONE:
-		//tcp_close(conn);
+		//tcp_close(app);
 		break;
 	default:
 		break;
 /**
  * Callback when new TCP data is recieved
  *
- * @v conn	a TCP Connection
+ * @v app	a TCP Application
  * @v data	a pointer to the data recieved
  * @v len	length of data buffer
  */
-static void http_newdata ( struct tcp_connection *conn, void *data,
+static void http_newdata ( struct tcp_application *app, void *data,
 			    size_t len ) {
-	struct http_request *http = tcp_to_http ( conn );
+	struct http_request *http = tcp_to_http ( app );
 	char *content_length;
 	char *start = data;
 	char *rcp; int rc;
 		//printf("File recv is %d\n", http->file_recv);
 		if ( http->file_recv == http->file_size ){
 			http->state = HTTP_DONE;
-			tcp_close(conn);
+			tcp_close(app);
 		}
 		break;
 	case HTTP_REQUEST_FILE:
 /**
  * Callback for sending TCP data
  *
- * @v conn	a TCP Connection
+ * @v app	a TCP Application
  */
-static void http_senddata ( struct tcp_connection *conn, void *buf, size_t len ) {
-	struct http_request *http = tcp_to_http ( conn );
+static void http_senddata ( struct tcp_application *app, void *buf, size_t len ) {
+	struct http_request *http = tcp_to_http ( app );
 
 	switch ( http->state ){
 	case HTTP_REQUEST_FILE:
 		printf("%s\n",(char *)buf);
         	// string is: GET <file> HTTP/1.0\r\n\r\n
 
-		tcp_send ( conn, buf, len);
+		tcp_send ( app, buf, len);
 		break;
 	case HTTP_PARSE_HEADER:
 	case HTTP_RECV_FILE:
 		break;
 	case HTTP_DONE:
-		//tcp_close(conn)
+		//tcp_close(app)
 		break;
 	default:
 		break;
  * @v http	a HTTP request
  */
 struct async_operation * get_http ( struct http_request *http ) {
+	int rc;
+
 	http->tcp.tcp_op = &http_tcp_operations;
 	http->state = HTTP_REQUEST_FILE;
-	tcp_connect ( &http->tcp );
+	if ( ( rc = tcp_connect ( &http->tcp, &http->server, 0 ) ) != 0 )
+		async_done ( &http->aop, rc );
+
 	return &http->aop;
 }

src/net/tcp/iscsi.c

 	/* Check for login redirection */
 	if ( response->status_class == ISCSI_STATUS_REDIRECT ) {
 		DBG ( "iSCSI %p redirecting to new server\n", iscsi );
-		/* Close the TCP connection; our TCP closed() method
-		 * will take care of the reconnection once this
-		 * connection has been cleanly terminated.
-		 */
 		tcp_close ( &iscsi->tcp );
+		iscsi->status = 0;
+		if ( ( rc = tcp_connect ( &iscsi->tcp, &iscsi->target,
+					  0 ) ) != 0 ) {
+			DBG ( "iSCSI %p could not open TCP connection\n",
+			      iscsi );
+			iscsi_done ( iscsi, rc );
+		}
 		return;
 	}
 
  */
 
 static inline struct iscsi_session *
-tcp_to_iscsi ( struct tcp_connection *conn ) {
-	return container_of ( conn, struct iscsi_session, tcp );
+tcp_to_iscsi ( struct tcp_application *app ) {
+	return container_of ( app, struct iscsi_session, tcp );
 }
 
 /**
  * Updates iscsi->tx_offset and, if applicable, transitions to the
  * next TX state.
  */
-static void iscsi_acked ( struct tcp_connection *conn, size_t len ) {
-	struct iscsi_session *iscsi = tcp_to_iscsi ( conn );
+static void iscsi_acked ( struct tcp_application *app, size_t len ) {
+	struct iscsi_session *iscsi = tcp_to_iscsi ( app );
 	struct iscsi_bhs_common *common = &iscsi->tx_bhs.common;
 	enum iscsi_tx_state next_state;
 	
  * 
  * Constructs data to be sent for the current TX state
  */
-static void iscsi_senddata ( struct tcp_connection *conn,
+static void iscsi_senddata ( struct tcp_application *app,
 			     void *buf, size_t len ) {
-	struct iscsi_session *iscsi = tcp_to_iscsi ( conn );
+	struct iscsi_session *iscsi = tcp_to_iscsi ( app );
 	struct iscsi_bhs_common *common = &iscsi->tx_bhs.common;
 	static const char pad[] = { '\0', '\0', '\0' };
 
 		/* Nothing to send */
 		break;
 	case ISCSI_TX_BHS:
-		tcp_send ( conn, &iscsi->tx_bhs.bytes[iscsi->tx_offset],
+		tcp_send ( app, &iscsi->tx_bhs.bytes[iscsi->tx_offset],
 			   ( sizeof ( iscsi->tx_bhs ) - iscsi->tx_offset ) );
 		break;
 	case ISCSI_TX_AHS:
 		iscsi_tx_data ( iscsi, buf, len );
 		break;
 	case ISCSI_TX_DATA_PADDING:
-		tcp_send ( conn, pad, ( ISCSI_DATA_PAD_LEN ( common->lengths )
+		tcp_send ( app, pad, ( ISCSI_DATA_PAD_LEN ( common->lengths )
 					- iscsi->tx_offset ) );
 		break;
 	default:
 /**
  * Receive new data
  *
- * @v tcp		TCP connection
+ * @v tcp		TCP application
  * @v data		Received data
  * @v len		Length of received data
  *
  * always has a full copy of the BHS available, even for portions of
  * the data in different packets to the BHS.
  */
-static void iscsi_newdata ( struct tcp_connection *conn, void *data,
+static void iscsi_newdata ( struct tcp_application *app, void *data,
 			    size_t len ) {
-	struct iscsi_session *iscsi = tcp_to_iscsi ( conn );
+	struct iscsi_session *iscsi = tcp_to_iscsi ( app );
 	struct iscsi_bhs_common *common = &iscsi->rx_bhs.common;
 	void ( *process ) ( struct iscsi_session *iscsi, void *data,
 			    size_t len, size_t remaining );
 	}
 }
 
-#warning "Remove me soon"
-static struct tcp_operations iscsi_tcp_operations;
-
 /**
  * Handle TCP connection closure
  *
- * @v conn		TCP connection
+ * @v app		TCP application
  * @v status		Error code, if any
  *
  */
-static void iscsi_closed ( struct tcp_connection *conn, int status ) {
-	struct iscsi_session *iscsi = tcp_to_iscsi ( conn );
-	int session_status = iscsi->status;
+static void iscsi_closed ( struct tcp_application *app, int status ) {
+	struct iscsi_session *iscsi = tcp_to_iscsi ( app );
+	int rc;
 
 	/* Clear session status */
 	iscsi->status = 0;
 
-	/* If we are deliberately closing down, exit cleanly */
-	if ( session_status & ISCSI_STATUS_CLOSING ) {
-		iscsi_done ( iscsi, status );
-		return;
-	}
-
 	/* Retry connection if within the retry limit, otherwise fail */
 	if ( ++iscsi->retry_count <= ISCSI_MAX_RETRIES ) {
 		DBG ( "iSCSI %p retrying connection\n", iscsi );
-		/* Re-copy address to handle redirection */
-		memset ( &iscsi->tcp, 0, sizeof ( iscsi->tcp ) );
-		iscsi->tcp.tcp_op = &iscsi_tcp_operations;
-		memcpy ( &iscsi->tcp.peer, &iscsi->target,
-			 sizeof ( iscsi->tcp.peer ) );
-		tcp_connect ( conn );
+		if ( ( rc = tcp_connect ( app, &iscsi->target, 0 ) ) != 0 ) {
+			DBG ( "iSCSI %p could not open TCP connection\n",
+			      iscsi );
+			iscsi_done ( iscsi, rc );
+		}
 	} else {
 		printf ( "iSCSI %p retry count exceeded\n", iscsi );
 		iscsi_done ( iscsi, status );
 /**
  * Handle TCP connection opening
  *
- * @v conn		TCP connection
+ * @v app		TCP application
  *
  */
-static void iscsi_connected ( struct tcp_connection *conn ) {
-	struct iscsi_session *iscsi = tcp_to_iscsi ( conn );
+static void iscsi_connected ( struct tcp_application *app ) {
+	struct iscsi_session *iscsi = tcp_to_iscsi ( app );
 
 	/* Set connected flag and reset retry count */
 	iscsi->status = ( ISCSI_STATUS_SECURITY_NEGOTIATION_PHASE |
  */
 struct async_operation * iscsi_issue ( struct iscsi_session *iscsi,
 				       struct scsi_command *command ) {
+	int rc;
+
 	assert ( iscsi->command == NULL );
 	iscsi->command = command;
 
 	} else {
 		/* Session not open: initiate login */
 		iscsi->tcp.tcp_op = &iscsi_tcp_operations;
-		memcpy ( &iscsi->tcp.peer, &iscsi->target,
-			 sizeof ( iscsi->tcp.peer ) );
-		tcp_connect ( &iscsi->tcp );
+		if ( ( rc = tcp_connect ( &iscsi->tcp, &iscsi->target,
+					  0 ) ) != 0 ) {
+			DBG ( "iSCSI %p could not open TCP connection\n",
+			      iscsi );
+			iscsi_done ( iscsi, rc );
+		}
 	}
 
 	return &iscsi->aop;
  * @v iscsi		iSCSI session
  * @ret aop		Asynchronous operation
  */
-struct async_operation * iscsi_shutdown ( struct iscsi_session *iscsi ) {
-	if ( iscsi->status ) {
-		iscsi->status |= ISCSI_STATUS_CLOSING;
-		tcp_close ( &iscsi->tcp );
-	}
-	return &iscsi->aop;
+void iscsi_shutdown ( struct iscsi_session *iscsi ) {
+	iscsi->status = 0;
+	tcp_close ( &iscsi->tcp );
 }

src/tests/ftptest.c

 	printf ( "FTP fetching %s\n", filename );
 	
 	memset ( &ftp, 0, sizeof ( ftp ) );
-	memcpy ( &ftp.tcp.peer, server, sizeof ( ftp.tcp.peer ) );
+	memcpy ( &ftp.server, server, sizeof ( ftp.server ) );
 	ftp.filename = filename;
 	ftp.callback = test_ftp_callback;
 

src/tests/hellotest.c

 		 inet_ntoa ( sin->sin_addr ), ntohs ( sin->sin_port ) );
 	
 	memset ( &hello, 0, sizeof ( hello ) );
-	memcpy ( &hello.tcp.peer, server, sizeof ( hello.tcp.peer ) );
+	memcpy ( &hello.server, server, sizeof ( hello.server ) );
 	hello.message = message;
 	hello.callback = test_hello_callback;
 

src/tests/httptest.c

 	int rc;
 
 	memset ( &http, 0, sizeof ( http ) );
-	memcpy ( &http.tcp.peer, server, sizeof ( http.tcp.peer ) );
+	memcpy ( &http.server, server, sizeof ( http.server ) );
 	http.filename = filename;
 	http.callback = test_http_callback;