xCAT/xNBA
2
0
Fork 0
mirror of https://github.com/xcat2/xNBA.git synced 2024-12-16 00:01:34 +00:00
Code Issues Projects Releases Wiki Activity

Changed to use the generic stream API.

Browse Source
This commit is contained in:
Michael Brown 2007-01-31 02:09:13 +00:00
parent 02f18565da
commit 6d32f0e6e2
10 changed files with 500 additions and 541 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/include/gpxe/ftp.h
View File

@ -9,7 +9,7 @@
#include <stdint.h>
#include <gpxe/async.h>
#include <gpxe/tcp.h>
#include <gpxe/stream.h>
struct buffer;
@ -57,10 +57,10 @@ struct ftp_request {
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,

6
src/include/gpxe/http.h
View File

@ -8,7 +8,7 @@
*/
#include <stdint.h>
#include <gpxe/tcp.h>
#include <gpxe/stream.h>
#include <gpxe/async.h>
#include <gpxe/linebuf.h>
#include <gpxe/uri.h>
@ -43,8 +43,8 @@ struct http_request {
/** 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 */

8
src/include/gpxe/iscsi.h
View File

@ -8,7 +8,7 @@
*/
#include <stdint.h>
#include <gpxe/tcp.h>
#include <gpxe/stream.h>
#include <gpxe/async.h>
#include <gpxe/scsi.h>
#include <gpxe/chap.h>
@ -489,7 +489,7 @@ struct iscsi_session {
/** 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) */
@ -499,8 +499,8 @@ struct iscsi_session {
/** 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

7
src/include/gpxe/stream.h
View File

@ -125,7 +125,7 @@ struct stream_connection_operations {
* 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
*
@ -167,6 +167,9 @@ struct stream_connection {
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,
@ -181,7 +184,7 @@ extern int stream_connect ( struct stream_application *app,
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 */

101
src/include/gpxe/tcp.h
View File

@ -11,6 +11,7 @@
#include "latch.h"
#include <gpxe/tcpip.h>
#include <gpxe/stream.h>
/**
* A TCP header
@ -252,105 +253,7 @@ struct tcp_mss_option {
*/
#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;

54
src/net/stream.c
View File

@ -25,8 +25,26 @@
#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
*
@ -45,7 +63,8 @@ void stream_connected ( struct stream_connection *conn ) {
}
/* Hand off to application */
app->op->connected ( app );
if ( app->op->connected )
app->op->connected ( app );
}
/**
@ -66,8 +85,13 @@ void stream_closed ( struct stream_connection *conn, int rc ) {
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 );
}
/**
@ -91,7 +115,8 @@ void stream_senddata ( struct stream_connection *conn,
}
/* Hand off to application */
app->op->senddata ( app, data, len );
if ( app->op->senddata )
app->op->senddata ( app, data, len );
}
/**
@ -116,7 +141,8 @@ void stream_acked ( struct stream_connection *conn, size_t len ) {
}
/* Hand off to application */
app->op->acked ( app, len );
if ( app->op->acked )
app->op->acked ( app, len );
}
/**
@ -140,7 +166,8 @@ void stream_newdata ( struct stream_connection *conn,
}
/* Hand off to application */
app->op->newdata ( app, data, len );
if ( app->op->newdata )
app->op->newdata ( app, data, len );
}
/**
@ -163,6 +190,8 @@ int stream_bind ( struct stream_application *app, struct sockaddr *local ) {
}
/* 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 ) );
@ -192,6 +221,8 @@ int stream_connect ( struct stream_application *app, struct sockaddr *peer ) {
}
/* 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 ) );
@ -217,7 +248,13 @@ void stream_close ( struct stream_application *app ) {
return;
}
/* Disassociate application from connection */
app->conn = NULL;
conn->app = NULL;
/* Hand off to connection */
if ( ! conn->op->close )
return;
conn->op->close ( conn );
}
@ -232,7 +269,8 @@ void stream_close ( struct stream_application *app ) {
* 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;
@ -245,6 +283,8 @@ int stream_send ( struct stream_application *app, void *data, size_t len ) {
}
/* 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 ) );
@ -273,6 +313,8 @@ int stream_kick ( struct stream_application *app ) {
}
/* 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 ) );

591
src/net/tcp.c
View File

File diff suppressed because it is too large Load Diff

111
src/net/tcp/ftp.c
View File

@ -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 );

50
src/net/tcp/http.c
View File

@ -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;

103
src/net/tcp/iscsi.c
View File

@ -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;
}
}