HTTP/DNS now working fully asynchronously. HTTP/IP addresses and any

other protocol won't work at the moment.

src/include/gpxe/http.h

 	/** HTTP Content-Length */
 	size_t content_length;
 
+	/** Server address */
+	struct sockaddr server;
 	/** TCP application for this request */
 	struct tcp_application tcp;
 	/** Number of bytes already sent */

src/include/usr/fetch.h

-#ifndef _USR_FETCH_H
-#define _USR_FETCH_H
-
-/**
- * @file
- *
- * Fetch file
- *
- */
-
-#include <stdint.h>
-#include <gpxe/uaccess.h>
-
-extern int fetch ( const char *uri_string, userptr_t *data, size_t *len );
-
-#endif /* _USR_FETCH_H */

src/net/tcp/ftp.c

 #include <gpxe/async.h>
 #include <gpxe/buffer.h>
 #include <gpxe/uri.h>
+#include <gpxe/download.h>
 #include <gpxe/ftp.h>
 
 /** @file
 	free ( ftp );
 	return rc;
 }
+
+/** HTTP download protocol */
+struct download_protocol ftp_download_protocol __download_protocol = {
+	.name = "ftp",
+	.start_download = ftp_get,
+};

src/net/tcp/http.c

 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
+#include <byteswap.h>
 #include <errno.h>
 #include <assert.h>
 #include <vsprintf.h>
 #include <gpxe/async.h>
 #include <gpxe/uri.h>
 #include <gpxe/buffer.h>
+#include <gpxe/download.h>
 #include <gpxe/http.h>
 
 static inline struct http_request *
 	free ( http );
 }
 
+/**
+ * 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 );
+	struct sockaddr_tcpip *st = ( struct sockaddr_tcpip * ) &http->server;
+	int rc;
+
+	/* Reap child */
+	async_wait ( async, &rc, 1 );
+
+	/* If name resolution failed, abort now */
+	if ( rc != 0 ) {
+		http_done ( http, rc );
+		return;
+	}
+
+	/* Otherwise, start the HTTP connection */
+	http->tcp.tcp_op = &http_tcp_operations;
+	st->st_port = htons ( uri_port ( http->uri, HTTP_PORT ) );
+	if ( ( rc = tcp_connect ( &http->tcp, st, 0 ) ) != 0 ) {
+		DBGC ( http, "HTTP %p could not open TCP connection: %s\n",
+		       http, strerror ( rc ) );
+		http_done ( http, rc );
+		return;
+	}
+}
+
 /** HTTP asynchronous operations */
 static struct async_operations http_async_operations = {
-	.reap			= http_reap,
+	.reap = http_reap,
+	.signal = {
+		[SIGCHLD] = http_sigchld,
+	},
 };
 
-#warning "Quick name resolution hack"
-#include <byteswap.h>
-
 /**
  * Initiate a HTTP connection
  *
 
 	/* Allocate and populate HTTP structure */
 	http = malloc ( sizeof ( *http ) );
-	if ( ! http ) {
-		rc = -ENOMEM;
-		goto err;
-	}
+	if ( ! http )
+		return -ENOMEM;
 	memset ( http, 0, sizeof ( *http ) );
 	http->uri = uri;
 	http->buffer = buffer;
-	http->tcp.tcp_op = &http_tcp_operations;
+	async_init ( &http->async, &http_async_operations, parent );
+
 
 #warning "Quick name resolution hack"
-	union {
-		struct sockaddr_tcpip st;
-		struct sockaddr_in sin;
-	} server;
-	server.sin.sin_port = htons ( HTTP_PORT );
-	server.sin.sin_family = AF_INET;
-	if ( inet_aton ( uri->host, &server.sin.sin_addr ) == 0 ) {
-		/* Try DNS */
-		struct async async;
-		
-		extern int dns_resolv ( const char *name,
-					struct sockaddr_tcpip *st,
-					struct async *parent );
+	extern int dns_resolv ( const char *name,
+				struct sockaddr *sa,
+				struct async *parent );
 		
-		async_init_orphan ( &async );
-		if ( ( rc = dns_resolv ( uri->host, &server.st,
-					 &async ) ) != 0 )
-			goto err;
-		async_wait ( &async, &rc, 1 );
-		if ( rc != 0 )
-			goto err;
-	}
-	
-
-	if ( ( rc = tcp_connect ( &http->tcp, &server.st, 0 ) ) != 0 )
+	if ( ( rc = dns_resolv ( uri->host, &http->server,
+				 &http->async ) ) != 0 )
 		goto err;
 
