Changed to use the generic stream API.

src/include/gpxe/ftp.h

 
 #include <stdint.h>
 #include <gpxe/async.h>
-#include <gpxe/tcp.h>
+#include <gpxe/stream.h>
 
 struct buffer;
 
 	char status_text[4];
 	/** Passive-mode parameters, as text */
 	char passive_text[24]; /* "aaa,bbb,ccc,ddd,eee,fff" */
-	/** TCP application for the control channel */
-	struct tcp_application tcp;
-	/** TCP application for the data channel */
-	struct tcp_application tcp_data;
+	/** Stream application for the control channel */
+	struct stream_application stream;
+	/** Stream application for the data channel */
+	struct stream_application stream_data;
 };
 
 extern int ftp_get ( struct uri *uri, struct buffer *buffer,

src/include/gpxe/http.h

  */
 
 #include <stdint.h>
-#include <gpxe/tcp.h>
+#include <gpxe/stream.h>
 #include <gpxe/async.h>
 #include <gpxe/linebuf.h>
 #include <gpxe/uri.h>
 
 	/** Server address */
 	struct sockaddr server;
-	/** TCP application for this request */
-	struct tcp_application tcp;
+	/** Stream application for this request */
+	struct stream_application stream;
 	/** Number of bytes already sent */
 	size_t tx_offset;
 	/** RX state */

src/include/gpxe/iscsi.h

  */
 
 #include <stdint.h>
-#include <gpxe/tcp.h>
+#include <gpxe/stream.h>
 #include <gpxe/async.h>
 #include <gpxe/scsi.h>
 #include <gpxe/chap.h>
 	/** Initiator IQN */
 	const char *initiator_iqn;
 	/** Target address */
-	struct sockaddr_tcpip target;
+	struct sockaddr target;
 	/** Target IQN */
 	const char *target_iqn;
 	/** Logical Unit Number (LUN) */
 	/** Password */
 	const char *password;
 
-	/** TCP application for this session */
-	struct tcp_application tcp;
+	/** Stream application for this session */
+	struct stream_application stream;
 	/** Session status
 	 *
 	 * This is the bitwise-OR of zero or more ISCSI_STATUS_XXX

src/include/gpxe/stream.h

 	 * application's senddata() method.
 	 */
 	int ( * send ) ( struct stream_connection *conn,
-			 void *data, size_t len );
+			 const void *data, size_t len );
 	/**
 	 * Notify connection that data is available to send
 	 *
 	struct stream_connection_operations *op;	
 };
 
+extern void stream_associate ( struct stream_application *app,
+			       struct stream_connection *conn );
+
 extern void stream_connected ( struct stream_connection *conn );
 extern void stream_closed ( struct stream_connection *conn, int rc );
 extern void stream_senddata ( struct stream_connection *conn,
 			    struct sockaddr *peer );
 extern void stream_close ( struct stream_application *app );
 extern int stream_send ( struct stream_application *app,
-			 void *data, size_t len );
+			 const void *data, size_t len );
 extern int stream_kick ( struct stream_application *app );
 
 #endif /* _GPXE_STREAM_H */

src/include/gpxe/tcp.h

 
 #include "latch.h"
 #include <gpxe/tcpip.h>
+#include <gpxe/stream.h>
 
 /**
  * A TCP header
  */
 #define TCP_MSL ( 2 * 60 * TICKS_PER_SEC )
 
-struct tcp_application;
-
-/**
- * TCP operations
- *
- */
-struct tcp_operations {
-	/*
-	 * Connection closed
-	 *
-	 * @v app	TCP application
-	 * @v status	Error code, if any
-	 *
-	 * This is called when the connection is closed for any
-	 * reason, including timeouts or aborts.  The status code
-	 * contains the negative error number, if the closure 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_application *app, int status );
-	/**
-	 * Connection established
-	 *
-	 * @v app	TCP application
-	 */
-	void ( * connected ) ( struct tcp_application *app );
-	/**
-	 * Data acknowledged
-	 *
-	 * @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_application *app, size_t len );
-	/**
-	 * New data received
-	 *
-	 * @v app	TCP application
-	 * @v data	Data
-	 * @v len	Length of data
-	 */
-	void ( * newdata ) ( struct tcp_application *app,
-			     void *data, size_t len );
-	/**
-	 * Transmit data
-	 *
-	 * @v app	TCP application
-	 * @v buf	Temporary data buffer
-	 * @v len	Length of temporary data buffer
-	 *
-	 * The application should transmit whatever it currently wants
-	 * to send using tcp_send().  If retransmissions are required,
-	 * senddata() will be called again and the application must
-	 * regenerate the data.  The easiest way to implement this is
-	 * to ensure that senddata() never changes the application's
-	 * state.
-	 *
-	 * The application may use the temporary data buffer to
-	 * construct the data to be sent.  Note that merely filling
-	 * the buffer will do nothing; the application must call
-	 * tcp_send() in order to actually transmit the data.  Use of
-	 * the buffer is not compulsory; the application may call
-	 * tcp_send() on any block of data.
-	 */
-	void ( * senddata ) ( struct tcp_application *app, void *buf,
-			      size_t len );
-};
-
-struct tcp_connection;
-
-/**
- * A TCP application
- *
- * This data structure represents an application with a TCP 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 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 );
+extern int tcp_open ( struct stream_application *app );
 
 extern struct tcpip_protocol tcp_protocol;
 

src/net/stream.c

 #include <stdint.h>
 #include <string.h>
 #include <errno.h>
+#include <assert.h>
 #include <gpxe/stream.h>
 
+/**
+ * Associate application with connection
+ *
+ * @v app		Stream application
+ * @v conn		Stream connection
+ */
+void stream_associate ( struct stream_application *app,
+			struct stream_connection *conn ) {
+
+	DBGC ( app, "Stream %p associating with connection %p\n", app, conn );
+
+	assert ( conn->app == NULL );
+	assert ( app->conn == NULL );
+	conn->app = app;
+	app->conn = conn;
+}
+
 /**
  * Connection established
  *
 	}
 
 	/* Hand off to application */
