Merge branch 'master' into mcb-tcp-xfer
authorMichael Brown <mcb30@etherboot.org>
Sat, 9 Jun 2007 21:58:27 +0000 (22:58 +0100)
committerMichael Brown <mcb30@etherboot.org>
Sat, 9 Jun 2007 21:58:27 +0000 (22:58 +0100)
20 files changed:
src/arch/i386/include/stdarg.h [new file with mode: 0644]
src/core/downloader.c
src/core/image.c
src/core/linebuf.c
src/core/open.c
src/core/posix_io.c
src/core/resolv.c
src/image/script.c
src/include/gpxe/downloader.h
src/include/gpxe/ftp.h
src/include/gpxe/http.h
src/include/gpxe/linebuf.h
src/include/gpxe/open.h
src/include/gpxe/resolv.h
src/include/gpxe/tcp.h
src/net/tcp.c
src/net/tcp/ftp.c
src/net/tcp/http.c
src/net/udp/dns.c
src/usr/imgmgmt.c

diff --git a/src/arch/i386/include/stdarg.h b/src/arch/i386/include/stdarg.h
new file mode 100644 (file)
index 0000000..1742cb3
--- /dev/null
@@ -0,0 +1,22 @@
+#ifndef _STDARG_H
+#define _STDARG_H
+
+typedef void * va_list;
+
+#define va_start( ap, last ) do {      \
+               ap = ( &last + 1 );     \
+       } while ( 0 )
+
+#define va_arg( ap, type ) ({          \
+               type *_this = ap;       \
+               ap = ( _this + 1 );     \
+               *(_this);               \
+       })
+
+#define va_end( ap ) do { } while ( 0 )
+
+#define va_copy( dest, src ) do {      \
+               dest = src;             \
+       } while ( 0 )
+
+#endif /* _STDARG_H */
index 15ef962..eec0c57 100644 (file)
@@ -17,6 +17,7 @@
  */
 
 #include <stdlib.h>
+#include <stdarg.h>
 #include <errno.h>
 #include <gpxe/xfer.h>
 #include <gpxe/open.h>
