Protocols now load data into a buffer; they don't execute it.

src/core/main.c

 MAIN - Kick off routine
 **************************************************************************/
 int main ( void ) {
+	struct buffer buffer;
 	int skip = 0;
 
 	/* Print out configuration */
 			continue;
 		}
 
-		/* Boot from the device */
-		load ( &dev, load_block );
+		/* Load boot file from the device */
+		init_buffer ( &buffer, 0x7c00, 0x100 );
+		if ( ! load ( &dev, &buffer ) ) {
+			/* Load (e.g. TFTP failed) */
+			printf ( "...load failed\n" );
+			continue;
+		}
+
+		printf ( "Loaded file of size %d\n", buffer.fill );
 
 	}
 

src/core/nic.c

 
 
 /*
- * Download a file from the specified URL and process it with the
- * specified function
+ * Download a file from the specified URL into the specified buffer
  *
  */
-int download_url ( char *url,
-		   int ( * process ) ( unsigned char *data,
-				       unsigned int blocknum,
-				       unsigned int len, int eof ) ) {
+int download_url ( char *url, struct buffer *buffer ) {
 	struct protocol *proto;
 	struct sockaddr_in server;
 	char *filename;
 	}
 	
 	/* Call protocol's method to download the file */
-	return proto->load ( url, &server, filename, process );
+	return proto->load ( url, &server, filename, buffer );
 }
 
 
 /**************************************************************************
 LOAD - Try to get booted
 **************************************************************************/
-static int nic_load ( struct type_dev *type_dev,
-		      int ( * process ) ( unsigned char *data,
-					  unsigned int blocknum,
-					  unsigned int size, int eof ) ) {
+static int nic_load ( struct type_dev *type_dev, struct buffer *buffer ) {
 	char	*kernel;
 
 	/* Now use TFTP to load file */
 #endif
 		: KERNEL_BUF;
 	if ( kernel ) {
-		download_url(kernel,process); /* We don't return except on error */
-		printf("Unable to load file.\n");
+		return download_url ( kernel, buffer );
 	} else {	
 		printf("No filename\n");
 	}
-	interruptible_sleep(2);		/* lay off the server for a while */
 	return 0;
 }
 

src/include/dev.h

 
 #include "stdint.h"
 #include "string.h"
+#include "buffer.h"
 #include "dhcp.h" /* for dhcp_dev_id */
 #include "tables.h"
 
 	struct type_dev *type_dev; /* single instance */
 	char * ( * describe_device ) ( struct type_dev *type_dev );
 	int ( * configure ) ( struct type_dev *type_dev );
-	int ( * load ) ( struct type_dev *type_dev, 
-			 int ( * process ) ( unsigned char *data,
-					     unsigned int blocknum,
-					     unsigned int len, int eof ) );
+	int ( * load ) ( struct type_dev *type_dev, struct buffer *buffer );
 };
 
 #define __type_driver __attribute__ (( used, __table_section(type_driver,01) ))
 	return dev->type_driver->configure ( dev->type_dev );
 }
 /* Boot from a device */
-static inline int load ( struct dev *dev,
-			 int ( * process ) ( unsigned char *data,
-					     unsigned int blocknum, 
-					     unsigned int len, int eof ) ) {
-	return dev->type_driver->load ( dev->type_dev, process );
+static inline int load ( struct dev *dev, struct buffer *buffer ) {
+	return dev->type_driver->load ( dev->type_dev, buffer );
 }
 
 #endif /* DEV_H */

src/include/proto.h

 #define PROTO_H
 
 #include "tables.h"
+#include "buffer.h"
 #include "in.h"
 
 struct protocol {
 	char *name;
 	in_port_t default_port;
-	int ( * load ) ( char *url,
-			 struct sockaddr_in *server,
-			 char *file,
-			 int ( * process ) ( unsigned char *data,
-					     unsigned int blocknum,
-					     unsigned int len,
-					     int eof ) );
+	int ( * load ) ( char *url, struct sockaddr_in *server, char *file,
+			 struct buffer *buffer );
 };
 
 /*

src/include/tftp.h

 #define	TFTP_H
 
 #include "in.h"
+#include "buffer.h"
 #include "nic.h"
 
 #define TFTP_PORT	69
  */
 extern int tftp_block ( struct tftpreq_info_t *request,
 			struct tftpblk_info_t *block );
-extern int tftp ( char *url,
-		  struct sockaddr_in *server,
-		  char *file,
-		  int ( * process ) ( unsigned char *data,
-				      unsigned int blocknum,
-				      unsigned int len, int eof ) );
+extern int tftp ( char *url, struct sockaddr_in *server, char *file,
+		  struct buffer *buffer );
 
 #endif	/* TFTP_H */

src/proto/tftp.c

  * Download a file via TFTP
  *
  */
-int tftp ( char *url __unused,
-	   struct sockaddr_in *server,
-	   char *file,
-	   int ( * process ) ( unsigned char *data,
-			       unsigned int blocknum,
-			       unsigned int len, int eof ) ) {
+int tftp ( char *url __unused, struct sockaddr_in *server, char *file,
+	   struct buffer *buffer ) {
 	struct tftpreq_info_t request_data = {
 		.server = server,
 		.name = file,
 	};
 	struct tftpreq_info_t *request = &request_data;
 	struct tftpblk_info_t block;
-	int rc;
+	off_t offset = 0;
 
-	while ( tftp_block ( request, &block ) ) {
+	do {
+		if ( ! tftp_block ( request, &block ) )
+			return 0;
+		if ( ! fill_buffer ( buffer, block.data, offset, block.len ) )
+			return 0;
+		offset += block.len;
 		request = NULL; /* Send request only once */
-		rc = process ( block.data, block.block, block.len, block.eof );
-		if ( rc <= 0 ) return ( rc );
-	}
-	return 0;
+	} while ( ! block.eof );
+
+	return 1;
 }
 
 struct protocol tftp_protocol __default_protocol = {