-	async_init ( &http->async, &http_async_operations, parent );
+
 	return 0;
 
  err:
 	DBGC ( http, "HTTP %p could not create request: %s\n", 
 	       http, strerror ( rc ) );
+	async_uninit ( &http->async );
 	free ( http );
 	return rc;
 }
+
+/** HTTP download protocol */
+struct download_protocol http_download_protocol __download_protocol = {
+	.name = "http",
+	.start_download = http_get,
+};

src/usr/fetch.c

-/*
- * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-/**
- * @file
- *
- * Fetch file as executable/loadable image
- *
- */
-
-#include <errno.h>
-#include <vsprintf.h>
-#include <gpxe/umalloc.h>
-#include <gpxe/ebuffer.h>
-#include <gpxe/image.h>
-#include <gpxe/uri.h>
-#include <usr/fetch.h>
-
-#include <byteswap.h>
-#include <gpxe/dhcp.h>
-#include <gpxe/tftp.h>
-#include <gpxe/http.h>
-#include <gpxe/ftp.h>
-
-/**
- * Fetch file
- *
- * @v filename		Filename to fetch
- * @ret data		Loaded file
- * @ret len		Length of loaded file
- * @ret rc		Return status code
- *
- * Fetch file to an external buffer allocated with umalloc().  The
- * caller is responsible for eventually freeing the buffer with
- * ufree().
- */
-int fetch ( const char *uri_string, userptr_t *data, size_t *len ) {
-	struct uri *uri;
-	struct buffer buffer;
-	int rc;
-
-	/* Parse the URI */
-	uri = parse_uri ( uri_string );
-	if ( ! uri ) {
-		rc = -ENOMEM;
-		goto err_parse_uri;
-	}
-
-	/* Allocate an expandable buffer to hold the file */
-	if ( ( rc = ebuffer_alloc ( &buffer, 0 ) ) != 0 ) {
-		goto err_ebuffer_alloc;
-	}
-
-#warning "Temporary pseudo-URL parsing code"
-
-	/* Retrieve the file */
-	struct async async;
-
-	int ( * download ) ( struct uri *uri, struct buffer *buffer,
-			     struct async *parent );
-
-	if ( ! uri->scheme ) {
-		download = tftp_get;
-	} else {
-		if ( strcmp ( uri->scheme, "http" ) == 0 ) {
-			download = http_get;
-		} else if ( strcmp ( uri->scheme, "ftp" ) == 0 ) {
-			download = ftp_get;
-		} else {
-			download = tftp_get;
-		}
-	}
-
-	if ( ( rc = async_block ( &async,
-				  download ( uri, &buffer, &async ) ) )  != 0 )
-		goto err;
-
-	/* Fill in buffer address and length */
-	*data = buffer.addr;
-	*len = buffer.fill;
-
-	/* Release temporary resources.  The ebuffer storage is now
-	 * owned by our caller, so we don't free it.
-	 */
-	free_uri ( uri );
-	return 0;
-
- err:
-	ufree ( buffer.addr );
- err_ebuffer_alloc:
-	free_uri ( uri );
- err_parse_uri:
-	return rc;
-}

src/usr/imgmgmt.c

 #include <vsprintf.h>
 #include <gpxe/image.h>
 #include <gpxe/umalloc.h>
-#include <usr/fetch.h>
+#include <gpxe/download.h>
 #include <usr/imgmgmt.h>
 
 /** @file
 /**
  * Fetch an image
  *
- * @v filename		Filename for image
+ * @v uri_string	URI as a string (e.g. "http://www.nowhere.com/vmlinuz")
  * @v name		Name for image, or NULL
  * @ret new_image	Newly created image
  * @ret rc		Return status code
  */
-int imgfetch ( const char *filename, const char *name,
+int imgfetch ( const char *uri_string, const char *name,
 	       struct image **new_image ) {
 	struct image *image;
+	struct async async;
 	int rc;
 
 	/* Allocate new image */
 	if ( name )
 		strncpy ( image->name, name, ( sizeof ( image->name ) - 1 ) );
 
-	/* Fetch the file */
-	if ( ( rc = fetch ( filename, &image->data, &image->len ) ) != 0 )
+	/* Download the file */
+	if ( ( rc = async_block ( &async, start_download ( uri_string, &async,
+							   &image->data,
+							   &image->len ))) !=0)
 		goto err;
 
 	/* Register the image */