-	app->op->connected ( app );
+	if ( app->op->connected )
+		app->op->connected ( app );
 }
 
 /**
 		return;
 	}
 
+	/* Disassociate application from connection */
+	app->conn = NULL;
+	conn->app = NULL;
+
 	/* Hand off to application */
-	app->op->closed ( app, rc );
+	if ( app->op->closed )
+		app->op->closed ( app, rc );
 }
 
 /**
 	}
 
 	/* Hand off to application */
-	app->op->senddata ( app, data, len );
+	if ( app->op->senddata )
+		app->op->senddata ( app, data, len );
 }
 
 /**
 	}
 
 	/* Hand off to application */
-	app->op->acked ( app, len );
+	if ( app->op->acked )
+		app->op->acked ( app, len );
 }
 
 /**
 	}
 
 	/* Hand off to application */
-	app->op->newdata ( app, data, len );
+	if ( app->op->newdata )
+		app->op->newdata ( app, data, len );
 }
 
 /**
 	}
 
 	/* Hand off to connection */
+	if ( ! conn->op->bind )
+		return -ENOTSUP;
 	if ( ( rc = conn->op->bind ( conn, local ) ) != 0 ) {
 		DBGC ( app, "Stream %p failed to bind: %s\n",
 		       app, strerror ( rc ) );
 	}
 
 	/* Hand off to connection */
+	if ( ! conn->op->connect )
+		return -ENOTSUP;
 	if ( ( rc = conn->op->connect ( conn, peer ) ) != 0 ) {
 		DBGC ( app, "Stream %p failed to connect: %s\n",
 		       app, strerror ( rc ) );
 		return;
 	}
 
+	/* Disassociate application from connection */
+	app->conn = NULL;
+	conn->app = NULL;
+
 	/* Hand off to connection */
+	if ( ! conn->op->close )
+		return;
 	conn->op->close ( conn );
 }
 
  * This method should be called only in the context of an
  * application's senddata() method.
  */
-int stream_send ( struct stream_application *app, void *data, size_t len ) {
+int stream_send ( struct stream_application *app,
+		  const void *data, size_t len ) {
 	struct stream_connection *conn = app->conn;
 	int rc;
 
 	}
 
 	/* Hand off to connection */
+	if ( ! conn->op->send )
+		return -ENOTSUP;
 	if ( ( rc = conn->op->send ( conn, data, len ) ) != 0 ) {
 		DBGC ( app, "Stream %p failed to send %zd bytes: %s\n",
 		       app, len, strerror ( rc ) );
 	}
 
 	/* Hand off to connection */
+	if ( ! conn->op->send )
+		return -ENOTSUP;
 	if ( ( rc = conn->op->kick ( conn ) ) != 0 ) {
 		DBGC ( app, "Stream %p failed to kick connection: %s\n",
 		       app, strerror ( rc ) );

src/net/tcp/ftp.c

 #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
 };
 
 /**
- * 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 );
 }
 
 /**
 
 	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 );
 /**
  * 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
 /**
  * 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.
  */
 		char *ptr = ftp->passive_text;
 		union {
 			struct sockaddr_in sin;
-			struct sockaddr_tcpip st;
+			struct sockaddr sa;
 		} sa;
 		int rc;
 
 				  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 );
 /**
  * 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;
 /**
  * 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;
 /**
  * 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 ) );
 }
 
 /** 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,
  */
 
 /**
- * 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
  *
  * 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 ) );
 /**
  * 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 */
 }
 
 /** 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,
 };
 	.reap = ftp_reap,
 };
 
-#warning "Quick name resolution hack"
-#include <byteswap.h>
-
 /**
  * Initiate an FTP connection
  *
 	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 );
 
 	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 );

src/net/tcp/http.c

 #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 );
 }
 
 /**
  */
 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;
  * @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;
 /**
  * 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;
 
 			 "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;
 }
 /**
  * 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 ) );
 	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,
 	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.
 	}
 
 	/* 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;

src/net/tcp/iscsi.c

 #include <gpxe/scsi.h>
 #include <gpxe/process.h>
 #include <gpxe/uaccess.h>
+#include <gpxe/tcp.h>
 #include <gpxe/iscsi.h>
 
 /** @file
  */
 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;
 		len = remaining;
 	copy_from_user ( buf, iscsi->command->data_out, offset, len );
 
-	tcp_send ( &iscsi->tcp, buf, len );
+	stream_send ( &iscsi->stream, buf, len );
 }
 
 /****************************************************************************
 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 );
 }
 
 	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;
 	}
 
 /****************************************************************************
  *
- * 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 );
 }
 
 /**
 }
 
 /**
- * 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;
 	
  * 
  * 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' };
 
 		/* 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:
 		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 );
 /**
  * Receive new data
  *
- * @v tcp		TCP application
+ * @v stream		Stream 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_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 );
 }
 
 /**
- * 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 */
 	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 );
 	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,
 	} 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;
 		}
 	}