@@ -243,19 +244,21 @@ static struct xfer_interface_operations downloader_xfer_operations = {
  * Instantiate a downloader
  *
  * @v job              Job control interface
- * @v uri_string       URI string
  * @v image            Image to fill with downloaded file
  * @v register_image   Image registration routine
+ * @v type             Location type to pass to xfer_open()
+ * @v ...              Remaining arguments to pass to xfer_open()
  * @ret rc             Return status code
  *
  * Instantiates a downloader object to download the specified URI into
  * the specified image object.  If the download is successful, the
  * image registration routine @c register_image() will be called.
  */
-int create_downloader ( struct job_interface *job, const char *uri_string,
-                       struct image *image,
-                       int ( * register_image ) ( struct image *image ) ) {
+int create_downloader ( struct job_interface *job, struct image *image,
+                       int ( * register_image ) ( struct image *image ),
+                       int type, ... ) {
        struct downloader *downloader;
+       va_list args;
        int rc;
 
        /* Allocate and initialise structure */
@@ -270,19 +273,21 @@ int create_downloader ( struct job_interface *job, const char *uri_string,
                    &downloader->refcnt );
        downloader->image = image_get ( image );
        downloader->register_image = register_image;
+       va_start ( args, type );
 
        /* Instantiate child objects and attach to our interfaces */
-       if ( ( rc = xfer_open ( &downloader->xfer, LOCATION_URI,
-                               uri_string ) ) != 0 )
+       if ( ( rc = xfer_vopen ( &downloader->xfer, type, args ) ) != 0 )
                goto err;
 
        /* Attach parent interface, mortalise self, and return */
        job_plug_plug ( &downloader->job, job );
        ref_put ( &downloader->refcnt );
+       va_end ( args );
        return 0;
 
  err:
        downloader_finished ( downloader, rc );
        ref_put ( &downloader->refcnt );
+       va_end ( args );
        return rc;
 }
index 5a2ee82..08a129f 100644 (file)
@@ -23,6 +23,7 @@
 #include <errno.h>
 #include <assert.h>
 #include <gpxe/list.h>
+#include <gpxe/umalloc.h>
 #include <gpxe/image.h>
 
 /** @file
@@ -40,6 +41,35 @@ static struct image_type image_types[0]
 static struct image_type image_types_end[0]
        __table_end ( struct image_type, image_types );
 
+/**
+ * Free executable/loadable image
+ *
+ * @v refcnt           Reference counter
+ */
+static void free_image ( struct refcnt *refcnt ) {
+       struct image *image = container_of ( refcnt, struct image, refcnt );
+
+       ufree ( image->data );
+       free ( image );
+       DBGC ( image, "IMAGE %p freed\n", image );
+}
+
+/**
+ * Allocate executable/loadable image
+ *
+ * @ret image          Executable/loadable image
+ */
+struct image * alloc_image ( void ) {
+       struct image *image;
+
+       image = malloc ( sizeof ( *image ) );
+       if ( image ) {
+               memset ( image, 0, sizeof ( *image ) );
+               image->refcnt.free = free_image;
+       }
+       return image;
+}
+
 /**
  * Register executable/loadable image
  *
@@ -56,6 +86,7 @@ int register_image ( struct image *image ) {
        }
 
        /* Add to image list */
+       image_get ( image );
        list_add_tail ( &image->list, &images );
        DBGC ( image, "IMAGE %p at [%lx,%lx) registered as %s\n",
               image, user_to_phys ( image->data, 0 ),
@@ -71,23 +102,10 @@ int register_image ( struct image *image ) {
  */
 void unregister_image ( struct image *image ) {
        list_del ( &image->list );
+       image_put ( image );
        DBGC ( image, "IMAGE %p unregistered\n", image );
 }
 
-/**
- * Move image to start of list of registered images
- *
- * @v image            Executable/loadable image
- *
- * Move the image to the start of the image list.  This makes it
- * easier to keep track of which of the images marked as loaded is
- * likely to still be valid.
- */
-void promote_image ( struct image *image ) {
-       list_del ( &image->list );
-       list_add ( &image->list, &images );
-}
-
 /**
  * Find image by name
  *
index ae72796..d02f37c 100644 (file)
@@ -57,23 +57,20 @@ void empty_line_buffer ( struct line_buffer *linebuf ) {
  * @v linebuf                  Line buffer
  * @v data                     New data to add
  * @v len                      Length of new data to add
- * @ret rc                     Return status code
- * 
- * If line_buffer() returns >0, then an end of line has been reached
- * and the buffered-up line can be obtained from buffered_line().
- * Carriage returns and newlines will have been stripped, and the line
- * will be NUL-terminated.  This buffered line is valid only until the
- * next call to line_buffer() (or to empty_line_buffer()).
+ * @ret len                    Consumed length, or negative error number
  *
- * @c data and @c len will be updated to reflect the data consumed by
- * line_buffer().
+ * After calling line_buffer(), use buffered_line() to determine
+ * whether or not a complete line is available.  Carriage returns and
+ * newlines will have been stripped, and the line will be
+ * NUL-terminated.  This buffered line is valid only until the next
+ * call to line_buffer() (or to empty_line_buffer()).
  *
  * Note that line buffers use dynamically allocated storage; you
  * should call empty_line_buffer() before freeing a @c struct @c
  * line_buffer.
  */
-int line_buffer ( struct line_buffer *linebuf,
-                 const char **data, size_t *len ) {
+ssize_t line_buffer ( struct line_buffer *linebuf,
+                     const char *data, size_t len ) {
        const char *eol;
        size_t consume;
        size_t new_len;
@@ -84,10 +81,10 @@ int line_buffer ( struct line_buffer *linebuf,
                empty_line_buffer ( linebuf );
 
        /* Search for line terminator */
-       if ( ( eol = memchr ( *data, '\n', *len ) ) ) {
-               consume = ( eol - *data + 1 );
+       if ( ( eol = memchr ( data, '\n', len ) ) ) {
+               consume = ( eol - data + 1 );
        } else {
-               consume = *len;
+               consume = len;
        }
 
        /* Reallocate data buffer and copy in new data */
@@ -95,15 +92,11 @@ int line_buffer ( struct line_buffer *linebuf,
        new_data = realloc ( linebuf->data, ( new_len + 1 ) );
        if ( ! new_data )
                return -ENOMEM;
-       memcpy ( ( new_data + linebuf->len ), *data, consume );
+       memcpy ( ( new_data + linebuf->len ), data, consume );
        new_data[new_len] = '\0';
        linebuf->data = new_data;
        linebuf->len = new_len;
 
-       /* Update data and len */
-       *data += consume;
-       *len -= consume;
-
        /* If we have reached end of line, trim the line and mark as ready */
        if ( eol ) {
                linebuf->data[--linebuf->len] = '\0'; /* trim NL */
@@ -112,5 +105,5 @@ int line_buffer ( struct line_buffer *linebuf,
                linebuf->ready = 1;
        }
 
-       return 0;
+       return consume;
 }
index 6c184e6..ea48534 100644 (file)
@@ -46,13 +46,33 @@ static struct socket_opener socket_openers_end[0]
  * Open URI
  *
  * @v xfer             Data transfer interface
+ * @v uri              URI
+ * @ret rc             Return status code
+ */
+int xfer_open_uri ( struct xfer_interface *xfer, struct uri *uri ) {
+       struct uri_opener *opener;
+
+       for ( opener = uri_openers ; opener < uri_openers_end ; opener++ ) {
+               if ( strcmp ( uri->scheme, opener->scheme ) == 0 )
+                       return opener->open ( xfer, uri );
+       }
+
+       DBGC ( xfer, "XFER %p attempted to open unsupported URI scheme "
+              "\"%s\"\n", xfer, uri->scheme );
+       return -ENOTSUP;
+}
+
+/**
+ * Open URI string
+ *
+ * @v xfer             Data transfer interface
  * @v uri_string       URI string (e.g. "http://etherboot.org/kernel")
  * @ret rc             Return status code
  */
-int xfer_open_uri ( struct xfer_interface *xfer, const char *uri_string ) {
+int xfer_open_uri_string ( struct xfer_interface *xfer,
+                          const char *uri_string ) {
        struct uri *uri;
-       struct uri_opener *opener;
-       int rc = -ENOTSUP;
+       int rc;
 
        DBGC ( xfer, "XFER %p opening URI %s\n", xfer, uri_string );
 
@@ -60,16 +80,8 @@ int xfer_open_uri ( struct xfer_interface *xfer, const char *uri_string ) {
        if ( ! uri )
                return -ENOMEM;
 
-       for ( opener = uri_openers ; opener < uri_openers_end ; opener++ ) {
-               if ( strcmp ( uri->scheme, opener->scheme ) == 0 ) {
-                       rc = opener->open ( xfer, uri );
-                       goto done;
-               }
-       }
+       rc = xfer_open_uri ( xfer, uri );
 
-       DBGC ( xfer, "XFER %p attempted to open unsupported URI scheme "
-              "\"%s\"\n", xfer, uri->scheme );
- done:
        uri_put ( uri );
        return rc;
 }
@@ -114,10 +126,12 @@ int xfer_open_socket ( struct xfer_interface *xfer, int semantics,
  */
 int xfer_vopen ( struct xfer_interface *xfer, int type, va_list args ) {
        switch ( type ) {
-       case LOCATION_URI: {
+       case LOCATION_URI_STRING: {
                const char *uri_string = va_arg ( args, const char * );
 
-               return xfer_open_uri ( xfer, uri_string ); }
+               return xfer_open_uri_string ( xfer, uri_string ); }
+       case LOCATION_URI:
+               
        case LOCATION_SOCKET: {
                int semantics = va_arg ( args, int );
                struct sockaddr *peer = va_arg ( args, struct sockaddr * );
index 3b5660e..31db866 100644 (file)
@@ -224,7 +224,7 @@ int open ( const char *uri_string ) {
        INIT_LIST_HEAD ( &file->data );
 
        /* Open URI on data transfer interface */
-       if ( ( rc = xfer_open_uri ( &file->xfer, uri_string ) ) != 0 )
+       if ( ( rc = xfer_open_uri_string ( &file->xfer, uri_string ) ) != 0 )
                goto err;
 
        /* Wait for open to succeed or fail */
index b2fbc93..bee391a 100644 (file)
@@ -21,6 +21,9 @@
 #include <string.h>
 #include <errno.h>
 #include <gpxe/in.h>
+#include <gpxe/xfer.h>
+#include <gpxe/open.h>
+#include <gpxe/process.h>
 #include <gpxe/resolv.h>
 
 /** @file
  *
  */
 
-static struct async_operations resolv_async_operations;
+/***************************************************************************
+ *
+ * Name resolution interfaces
+ *
+ ***************************************************************************
+ */
+
+/**
+ * Name resolution completed
+ *
+ * @v resolv           Name resolution interface
+ * @v sa               Completed socket address (if successful)
+ * @v rc               Final status code
+ */
+void resolv_done ( struct resolv_interface *resolv, struct sockaddr *sa,
+                  int rc ) {
+       struct resolv_interface *dest = resolv_get_dest ( resolv );
+
+       dest->op->done ( dest, sa, rc );
+       resolv_unplug ( resolv );
+       resolv_put ( dest );
+}
+
+/**
+ * Ignore name resolution done() event
+ *
+ * @v resolv           Name resolution interface
+ * @v sa               Completed socket address (if successful)
+ * @v rc               Final status code
+ */
+void ignore_resolv_done ( struct resolv_interface *resolv __unused,
+                         struct sockaddr *sa __unused, int rc __unused ) {
+       /* Do nothing */
+}
+
+/** Null name resolution interface operations */
+struct resolv_interface_operations null_resolv_ops = {
+       .done           = ignore_resolv_done,
+};
+
+/** Null name resolution interface */
+struct resolv_interface null_resolv = {
+       .intf = {
+               .dest = &null_resolv.intf,
+               .refcnt = NULL,
+       },
+       .op = &null_resolv_ops,
+};
+
+/***************************************************************************
+ *
+ * Numeric name resolver
+ *
+ ***************************************************************************
+ */
+
+/** A numeric name resolver */
+struct numeric_resolv {
+       /** Reference counter */
+       struct refcnt refcnt;
+       /** Name resolution interface */
+       struct resolv_interface resolv;
+       /** Process */
+       struct process process;
+       /** Completed socket address */
+       struct sockaddr sa;
+       /** Overall status code */
+       int rc;
+};
+
+static void numeric_step ( struct process *process ) {
+       struct numeric_resolv *numeric =
+               container_of ( process, struct numeric_resolv, process );
+       
+       resolv_done ( &numeric->resolv, &numeric->sa, numeric->rc );
+       process_del ( process );
+}
+
+static int numeric_resolv ( struct resolv_interface *resolv,
+                           const char *name, struct sockaddr *sa ) {
+       struct numeric_resolv *numeric;
+       struct sockaddr_in *sin;
+
+       /* Allocate and initialise structure */
+       numeric = malloc ( sizeof ( *numeric ) );
+       if ( ! numeric )
+               return -ENOMEM;
+       memset ( numeric, 0, sizeof ( *numeric ) );
+       resolv_init ( &numeric->resolv, &null_resolv_ops, &numeric->refcnt );
+       process_init ( &numeric->process, numeric_step, &numeric->refcnt );
+       memcpy ( &numeric->sa, sa, sizeof ( numeric->sa ) );
+
+       DBGC ( numeric, "NUMERIC %p attempting to resolve \"%s\"\n",
+              numeric, name );
+
+       /* Attempt to resolve name */
+       sin = ( ( struct sockaddr_in * ) &numeric->sa );
+       sin->sin_family = AF_INET;
+       if ( inet_aton ( name, &sin->sin_addr ) == 0 )
+               numeric->rc = -EINVAL;
+
+       /* Attach to parent interface, mortalise self, and return */
+       resolv_plug_plug ( &numeric->resolv, resolv );
+       ref_put ( &numeric->refcnt );
+       return 0;
+}
+
+struct resolver numeric_resolver __resolver ( RESOLV_NUMERIC ) = {
+       .name = "NUMERIC",
+       .resolv = numeric_resolv,
+};
+
+/***************************************************************************
+ *
+ * Name resolution multiplexer
+ *
+ ***************************************************************************
+ */
 
 /** Registered name resolvers */
 static struct resolver resolvers[0]
@@ -37,104 +157,262 @@ static struct resolver resolvers[0]
 static struct resolver resolvers_end[0]
        __table_end ( struct resolver, resolvers );
 
+/** A name resolution multiplexer */
+struct resolv_mux {
+       /** Reference counter */
+       struct refcnt refcnt;
+       /** Parent name resolution interface */
+       struct resolv_interface parent;
+
+       /** Child name resolution interface */
+       struct resolv_interface child;
+       /** Current child resolver */
+       struct resolver *resolver;
+
+       /** Socket address to complete */
+       struct sockaddr sa;
+       /** Name to be resolved
+        *
+        * Must be at end of structure
+        */
+       char name[0];
+};
+
 /**
- * Start name resolution
+ * Try current child name resolver
  *
- * @v name             Host name to resolve
- * @v sa               Socket address to fill in
- * @v parent           Parent asynchronous operation
+ * @v mux              Name resolution multiplexer
  * @ret rc             Return status code
  */
-int resolv ( const char *name, struct sockaddr *sa, struct async *parent ) {
-       struct resolution *resolution;
-       struct resolver *resolver;
-       struct sockaddr_in *sin = ( struct sockaddr_in * ) sa;
-       struct in_addr in;
-       int rc = -ENXIO;
+static int resolv_mux_try ( struct resolv_mux *mux ) {
+       struct resolver *resolver = mux->resolver;
+       int rc;
 
-       /* Allocate and populate resolution structure */
-       resolution = malloc ( sizeof ( *resolution ) );
-       if ( ! resolution )
-               return -ENOMEM;
-       memset ( resolution, 0, sizeof ( *resolution ) );
-       async_init ( &resolution->async, &resolv_async_operations, parent );
-
-       /* Check for a dotted quad IP address first */
-       if ( inet_aton ( name, &in ) != 0 ) {
-               DBGC ( resolution, "RESOLV %p saw valid IP address %s\n",
-                      resolution, name );
-               sin->sin_family = AF_INET;
-               sin->sin_addr = in;
-               async_done ( &resolution->async, 0 );
-               return 0;
-       }
+       DBGC ( mux, "RESOLV %p trying method %s\n", mux, resolver->name );
 
-       /* Start up all resolvers */
-       for ( resolver = resolvers ; resolver < resolvers_end ; resolver++ ) {
-               if ( ( rc = resolver->resolv ( name, sa,
-                                              &resolution->async ) ) != 0 ) {
-                       DBGC ( resolution, "RESOLV %p could not start %s: "
-                              "%s\n", resolution, resolver->name,
-                              strerror ( rc ) );
-                       /* Continue to try other resolvers */
-                       continue;
-               }
-               (resolution->pending)++;
+       if ( ( rc = resolver->resolv ( &mux->child, mux->name,
+                                      &mux->sa ) ) != 0 ) {
+               DBGC ( mux, "RESOLV %p could not use method %s: %s\n",
+                      mux, resolver->name, strerror ( rc ) );
+               return rc;
        }
-       if ( ! resolution->pending )
-               goto err;
 
        return 0;
+}
 
- err:
-       async_uninit ( &resolution->async );
-       free ( resolution );
-       return rc;
+/**
+ * Handle done() event from child name resolver
+ *
+ * @v resolv           Child name resolution interface
+ * @v sa               Completed socket address (if successful)
+ * @v rc               Final status code
+ */
+static void resolv_mux_done ( struct resolv_interface *resolv,
+                             struct sockaddr *sa, int rc ) {
+       struct resolv_mux *mux =
+               container_of ( resolv, struct resolv_mux, child );
+
+       /* Unplug child */
+       resolv_unplug ( &mux->child );
+
+       /* If this resolution succeeded, stop now */
+       if ( rc == 0 ) {
+               DBGC ( mux, "RESOLV %p succeeded using method %s\n",
+                      mux, mux->resolver->name );
+               goto finished;
+       }
+
+       /* Attempt next child resolver, if possible */
+       mux->resolver++;
+       if ( mux->resolver >= resolvers_end ) {
+               DBGC ( mux, "RESOLV %p failed to resolve name\n", mux );
+               goto finished;
+       }
+       if ( ( rc = resolv_mux_try ( mux ) ) != 0 )
+               goto finished;
+
+       /* Next resolver is now running */
+       return;
+       
+ finished:
+       resolv_done ( &mux->parent, sa, rc );
 }
 
+/** Name resolution multiplexer operations */
+static struct resolv_interface_operations resolv_mux_child_ops = {
+       .done           = resolv_mux_done,
+};
+
 /**
- * Handle child name resolution completion
+ * Start name resolution
  *
- * @v async            Name resolution asynchronous operation
- * @v signal           SIGCHLD
+ * @v resolv           Name resolution interface
+ * @v name             Name to resolve
+ * @v sa               Socket address to complete
+ * @ret rc             Return status code
  */
-static void resolv_sigchld ( struct async *async,
-                            enum signal signal __unused ) {
-       struct resolution *resolution =
-               container_of ( async, struct resolution, async );
+int resolv ( struct resolv_interface *resolv, const char *name,
+            struct sockaddr *sa ) {
+       struct resolv_mux *mux;
+       size_t name_len = ( strlen ( name ) + 1 );
        int rc;
 
-       /* Reap the child */
-       async_wait ( async, &rc, 1 );
+       /* Allocate and initialise structure */
+       mux = malloc ( sizeof ( *mux ) + name_len );
+       if ( ! mux )
+               return -ENOMEM;
+       memset ( mux, 0, sizeof ( *mux ) );
+       resolv_init ( &mux->parent, &null_resolv_ops, &mux->refcnt );
+       resolv_init ( &mux->child, &resolv_mux_child_ops, &mux->refcnt );
+       mux->resolver = resolvers;
+       memcpy ( &mux->sa, sa, sizeof ( mux->sa ) );
+       memcpy ( mux->name, name, name_len );
+
+       DBGC ( mux, "RESOLV %p attempting to resolve \"%s\"\n", mux, name );
 
-       /* If this child succeeded, kill all the others.  They should
-        * immediately die (invoking resolv_sigchld() again, which
-        * won't do anything because the exit status is non-zero and
-        * the pending count won't reach zero until this instance
-        * completes).
+       /* Start first resolver in chain.  There will always be at
+        * least one resolver (the numeric resolver), so no need to
+        * check for the zero-resolvers-available case.
         */
-       if ( rc == 0 )
-               async_signal_children ( async, SIGKILL );
+       if ( ( rc = resolv_mux_try ( mux ) ) != 0 )
+               goto err;
+
+       /* Attach parent interface, mortalise self, and return */
+       resolv_plug_plug ( &mux->parent, resolv );
+       ref_put ( &mux->refcnt );
+       return 0;
 
-       /* When we have no children left, exit */
-       if ( --(resolution->pending) == 0 )
-               async_done ( async, rc );
+ err:
+       ref_put ( &mux->refcnt );
+       return rc;      
 }
 
+/***************************************************************************
+ *
+ * Named socket opening
+ *
+ ***************************************************************************
+ */
+
+/** A named socket */
+struct named_socket {
+       /** Reference counter */
+       struct refcnt refcnt;
+       /** Data transfer interface */
+       struct xfer_interface xfer;
+       /** Name resolution interface */
+       struct resolv_interface resolv;
+       /** Communication semantics (e.g. SOCK_STREAM) */
+       int semantics;
+       /** Stored local socket address, if applicable */
+       struct sockaddr local;
+       /** Stored local socket address exists */
+       int have_local;
+};
+
 /**
- * Free name resolution structure
+ * Handle seek() event
  *
- * @v async            Asynchronous operation
+ * @v xfer             Data transfer interface
+ * @v offset           Offset to new position
+ * @v whence           Basis for new position
+ * @ret rc             Return status code
  */
-static void resolv_reap ( struct async *async ) {
-       free ( container_of ( async, struct resolution, async ) );
+static int resolv_xfer_seek ( struct xfer_interface *xfer __unused,
+                             off_t offset __unused, int whence __unused ) {
+       /* Never ready to accept data */
+       return -EAGAIN;
 }
 
-/** Name resolution asynchronous operations */
-static struct async_operations resolv_async_operations = {
-       .reap = resolv_reap,
-       .signal = {
-               [SIGKILL] = async_signal_children,
-               [SIGCHLD] = resolv_sigchld,
-       },
+/** Named socket opener data transfer interface operations */
+static struct xfer_interface_operations named_xfer_ops = {
+       .close          = ignore_xfer_close,
+       .vredirect      = ignore_xfer_vredirect,
+       .request        = ignore_xfer_request,
+       .seek           = resolv_xfer_seek,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = xfer_deliver_as_raw,
+       .deliver_raw    = ignore_xfer_deliver_raw,
 };
+
+/**
+ * Handle done() event
+ *
+ * @v resolv           Name resolution interface
+ * @v sa               Completed socket address (if successful)
+ * @v rc               Final status code
+ */
+static void named_resolv_done ( struct resolv_interface *resolv,
+                               struct sockaddr *sa, int rc ) {
+       struct named_socket *named =
+               container_of ( resolv, struct named_socket, resolv );
+
+       /* Unplug resolver and nullify data transfer interface */
+       resolv_unplug ( &named->resolv );
+       xfer_nullify ( &named->xfer );
+
+       /* Redirect if name resolution was successful */
+       if ( rc == 0 ) {
+               rc = xfer_redirect ( &named->xfer, LOCATION_SOCKET,
+                                    named->semantics, sa,
+                                    ( named->have_local ?
+                                      &named->local : NULL ) );
+       }
+
+       /* Close data transfer interface if redirection failed */
+       if ( rc != 0 )
+               xfer_close ( &named->xfer, rc );
+
+       /* Unplug data transfer interface */
+       xfer_unplug ( &named->xfer );
+}
+
+/** Named socket opener name resolution interface operations */
+static struct resolv_interface_operations named_resolv_ops = {
+       .done           = named_resolv_done,
+};
+
+/**
+ * Open named socket
+ *
+ * @v semantics                Communication semantics (e.g. SOCK_STREAM)
+ * @v peer             Peer socket address to complete
+ * @v name             Name to resolve
+ * @v local            Local socket address, or NULL
+ * @ret rc             Return status code
+ */
+int xfer_open_named_socket ( struct xfer_interface *xfer, int semantics,
+                            struct sockaddr *peer, const char *name,
+                            struct sockaddr *local ) {
+       struct named_socket *named;
+       int rc;
+
+       /* Allocate and initialise structure */
+       named = malloc ( sizeof ( *named ) );
+       if ( ! named )
+               return -ENOMEM;
+       memset ( named, 0, sizeof ( *named ) );
+       xfer_init ( &named->xfer, &named_xfer_ops, &named->refcnt );
+       resolv_init ( &named->resolv, &named_resolv_ops, &named->refcnt );
+       named->semantics = semantics;
+       if ( local ) {
+               memcpy ( &named->local, local, sizeof ( named->local ) );
+               named->have_local = 1;
+       }
+
+       DBGC ( named, "RESOLV %p opening named socket \"%s\"\n",
+              named, name );
+
+       /* Start name resolution */
+       if ( ( rc = resolv ( &named->resolv, name, peer ) ) != 0 )
+               goto err;
+
+       /* Attach parent interface, mortalise self, and return */
+       xfer_plug_plug ( &named->xfer, xfer );
+       ref_put ( &named->refcnt );
+       return 0;
+
+ err:
+       ref_put ( &named->refcnt );
+       return rc;
+}
index 8443243..8e511d2 100644 (file)
@@ -44,6 +44,13 @@ static int script_exec ( struct image *image ) {
        char *eol;
        int rc;
 
+       /* Temporarily de-register image, so that a "boot" command
+        * doesn't throw us into an execution loop.  Hold a reference
+        * to avoid the image's being freed.
+        */
+       image_get ( image );
+       unregister_image ( image );
+
        while ( offset < image->len ) {
        
                /* Read up to cmdbuf bytes from script into buffer */
@@ -60,7 +67,8 @@ static int script_exec ( struct image *image ) {
                if ( ! eol ) {
                        DBG ( "Script line too long (max %d bytes)\n",
                              sizeof ( cmdbuf ) );
-                       return -ENOEXEC;
+                       rc = -ENOEXEC;
+                       goto done;
                }
 
                /* Mark end of line and execute command */
@@ -69,14 +77,19 @@ static int script_exec ( struct image *image ) {
                if ( ( rc = system ( cmdbuf ) ) != 0 ) {
                        DBG ( "Command \"%s\" exited with status %d\n",
                              cmdbuf, rc );
-                       return rc;
+                       goto done;
                }
                
                /* Move to next line */
                offset += ( ( eol - cmdbuf ) + 1 );
        }
 
-       return 0;
+       rc = 0;
+ done:
+       /* Re-register image and return */
+       register_image ( image );
+       image_put ( image );
+       return rc;
 }
 
 /**
index 956bbce..33aa769 100644 (file)
@@ -10,8 +10,8 @@
 struct job_interface;
 struct image;
 
-extern int create_downloader ( struct job_interface *job,
-                              const char *uri_string, struct image *image,
-                              int ( * register_image ) ( struct image * ) );
+extern int create_downloader ( struct job_interface *job, struct image *image,
+                              int ( * register_image ) ( struct image *image ),
+                              int type, ... );
 
 #endif /* _GPXE_DOWNLOADER_H */
index 41eca8c..370285c 100644 (file)
@@ -7,63 +7,7 @@
  *
  */
 
-#include <stdint.h>
-#include <gpxe/async.h>
-#include <gpxe/stream.h>
-
-struct buffer;
-
 /** FTP default port */
 #define FTP_PORT 21
 
-/**
- * FTP states
- *
- * These @b must be sequential, i.e. a successful FTP session must
- * pass through each of these states in order.
- */
-enum ftp_state {
-       FTP_CONNECT = 0,
-       FTP_USER,
-       FTP_PASS,
-       FTP_TYPE,
-       FTP_PASV,
-       FTP_RETR,
-       FTP_QUIT,
-       FTP_DONE,
-};
-
-/**
- * An FTP request
- *
- */
-struct ftp_request {
-       /** URI being fetched */
-       struct uri *uri;
-       /** Data buffer to fill */
-       struct buffer *buffer;
-       /** Asynchronous operation */
-       struct async async;
-
-       /** Current state */
-       enum ftp_state state;
-       /** Amount of current message already transmitted */
-       size_t already_sent;
-       /** Buffer to be filled with data received via the control channel */
-       char *recvbuf;
-       /** Remaining size of recvbuf */
-       size_t recvsize;
-       /** FTP status code, as text */
-       char status_text[4];
-       /** Passive-mode parameters, as text */
-       char passive_text[24]; /* "aaa,bbb,ccc,ddd,eee,fff" */
-       /** 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,
-                    struct async *parent );
-
 #endif /* _GPXE_FTP_H */
index 5490f43..a2abec1 100644 (file)
@@ -7,56 +7,10 @@
  *
  */
 
-#include <stdint.h>
-#include <gpxe/stream.h>
-#include <gpxe/async.h>
-#include <gpxe/linebuf.h>
-#include <gpxe/uri.h>
-
 /** HTTP default port */
 #define HTTP_PORT 80
 
 /** HTTPS default port */
 #define HTTPS_PORT 443
 
-/** HTTP receive state */
-enum http_rx_state {
-       HTTP_RX_RESPONSE = 0,
-       HTTP_RX_HEADER,
-       HTTP_RX_DATA,
-       HTTP_RX_DEAD,
-};
-
-/**
- * An HTTP request
- *
- */
-struct http_request {
-       /** URI being fetched */
-       struct uri *uri;
-       /** Data buffer to fill */
-       struct buffer *buffer;
-       /** Asynchronous operation */
-       struct async async;
-
-       /** HTTP response code */
-       unsigned int response;
-       /** HTTP Content-Length */
-       size_t content_length;
-
-       /** Server address */
-       struct sockaddr server;
-       /** Stream application for this request */
-       struct stream_application stream;
-       /** Number of bytes already sent */
-       size_t tx_offset;
-       /** RX state */
-       enum http_rx_state rx_state;
-       /** Line buffer for received header lines */
-       struct line_buffer linebuf;
-};
-
-extern int http_get ( struct uri *uri, struct buffer *buffer,
-                     struct async *parent );
-
 #endif /* _GPXE_HTTP_H */
index 5d81539..676731a 100644 (file)
@@ -21,8 +21,8 @@ struct line_buffer {
 };
 
 extern char * buffered_line ( struct line_buffer *linebuf );
-extern int line_buffer ( struct line_buffer *linebuf,
-                        const char **data, size_t *len );
+extern ssize_t line_buffer ( struct line_buffer *linebuf,
+                            const char *data, size_t len );
 extern void empty_line_buffer ( struct line_buffer *linebuf );
 
 #endif /* _GPXE_LINEBUF_H */
index 5e36848..abba29c 100644 (file)
@@ -15,13 +15,20 @@ struct sockaddr;
 
 /** Location types */
 enum {
+       /** Location is a URI
+        *
+        * Parameter list for open() is:
+        *
+        * struct uri *uri;
+        */
+       LOCATION_URI = 1,
        /** Location is a URI string
         *
         * Parameter list for open() is:
         *
         * const char *uri_string;
         */
-       LOCATION_URI = 1,
+       LOCATION_URI_STRING,
        /** Location is a socket
         *
         * Parameter list for open() is:
@@ -73,8 +80,9 @@ struct socket_opener {
 /** Register a socket opener */
 #define __socket_opener __table ( struct socket_opener, socket_openers, 01 )
 
-extern int xfer_open_uri ( struct xfer_interface *xfer,
-                          const char *uri_string );
+extern int xfer_open_uri ( struct xfer_interface *xfer, struct uri *uri );
+extern int xfer_open_uri_string ( struct xfer_interface *xfer,
+                                 const char *uri_string );
 extern int xfer_open_named_socket ( struct xfer_interface *xfer,
                                    int semantics, struct sockaddr *peer,
                                    const char *name, struct sockaddr *local );
index 7136401..4a4de4c 100644 (file)
  *
  */
 
+#include <gpxe/refcnt.h>
+#include <gpxe/interface.h>
+#include <gpxe/tables.h>
+
 struct sockaddr;
+struct resolv_interface;
 
-#include <gpxe/async.h>
-#include <gpxe/tables.h>
+/** Name resolution interface operations */
+struct resolv_interface_operations {
+       /** Name resolution completed
+        *
+        * @v resolv            Name resolution interface
+        * @v sa                Completed socket address (if successful)
+        * @v rc                Final status code
+        */
+       void ( * done ) ( struct resolv_interface *resolv,
+                         struct sockaddr *sa, int rc );
+};
+
+/** A name resolution interface */
+struct resolv_interface {
+       /** Generic object communication interface */
+       struct interface intf;
+       /** Operations for received messages */
+       struct resolv_interface_operations *op;
+};
+
+extern struct resolv_interface null_resolv;
+extern struct resolv_interface_operations null_resolv_ops;
+
+/**
+ * Initialise a name resolution interface
+ *
+ * @v resolv           Name resolution interface
+ * @v op               Name resolution interface operations
+ * @v refcnt           Containing object reference counter, or NULL
+ */
+static inline void resolv_init ( struct resolv_interface *resolv,
+                                struct resolv_interface_operations *op,
+                                struct refcnt *refcnt ) {
+       resolv->intf.dest = &null_resolv.intf;
+       resolv->intf.refcnt = refcnt;
+       resolv->op = op;
+}
+
+/**
+ * Get name resolution interface from generic object communication interface
+ *
+ * @v intf             Generic object communication interface
+ * @ret resolv         Name resolution interface
+ */
+static inline __attribute__ (( always_inline )) struct resolv_interface *
+intf_to_resolv ( struct interface *intf ) {
+       return container_of ( intf, struct resolv_interface, intf );
+}
+
+/**
+ * Get reference to destination name resolution interface
+ *
+ * @v resolv           Name resolution interface
+ * @ret dest           Destination interface
+ */
+static inline __attribute__ (( always_inline )) struct resolv_interface *
+resolv_get_dest ( struct resolv_interface *resolv ) {
+       return intf_to_resolv ( intf_get ( resolv->intf.dest ) );
+}
+
+/**
+ * Drop reference to name resolution interface
+ *
+ * @v resolv           name resolution interface
+ */
+static inline __attribute__ (( always_inline )) void
+resolv_put ( struct resolv_interface *resolv ) {
+       intf_put ( &resolv->intf );
+}
+
+/**
+ * Plug a name resolution interface into a new destination interface
+ *
+ * @v resolv           Name resolution interface
+ * @v dest             New destination interface
+ */
+static inline __attribute__ (( always_inline )) void
+resolv_plug ( struct resolv_interface *resolv, struct resolv_interface *dest ) {
+       plug ( &resolv->intf, &dest->intf );
+}
+
+/**
+ * Plug two name resolution interfaces together
+ *
+ * @v a                        Name resolution interface A
+ * @v b                        Name resolution interface B
+ */
+static inline __attribute__ (( always_inline )) void
+resolv_plug_plug ( struct resolv_interface *a, struct resolv_interface *b ) {
+       plug_plug ( &a->intf, &b->intf );
+}
+
+/**
+ * Unplug a name resolution interface
+ *
+ * @v resolv           Name resolution interface
+ */
+static inline __attribute__ (( always_inline )) void
+resolv_unplug ( struct resolv_interface *resolv ) {
+       plug ( &resolv->intf, &null_resolv.intf );
+}
+
+/**
+ * Stop using a name resolution interface
+ *
+ * @v resolv           Name resolution interface
+ *
+ * After calling this method, no further messages will be received via
+ * the interface.
+ */
+static inline void resolv_nullify ( struct resolv_interface *resolv ) {
+       resolv->op = &null_resolv_ops;
+};
 
 /** A name resolver */
 struct resolver {
@@ -18,30 +134,26 @@ struct resolver {
        const char *name;
        /** Start name resolution
         *
-        * @v name              Host name to resolve
-        * @v sa                Socket address to fill in
-        * @v parent            Parent asynchronous operation
+        * @v resolv            Name resolution interface
+        * @v name              Name to resolve
+        * @v sa                Socket address to complete
         * @ret rc              Return status code
-        *
-        * The asynchronous process must be prepared to accept
-        * SIGKILL.
         */
-       int ( * resolv ) ( const char *name, struct sockaddr *sa,
-                          struct async *parent );
+       int ( * resolv ) ( struct resolv_interface *resolv, const char *name,
+                          struct sockaddr *sa );
 };
 
-/** A name resolution in progress */
-struct resolution {
-       /** Asynchronous operation */
-       struct async async;
-       /** Numner of active child resolvers */
-       unsigned int pending;
-};
+/** Numeric resolver priority */
+#define RESOLV_NUMERIC 01
+
+/** Normal resolver priority */
+#define RESOLV_NORMAL 02
 
 /** Register as a name resolver */
-#define __resolver __table ( struct resolver, resolvers, 01 )
+#define __resolver( resolv_order ) \
+       __table ( struct resolver, resolvers, resolv_order )
 
-extern int resolv ( const char *name, struct sockaddr *sa,
-                   struct async *parent );
+extern int resolv ( struct resolv_interface *resolv, const char *name,
+                   struct sockaddr *sa );
 
 #endif /* _GPXE_RESOLV_H */
index f16ca08..ba9ae0e 100644 (file)
@@ -253,8 +253,6 @@ struct tcp_mss_option {
  */
 #define TCP_MSL ( 2 * 60 * TICKS_PER_SEC )
 
-extern int tcp_open ( struct stream_application *app );
-
 extern struct tcpip_protocol tcp_protocol;
 
 #endif /* _GPXE_TCP_H */
index 909f58f..830e8d5 100644 (file)
@@ -8,7 +8,10 @@
 #include <gpxe/iobuf.h>
 #include <gpxe/malloc.h>
 #include <gpxe/retry.h>
-#include <gpxe/stream.h>
+#include <gpxe/refcnt.h>
+#include <gpxe/xfer.h>
+#include <gpxe/open.h>
+#include <gpxe/uri.h>
 #include <gpxe/tcpip.h>
 #include <gpxe/tcp.h>
 
  *
  */
 
-struct tcp_connection;
-static void tcp_expired ( struct retry_timer *timer, int over );
-static int tcp_senddata_conn ( struct tcp_connection *tcp, int force_send );
-static struct stream_connection_operations tcp_op;
-
-/**
- * A TCP connection
- *
- * This data structure represents the internal state of a TCP
- * connection.
- */
+/** A TCP connection */
 struct tcp_connection {
-       /** The stream connection */
-       struct stream_connection stream;
+       /** Reference counter */
+       struct refcnt refcnt;
        /** List of TCP connections */
        struct list_head list;
 
+       /** Data transfer interface */
+       struct xfer_interface xfer;
+       /** Data transfer interface closed flag */
+       int xfer_closed;
+
        /** Remote socket address */
        struct sockaddr_tcpip peer;
        /** Local port, in network byte order */
-       uint16_t local_port;
+       unsigned int local_port;
 
        /** Current TCP state */
        unsigned int tcp_state;
@@ -68,12 +66,8 @@ struct tcp_connection {
         */
        uint32_t rcv_ack;
 
-       /** Transmit I/O buffer
-        *
-        * This buffer is allocated prior to calling the application's
-        * senddata() method, to provide temporary storage space.
-        */
-       struct io_buffer *tx_iob;
+       /** Transmit queue */
+       struct list_head queue;
        /** Retransmission timer */
        struct retry_timer timer;
 };
@@ -83,6 +77,12 @@ struct tcp_connection {
  */
 static LIST_HEAD ( tcp_conns );
 
+/* Forward declarations */
+static struct xfer_interface_operations tcp_xfer_operations;
+static void tcp_expired ( struct retry_timer *timer, int over );
+static int tcp_rx_ack ( struct tcp_connection *tcp, uint32_t ack,
+                       uint32_t win );
+
 /**
  * Name TCP state
  *
@@ -141,70 +141,207 @@ tcp_dump_flags ( struct tcp_connection *tcp, unsigned int flags ) {
                DBGC ( tcp, " ACK" );
 }
 
+/***************************************************************************
+ *
+ * Open and close
+ *
+ ***************************************************************************
+ */
+
 /**
- * Allocate TCP connection
+ * Bind TCP connection to local port
  *
- * @ret conn           TCP connection, or NULL
+ * @v tcp              TCP connection
+ * @v port             Local port number, in network-endian order
+ * @ret rc             Return status code
  *
- * Allocates TCP connection and adds it to the TCP connection list.
+ * If the port is 0, the connection is assigned an available port
+ * between 1024 and 65535.
  */
-static struct tcp_connection * alloc_tcp ( void ) {
-       struct tcp_connection *tcp;
+static int tcp_bind ( struct tcp_connection *tcp, unsigned int port ) {
+       struct tcp_connection *existing;
+       static uint16_t try_port = 1024;
 
-       tcp = malloc ( sizeof ( *tcp ) );
-       if ( tcp ) {
-               DBGC ( tcp, "TCP %p allocated\n", tcp );
-               memset ( tcp, 0, sizeof ( *tcp ) );
-               tcp->tcp_state = tcp->prev_tcp_state = TCP_CLOSED;
-               tcp->snd_seq = random();
-               tcp->timer.expired = tcp_expired;
-               tcp->stream.op = &tcp_op;
-               list_add ( &tcp->list, &tcp_conns );
+       /* If no port specified, find the first available port */
+       if ( ! port ) {
+               for ( ; try_port ; try_port++ ) {
+                       if ( try_port < 1024 )
+                               continue;
+                       if ( tcp_bind ( tcp, htons ( try_port ) ) == 0 )
+                               return 0;
+               }
+               DBGC ( tcp, "TCP %p could not bind: no free ports\n", tcp );
+               return -EADDRINUSE;
        }
-       return tcp;
+
+       /* Attempt bind to local port */
+       list_for_each_entry ( existing, &tcp_conns, list ) {
+               if ( existing->local_port == port ) {
+                       DBGC ( tcp, "TCP %p could not bind: port %d in use\n",
+                              tcp, ntohs ( port ) );
+                       return -EADDRINUSE;
+               }
+       }
+       tcp->local_port = port;
+
+       DBGC ( tcp, "TCP %p bound to port %d\n", tcp, ntohs ( port ) );
+       return 0;
 }
 
 /**
- * Free TCP connection
- *
- * @v tcp              TCP connection
+ * Open a TCP connection
  *
- * Removes connection from TCP connection list and frees the data
- * structure.
+ * @v xfer             Data transfer interface
+ * @v peer             Peer socket address
+ * @v local            Local socket address, or NULL
+ * @ret rc             Return status code
  */
-static void free_tcp ( struct tcp_connection *tcp ) {
+static int tcp_open ( struct xfer_interface *xfer, struct sockaddr *peer,
+                     struct sockaddr *local ) {
+       struct sockaddr_tcpip *st_peer = ( struct sockaddr_tcpip * ) peer;
+       struct sockaddr_tcpip *st_local = ( struct sockaddr_tcpip * ) local;
+       struct tcp_connection *tcp;
+       unsigned int bind_port;
+       int rc;
 
-       assert ( tcp );
-       assert ( tcp->tcp_state == TCP_CLOSED );
+       /* Allocate and initialise structure */
+       tcp = malloc ( sizeof ( *tcp ) );
+       if ( ! tcp )
+               return -ENOMEM;
+       DBGC ( tcp, "TCP %p allocated\n", tcp );
+       memset ( tcp, 0, sizeof ( *tcp ) );
+       xfer_init ( &tcp->xfer, &tcp_xfer_operations, &tcp->refcnt );
+       tcp->prev_tcp_state = TCP_CLOSED;
+       tcp->tcp_state = TCP_STATE_SENT ( TCP_SYN );
+       tcp_dump_state ( tcp );
+       tcp->snd_seq = random();
+       INIT_LIST_HEAD ( &tcp->queue );
+       tcp->timer.expired = tcp_expired;
+       memcpy ( &tcp->peer, st_peer, sizeof ( tcp->peer ) );
 
-       stop_timer ( &tcp->timer );
-       list_del ( &tcp->list );
-       free ( tcp );
-       DBGC ( tcp, "TCP %p freed\n", tcp );
+       /* Bind to local port */
+       bind_port = ( st_local ? st_local->st_port : 0 );
+       if ( ( rc = tcp_bind ( tcp, bind_port ) ) != 0 )
+               goto err;
+
+       /* Start timer to initiate SYN */
+       start_timer ( &tcp->timer );
+
+       /* Attach parent interface, transfer reference to connection
+        * list and return
+        */
+       xfer_plug_plug ( &tcp->xfer, xfer );
+       list_add ( &tcp->list, &tcp_conns );
+       return 0;
+
+ err:
+       ref_put ( &tcp->refcnt );
+       return rc;
 }
 
 /**
- * Abort TCP connection
+ * Close TCP connection
  *
  * @v tcp              TCP connection
- * @v send_rst         Send a RST after closing
- * @v rc               Reason code
+ * @v rc               Reason for close
+ *
+ * Closes the data transfer interface.  If the TCP state machine is in
+ * a suitable state, the connection will be deleted.
  */
-static void tcp_abort ( struct tcp_connection *tcp, int send_rst, int rc ) {
+static void tcp_close ( struct tcp_connection *tcp, int rc ) {
+       struct io_buffer *iobuf;
+       struct io_buffer *tmp;
 
-       /* Transition to CLOSED */
-       tcp->tcp_state = TCP_CLOSED;
-       tcp_dump_state ( tcp );
+       /* Close data transfer interface */
+       xfer_nullify ( &tcp->xfer );
+       xfer_close ( &tcp->xfer, rc );
+       tcp->xfer_closed = 1;
 
-       /* Send RST if requested to do so */
-       if ( send_rst )
-               tcp_senddata_conn ( tcp, 1 );
+       /* If we are in CLOSED, or have otherwise not yet received a
+        * SYN (i.e. we are in LISTEN or SYN_SENT), just delete the
+        * connection.
+        */
+       if ( ! ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) {
 
-       /* Close stream */
-       stream_closed ( &tcp->stream, rc );
+               /* Transition to CLOSED for the sake of debugging messages */
+               tcp->tcp_state = TCP_CLOSED;
+               tcp_dump_state ( tcp );
 
-       /* Free the connection */
-       free_tcp ( tcp );
+               /* Free any unsent I/O buffers */
+               list_for_each_entry_safe ( iobuf, tmp, &tcp->queue, list ) {
+                       list_del ( &iobuf->list );
+                       free_iob ( iobuf );
+               }
+
+               /* Remove from list and drop reference */
+               stop_timer ( &tcp->timer );
+               list_del ( &tcp->list );
+               ref_put ( &tcp->refcnt );
+               DBGC ( tcp, "TCP %p connection deleted\n", tcp );
+               return;
+       }
+
+       /* If we have not had our SYN acknowledged (i.e. we are in
+        * SYN_RCVD), pretend that it has been acknowledged so that we
+        * can send a FIN without breaking things.
+        */
+       if ( ! ( tcp->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) )
+               tcp_rx_ack ( tcp, ( tcp->snd_seq + 1 ), 0 );
+
+       /* If we have no data remaining to send, start sending FIN */
+       if ( list_empty ( &tcp->queue ) ) {
+               tcp->tcp_state |= TCP_STATE_SENT ( TCP_FIN );
+               tcp_dump_state ( tcp );
+       }
+}
+
+/***************************************************************************
+ *
+ * Transmit data path
+ *
+ ***************************************************************************
+ */
+
+/**
+ * Process TCP transmit queue
+ *
+ * @v tcp              TCP connection
+ * @v max_len          Maximum length to process
+ * @v dest             I/O buffer to fill with data, or NULL
+ * @v remove           Remove data from queue
+ * @ret len            Length of data processed
+ *
+ * This processes at most @c max_len bytes from the TCP connection's
+ * transmit queue.  Data will be copied into the @c dest I/O buffer
+ * (if provided) and, if @c remove is true, removed from the transmit
+ * queue.
+ */
+static size_t tcp_process_queue ( struct tcp_connection *tcp, size_t max_len,
+                                 struct io_buffer *dest, int remove ) {
+       struct io_buffer *iobuf;
+       struct io_buffer *tmp;
+       size_t frag_len;
+       size_t len = 0;
+
+       list_for_each_entry_safe ( iobuf, tmp, &tcp->queue, list ) {
+               frag_len = iob_len ( iobuf );
+               if ( frag_len > max_len )
+                       frag_len = max_len;
+               if ( dest ) {
+                       memcpy ( iob_put ( dest, frag_len ), iobuf->data,
+                                frag_len );
+               }
+               if ( remove ) {
+                       iob_pull ( iobuf, frag_len );
+                       if ( ! iob_len ( iobuf ) ) {
+                               list_del ( &iobuf->list );
+                               free_iob ( iobuf );
+                       }
+               }
+               len += frag_len;
+               max_len -= frag_len;
+       }
+       return len;
 }
 
 /**
@@ -213,80 +350,65 @@ static void tcp_abort ( struct tcp_connection *tcp, int send_rst, int rc ) {
  * @v tcp              TCP connection
  * @v force_send       Force sending of packet
  * 
- * Transmits any outstanding data on the connection.  If the
- * connection is in a connected state, the application's senddata()
- * method will be called to generate the data payload, if any.
+ * Transmits any outstanding data on the connection.
  *
  * Note that even if an error is returned, the retransmission timer
  * will have been started if necessary, and so the stack will
  * eventually attempt to retransmit the failed packet.
  */
-static int tcp_senddata_conn ( struct tcp_connection *tcp, int force_send ) {
+static int tcp_xmit ( struct tcp_connection *tcp, int force_send ) {
        struct io_buffer *iobuf;
        struct tcp_header *tcphdr;
        struct tcp_mss_option *mssopt;
        void *payload;
        unsigned int flags;
-       size_t len;
+       size_t len = 0;
        size_t seq_len;
        size_t window;
        int rc;
 
-       /* Allocate space to the TX buffer */
-       iobuf = alloc_iob ( MAX_IOB_LEN );
-       if ( ! iobuf ) {
-               DBGC ( tcp, "TCP %p could not allocate data buffer\n", tcp );
-               /* Start the retry timer so that we attempt to
-                * retransmit this packet later.  (Start it
-                * unconditionally, since without a I/O buffer we
-                * can't call the senddata() callback, and so may not
-                * be able to tell whether or not we have something
-                * that actually needs to be retransmitted).
-                */
-               start_timer ( &tcp->timer );
-               return -ENOMEM;
-       }
-       iob_reserve ( iobuf, MAX_HDR_LEN );
+       /* If retransmission timer is already running, do nothing */
+       if ( timer_running ( &tcp->timer ) )
+               return 0;
 
-       /* If we are connected, call the senddata() method, which may
-        * call tcp_send() to queue up a data payload.
+       /* Calculate both the actual (payload) and sequence space
+        * lengths that we wish to transmit.
         */
        if ( TCP_CAN_SEND_DATA ( tcp->tcp_state ) ) {
-               tcp->tx_iob = iobuf;
-               stream_senddata ( &tcp->stream, iobuf->data,
-                                 iob_tailroom ( iobuf ) );
-               tcp->tx_iob = NULL;
+               len = tcp_process_queue ( tcp, tcp->snd_win, NULL, 0 );
        }
-
-       /* Truncate payload length to fit transmit window */
-       len = iob_len ( iobuf );
-       if ( len > tcp->snd_win )
-               len = tcp->snd_win;
-
-       /* Calculate amount of sequence space that this transmission
-        * consumes.  (SYN or FIN consume one byte, and we can never
-        * send both at once).
-        */
        seq_len = len;
        flags = TCP_FLAGS_SENDING ( tcp->tcp_state );
-       assert ( ! ( ( flags & TCP_SYN ) && ( flags & TCP_FIN ) ) );
-       if ( flags & ( TCP_SYN | TCP_FIN ) )
+       if ( flags & ( TCP_SYN | TCP_FIN ) ) {
+               /* SYN or FIN consume one byte, and we can never send both */
+               assert ( ! ( ( flags & TCP_SYN ) && ( flags & TCP_FIN ) ) );
                seq_len++;
+       }
        tcp->snd_sent = seq_len;
 
-       /* If we have nothing to transmit, drop the packet */
-       if ( ( seq_len == 0 ) && ! force_send ) {
-               free_iob ( iobuf );
+       /* If we have nothing to transmit, stop now */
+       if ( ( seq_len == 0 ) && ! force_send )
                return 0;
-       }
 
        /* If we are transmitting anything that requires
         * acknowledgement (i.e. consumes sequence space), start the
-        * retransmission timer.
+        * retransmission timer.  Do this before attempting to
+        * allocate the I/O buffer, in case allocation itself fails.
         */
        if ( seq_len )
                start_timer ( &tcp->timer );
 
+       /* Allocate I/O buffer */
+       iobuf = alloc_iob ( len + MAX_HDR_LEN );
+       if ( ! iobuf ) {
+               DBGC ( tcp, "TCP %p could not allocate data buffer\n", tcp );
+               return -ENOMEM;
+       }
+       iob_reserve ( iobuf, MAX_HDR_LEN );
+
+       /* Fill data payload from transmit queue */
+       tcp_process_queue ( tcp, len, iobuf, 0 );
+
        /* Estimate window size */
        window = ( ( freemem * 3 ) / 4 );
        if ( window > TCP_MAX_WINDOW_SIZE )
@@ -334,64 +456,14 @@ static int tcp_senddata_conn ( struct tcp_connection *tcp, int force_send ) {
             ( rc == -ENETUNREACH ) ) {
                DBGC ( tcp, "TCP %p aborting after TX failed: %s\n",
                       tcp, strerror ( rc ) );
-               tcp_abort ( tcp, 0, rc );
+               tcp->tcp_state = TCP_CLOSED;
+               tcp_dump_state ( tcp );
+               tcp_close ( tcp, rc );
        }
 
        return rc;
 }
 
-/**
- * Transmit any outstanding data
- *
- * @v stream           TCP stream
- * 
- * This function allocates space to the transmit buffer and invokes
- * the senddata() callback function, to allow the application to
- * transmit new data.
- */
-static int tcp_kick ( struct stream_connection *stream ) {
-       struct tcp_connection *tcp =
-               container_of ( stream, struct tcp_connection, stream );
-
-       return tcp_senddata_conn ( tcp, 0 );
-}
-
-/**
- * Transmit data
- *
- * @v stream           TCP stream
- * @v data             Data to be sent
- * @v len              Length of the data
- * @ret rc             Return status code
- *
- * This function queues data to be sent via the TCP connection.  It
- * can be called only in the context of an application's senddata()
- * method.
- */
-static int tcp_send ( struct stream_connection *stream,
-                     const void *data, size_t len ) {
-       struct tcp_connection *tcp =
-               container_of ( stream, struct tcp_connection, stream );
-       struct io_buffer *iobuf;
-
-       /* Check that we have a I/O buffer to fill */
-       iobuf = tcp->tx_iob;
-       if ( ! iobuf ) {
-               DBGC ( tcp, "TCP %p tried to send data outside of the "
-                      "senddata() method\n", tcp );
-               return -EINVAL;
-       }
-
-       /* Truncate length to fit I/O buffer */
-       if ( len > iob_tailroom ( iobuf ) )
-               len = iob_tailroom ( iobuf );
-
-       /* Copy payload */
-       memmove ( iob_put ( iobuf, len ), data, len );
-
-       return 0;
-}
-
 /**
  * Retransmission timer expired
  *
@@ -419,10 +491,12 @@ static void tcp_expired ( struct retry_timer *timer, int over ) {
                 * this is the result of a graceful close, terminate
                 * the connection
                 */
-               tcp_abort ( tcp, 1, -ETIMEDOUT );
+               tcp->tcp_state = TCP_CLOSED;
+               tcp_dump_state ( tcp );
+               tcp_close ( tcp, -ETIMEDOUT );
        } else {
                /* Otherwise, retransmit the packet */
-               tcp_senddata_conn ( tcp, 0 );
+               tcp_xmit ( tcp, 0 );
        }
 }
 
@@ -432,7 +506,8 @@ static void tcp_expired ( struct retry_timer *timer, int over ) {
  * @v in_tcphdr                TCP header of incoming packet
  * @ret rc             Return status code
  */
-static int tcp_send_reset ( struct tcp_connection *tcp,
+static int tcp_xmit_reset ( struct tcp_connection *tcp,
+                           struct sockaddr_tcpip *st_dest,
                            struct tcp_header *in_tcphdr ) {
        struct io_buffer *iobuf;
        struct tcp_header *tcphdr;
@@ -466,17 +541,24 @@ static int tcp_send_reset ( struct tcp_connection *tcp,
        DBGC ( tcp, "\n" );
 
        /* Transmit packet */
-       return tcpip_tx ( iobuf, &tcp_protocol, &tcp->peer,
+       return tcpip_tx ( iobuf, &tcp_protocol, st_dest,
                          NULL, &tcphdr->csum );
 }
 
+/***************************************************************************
+ *
+ * Receive data path
+ *
+ ***************************************************************************
+ */
+
 /**
  * Identify TCP connection by local port number
  *
  * @v local_port       Local port (in network-endian order)
  * @ret tcp            TCP connection, or NULL
  */
-static struct tcp_connection * tcp_demux ( uint16_t local_port ) {
+static struct tcp_connection * tcp_demux ( unsigned int local_port ) {
        struct tcp_connection *tcp;
 
        list_for_each_entry ( tcp, &tcp_conns, list ) {
@@ -505,15 +587,11 @@ static int tcp_rx_syn ( struct tcp_connection *tcp, uint32_t seq ) {
 
        /* Mark SYN as received and start sending ACKs with each packet */
        tcp->tcp_state |= ( TCP_STATE_SENT ( TCP_ACK ) |
-                            TCP_STATE_RCVD ( TCP_SYN ) );
+                           TCP_STATE_RCVD ( TCP_SYN ) );
 
        /* Acknowledge SYN */
        tcp->rcv_ack++;
 
-       /* Notify application of established connection, if applicable */
-       if ( ( tcp->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) )
-               stream_connected ( &tcp->stream );
-
        return 0;
 }
 
@@ -529,7 +607,7 @@ static int tcp_rx_ack ( struct tcp_connection *tcp, uint32_t ack,
                        uint32_t win ) {
        size_t ack_len = ( ack - tcp->snd_seq );
        size_t len;
-       unsigned int acked_flags = 0;
+       unsigned int acked_flags;
 
        /* Ignore duplicate or out-of-range ACK */
        if ( ack_len > tcp->snd_sent ) {
@@ -540,18 +618,12 @@ static int tcp_rx_ack ( struct tcp_connection *tcp, uint32_t ack,
                return -EINVAL;
        }
 
-       /* If we are sending flags and this ACK acknowledges all
-        * outstanding sequence points, then it acknowledges the
-        * flags.  (This works since both SYN and FIN will always be
-        * the last outstanding sequence point.)
-        */
+       /* Acknowledge any flags being sent */
        len = ack_len;
-       if ( ack_len == tcp->snd_sent ) {
-               acked_flags = ( TCP_FLAGS_SENDING ( tcp->tcp_state ) &
-                               ( TCP_SYN | TCP_FIN ) );
-               if ( acked_flags )
-                       len--;
-       }
+       acked_flags = ( TCP_FLAGS_SENDING ( tcp->tcp_state ) &
+                       ( TCP_SYN | TCP_FIN ) );
+       if ( acked_flags )
+               len--;
 
        /* Update SEQ and sent counters, and window size */
        tcp->snd_seq = ack;
@@ -561,19 +633,16 @@ static int tcp_rx_ack ( struct tcp_connection *tcp, uint32_t ack,
        /* Stop the retransmission timer */
        stop_timer ( &tcp->timer );
 
-       /* Notify application of acknowledged data, if any */
-       if ( len )
-               stream_acked ( &tcp->stream, len );
-
+       /* Remove any acknowledged data from transmit queue */
+       tcp_process_queue ( tcp, len, NULL, 1 );
+               
        /* Mark SYN/FIN as acknowledged if applicable. */
        if ( acked_flags )
                tcp->tcp_state |= TCP_STATE_ACKED ( acked_flags );
 
-       /* Notify application of established connection, if applicable */
-       if ( ( acked_flags & TCP_SYN ) &&
-            ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) {
-               stream_connected ( &tcp->stream );
-       }
+       /* Start sending FIN if we've had all possible data ACKed */
+       if ( list_empty ( &tcp->queue ) && tcp->xfer_closed )
+               tcp->tcp_state |= TCP_STATE_SENT ( TCP_FIN );
 
        return 0;
 }
@@ -583,27 +652,32 @@ static int tcp_rx_ack ( struct tcp_connection *tcp, uint32_t ack,
  *
  * @v tcp              TCP connection
  * @v seq              SEQ value (in host-endian order)
- * @v data             Data buffer
- * @v len              Length of data buffer
+ * @v iobuf            I/O buffer
  * @ret rc             Return status code
+ *
+ * This function takes ownership of the I/O buffer.
  */
 static int tcp_rx_data ( struct tcp_connection *tcp, uint32_t seq,
-                        void *data, size_t len ) {
+                        struct io_buffer *iobuf ) {
        size_t already_rcvd;
+       size_t len;
+       int rc;
 
        /* Ignore duplicate data */
        already_rcvd = ( tcp->rcv_ack - seq );
-       if ( already_rcvd >= len )
+       len = iob_len ( iobuf );
+       if ( already_rcvd >= len ) {
+               free_iob ( iobuf );
                return 0;
-       data += already_rcvd;
-       len -= already_rcvd;
+       }
+       iob_pull ( iobuf, already_rcvd );
+
+       /* Deliver data to application */
+       if ( ( rc = xfer_deliver_iob ( &tcp->xfer, iobuf ) ) != 0 )
+               return rc;
 
        /* Acknowledge new data */
        tcp->rcv_ack += len;
-
-       /* Notify application */
-       stream_newdata ( &tcp->stream, data, len );
-
        return 0;
 }
 
@@ -620,13 +694,12 @@ static int tcp_rx_fin ( struct tcp_connection *tcp, uint32_t seq ) {
        if ( ( tcp->rcv_ack - seq ) > 0 )
                return 0;
 
-       /* Mark FIN as received, acknowledge it, and send our own FIN */
-       tcp->tcp_state |= ( TCP_STATE_RCVD ( TCP_FIN ) |
-                            TCP_STATE_SENT ( TCP_FIN ) );
+       /* Mark FIN as received and acknowledge it */
+       tcp->tcp_state |= TCP_STATE_RCVD ( TCP_FIN );
        tcp->rcv_ack++;
 
-       /* Close stream */
-       stream_closed ( &tcp->stream, 0 );
+       /* Close connection */
+       tcp_close ( tcp, 0 );
 
        return 0;
 }
@@ -653,8 +726,10 @@ static int tcp_rx_rst ( struct tcp_connection *tcp, uint32_t seq ) {
                        return 0;
        }
 
-       /* Abort connection without sending a RST */
-       tcp_abort ( tcp, 0, -ECONNRESET );
+       /* Abort connection */
+       tcp->tcp_state = TCP_CLOSED;
+       tcp_dump_state ( tcp );
+       tcp_close ( tcp, -ECONNRESET );
 
        return -ECONNRESET;
 }
@@ -669,7 +744,7 @@ static int tcp_rx_rst ( struct tcp_connection *tcp, uint32_t seq ) {
  * @ret rc             Return status code
   */
 static int tcp_rx ( struct io_buffer *iobuf,
-                   struct sockaddr_tcpip *st_src __unused,
+                   struct sockaddr_tcpip *st_src,
                    struct sockaddr_tcpip *st_dest __unused,
                    uint16_t pshdr_csum ) {
        struct tcp_header *tcphdr = iobuf->data;
@@ -681,7 +756,6 @@ static int tcp_rx ( struct io_buffer *iobuf,
        uint32_t ack;
        uint32_t win;
        unsigned int flags;
-       void *data;
        size_t len;
        int rc;
 
@@ -690,27 +764,27 @@ static int tcp_rx ( struct io_buffer *iobuf,
                DBG ( "TCP packet too short at %d bytes (min %d bytes)\n",
                      iob_len ( iobuf ), sizeof ( *tcphdr ) );
                rc = -EINVAL;
-               goto done;
+               goto discard;
        }
        hlen = ( ( tcphdr->hlen & TCP_MASK_HLEN ) / 16 ) * 4;
        if ( hlen < sizeof ( *tcphdr ) ) {
                DBG ( "TCP header too short at %d bytes (min %d bytes)\n",
                      hlen, sizeof ( *tcphdr ) );
                rc = -EINVAL;
-               goto done;
+               goto discard;
        }
        if ( hlen > iob_len ( iobuf ) ) {
                DBG ( "TCP header too long at %d bytes (max %d bytes)\n",
                      hlen, iob_len ( iobuf ) );
                rc = -EINVAL;
-               goto done;
+               goto discard;
        }
        csum = tcpip_continue_chksum ( pshdr_csum, iobuf->data, iob_len ( iobuf ));
        if ( csum != 0 ) {
                DBG ( "TCP checksum incorrect (is %04x including checksum "
                      "field, should be 0000)\n", csum );
                rc = -EINVAL;
-               goto done;
+               goto discard;
        }
        
        /* Parse parameters from header and strip header */
@@ -719,7 +793,7 @@ static int tcp_rx ( struct io_buffer *iobuf,
        ack = ntohl ( tcphdr->ack );
        win = ntohs ( tcphdr->win );
        flags = tcphdr->flags;
-       data = iob_pull ( iobuf, hlen );
+       iob_pull ( iobuf, hlen );
        len = iob_len ( iobuf );
 
        /* Dump header */
@@ -733,16 +807,16 @@ static int tcp_rx ( struct io_buffer *iobuf,
 
        /* If no connection was found, send RST */
        if ( ! tcp ) {
-               tcp_send_reset ( tcp, tcphdr );
+               tcp_xmit_reset ( tcp, st_src, tcphdr );
                rc = -ENOTCONN;
-               goto done;
+               goto discard;
        }
 
        /* Handle ACK, if present */
        if ( flags & TCP_ACK ) {
                if ( ( rc = tcp_rx_ack ( tcp, ack, win ) ) != 0 ) {
-                       tcp_send_reset ( tcp, tcphdr );
-                       goto done;
+                       tcp_xmit_reset ( tcp, st_src, tcphdr );
+                       goto discard;
                }
        }
 
@@ -755,11 +829,11 @@ static int tcp_rx ( struct io_buffer *iobuf,
        /* Handle RST, if present */
        if ( flags & TCP_RST ) {
                if ( ( rc = tcp_rx_rst ( tcp, seq ) ) != 0 )
-                       goto done;
+                       goto discard;
        }
 
        /* Handle new data, if any */
-       tcp_rx_data ( tcp, seq, data, len );
+       tcp_rx_data ( tcp, seq, iobuf );
        seq += len;
 
        /* Handle FIN, if present */
@@ -774,7 +848,7 @@ static int tcp_rx ( struct io_buffer *iobuf,
        /* Send out any pending data.  If peer is expecting an ACK for
         * this packet then force sending a reply.
         */
-       tcp_senddata_conn ( tcp, ( start_seq != seq ) );
+       tcp_xmit ( tcp, ( start_seq != seq ) );
 
        /* If this packet was the last we expect to receive, set up
         * timer to expire and cause the connection to be freed.
@@ -784,177 +858,143 @@ static int tcp_rx ( struct io_buffer *iobuf,
                start_timer ( &tcp->timer );
        }
 
-       rc = 0;
- done:
+       return 0;
+
+ discard:
        /* Free received packet */
        free_iob ( iobuf );
        return rc;
 }
 
-/**
- * Bind TCP connection to local port
+/** TCP protocol */
+struct tcpip_protocol tcp_protocol __tcpip_protocol = {
+       .name = "TCP",
+       .rx = tcp_rx,
+       .tcpip_proto = IP_TCP,
+};
+
+/***************************************************************************
  *
- * @v stream           TCP stream
- * @v local            Local address
- * @ret rc             Return status code
+ * Data transfer interface
  *
- * Only the port portion of the local address is used.  If the local
- * port is 0, the connection is assigned an available port between
- * 1024 and 65535.
+ ***************************************************************************
  */
-static int tcp_bind ( struct stream_connection *stream,
-                     struct sockaddr *local ) {
-       struct tcp_connection *tcp =
-               container_of ( stream, struct tcp_connection, stream );
-       struct sockaddr_tcpip *st = ( ( struct sockaddr_tcpip * ) local );
-       struct tcp_connection *existing;
-       struct sockaddr_tcpip try;
-       static uint16_t try_port = 1024;
-       uint16_t local_port = st->st_port;
 
-       /* If no port specified, find the first available port */
-       if ( ! local_port ) {
-               for ( ; try_port ; try_port++ ) {
-                       if ( try_port < 1024 )
-                               continue;
-                       try.st_port = htons ( try_port );
-                       if ( tcp_bind ( stream,
-                                       ( struct sockaddr * ) &try ) == 0 ) {
-                               return 0;
-                       }
-               }
-               DBGC ( tcp, "TCP %p could not bind: no free ports\n", tcp );
-               return -EADDRINUSE;
-       }
+/**
+ * Close interface
+ *
+ * @v xfer             Data transfer interface
+ * @v rc               Reason for close
+ */
+static void tcp_xfer_close ( struct xfer_interface *xfer, int rc ) {
+       struct tcp_connection *tcp =
+               container_of ( xfer, struct tcp_connection, xfer );
 
-       /* Attempt bind to local port */
-       list_for_each_entry ( existing, &tcp_conns, list ) {
-               if ( existing->local_port == local_port ) {
-                       DBGC ( tcp, "TCP %p could not bind: port %d in use\n",
-                              tcp, ntohs ( local_port ) );
-                       return -EADDRINUSE;
-               }
-       }
-       tcp->local_port = local_port;
+       /* Close data transfer interface */
+       tcp_close ( tcp, rc );
 
-       DBGC ( tcp, "TCP %p bound to port %d\n", tcp, ntohs ( local_port ) );
-       return 0;
+       /* Transmit FIN, if possible */
+       tcp_xmit ( tcp, 0 );
 }
 
 /**
- * Connect to a remote server
+ * Seek to position
  *
- * @v stream           TCP stream
- * @v peer             Remote socket address
+ * @v xfer             Data transfer interface
+ * @v offset           Offset to new position
+ * @v whence           Basis for new position
  * @ret rc             Return status code
- *
- * This function initiates a TCP connection to the socket address specified in
- * peer. It sends a SYN packet to peer. When the connection is established, the
- * TCP stack calls the connected() callback function.
  */
-static int tcp_connect ( struct stream_connection *stream,
-                        struct sockaddr *peer ) {
+static int tcp_xfer_seek ( struct xfer_interface *xfer, off_t offset,
+                          int whence ) {
        struct tcp_connection *tcp =
-               container_of ( stream, struct tcp_connection, stream );
-       struct sockaddr_tcpip *st = ( ( struct sockaddr_tcpip * ) peer );
-       struct sockaddr_tcpip local;
-       int rc;
+               container_of ( xfer, struct tcp_connection, xfer );
 
-       /* Bind to local port if not already bound */
-       if ( ! tcp->local_port ) {
-               local.st_port = 0;
-               if ( ( rc = tcp_bind ( stream,
-                                      ( struct sockaddr * ) &local ) ) != 0 ){
-                       return rc;
-               }
-       }
+       /* TCP doesn't support seeking to arbitrary positions */
+       if ( ( whence != SEEK_CUR ) || ( offset != 0 ) )
+               return -EINVAL;
 
-       /* Bind to peer */
-       memcpy ( &tcp->peer, st, sizeof ( tcp->peer ) );
+       /* Not ready if we're not in a suitable connection state */
+       if ( ! TCP_CAN_SEND_DATA ( tcp->tcp_state ) )
+               return -EAGAIN;
 
-       /* Transition to TCP_SYN_SENT and send the SYN */
-       tcp->tcp_state = TCP_SYN_SENT;
-       tcp_dump_state ( tcp );
-       tcp_senddata_conn ( tcp, 0 );
+       /* Not ready if data queue is non-empty */
+       if ( ! list_empty ( &tcp->queue ) )
+               return -EAGAIN;
 
        return 0;
 }
 
 /**
- * Close the connection
+ * Deliver datagram as I/O buffer
  *
- * @v stream           TCP stream
- *
- * The TCP connection will persist until the state machine has
- * returned to the TCP_CLOSED state.
+ * @v xfer             Data transfer interface
+ * @v iobuf            Datagram I/O buffer
+ * @ret rc             Return status code
  */
-static void tcp_close ( struct stream_connection *stream ) {
+static int tcp_xfer_deliver_iob ( struct xfer_interface *xfer,
+                                 struct io_buffer *iobuf ) {
        struct tcp_connection *tcp =
-               container_of ( stream, struct tcp_connection, stream );
+               container_of ( xfer, struct tcp_connection, xfer );
 
-       /* If we have not yet received a SYN (i.e. we are in CLOSED,
-        * LISTEN or SYN_SENT), just delete the connection
-        */
-       if ( ! ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) {
-               tcp->tcp_state = TCP_CLOSED;
-               tcp_dump_state ( tcp );
-               free_tcp ( tcp );
-               return;
-       }
+       /* Enqueue packet */
+       list_add_tail ( &iobuf->list, &tcp->queue );
 
-       /* If we have not had our SYN acknowledged (i.e. we are in
-        * SYN_RCVD), pretend that it has been acknowledged so that we
-        * can send a FIN without breaking things.
-        */
-       if ( ! ( tcp->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) )
-               tcp_rx_ack ( tcp, ( tcp->snd_seq + 1 ), 0 );
+       /* Transmit data, if possible */
+       tcp_xmit ( tcp, 0 );
 
-       /* Send a FIN to initiate the close */
-       tcp->tcp_state |= TCP_STATE_SENT ( TCP_FIN );
-       tcp_dump_state ( tcp );
-       tcp_senddata_conn ( tcp, 0 );
+       return 0;
 }
 
-/**
- * Open TCP connection
+/** TCP data transfer interface operations */
+static struct xfer_interface_operations tcp_xfer_operations = {
+       .close          = tcp_xfer_close,
+       .vredirect      = ignore_xfer_vredirect,
+       .request        = ignore_xfer_request,
+       .seek           = tcp_xfer_seek,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = tcp_xfer_deliver_iob,
+       .deliver_raw    = xfer_deliver_as_iob,
+};
+
+/***************************************************************************
  *
- * @v app              Stream application
- * @ret rc             Return status code
+ * Openers
+ *
+ ***************************************************************************
  */
-int tcp_open ( struct stream_application *app ) {
-       struct tcp_connection *tcp;
 
-       /* Application must not already have an open connection */
-       if ( app->conn ) {
-               DBG ( "TCP app %p already open on %p\n", app, app->conn );
-               return -EISCONN;
-       }
+/** TCP socket opener */
+struct socket_opener tcp_socket_opener __socket_opener = {
+       .semantics      = SOCK_STREAM,
+       .family         = AF_INET,
+       .open           = tcp_open,
+};
 
-       /* Allocate connection state storage and add to connection list */
-       tcp = alloc_tcp();
-       if ( ! tcp ) {
-               DBG ( "TCP app %p could not allocate connection\n", app );
-               return -ENOMEM;
-       }
+/**
+ * Open TCP URI
+ *
+ * @v xfer             Data transfer interface
+ * @v uri              URI
+ * @ret rc             Return status code
+ */
+static int tcp_open_uri ( struct xfer_interface *xfer, struct uri *uri ) {
+       struct sockaddr_tcpip peer;
 
-       /* Associate application with connection */
-       stream_associate ( app, &tcp->stream );
+       /* Sanity check */
+       if ( ! uri->host )
+               return -EINVAL;
 
-       return 0;
+       memset ( &peer, 0, sizeof ( peer ) );
+       peer.st_port = htons ( uri_port ( uri, 0 ) );
+       return xfer_open_named_socket ( xfer, SOCK_STREAM,
+                                       ( struct sockaddr * ) &peer,
+                                       uri->host, NULL );
 }
 
-/** TCP stream operations */
-static struct stream_connection_operations tcp_op = {
-       .bind           = tcp_bind,
-       .connect        = tcp_connect,
-       .close          = tcp_close,
-       .send           = tcp_send,
-       .kick           = tcp_kick,
+/** TCP URI opener */
+struct uri_opener tcp_uri_opener __uri_opener = {
+       .scheme         = "tcp",
+       .open           = tcp_open_uri,
 };
 
-/** TCP protocol */
-struct tcpip_protocol tcp_protocol __tcpip_protocol = {
-       .name = "TCP",
-       .rx = tcp_rx,
-       .tcpip_proto = IP_TCP,
-};
index 061240c..f90e793 100644 (file)
@@ -1,15 +1,16 @@
-#include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
 #include <byteswap.h>
-#include <gpxe/async.h>
-#include <gpxe/buffer.h>
+#include <gpxe/socket.h>
+#include <gpxe/tcpip.h>
+#include <gpxe/in.h>
+#include <gpxe/xfer.h>
+#include <gpxe/open.h>
 #include <gpxe/uri.h>
-#include <gpxe/download.h>
-#include <gpxe/tcp.h>
 #include <gpxe/ftp.h>
 
 /** @file
  *
  */
 
+/**
+ * FTP states
+ *
+ * These @b must be sequential, i.e. a successful FTP session must
+ * pass through each of these states in order.
+ */
+enum ftp_state {
+       FTP_CONNECT = 0,
+       FTP_USER,
+       FTP_PASS,
+       FTP_TYPE,
+       FTP_PASV,
+       FTP_RETR,
+       FTP_QUIT,
+       FTP_DONE,
+};
+
+/**
+ * An FTP request
+ *
+ */
+struct ftp_request {
+       /** Reference counter */
+       struct refcnt refcnt;
+       /** Data transfer interface */
+       struct xfer_interface xfer;
+
+       /** URI being fetched */
+       struct uri *uri;
+       /** FTP control channel interface */
+       struct xfer_interface control;
+       /** FTP data channel interface */
+       struct xfer_interface data;
+
+       /** Current state */
+       enum ftp_state state;
+       /** Buffer to be filled with data received via the control channel */
+       char *recvbuf;
+       /** Remaining size of recvbuf */
+       size_t recvsize;
+       /** FTP status code, as text */
+       char status_text[5];
+       /** Passive-mode parameters, as text */
+       char passive_text[24]; /* "aaa,bbb,ccc,ddd,eee,fff" */
+};
+
+/**
+ * Free FTP request
+ *
+ * @v refcnt           Reference counter
+ */
+static void ftp_free ( struct refcnt *refcnt ) {
+       struct ftp_request *ftp =
+               container_of ( refcnt, struct ftp_request, refcnt );
+
+       DBGC ( ftp, "FTP %p freed\n", ftp );
+
+       uri_put ( ftp->uri );
+       free ( ftp );
+}
+
+/**
+ * Mark FTP operation as complete
+ *
+ * @v ftp              FTP request
+ * @v rc               Return status code
+ */
+static void ftp_done ( struct ftp_request *ftp, int rc ) {
+
+       DBGC ( ftp, "FTP %p completed (%s)\n", ftp, strerror ( rc ) );
+
+       /* Close all data transfer interfaces */
+       xfer_nullify ( &ftp->xfer );
+       xfer_close ( &ftp->xfer, rc );
+       xfer_nullify ( &ftp->control );
+       xfer_close ( &ftp->control, rc );
+       xfer_nullify ( &ftp->data );
+       xfer_close ( &ftp->data, rc );
+}
+
 /*****************************************************************************
  *
  * FTP control channel
  *
  */
 
-/** FTP control channel strings
+/**
+ * FTP control channel strings
  *
  * These are used as printf() format strings.  Since only one of them
  * (RETR) takes an argument, we always supply that argument to the
@@ -42,32 +124,23 @@ static const char * ftp_strings[] = {
 };
 
 /**
- * Get FTP request from control stream application
+ * Handle control channel being closed
  *
- * @v app              Stream application
- * @ret ftp            FTP request
- */
-static inline struct ftp_request *
-stream_to_ftp ( struct stream_application *app ) {
-       return container_of ( app, struct ftp_request, stream );
-}
-
-/**
- * Mark FTP operation as complete
+ * @v control          FTP control channel interface
+ * @v rc               Reason for close
  *
- * @v ftp              FTP request
- * @v rc               Return status code
+ * When the control channel is closed, the data channel must also be
+ * closed, if it is currently open.
  */
-static void ftp_done ( struct ftp_request *ftp, int rc ) {
-
-       DBGC ( ftp, "FTP %p completed with status %d\n", ftp, rc );
+static void ftp_control_close ( struct xfer_interface *control, int rc ) {
+       struct ftp_request *ftp =
+               container_of ( control, struct ftp_request, control );
 
-       /* Close both stream connections */
-       stream_close ( &ftp->stream );
-       stream_close ( &ftp->stream_data );
+       DBGC ( ftp, "FTP %p control connection closed: %s\n",
+              ftp, strerror ( rc ) );
 
-       /* Mark asynchronous operation as complete */
-       async_done ( &ftp->async, rc );
+       /* Complete FTP operation */
+       ftp_done ( ftp, rc );
 }
 
 /**
@@ -102,9 +175,14 @@ static void ftp_parse_value ( char **text, uint8_t *value, size_t len ) {
  */
 static void ftp_reply ( struct ftp_request *ftp ) {
        char status_major = ftp->status_text[0];
+       char separator = ftp->status_text[3];
 
        DBGC ( ftp, "FTP %p received status %s\n", ftp, ftp->status_text );
 
+       /* Ignore malformed lines */
+       if ( separator != ' ' )
+               return;
+
        /* Ignore "intermediate" responses (1xx codes) */
        if ( status_major == '1' )
                return;
@@ -133,47 +211,42 @@ 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_open ( &ftp->stream_data ) ) != 0 ) {
+               if ( ( rc = xfer_open_socket ( &ftp->data, SOCK_STREAM,
+                                              &sa.sa, NULL ) ) != 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 );
-                       return;
-               }
        }
 
        /* Move to next state */
        if ( ftp->state < FTP_DONE )
                ftp->state++;
-       ftp->already_sent = 0;
 
+       /* Send control string */
        if ( ftp->state < FTP_DONE ) {
                DBGC ( ftp, "FTP %p sending ", ftp );
                DBGC ( ftp, ftp_strings[ftp->state], ftp->uri->path );
+               xfer_printf ( &ftp->control, ftp_strings[ftp->state],
+                             ftp->uri->path );
        }
-
-       return;
 }
 
 /**
  * Handle new data arriving on FTP control channel
  *
- * @v app              Stream application
+ * @v control          FTP control channel interface
  * @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 stream_application *app,
-                         void *data, size_t len ) {
-       struct ftp_request *ftp = stream_to_ftp ( app );
+static int ftp_control_deliver_raw ( struct xfer_interface *control,
+                                    const void *data, size_t len ) {
+       struct ftp_request *ftp =
+               container_of ( control, struct ftp_request, control );
        char *recvbuf = ftp->recvbuf;
        size_t recvsize = ftp->recvsize;
        char c;
@@ -215,62 +288,19 @@ static void ftp_newdata ( struct stream_application *app,
        /* Store for next invocation */
        ftp->recvbuf = recvbuf;
        ftp->recvsize = recvsize;
-}
-
-/**
- * Handle acknowledgement of data sent on FTP control channel
- *
- * @v app              Stream application
- */
-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              Stream application
- * @v buf              Temporary data buffer
- * @v len              Length of temporary data buffer
- */
-static void ftp_senddata ( struct stream_application *app,
-                          void *buf, size_t len ) {
-       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 );
-       stream_send ( app, buf + ftp->already_sent, len - ftp->already_sent );
-}
-
-/**
- * Handle control channel being closed
- *
- * @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 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 ) );
-
-       /* Complete FTP operation */
-       ftp_done ( ftp, rc );
+       return 0;
 }
 
 /** FTP control channel operations */
-static struct stream_application_operations ftp_stream_operations = {
-       .closed         = ftp_closed,
-       .acked          = ftp_acked,
-       .newdata        = ftp_newdata,
-       .senddata       = ftp_senddata,
+static struct xfer_interface_operations ftp_control_operations = {
+       .close          = ftp_control_close,
+       .vredirect      = xfer_vopen,
+       .request        = ignore_xfer_request,
+       .seek           = ignore_xfer_seek,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = xfer_deliver_as_raw,
+       .deliver_raw    = ftp_control_deliver_raw,
 };
 
 /*****************************************************************************
@@ -280,20 +310,10 @@ static struct stream_application_operations ftp_stream_operations = {
  */
 
 /**
- * Get FTP request from data stream application
- *
- * @v app              Stream application
- * @ret ftp            FTP request
- */
-static inline struct ftp_request *
-stream_to_ftp_data ( struct stream_application *app ) {
-       return container_of ( app, struct ftp_request, stream_data );
-}
-
-/**
- * Handle data channel being closed
+ * Handle FTP data channel being closed
  *
- * @v app              Stream application
+ * @v data             FTP data channel interface
+ * @v rc               Reason for closure
  *
  * When the data channel is closed, the control channel should be left
  * alone; the server will send a completion message via the control
@@ -301,8 +321,9 @@ stream_to_ftp_data ( struct stream_application *app ) {
  *
  * If the data channel is closed due to an error, we abort the request.
  */
-static void ftp_data_closed ( struct stream_application *app, int rc ) {
-       struct ftp_request *ftp = stream_to_ftp_data ( app );
+static void ftp_data_closed ( struct xfer_interface *data, int rc ) {
+       struct ftp_request *ftp =
+               container_of ( data, struct ftp_request, data );
 
        DBGC ( ftp, "FTP %p data connection closed: %s\n",
               ftp, strerror ( rc ) );
@@ -313,121 +334,133 @@ static void ftp_data_closed ( struct stream_application *app, int rc ) {
 }
 
 /**
- * Handle new data arriving on the FTP data channel
+ * Handle data delivery via FTP data channel
  *
- * @v app              Stream application
- * @v data             New data
- * @v len              Length of new data
+ * @v xfer             FTP data channel interface
+ * @v iobuf            I/O buffer
+ * @ret rc             Return status code
  */
-static void ftp_data_newdata ( struct stream_application *app,
-                              void *data, size_t len ) {
-       struct ftp_request *ftp = stream_to_ftp_data ( app );
+static int ftp_data_deliver_iob ( struct xfer_interface *data,
+                                 struct io_buffer *iobuf ) {
+       struct ftp_request *ftp =
+               container_of ( data, struct ftp_request, data );
        int rc;
 
-       /* Fill data buffer */
-       if ( ( rc = fill_buffer ( ftp->buffer, data,
-                                 ftp->buffer->fill, len ) ) != 0 ){
-               DBGC ( ftp, "FTP %p failed to fill data buffer: %s\n",
+       if ( ( rc = xfer_deliver_iob ( &ftp->xfer, iobuf ) ) != 0 ) {
+               DBGC ( ftp, "FTP %p failed to deliver data: %s\n",
                       ftp, strerror ( rc ) );
-               ftp_done ( ftp, rc );
-               return;
+               return rc;
        }
+
+       return 0;
 }
 
 /** FTP data channel operations */
-static struct stream_application_operations ftp_data_stream_operations = {
-       .closed         = ftp_data_closed,
-       .newdata        = ftp_data_newdata,
+static struct xfer_interface_operations ftp_data_operations = {
+       .close          = ftp_data_closed,
+       .vredirect      = xfer_vopen,
+       .request        = ignore_xfer_request,
+       .seek           = ignore_xfer_seek,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = ftp_data_deliver_iob,
+       .deliver_raw    = xfer_deliver_as_iob,
 };
 
 /*****************************************************************************
  *
- * API
+ * Data transfer interface
  *
  */
 
 /**
- * Reap asynchronous operation
+ * Close FTP data transfer interface
  *
- * @v async            Asynchronous operation
+ * @v xfer             FTP data transfer interface
+ * @v rc               Reason for close
  */
-static void ftp_reap ( struct async *async ) {
+static void ftp_xfer_closed ( struct xfer_interface *xfer, int rc ) {
        struct ftp_request *ftp =
-               container_of ( async, struct ftp_request, async );
+               container_of ( xfer, struct ftp_request, xfer );
 
-       free ( ftp );
+       DBGC ( ftp, "FTP %p data transfer interface closed: %s\n",
+              ftp, strerror ( rc ) );
+       
+       ftp_done ( ftp, rc );
 }
 
-/** FTP asynchronous operations */
-static struct async_operations ftp_async_operations = {
-       .reap = ftp_reap,
+/** FTP data transfer interface operations */
+static struct xfer_interface_operations ftp_xfer_operations = {
+       .close          = ftp_xfer_closed,
+       .vredirect      = ignore_xfer_vredirect,
+       .request        = ignore_xfer_request,
+       .seek           = ignore_xfer_seek,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = xfer_deliver_as_raw,
+       .deliver_raw    = ignore_xfer_deliver_raw,
 };
 
+/*****************************************************************************
+ *
+ * URI opener
+ *
+ */
+
 /**
  * Initiate an FTP connection
  *
+ * @v xfer             Data transfer interface
  * @v uri              Uniform Resource Identifier
- * @v buffer           Buffer into which to download file
- * @v parent           Parent asynchronous operation
  * @ret rc             Return status code
  */
-int ftp_get ( struct uri *uri, struct buffer *buffer, struct async *parent ) {
-       struct ftp_request *ftp = NULL;
+static int ftp_open ( struct xfer_interface *xfer, struct uri *uri ) {
+       struct ftp_request *ftp;
+       struct sockaddr_tcpip server;
        int rc;
 
        /* Sanity checks */
-       if ( ! uri->path ) {
-               rc = -EINVAL;
-               goto err;
-       }
+       if ( ! uri->path )
+               return -EINVAL;
+       if ( ! uri->host )
+               return -EINVAL;
 
-       /* Allocate and populate FTP structure */
+       /* Allocate and populate structure */
        ftp = malloc ( sizeof ( *ftp ) );
-       if ( ! ftp ) {
-               rc = -ENOMEM;
-               goto err;
-       }
+       if ( ! ftp )
+               return -ENOMEM;
        memset ( ftp, 0, sizeof ( *ftp ) );
-       ftp->uri = uri;
-       ftp->buffer = buffer;
-       ftp->state = FTP_CONNECT;
-       ftp->already_sent = 0;
+       ftp->refcnt.free = ftp_free;
+       xfer_init ( &ftp->xfer, &ftp_xfer_operations, &ftp->refcnt );
+       ftp->uri = uri_get ( uri );
+       xfer_init ( &ftp->control, &ftp_control_operations, &ftp->refcnt );
+       xfer_init ( &ftp->data, &ftp_data_operations, &ftp->refcnt );
        ftp->recvbuf = ftp->status_text;
        ftp->recvsize = sizeof ( ftp->status_text ) - 1;
-       ftp->stream.op = &ftp_stream_operations;
-       ftp->stream_data.op = &ftp_data_stream_operations;
-
-#warning "Quick name resolution hack"
-       union {
-               struct sockaddr sa;
-               struct sockaddr_in sin;
-       } server;
-       server.sin.sin_port = htons ( FTP_PORT );
-       server.sin.sin_family = AF_INET;
-       if ( inet_aton ( uri->host, &server.sin.sin_addr ) == 0 ) {
-               rc = -EINVAL;
-               goto err;
-       }
 
        DBGC ( ftp, "FTP %p fetching %s\n", ftp, ftp->uri->path );
 
-       if ( ( rc = tcp_open ( &ftp->stream ) ) != 0 )
-               goto err;
-       if ( ( rc = stream_connect ( &ftp->stream, &server.sa ) ) != 0 )
+       /* Open control connection */
+       memset ( &server, 0, sizeof ( server ) );
+       server.st_port = htons ( uri_port ( uri, FTP_PORT ) );
+       if ( ( rc = xfer_open_named_socket ( &ftp->control, SOCK_STREAM,
+                                            ( struct sockaddr * ) &server,
+                                            uri->host, NULL ) ) != 0 )
                goto err;
 
-       async_init ( &ftp->async, &ftp_async_operations, parent );
+       /* Attach to parent interface, mortalise self, and return */
+       xfer_plug_plug ( &ftp->xfer, xfer );
+       ref_put ( &ftp->refcnt );
        return 0;
 
  err:
        DBGC ( ftp, "FTP %p could not create request: %s\n", 
               ftp, strerror ( rc ) );
-       free ( ftp );
+       ftp_done ( ftp, rc );
+       ref_put ( &ftp->refcnt );
        return rc;
 }
 
-/** HTTP download protocol */
-struct download_protocol ftp_download_protocol __download_protocol = {
-       .name = "ftp",
-       .start_download = ftp_get,
+/** FTP URI opener */
+struct uri_opener ftp_uri_opener __uri_opener = {
+       .scheme = "ftp",
+       .open   = ftp_open,
 };
index f7f0e44..cdd6fb9 100644 (file)
@@ -23,7 +23,7 @@
  *
  */
 
-#include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <byteswap.h>
 #include <errno.h>
 #include <assert.h>
-#include <gpxe/async.h>
 #include <gpxe/uri.h>
-#include <gpxe/buffer.h>
-#include <gpxe/download.h>
-#include <gpxe/resolv.h>
-#include <gpxe/tcp.h>
+#include <gpxe/refcnt.h>
+#include <gpxe/iobuf.h>
+#include <gpxe/xfer.h>
+#include <gpxe/open.h>
+#include <gpxe/socket.h>
+#include <gpxe/tcpip.h>
+#include <gpxe/process.h>
+#include <gpxe/linebuf.h>
 #include <gpxe/tls.h>
 #include <gpxe/http.h>
 
-static struct async_operations http_async_operations;
+/** HTTP receive state */
+enum http_rx_state {
+       HTTP_RX_RESPONSE = 0,
+       HTTP_RX_HEADER,
+       HTTP_RX_DATA,
+       HTTP_RX_DEAD,
+};
 
-static inline struct http_request *
-stream_to_http ( struct stream_application *app ) {
-       return container_of ( app, struct http_request, stream );
-}
+/**
+ * An HTTP request
+ *
+ */
+struct http_request {
+       /** Reference count */
+       struct refcnt refcnt;
+       /** Data transfer interface */
+       struct xfer_interface xfer;
+
+       /** URI being fetched */
+       struct uri *uri;
+       /** Transport layer interface */
+       struct xfer_interface socket;
+
+       /** TX process */
+       struct process process;
+
+       /** HTTP response code */
+       unsigned int response;
+       /** HTTP Content-Length */
+       size_t content_length;
+       /** Received length */
+       size_t rx_len;
+       /** RX state */
+       enum http_rx_state rx_state;
+       /** Line buffer for received header lines */
+       struct line_buffer linebuf;
+};
+
+/**
+ * Free HTTP request
+ *
+ * @v refcnt           Reference counter
+ */
+static void http_free ( struct refcnt *refcnt ) {
+       struct http_request *http =
+               container_of ( refcnt, struct http_request, refcnt );
+
+       uri_put ( http->uri );
+       empty_line_buffer ( &http->linebuf );
+       free ( http );
+};
 
 /**
  * Mark HTTP request as complete
  *
  * @v http             HTTP request
  * @v rc               Return status code
- *
  */
 static void http_done ( struct http_request *http, int rc ) {
 
-       /* Close stream connection */
-       stream_close ( &http->stream );
-
        /* Prevent further processing of any current packet */
        http->rx_state = HTTP_RX_DEAD;
 
-       /* Free up any dynamically allocated storage */
-       empty_line_buffer ( &http->linebuf );
-
        /* If we had a Content-Length, and the received content length
         * isn't correct, flag an error
         */
        if ( http->content_length &&
-            ( http->content_length != http->buffer->fill ) ) {
+            ( http->content_length != http->rx_len ) ) {
                DBGC ( http, "HTTP %p incorrect length %zd, should be %zd\n",
-                      http, http->buffer->fill, http->content_length );
+                      http, http->rx_len, http->content_length );
                rc = -EIO;
        }
 
-       /* Mark async operation as complete */
-       async_done ( &http->async, rc );
+       /* Remove process */
+       process_del ( &http->process );
+
+       /* Close all data transfer interfaces */
+       xfer_nullify ( &http->socket );
+       xfer_close ( &http->socket, rc );
+       xfer_nullify ( &http->xfer );
+       xfer_close ( &http->xfer, rc );
 }
 
 /**
@@ -103,33 +150,29 @@ static int http_response_to_rc ( unsigned int response ) {
  *
  * @v http             HTTP request
  * @v response         HTTP response
+ * @ret rc             Return status code
  */
-static void http_rx_response ( struct http_request *http, char *response ) {
+static int http_rx_response ( struct http_request *http, char *response ) {
        char *spc;
-       int rc = -EIO;
+       int rc;
 
        DBGC ( http, "HTTP %p response \"%s\"\n", http, response );
 
        /* Check response starts with "HTTP/" */
        if ( strncmp ( response, "HTTP/", 5 ) != 0 )
-               goto err;
+               return -EIO;
 
        /* Locate and check response code */
        spc = strchr ( response, ' ' );
        if ( ! spc )
-               goto err;
+               return -EIO;
        http->response = strtoul ( spc, NULL, 10 );
        if ( ( rc = http_response_to_rc ( http->response ) ) != 0 )
-               goto err;
+               return rc;
 
        /* Move to received headers */
        http->rx_state = HTTP_RX_HEADER;
-       return;
-
- err:
-       DBGC ( http, "HTTP %p bad response\n", http );
-       http_done ( http, rc );
-       return;
+       return 0;
 }
 
 /**
@@ -142,7 +185,6 @@ static void http_rx_response ( struct http_request *http, char *response ) {
 static int http_rx_content_length ( struct http_request *http,
                                    const char *value ) {
        char *endp;
-       int rc;
 
        http->content_length = strtoul ( value, &endp, 10 );
        if ( *endp != '\0' ) {
@@ -151,22 +193,14 @@ static int http_rx_content_length ( struct http_request *http,
                return -EIO;
        }
 
-       /* Try to presize the receive buffer */
-       if ( ( rc = expand_buffer ( http->buffer,
-                                   http->content_length ) ) != 0 ) {
-               /* May as well abandon the download now; it will fail */
-               DBGC ( http, "HTTP %p could not presize buffer: %s\n",
-                      http, strerror ( rc ) );
-               return rc;
-       }
+       /* Use seek() to notify recipient of filesize */
+       xfer_seek ( &http->xfer, http->content_length, SEEK_SET );
+       xfer_seek ( &http->xfer, 0, SEEK_SET );
 
        return 0;
 }
 
-/**
- * An HTTP header handler
- *
- */
+/** An HTTP header handler */
 struct http_header_handler {
        /** Name (e.g. "Content-Length") */
        const char *header;
@@ -195,27 +229,30 @@ struct http_header_handler http_header_handlers[] = {
  *
  * @v http             HTTP request
  * @v header           HTTP header
+ * @ret rc             Return status code
  */
-static void http_rx_header ( struct http_request *http, char *header ) {
+static int http_rx_header ( struct http_request *http, char *header ) {
        struct http_header_handler *handler;
        char *separator;
        char *value;
-       int rc = -EIO;
+       int rc;
 
        /* An empty header line marks the transition to the data phase */
        if ( ! header[0] ) {
                DBGC ( http, "HTTP %p start of data\n", http );
                empty_line_buffer ( &http->linebuf );
                http->rx_state = HTTP_RX_DATA;
-               return;
+               return 0;
        }
 
        DBGC ( http, "HTTP %p header \"%s\"\n", http, header );
 
        /* Split header at the ": " */
        separator = strstr ( header, ": " );
-       if ( ! separator )
-               goto err;
+       if ( ! separator ) {
+               DBGC ( http, "HTTP %p malformed header\n", http );
+               return -EIO;
+       }
        *separator = '\0';
        value = ( separator + 2 );
 
@@ -223,265 +260,265 @@ static void http_rx_header ( struct http_request *http, char *header ) {
        for ( handler = http_header_handlers ; handler->header ; handler++ ) {
                if ( strcasecmp ( header, handler->header ) == 0 ) {
                        if ( ( rc = handler->rx ( http, value ) ) != 0 )
-                               goto err;
+                               return rc;
                        break;
                }
        }
-       return;
-
- err:
-       DBGC ( http, "HTTP %p bad header\n", http );
-       http_done ( http, rc );
-       return;
+       return 0;
 }
 
+/** An HTTP line-based data handler */
+struct http_line_handler {
+       /** Handle line
+        *
+        * @v http      HTTP request
+        * @v line      Line to handle
+        * @ret rc      Return status code
+        */
+       int ( * rx ) ( struct http_request *http, char *line );
+};
+
+/** List of HTTP line-based data handlers */
+struct http_line_handler http_line_handlers[] = {
+       [HTTP_RX_RESPONSE]      = { .rx = http_rx_response },
+       [HTTP_RX_HEADER]        = { .rx = http_rx_header },
+};
+
 /**
  * Handle new data arriving via HTTP connection in the data phase
  *
  * @v http             HTTP request
- * @v data             New data
- * @v len              Length of new data
+ * @v iobuf            I/O buffer
+ * @ret rc             Return status code
  */
-static void http_rx_data ( struct http_request *http,
-                          const char *data, size_t len ) {
+static int http_rx_data ( struct http_request *http,
+                         struct io_buffer *iobuf ) {
        int rc;
 
-       /* Fill data buffer */
-       if ( ( rc = fill_buffer ( http->buffer, data,
-                                 http->buffer->fill, len ) ) != 0 ) {
-               DBGC ( http, "HTTP %p failed to fill data buffer: %s\n",
-                      http, strerror ( rc ) );
-               http_done ( http, rc );
-               return;
-       }
+       /* Update received length */
+       http->rx_len += iob_len ( iobuf );
 
-       /* Update progress */
-       http->async.completed = http->buffer->fill;
-       http->async.total = http->content_length;
+       /* Hand off data buffer */
+       if ( ( rc = xfer_deliver_iob ( &http->xfer, iobuf ) ) != 0 )
+               return rc;
 
        /* If we have reached the content-length, stop now */
        if ( http->content_length &&
-            ( http->buffer->fill >= http->content_length ) ) {
+            ( http->rx_len >= http->content_length ) ) {
                http_done ( http, 0 );
        }
+
+       return 0;
 }
 
 /**
  * Handle new data arriving via HTTP connection
  *
- * @v http             HTTP request
- * @v data             New data
- * @v len              Length of new data
+ * @v socket           Transport layer interface
+ * @v iobuf            I/O buffer
+ * @ret rc             Return status code
  */
-static void http_newdata ( struct stream_application *app,
-                          void *data, size_t len ) {
-       struct http_request *http = stream_to_http ( app );
-       const char *buf = data;
+static int http_socket_deliver_iob ( struct xfer_interface *socket,
+                                    struct io_buffer *iobuf ) {
+       struct http_request *http =
+               container_of ( socket, struct http_request, socket );
+       struct http_line_handler *lh;
        char *line;
-       int rc;
+       ssize_t len;
+       int rc = 0;
 
-       while ( len ) {
-               if ( http->rx_state == HTTP_RX_DEAD ) {
+       while ( iob_len ( iobuf ) ) {
+               switch ( http->rx_state ) {
+               case HTTP_RX_DEAD:
                        /* Do no further processing */
-                       return;
-               } else if ( http->rx_state == HTTP_RX_DATA ) {
+                       goto done;
+               case HTTP_RX_DATA:
                        /* Once we're into the data phase, just fill
                         * the data buffer
                         */
-                       http_rx_data ( http, buf, len );
-                       return;
-               } else {
+                       rc = http_rx_data ( http, iobuf );
+                       iobuf = NULL;
+                       goto done;
+               case HTTP_RX_RESPONSE:
+               case HTTP_RX_HEADER:
                        /* In the other phases, buffer and process a
                         * line at a time
                         */
-                       if ( ( rc = line_buffer ( &http->linebuf, &buf,
-                                                 &len ) ) != 0 ) {
+                       len = line_buffer ( &http->linebuf, iobuf->data,
+                                           iob_len ( iobuf ) );
+                       if ( len < 0 ) {
                                DBGC ( http, "HTTP %p could not buffer line: "
                                       "%s\n", http, strerror ( rc ) );
-                               http_done ( http, rc );
-                               return;
+                               goto done;
                        }
-                       if ( ( line = buffered_line ( &http->linebuf ) ) ) {
-                               switch ( http->rx_state ) {
-                               case HTTP_RX_RESPONSE:
-                                       http_rx_response ( http, line );
-                                       break;
-                               case HTTP_RX_HEADER:
-                                       http_rx_header ( http, line );
-                                       break;
-                               default:
-                                       assert ( 0 );
-                                       break;
-                               }
+                       iob_pull ( iobuf, len );
+                       line = buffered_line ( &http->linebuf );
+                       if ( line ) {
+                               lh = &http_line_handlers[http->rx_state];
+                               if ( ( rc = lh->rx ( http, line ) ) != 0 )
+                                       goto done;
                        }
+                       break;
+               default:
+                       assert ( 0 );
+                       break;
                }
        }
+
+ done:
+       if ( rc )
+               http_done ( http, rc );
+       free_iob ( iobuf );
+       return rc;
 }
 
 /**
- * Send HTTP data
+ * HTTP process
  *
- * @v app              Stream application
- * @v buf              Temporary data buffer
- * @v len              Length of temporary data buffer
+ * @v process          Process
  */
-static void http_senddata ( struct stream_application *app,
-                           void *buf, size_t len ) {
-       struct http_request *http = stream_to_http ( app );
+static void http_step ( struct process *process ) {
+       struct http_request *http =
+               container_of ( process, struct http_request, process );
        const char *path = http->uri->path;
        const char *host = http->uri->host;
        const char *query = http->uri->query;
+       int rc;
 
-       len = snprintf ( buf, len,
-                        "GET %s%s%s HTTP/1.1\r\n"
-                        "User-Agent: gPXE/" VERSION "\r\n"
-                        "Host: %s\r\n"
-                        "\r\n",
-                        ( path ? path : "/" ),
-                        ( query ? "?" : "" ),
-                        ( query ? query : "" ),
-                        host );
-
-       stream_send ( app, ( buf + http->tx_offset ),
-                     ( len - http->tx_offset ) );
+       if ( xfer_ready ( &http->socket ) == 0 ) {
+               process_del ( &http->process );
+               if ( ( rc = xfer_printf ( &http->socket,
+                                         "GET %s%s%s HTTP/1.1\r\n"
+                                         "User-Agent: gPXE/" VERSION "\r\n"
+                                         "Host: %s\r\n"
+                                         "\r\n",
+                                         ( path ? path : "/" ),
+                                         ( query ? "?" : "" ),
+                                         ( query ? query : "" ),
+                                         host ) ) != 0 ) {
+                       http_done ( http, rc );
+               }
+       }
 }
 
 /**
- * HTTP data acknowledged
+ * HTTP connection closed by network stack
  *
- * @v app              Stream application
- * @v len              Length of acknowledged data
+ * @v socket           Transport layer interface
+ * @v rc               Reason for close
  */
-static void http_acked ( struct stream_application *app, size_t len ) {
-       struct http_request *http = stream_to_http ( app );
+static void http_socket_close ( struct xfer_interface *socket, int rc ) {
+       struct http_request *http =
+               container_of ( socket, struct http_request, socket );
 
-       http->tx_offset += len;
+       DBGC ( http, "HTTP %p socket closed: %s\n",
+              http, strerror ( rc ) );
+       
+       http_done ( http, rc );
 }
 
+/** HTTP socket operations */
+static struct xfer_interface_operations http_socket_operations = {
+       .close          = http_socket_close,
+       .vredirect      = xfer_vopen,
+       .request        = ignore_xfer_request,
+       .seek           = ignore_xfer_seek,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = http_socket_deliver_iob,
+       .deliver_raw    = xfer_deliver_as_iob,
+};
+
 /**
- * HTTP connection closed by network stack
+ * Close HTTP data transfer interface
  *
- * @v app              Stream application
+ * @v xfer             Data transfer interface
+ * @v rc               Reason for close
  */
-static void http_closed ( struct stream_application *app, int rc ) {
-       struct http_request *http = stream_to_http ( app );
+static void http_xfer_close ( struct xfer_interface *xfer, int rc ) {
+       struct http_request *http =
+               container_of ( xfer, struct http_request, xfer );
 
-       DBGC ( http, "HTTP %p connection closed: %s\n",
+       DBGC ( http, "HTTP %p interface closed: %s\n",
               http, strerror ( rc ) );
-       
+
        http_done ( http, rc );
 }
 
-/** HTTP stream operations */
-static struct stream_application_operations http_stream_operations = {
-       .closed         = http_closed,
-       .acked          = http_acked,
-       .newdata        = http_newdata,
-       .senddata       = http_senddata,
+/** HTTP data transfer interface operations */
+static struct xfer_interface_operations http_xfer_operations = {
+       .close          = http_xfer_close,
+       .vredirect      = ignore_xfer_vredirect,
+       .request        = ignore_xfer_request,
+       .seek           = ignore_xfer_seek,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = xfer_deliver_as_raw,
+       .deliver_raw    = ignore_xfer_deliver_raw,
 };
 
 /**
- * Initiate a HTTP connection
+ * Initiate an HTTP connection
  *
+ * @v xfer             Data transfer interface
  * @v uri              Uniform Resource Identifier
- * @v buffer           Buffer into which to download file
- * @v parent           Parent asynchronous operation
  * @ret rc             Return status code
  */
-int http_get ( struct uri *uri, struct buffer *buffer, struct async *parent ) {
-       struct http_request *http = NULL;
-       struct sockaddr_tcpip *st;
+int http_open ( struct xfer_interface *xfer, struct uri *uri ) {
+       struct http_request *http;
+       struct sockaddr_tcpip server;
        int rc;
 
+       /* Sanity checks */
+       if ( ! uri->host )
+               return -EINVAL;
+
        /* Allocate and populate HTTP structure */
        http = malloc ( sizeof ( *http ) );
        if ( ! http )
                return -ENOMEM;
        memset ( http, 0, sizeof ( *http ) );
-       http->uri = uri;
-       http->buffer = buffer;
-       async_init ( &http->async, &http_async_operations, parent );
-       http->stream.op = &http_stream_operations;
-       st = ( struct sockaddr_tcpip * ) &http->server;
-       st->st_port = htons ( uri_port ( http->uri, HTTP_PORT ) );
-
-       /* Open TCP connection */
-       if ( ( rc = tcp_open ( &http->stream ) ) != 0 )
+       http->refcnt.free = http_free;
+       xfer_init ( &http->xfer, &http_xfer_operations, &http->refcnt );
+               http->uri = uri_get ( uri );
+       xfer_init ( &http->socket, &http_socket_operations, &http->refcnt );
+       process_init ( &http->process, http_step, &http->refcnt );
+
+       /* Open socket */
+       memset ( &server, 0, sizeof ( server ) );
+       server.st_port = htons ( uri_port ( http->uri, HTTP_PORT ) );
+       if ( ( rc = xfer_open_named_socket ( &http->socket, SOCK_STREAM,
+                                            ( struct sockaddr * ) &server,
+                                            uri->host, NULL ) ) != 0 )
                goto err;
+
+#if 0
        if ( strcmp ( http->uri->scheme, "https" ) == 0 ) {
                st->st_port = htons ( uri_port ( http->uri, HTTPS_PORT ) );
                if ( ( rc = add_tls ( &http->stream ) ) != 0 )
                        goto err;
        }
+#endif
 
-       /* Start name resolution.  The download proper will start when
-        * name resolution completes.
-        */
-       if ( ( rc = resolv ( uri->host, &http->server, &http->async ) ) != 0 )
-               goto err;
-
+       /* Attach to parent interface, mortalise self, and return */
+       xfer_plug_plug ( &http->xfer, xfer );
+       ref_put ( &http->refcnt );
        return 0;
 
  err:
        DBGC ( http, "HTTP %p could not create request: %s\n", 
               http, strerror ( rc ) );
-       async_uninit ( &http->async );
-       free ( http );
+       http_done ( http, rc );
+       ref_put ( &http->refcnt );
        return rc;
 }
 
-/**
- * Handle name resolution completion
- *
- * @v async            HTTP asynchronous operation
- * @v signal           SIGCHLD
- */
-static void http_sigchld ( struct async *async, enum signal signal __unused ) {
-       struct http_request *http =
-               container_of ( async, struct http_request, async );
-       int rc;
-
-       /* If name resolution failed, abort now */
-       async_wait ( async, &rc, 1 );
-       if ( rc != 0 ) {
-               http_done ( http, rc );
-               return;
-       }
-
-       /* Otherwise, start the HTTP connection */
-       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;
-       }
-}
-
-/**
- * Free HTTP connection
- *
- * @v async            Asynchronous operation
- */
-static void http_reap ( struct async *async ) {
-       free ( container_of ( async, struct http_request, async ) );
-}
-
-/** HTTP asynchronous operations */
-static struct async_operations http_async_operations = {
-       .reap = http_reap,
-       .signal = {
-               [SIGCHLD] = http_sigchld,
-       },
-};
-
-/** HTTP download protocol */
-struct download_protocol http_download_protocol __download_protocol = {
-       .name = "http",
-       .start_download = http_get,
+/** HTTP URI opener */
+struct uri_opener http_uri_opener __uri_opener = {
+       .scheme = "http",
+       .open   = http_open,
 };
 
-/** HTTPS download protocol */
-struct download_protocol https_download_protocol __download_protocol = {
-       .name = "https",
-       .start_download = http_get,
+/** HTTPS URI opener */
+struct uri_opener https_uri_opener __uri_opener = {
+       .scheme = "https",
+       .open   = http_open,
 };
index ee6a58b..2268052 100644 (file)
@@ -486,7 +486,7 @@ int dns_resolv ( const char *name, struct sockaddr *sa,
 }
 
 /** DNS name resolver */
-struct resolver dns_resolver __resolver = {
+struct resolver dns_resolver __resolver ( RESOLV_NORMAL ) = {
        .name = "DNS",
        .resolv = dns_resolv,
 };
index 28801fe..9fe2e14 100644 (file)
@@ -89,7 +89,8 @@ int imgload ( struct image *image ) {
                return rc;
 
        /* If we succeed, move the image to the start of the list */
-       promote_image ( image );
+#warning "No longer exists"
+       //      promote_image ( image );
 
        return 0;
 }