Changed to use the generic stream API.

3 files changed, 151 insertions, 113 deletions

diff --git a/src/net/tcp/ftp.c b/src/net/tcp/ftp.c
index 785678842..061240c3c 100644
--- a/src/net/tcp/ftp.c
+++ b/src/net/tcp/ftp.c
@@ -4,10 +4,12 @@
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
+#include <byteswap.h>
 #include <gpxe/async.h>
 #include <gpxe/buffer.h>
 #include <gpxe/uri.h>
 #include <gpxe/download.h>
+#include <gpxe/tcp.h>
 #include <gpxe/ftp.h>
 
 /** @file
@@ -40,13 +42,14 @@ static const char * ftp_strings[] = {
 };
 
 /**
- * Get FTP request from control TCP application
+ * Get FTP request from control stream application
  *
- * @v app		TCP application
+ * @v app		Stream application
  * @ret ftp		FTP request
  */
-static inline struct ftp_request * tcp_to_ftp ( struct tcp_application *app ) {
-	return container_of ( app, struct ftp_request, tcp );
+static inline struct ftp_request *
+stream_to_ftp ( struct stream_application *app ) {
+	return container_of ( app, struct ftp_request, stream );
 }
 
 /**
@@ -59,9 +62,9 @@ static void ftp_done ( struct ftp_request *ftp, int rc ) {
 
 	DBGC ( ftp, "FTP %p completed with status %d\n", ftp, rc );
 
-	/* Close both TCP connections */
-	tcp_close ( &ftp->tcp );
-	tcp_close ( &ftp->tcp_data );
+	/* Close both stream connections */
+	stream_close ( &ftp->stream );
+	stream_close ( &ftp->stream_data );
 
 	/* Mark asynchronous operation as complete */
 	async_done ( &ftp->async, rc );
@@ -70,9 +73,9 @@ static void ftp_done ( struct ftp_request *ftp, int rc ) {
 /**
  * Parse FTP byte sequence value
  *
- * @v text	Text string
- * @v value	Value buffer
- * @v len	Length of value buffer
+ * @v text		Text string
+ * @v value		Value buffer
+ * @v len		Length of value buffer
  *
  * This parses an FTP byte sequence value (e.g. the "aaa,bbb,ccc,ddd"
  * form for IP addresses in PORT commands) into a byte sequence.  @c
@@ -93,7 +96,7 @@ static void ftp_parse_value ( char **text, uint8_t *value, size_t len ) {
 /**
  * Handle an FTP control channel response
  *
- * @v ftp	FTP request
+ * @v ftp		FTP request
  *
  * This is called once we have received a complete response line.
  */
@@ -121,7 +124,7 @@ static void ftp_reply ( struct ftp_request *ftp ) {
 		char *ptr = ftp->passive_text;
 		union {
 			struct sockaddr_in sin;
-			struct sockaddr_tcpip st;
+			struct sockaddr sa;
 		} sa;
 		int rc;
 
@@ -130,7 +133,14 @@ static void ftp_reply ( struct ftp_request *ftp ) {
 				  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 ){
+		if ( ( rc = tcp_open ( &ftp->stream_data ) ) != 0 ) {
+			DBGC ( ftp, "FTP %p could not open data connection\n",
+			       ftp );
+			ftp_done ( ftp, rc );
+			return;
+		}
+		if ( ( rc = stream_connect ( &ftp->stream_data,
+					     &sa.sa ) ) != 0 ){
 			DBGC ( ftp, "FTP %p could not make data connection\n",
 			       ftp );
 			ftp_done ( ftp, rc );
@@ -154,16 +164,16 @@ static void ftp_reply ( struct ftp_request *ftp ) {
 /**
  * Handle new data arriving on FTP control channel
  *
- * @v app	TCP application
- * @v data	New data
- * @v len	Length of new data
+ * @v app		Stream 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_application *app,
+static void ftp_newdata ( struct stream_application *app,
 			  void *data, size_t len ) {
-	struct ftp_request *ftp = tcp_to_ftp ( app );
+	struct ftp_request *ftp = stream_to_ftp ( app );
 	char *recvbuf = ftp->recvbuf;
 	size_t recvsize = ftp->recvsize;
 	char c;
@@ -210,10 +220,10 @@ static void ftp_newdata ( struct tcp_application *app,
 /**
  * Handle acknowledgement of data sent on FTP control channel
  *
- * @v app	TCP application
+ * @v app		Stream application
  */
-static void ftp_acked ( struct tcp_application *app, size_t len ) {
-	struct ftp_request *ftp = tcp_to_ftp ( app );
+static void ftp_acked ( struct stream_application *app, size_t len ) {
+	struct ftp_request *ftp = stream_to_ftp ( app );
 	
 	/* Mark off ACKed portion of the currently-transmitted data */
 	ftp->already_sent += len;
@@ -222,31 +232,31 @@ static void ftp_acked ( struct tcp_application *app, size_t len ) {
 /**
  * Construct data to send on FTP control channel
  *
- * @v app	TCP application
- * @v buf	Temporary data buffer
- * @v len	Length of temporary data buffer
+ * @v app		Stream application
+ * @v buf		Temporary data buffer
+ * @v len		Length of temporary data buffer
  */
-static void ftp_senddata ( struct tcp_application *app,
+static void ftp_senddata ( struct stream_application *app,
 			   void *buf, size_t len ) {
-	struct ftp_request *ftp = tcp_to_ftp ( app );
+	struct ftp_request *ftp = stream_to_ftp ( app );
 
 	/* Send the as-yet-unACKed portion of the string for the
 	 * current state.
 	 */
 	len = snprintf ( buf, len, ftp_strings[ftp->state], ftp->uri->path );
-	tcp_send ( app, buf + ftp->already_sent, len - ftp->already_sent );
+	stream_send ( app, buf + ftp->already_sent, len - ftp->already_sent );
 }
 
 /**
  * Handle control channel being closed
  *
- * @v app		TCP application
+ * @v app		Stream 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_application *app, int rc ) {
-	struct ftp_request *ftp = tcp_to_ftp ( app );
+static void ftp_closed ( struct stream_application *app, int rc ) {
+	struct ftp_request *ftp = stream_to_ftp ( app );
 
 	DBGC ( ftp, "FTP %p control connection closed: %s\n",
 	       ftp, strerror ( rc ) );
@@ -256,7 +266,7 @@ static void ftp_closed ( struct tcp_application *app, int rc ) {
 }
 
 /** FTP control channel operations */
-static struct tcp_operations ftp_tcp_operations = {
+static struct stream_application_operations ftp_stream_operations = {
 	.closed		= ftp_closed,
 	.acked		= ftp_acked,
 	.newdata	= ftp_newdata,
@@ -270,20 +280,20 @@ static struct tcp_operations ftp_tcp_operations = {
  */
 
 /**
- * Get FTP request from data TCP application
+ * Get FTP request from data stream application
  *
- * @v app		TCP application
+ * @v app		Stream application
  * @ret ftp		FTP request
  */
 static inline struct ftp_request *
-tcp_to_ftp_data ( struct tcp_application *app ) {
-	return container_of ( app, struct ftp_request, tcp_data );
+stream_to_ftp_data ( struct stream_application *app ) {
+	return container_of ( app, struct ftp_request, stream_data );
 }
 
 /**
  * Handle data channel being closed
  *
- * @v app		TCP application
+ * @v app		Stream application
  *
  * When the data channel is closed, the control channel should be left
  * alone; the server will send a completion message via the control
@@ -291,8 +301,8 @@ tcp_to_ftp_data ( struct tcp_application *app ) {
  *
  * If the data channel is closed due to an error, we abort the request.
  */
-static void ftp_data_closed ( struct tcp_application *app, int rc ) {
-	struct ftp_request *ftp = tcp_to_ftp_data ( app );
+static void ftp_data_closed ( struct stream_application *app, int rc ) {
+	struct ftp_request *ftp = stream_to_ftp_data ( app );
 
 	DBGC ( ftp, "FTP %p data connection closed: %s\n",
 	       ftp, strerror ( rc ) );
@@ -305,13 +315,13 @@ static void ftp_data_closed ( struct tcp_application *app, int rc ) {
 /**
  * Handle new data arriving on the FTP data channel
  *
- * @v app	TCP application
- * @v data	New data
- * @v len	Length of new data
+ * @v app		Stream application
+ * @v data		New data
+ * @v len		Length of new data
  */
-static void ftp_data_newdata ( struct tcp_application *app,
+static void ftp_data_newdata ( struct stream_application *app,
 			       void *data, size_t len ) {
-	struct ftp_request *ftp = tcp_to_ftp_data ( app );
+	struct ftp_request *ftp = stream_to_ftp_data ( app );
 	int rc;
 
 	/* Fill data buffer */
@@ -325,7 +335,7 @@ static void ftp_data_newdata ( struct tcp_application *app,
 }
 
 /** FTP data channel operations */
-static struct tcp_operations ftp_data_tcp_operations = {
+static struct stream_application_operations ftp_data_stream_operations = {
 	.closed		= ftp_data_closed,
 	.newdata	= ftp_data_newdata,
 };
@@ -353,9 +363,6 @@ static struct async_operations ftp_async_operations = {
 	.reap = ftp_reap,
 };
 
-#warning "Quick name resolution hack"
-#include <byteswap.h>
-
 /**
  * Initiate an FTP connection
  *
@@ -387,12 +394,12 @@ int ftp_get ( struct uri *uri, struct buffer *buffer, struct async *parent ) {
 	ftp->already_sent = 0;
 	ftp->recvbuf = ftp->status_text;
 	ftp->recvsize = sizeof ( ftp->status_text ) - 1;
-	ftp->tcp.tcp_op = &ftp_tcp_operations;
-	ftp->tcp_data.tcp_op = &ftp_data_tcp_operations;
+	ftp->stream.op = &ftp_stream_operations;
+	ftp->stream_data.op = &ftp_data_stream_operations;
 
 #warning "Quick name resolution hack"
 	union {
-		struct sockaddr_tcpip st;
+		struct sockaddr sa;
 		struct sockaddr_in sin;
 	} server;
 	server.sin.sin_port = htons ( FTP_PORT );
@@ -404,7 +411,9 @@ int ftp_get ( struct uri *uri, struct buffer *buffer, struct async *parent ) {
 
 	DBGC ( ftp, "FTP %p fetching %s\n", ftp, ftp->uri->path );
 
-	if ( ( rc = tcp_connect ( &ftp->tcp, &server.st, 0 ) ) != 0 )
+	if ( ( rc = tcp_open ( &ftp->stream ) ) != 0 )
+		goto err;
+	if ( ( rc = stream_connect ( &ftp->stream, &server.sa ) ) != 0 )
 		goto err;
 
 	async_init ( &ftp->async, &ftp_async_operations, parent );
diff --git a/src/net/tcp/http.c b/src/net/tcp/http.c
index 18030fe60..381ab1f47 100644
--- a/src/net/tcp/http.c
+++ b/src/net/tcp/http.c
@@ -36,13 +36,14 @@
 #include <gpxe/buffer.h>
 #include <gpxe/download.h>
 #include <gpxe/resolv.h>
+#include <gpxe/tcp.h>
 #include <gpxe/http.h>
 
 static struct async_operations http_async_operations;
 
 static inline struct http_request *
-tcp_to_http ( struct tcp_application *app ) {
-	return container_of ( app, struct http_request, tcp );
+stream_to_http ( struct stream_application *app ) {
+	return container_of ( app, struct http_request, stream );
 }
 
 /**
@@ -54,8 +55,8 @@ tcp_to_http ( struct tcp_application *app ) {
  */
 static void http_done ( struct http_request *http, int rc ) {
 
-	/* Close TCP connection */
-	tcp_close ( &http->tcp );
+	/* Close stream connection */
+	stream_close ( &http->stream );
 
 	/* Prevent further processing of any current packet */
 	http->rx_state = HTTP_RX_DEAD;
@@ -271,9 +272,9 @@ static void http_rx_data ( struct http_request *http,
  * @v data		New data
  * @v len		Length of new data
  */
-static void http_newdata ( struct tcp_application *app,
+static void http_newdata ( struct stream_application *app,
 			   void *data, size_t len ) {
-	struct http_request *http = tcp_to_http ( app );
+	struct http_request *http = stream_to_http ( app );
 	const char *buf = data;
 	char *line;
 	int rc;
@@ -319,13 +320,13 @@ static void http_newdata ( struct tcp_application *app,
 /**
  * Send HTTP data
  *
- * @v app		TCP application
+ * @v app		Stream application
  * @v buf		Temporary data buffer
  * @v len		Length of temporary data buffer
  */
-static void http_senddata ( struct tcp_application *app,
+static void http_senddata ( struct stream_application *app,
 			    void *buf, size_t len ) {
-	struct http_request *http = tcp_to_http ( app );
+	struct http_request *http = stream_to_http ( app );
 	const char *path = http->uri->path;
 	const char *host = http->uri->host;
 
@@ -338,17 +339,18 @@ static void http_senddata ( struct tcp_application *app,
 			 "Host: %s\r\n"
 			 "\r\n", path, host );
 
-	tcp_send ( app, ( buf + http->tx_offset ), ( len - http->tx_offset ) );
+	stream_send ( app, ( buf + http->tx_offset ),
+		      ( len - http->tx_offset ) );
 }
 
 /**
  * HTTP data acknowledged
  *
- * @v app		TCP application
+ * @v app		Stream application
  * @v len		Length of acknowledged data
  */
-static void http_acked ( struct tcp_application *app, size_t len ) {
-	struct http_request *http = tcp_to_http ( app );
+static void http_acked ( struct stream_application *app, size_t len ) {
+	struct http_request *http = stream_to_http ( app );
 
 	http->tx_offset += len;
 }
@@ -356,10 +358,10 @@ static void http_acked ( struct tcp_application *app, size_t len ) {
 /**
  * HTTP connection closed by network stack
  *
- * @v app		TCP application
+ * @v app		Stream application
  */
-static void http_closed ( struct tcp_application *app, int rc ) {
-	struct http_request *http = tcp_to_http ( app );
+static void http_closed ( struct stream_application *app, int rc ) {
+	struct http_request *http = stream_to_http ( app );
 
 	DBGC ( http, "HTTP %p connection closed: %s\n",
 	       http, strerror ( rc ) );
@@ -367,8 +369,8 @@ static void http_closed ( struct tcp_application *app, int rc ) {
 	http_done ( http, rc );
 }
 
-/** HTTP TCP operations */
-static struct tcp_operations http_tcp_operations = {
+/** HTTP stream operations */
+static struct stream_application_operations http_stream_operations = {
 	.closed		= http_closed,
 	.acked		= http_acked,
 	.newdata	= http_newdata,
@@ -395,6 +397,7 @@ int http_get ( struct uri *uri, struct buffer *buffer, struct async *parent ) {
 	http->uri = uri;
 	http->buffer = buffer;
 	async_init ( &http->async, &http_async_operations, parent );
+	http->stream.op = &http_stream_operations;
 
 	/* Start name resolution.  The download proper will start when
 	 * name resolution completes.
@@ -432,10 +435,15 @@ static void http_sigchld ( struct async *async, enum signal signal __unused ) {
 	}
 
 	/* Otherwise, start the HTTP connection */
-	http->tcp.tcp_op = &http_tcp_operations;
+	if ( ( rc = tcp_open ( &http->stream ) ) != 0 ) {
+		DBGC ( http, "HTTP %p could not open stream connection: %s\n",
+		       http, strerror ( rc ) );
+		http_done ( http, rc );
+		return;
+	}
 	st->st_port = htons ( uri_port ( http->uri, HTTP_PORT ) );
-	if ( ( rc = tcp_connect ( &http->tcp, st, 0 ) ) != 0 ) {
-		DBGC ( http, "HTTP %p could not open TCP connection: %s\n",
+	if ( ( rc = stream_connect ( &http->stream, &http->server ) ) != 0 ) {
+		DBGC ( http, "HTTP %p could not connect stream: %s\n",
 		       http, strerror ( rc ) );
 		http_done ( http, rc );
 		return;
diff --git a/src/net/tcp/iscsi.c b/src/net/tcp/iscsi.c
index 4d95c0b9a..56567976f 100644
--- a/src/net/tcp/iscsi.c
+++ b/src/net/tcp/iscsi.c
@@ -26,6 +26,7 @@
 #include <gpxe/scsi.h>
 #include <gpxe/process.h>
 #include <gpxe/uaccess.h>
+#include <gpxe/tcp.h>
 #include <gpxe/iscsi.h>
 
 /** @file
@@ -85,8 +86,8 @@ static void iscsi_rx_buffered_data_done ( struct iscsi_session *iscsi ) {
  */
 static void iscsi_close ( struct iscsi_session *iscsi ) {
 
-	/* Close TCP connection */
-	tcp_close ( &iscsi->tcp );
+	/* Close stream connection */
+	stream_close ( &iscsi->stream );
 
 	/* Clear connection status */
 	iscsi->status = 0;
@@ -338,7 +339,7 @@ static void iscsi_tx_data_out ( struct iscsi_session *iscsi,
 		len = remaining;
 	copy_from_user ( buf, iscsi->command->data_out, offset, len );
 
-	tcp_send ( &iscsi->tcp, buf, len );
+	stream_send ( &iscsi->stream, buf, len );
 }
 
 /****************************************************************************
@@ -507,7 +508,7 @@ static void iscsi_login_request_done ( struct iscsi_session *iscsi ) {
 static void iscsi_tx_login_request ( struct iscsi_session *iscsi,
 				     void *buf, size_t len ) {
 	len = iscsi_build_login_request_strings ( iscsi, buf, len );
-	tcp_send ( &iscsi->tcp, buf + iscsi->tx_offset,
+	stream_send ( &iscsi->stream, buf + iscsi->tx_offset,
 		   len - iscsi->tx_offset );
 }
 
@@ -750,11 +751,18 @@ static void iscsi_rx_login_response ( struct iscsi_session *iscsi, void *data,
 	if ( response->status_class == ISCSI_STATUS_REDIRECT ) {
 		DBGC ( iscsi, "iSCSI %p redirecting to new server\n", iscsi );
 		iscsi_close ( iscsi );
-		if ( ( rc = tcp_connect ( &iscsi->tcp, &iscsi->target,
-					  0 ) ) != 0 ) {
-			DBGC ( iscsi, "iSCSI %p could not open TCP "
-			       "connection: %s\n", iscsi, strerror ( rc ) );
+		if ( ( rc = tcp_open ( &iscsi->stream ) ) != 0 ) {
+			DBGC ( iscsi, "iSCSI %p could not open stream: %s\n ",
+			       iscsi, strerror ( rc ) );
 			iscsi_done ( iscsi, rc );
+			return;
+		}
+		if ( ( rc = stream_connect ( &iscsi->stream,
+					     &iscsi->target ) != 0 ) != 0 ) {
+			DBGC ( iscsi, "iSCSI %p could not connect: %s\n ",
+			       iscsi, strerror ( rc ) );
+			iscsi_done ( iscsi, rc );
+			return;
 		}
 		return;
 	}
@@ -810,13 +818,13 @@ static void iscsi_rx_login_response ( struct iscsi_session *iscsi, void *data,
 
 /****************************************************************************
  *
- * iSCSI to TCP interface
+ * iSCSI to stream interface
  *
  */
 
 static inline struct iscsi_session *
-tcp_to_iscsi ( struct tcp_application *app ) {
-	return container_of ( app, struct iscsi_session, tcp );
+stream_to_iscsi ( struct stream_application *app ) {
+	return container_of ( app, struct iscsi_session, stream );
 }
 
 /**
@@ -889,15 +897,15 @@ static void iscsi_tx_done ( struct iscsi_session *iscsi ) {
 }
 
 /**
- * Handle TCP ACKs
+ * Handle stream ACKs
  *
  * @v iscsi		iSCSI session
  * 
  * Updates iscsi->tx_offset and, if applicable, transitions to the
  * next TX state.
  */
-static void iscsi_acked ( struct tcp_application *app, size_t len ) {
-	struct iscsi_session *iscsi = tcp_to_iscsi ( app );
+static void iscsi_acked ( struct stream_application *app, size_t len ) {
+	struct iscsi_session *iscsi = stream_to_iscsi ( app );
 	struct iscsi_bhs_common *common = &iscsi->tx_bhs.common;
 	enum iscsi_tx_state next_state;
 	
@@ -953,9 +961,9 @@ static void iscsi_acked ( struct tcp_application *app, size_t len ) {
  * 
  * Constructs data to be sent for the current TX state
  */
-static void iscsi_senddata ( struct tcp_application *app,
+static void iscsi_senddata ( struct stream_application *app,
 			     void *buf, size_t len ) {
-	struct iscsi_session *iscsi = tcp_to_iscsi ( app );
+	struct iscsi_session *iscsi = stream_to_iscsi ( app );
 	struct iscsi_bhs_common *common = &iscsi->tx_bhs.common;
 	static const char pad[] = { '\0', '\0', '\0' };
 
@@ -964,7 +972,7 @@ static void iscsi_senddata ( struct tcp_application *app,
 		/* Nothing to send */
 		break;
 	case ISCSI_TX_BHS:
-		tcp_send ( app, &iscsi->tx_bhs.bytes[iscsi->tx_offset],
+		stream_send ( app, &iscsi->tx_bhs.bytes[iscsi->tx_offset],
 			   ( sizeof ( iscsi->tx_bhs ) - iscsi->tx_offset ) );
 		break;
 	case ISCSI_TX_AHS:
@@ -975,8 +983,8 @@ static void iscsi_senddata ( struct tcp_application *app,
 		iscsi_tx_data ( iscsi, buf, len );
 		break;
 	case ISCSI_TX_DATA_PADDING:
-		tcp_send ( app, pad, ( ISCSI_DATA_PAD_LEN ( common->lengths )
-					- iscsi->tx_offset ) );
+		stream_send ( app, pad, ( ISCSI_DATA_PAD_LEN( common->lengths )
+					  - iscsi->tx_offset ) );
 		break;
 	default:
 		assert ( 0 );
@@ -1068,7 +1076,7 @@ static void iscsi_rx_bhs ( struct iscsi_session *iscsi, void *data,
 /**
  * Receive new data
  *
- * @v tcp		TCP application
+ * @v stream		Stream application
  * @v data		Received data
  * @v len		Length of received data
  *
@@ -1079,9 +1087,9 @@ static void iscsi_rx_bhs ( struct iscsi_session *iscsi, void *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_application *app, void *data,
+static void iscsi_newdata ( struct stream_application *app, void *data,
 			    size_t len ) {
-	struct iscsi_session *iscsi = tcp_to_iscsi ( app );
+	struct iscsi_session *iscsi = stream_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 );
@@ -1138,14 +1146,14 @@ static void iscsi_newdata ( struct tcp_application *app, void *data,
 }
 
 /**
- * Handle TCP connection closure
+ * Handle stream connection closure
  *
- * @v app		TCP application
+ * @v app		Stream application
  * @v status		Error code, if any
  *
  */
-static void iscsi_closed ( struct tcp_application *app, int status ) {
-	struct iscsi_session *iscsi = tcp_to_iscsi ( app );
+static void iscsi_closed ( struct stream_application *app, int status ) {
+	struct iscsi_session *iscsi = stream_to_iscsi ( app );
 	int rc;
 
 	/* Even a graceful close counts as an error for iSCSI */
@@ -1159,26 +1167,34 @@ static void iscsi_closed ( struct tcp_application *app, int status ) {
 	if ( ++iscsi->retry_count <= ISCSI_MAX_RETRIES ) {
 		DBGC ( iscsi, "iSCSI %p retrying connection (retry #%d)\n",
 		       iscsi, iscsi->retry_count );
-		if ( ( rc = tcp_connect ( app, &iscsi->target, 0 ) ) != 0 ) {
-			DBGC ( iscsi, "iSCSI %p could not open TCP "
-			       "connection: %s\n", iscsi, strerror ( rc ) );
+		if ( ( rc = tcp_open ( app ) ) != 0 ) {
+			DBGC ( iscsi, "iSCSI %p could not open stream: %s\n ",
+			       iscsi, strerror ( rc ) );
 			iscsi_done ( iscsi, rc );
+			return;
+		}
+		if ( ( rc = stream_connect ( app, &iscsi->target ) ) != 0 ){
+			DBGC ( iscsi, "iSCSI %p could not connect: %s\n",
+			       iscsi, strerror ( rc ) );
+			iscsi_done ( iscsi, rc );
+			return;
 		}
 	} else {
 		DBGC ( iscsi, "iSCSI %p retry count exceeded\n", iscsi );
 		iscsi->instant_rc = status;
 		iscsi_done ( iscsi, status );
+		return;
 	}
 }
 
 /**
- * Handle TCP connection opening
+ * Handle stream connection opening
  *
- * @v app		TCP application
+ * @v app		Stream application
  *
  */
-static void iscsi_connected ( struct tcp_application *app ) {
-	struct iscsi_session *iscsi = tcp_to_iscsi ( app );
+static void iscsi_connected ( struct stream_application *app ) {
+	struct iscsi_session *iscsi = stream_to_iscsi ( app );
 
 	assert ( iscsi->rx_state == ISCSI_RX_BHS );
 	assert ( iscsi->rx_offset == 0 );
@@ -1194,8 +1210,8 @@ static void iscsi_connected ( struct tcp_application *app ) {
 	iscsi_start_login ( iscsi );
 }
 
-/** iSCSI TCP operations */
-static struct tcp_operations iscsi_tcp_operations = {
+/** iSCSI stream operations */
+static struct stream_application_operations iscsi_stream_operations = {
 	.closed		= iscsi_closed,
 	.connected	= iscsi_connected,
 	.acked		= iscsi_acked,
@@ -1224,14 +1240,19 @@ int iscsi_issue ( struct iscsi_session *iscsi, struct scsi_command *command,
 	} else if ( iscsi->status ) {
 		/* Session already open: issue command */
 		iscsi_start_command ( iscsi );
-		tcp_senddata ( &iscsi->tcp );
+		stream_kick ( &iscsi->stream );
 	} else {
 		/* Session not open: initiate login */
-		iscsi->tcp.tcp_op = &iscsi_tcp_operations;
-		if ( ( rc = tcp_connect ( &iscsi->tcp, &iscsi->target,
-					  0 ) ) != 0 ) {
-			DBGC ( iscsi, "iSCSI %p could not open TCP "
-			       "connection: %s\n", iscsi, strerror ( rc ) );
+		iscsi->stream.op = &iscsi_stream_operations;
+		if ( ( rc = tcp_open ( &iscsi->stream ) ) != 0 ) {
+			DBGC ( iscsi, "iSCSI %p could not open stream: %s\n ",
+			       iscsi, strerror ( rc ) );
+			return rc;
+		}
+		if ( ( rc = stream_connect ( &iscsi->stream,
+					     &iscsi->target ) ) != 0 ) {
+			DBGC ( iscsi, "iSCSI %p could not connect: %s\n",
+			       iscsi, strerror ( rc ) );
 			return rc;
 		}
 	}