Moved protocols to proto/

4 files changed, 1848 insertions, 0 deletions

diff --git a/src/proto/http.c b/src/proto/http.c
new file mode 100644
index 000000000..f2dc9dd18
--- /dev/null
+++ b/src/proto/http.c
@@ -0,0 +1,206 @@
+#include "etherboot.h"
+#include "http.h"
+
+#ifdef DOWNLOAD_PROTO_HTTP
+
+/* The block size is currently chosen to be 512 bytes. This means, we can
+   allocate the receive buffer on the stack, but it results in a noticeable
+   performance penalty.
+   This is what needs to be done in order to increase the block size:
+     - size negotiation needs to be implemented in TCP
+     - the buffer needs to be allocated on the heap
+     - path MTU discovery needs to be implemented
+*/ /***/ /* FIXME */
+#define BLOCKSIZE TFTP_DEFAULTSIZE_PACKET
+
+/**************************************************************************
+SEND_TCP_CALLBACK - Send data using TCP
+**************************************************************************/
+struct send_recv_state {
+	int (*fnc)(unsigned char *data, int block, int len, int eof);
+	char *send_buffer;
+	char *recv_buffer;
+	int send_length;
+	int recv_length;
+	int bytes_sent;
+	int block;
+	int bytes_received;
+	enum { RESULT_CODE, HEADER, DATA, ERROR, MOVED } recv_state;
+	int rc;
+	char location[MAX_URL+1];
+};
+
+static int send_tcp_request(int length, void *buffer, void *ptr) {
+	struct send_recv_state *state = (struct send_recv_state *)ptr;
+
+	if (length > state->send_length - state->bytes_sent)
+		length = state->send_length - state->bytes_sent;
+	memcpy(buffer, state->send_buffer + state->bytes_sent, length);
+	state->bytes_sent += length;
+	return (length);
+}
+
+/**************************************************************************
+RECV_TCP_CALLBACK - Receive data using TCP
+**************************************************************************/
+static int recv_tcp_request(int length, const void *buffer, void *ptr) {
+	struct send_recv_state *state = (struct send_recv_state *)ptr;
+
+	/* Assume that the lines in an HTTP header do not straddle a packet */
+	/* boundary. This is probably a reasonable assumption */
+	if (state->recv_state == RESULT_CODE) {
+		while (length > 0) {
+			/* Find HTTP result code */
+			if (*(const char *)buffer == ' ') {
+				const char *ptr = ((const char *)buffer) + 1;
+				int rc = strtoul(ptr, &ptr, 10);
+				if (ptr >= (const char *)buffer + length) {
+					state->recv_state = ERROR;
+					return 0;
+				}
+				state->rc = rc;
+				state->recv_state = HEADER;
+				goto header;
+			}
+			++(const char *)buffer;
+			length--;
+		}
+		state->recv_state = ERROR;
+		return 0;
+	}
+	if (state->recv_state == HEADER) {
+	header: while (length > 0) {
+			/* Check for HTTP redirect */
+			if (state->rc >= 300 && state->rc < 400 &&
+			    !memcmp(buffer, "Location: ", 10)) {
+				char *ptr = state->location;
+				int i;
+				memcpy(ptr, buffer + 10, MAX_URL);
+				for (i = 0; i < MAX_URL && *ptr > ' ';
+				     i++, ptr++);
+				*ptr = '\000';
+				state->recv_state = MOVED;
+				return 1;
+			}
+			/* Find beginning of line */
+			while (length > 0) {
+				length--;
+				if (*((const char *)buffer)++ == '\n')
+					break;
+			}
+			/* Check for end of header */
+			if (length >= 2 && !memcmp(buffer, "\r\n", 2)) {
+				state->recv_state = DATA;
+				buffer += 2;
+				length -= 2;
+				break;
+			}
+		}
+	}
+	if (state->recv_state == DATA) {
+		state->bytes_received += length;
+		while (length > 0) {
+			int copy_length = BLOCKSIZE - state->recv_length;
+			if (copy_length > length)
+				copy_length = length;
+			memcpy(state->recv_buffer + state->recv_length,
+			       buffer, copy_length);
+			if ((state->recv_length += copy_length) == BLOCKSIZE) {
+				if (!state->fnc(state->recv_buffer,
+						++state->block, BLOCKSIZE, 0))
+					return 0;
+				state->recv_length = 0;
+			}
+			length -= copy_length;
+			buffer += copy_length;
+		}
+	}
+	return 1;
+}
+
+/**************************************************************************
+HTTP_GET - Get data using HTTP
+**************************************************************************/
+int http(const char *url,
+		int (*fnc)(unsigned char *, unsigned int, unsigned int, int)) {
+	static const char GET[] = "GET /%s HTTP/1.0\r\n\r\n";
+	static char recv_buffer[BLOCKSIZE];
+	in_addr destip;
+	int port;
+	int length;
+	struct send_recv_state state;
+
+	state.fnc = fnc;
+	state.rc = -1;
+	state.block = 0;
+	state.recv_buffer = recv_buffer;
+	length = strlen(url);
+	if (length <= MAX_URL) {
+		memcpy(state.location, url, length+1);
+		destip = arptable[ARP_SERVER].ipaddr;
+		port = url_port;
+		if (port == -1)
+		  port = 80;
+		goto first_time;
+
+		do {
+			state.rc = -1;
+			state.block = 0;
+			url = state.location;
+			if (memcmp("http://", url, 7))
+				break;
+			url += 7;
+			length = inet_aton(url, &destip);
+			if (!length) {
+				/* As we do not have support for DNS, assume*/
+				/* that HTTP redirects always point to the */
+				/* same machine */
+				if (state.recv_state == MOVED) {
+					while (*url &&
+					*url != ':' && *url != '/') url++;
+				} else {
+					break;
+				}
+			}
+			if (*(url += length) == ':') {
+				port = strtoul(url, &url, 10);
+			} else {
+				port = 80;
+			}
+			if (!*url)
+				url = "/";
+			if (*url != '/')
+				break;
+			url++;
+
+		first_time:
+			length = strlen(url);
+			state.send_length = sizeof(GET) - 3 + length;
+			
+			{ char buf[state.send_length + 1];
+			sprintf(state.send_buffer = buf, GET, url);
+			state.bytes_sent = 0;
+			
+			state.bytes_received = 0;
+			state.recv_state = RESULT_CODE;
+			
+			state.recv_length = 0;
+			tcp_transaction(destip.s_addr, 80, &state,
+					send_tcp_request, recv_tcp_request);
+			}
+		} while (state.recv_state == MOVED);
+	} else {
+		memcpy(state.location, url, MAX_URL);
+		state.location[MAX_URL] = '\000';
+	}
+
+	if (state.rc == 200) {
+		return fnc(recv_buffer, ++state.block, state.recv_length, 1);
+	} else {
+		printf("Failed to download %s (rc = %d)\n",
+		       state.location, state.rc);
+		return 0;
+	}
+}
+
+#endif /* DOWNLOAD_PROTO_HTTP */
diff --git a/src/proto/nfs.c b/src/proto/nfs.c
new file mode 100644
index 000000000..cbda6ab7b
--- /dev/null
+++ b/src/proto/nfs.c
@@ -0,0 +1,610 @@
+#ifdef	DOWNLOAD_PROTO_NFS
+
+#include "etherboot.h"
+#include "nic.h"
+
+/* NOTE: the NFS code is heavily inspired by the NetBSD netboot code (read:
+ * large portions are copied verbatim) as distributed in OSKit 0.97.  A few
+ * changes were necessary to adapt the code to Etherboot and to fix several
+ * inconsistencies.  Also the RPC message preparation is done "by hand" to
+ * avoid adding netsprintf() which I find hard to understand and use.  */
+
+/* NOTE 2: Etherboot does not care about things beyond the kernel image, so
+ * it loads the kernel image off the boot server (ARP_SERVER) and does not
+ * access the client root disk (root-path in dhcpd.conf), which would use
+ * ARP_ROOTSERVER.  The root disk is something the operating system we are
+ * about to load needs to use.  This is different from the OSKit 0.97 logic.  */
+
+/* NOTE 3: Symlink handling introduced by Anselm M Hoffmeister, 2003-July-14
+ * If a symlink is encountered, it is followed as far as possible (recursion
+ * possible, maximum 16 steps). There is no clearing of ".."'s inside the
+ * path, so please DON'T DO THAT. thx. */
+
+#define START_OPORT 700		/* mountd usually insists on secure ports */
+#define OPORT_SWEEP 200		/* make sure we don't leave secure range */
+
+static int oport = START_OPORT;
+static int mount_port = -1;
+static int nfs_port = -1;
+static int fs_mounted = 0;
+static unsigned long rpc_id;
+
+/**************************************************************************
+RPC_INIT - set up the ID counter to something fairly random
+**************************************************************************/
+void rpc_init(void)
+{
+	unsigned long t;
+
+	t = currticks();
+	rpc_id = t ^ (t << 8) ^ (t << 16);
+}
+
+
+/**************************************************************************
+RPC_PRINTERROR - Print a low level RPC error message
+**************************************************************************/
+static void rpc_printerror(struct rpc_t *rpc)
+{
+	if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
+	    rpc->u.reply.astatus) {
+		/* rpc_printerror() is called for any RPC related error,
+		 * suppress output if no low level RPC error happened.  */
+		printf("RPC error: (%d,%d,%d)\n", ntohl(rpc->u.reply.rstatus),
+			ntohl(rpc->u.reply.verifier),
+			ntohl(rpc->u.reply.astatus));
+	}
+}
+
+/**************************************************************************
+AWAIT_RPC - Wait for an rpc packet
+**************************************************************************/
+static int await_rpc(int ival, void *ptr,
+	unsigned short ptype, struct iphdr *ip, struct udphdr *udp)
+{
+	struct rpc_t *rpc;
+	if (!udp) 
+		return 0;
+	if (arptable[ARP_CLIENT].ipaddr.s_addr != ip->dest.s_addr)
+		return 0;
+	if (ntohs(udp->dest) != ival)
+		return 0;
+	if (nic.packetlen < ETH_HLEN + sizeof(struct iphdr) + sizeof(struct udphdr) + 8)
+		return 0;
+	rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
+	if (*(unsigned long *)ptr != ntohl(rpc->u.reply.id))
+		return 0;
+	if (MSG_REPLY != ntohl(rpc->u.reply.type))
+		return 0;
+	return 1;
+}
+
+/**************************************************************************
+RPC_LOOKUP - Lookup RPC Port numbers
+**************************************************************************/
+static int rpc_lookup(int addr, int prog, int ver, int sport)
+{
+	struct rpc_t buf, *rpc;
+	unsigned long id;
+	int retries;
+	long *p;
+
+	id = rpc_id++;
+	buf.u.call.id = htonl(id);
+	buf.u.call.type = htonl(MSG_CALL);
+	buf.u.call.rpcvers = htonl(2);	/* use RPC version 2 */
+	buf.u.call.prog = htonl(PROG_PORTMAP);
+	buf.u.call.vers = htonl(2);	/* portmapper is version 2 */
+	buf.u.call.proc = htonl(PORTMAP_GETPORT);
+	p = (long *)buf.u.call.data;
+	*p++ = 0; *p++ = 0;				/* auth credential */
+	*p++ = 0; *p++ = 0;				/* auth verifier */
+	*p++ = htonl(prog);
+	*p++ = htonl(ver);
+	*p++ = htonl(IP_UDP);
+	*p++ = 0;
+	for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
+		long timeout;
+		udp_transmit(arptable[addr].ipaddr.s_addr, sport, SUNRPC_PORT,
+			(char *)p - (char *)&buf, &buf);
+		timeout = rfc2131_sleep_interval(TIMEOUT, retries);
+		if (await_reply(await_rpc, sport, &id, timeout)) {
+			rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
+			if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
+			    rpc->u.reply.astatus) {
+				rpc_printerror(rpc);
+				return -1;
+			} else {
+				return ntohl(rpc->u.reply.data[0]);
+			}
+		}
+	}
+	return -1;
+}
+
+/**************************************************************************
+RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
+**************************************************************************/
+static long *rpc_add_credentials(long *p)
+{
+	int hl;
+
+	/* Here's the executive summary on authentication requirements of the
+	 * various NFS server implementations:  Linux accepts both AUTH_NONE
+	 * and AUTH_UNIX authentication (also accepts an empty hostname field
+	 * in the AUTH_UNIX scheme).  *BSD refuses AUTH_NONE, but accepts
+	 * AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
+	 * scheme).  To be safe, use AUTH_UNIX and pass the hostname if we have
+	 * it (if the BOOTP/DHCP reply didn't give one, just use an empty
+	 * hostname).  */
+
+	hl = (hostnamelen + 3) & ~3;
+
+	/* Provide an AUTH_UNIX credential.  */
+	*p++ = htonl(1);		/* AUTH_UNIX */
+	*p++ = htonl(hl+20);		/* auth length */
+	*p++ = htonl(0);		/* stamp */
+	*p++ = htonl(hostnamelen);	/* hostname string */
+	if (hostnamelen & 3) {
+		*(p + hostnamelen / 4) = 0; /* add zero padding */
+	}
+	memcpy(p, hostname, hostnamelen);
+	p += hl / 4;
+	*p++ = 0;			/* uid */
+	*p++ = 0;			/* gid */
+	*p++ = 0;			/* auxiliary gid list */
+
+	/* Provide an AUTH_NONE verifier.  */
+	*p++ = 0;			/* AUTH_NONE */
+	*p++ = 0;			/* auth length */
+
+	return p;
+}
+
+/**************************************************************************
+NFS_PRINTERROR - Print a NFS error message
+**************************************************************************/
+static void nfs_printerror(int err)
+{
+	switch (-err) {
+	case NFSERR_PERM:
+		printf("Not owner\n");
+		break;
+	case NFSERR_NOENT:
+		printf("No such file or directory\n");
+		break;
+	case NFSERR_ACCES:
+		printf("Permission denied\n");
+		break;
+	case NFSERR_ISDIR:
+		printf("Directory given where filename expected\n");
+		break;
+	case NFSERR_INVAL:
+		printf("Invalid filehandle\n");
+		break; // INVAL is not defined in NFSv2, some NFS-servers
+		// seem to use it in answers to v2 nevertheless.
+	case 9998:
+		printf("low-level RPC failure (parameter decoding problem?)\n");
+		break;
+	case 9999:
+		printf("low-level RPC failure (authentication problem?)\n");
+		break;
+	default:
+		printf("Unknown NFS error %d\n", -err);
+	}
+}
+
+/**************************************************************************
+NFS_MOUNT - Mount an NFS Filesystem
+**************************************************************************/
+static int nfs_mount(int server, int port, char *path, char *fh, int sport)
+{
+	struct rpc_t buf, *rpc;
+	unsigned long id;
+	int retries;
+	long *p;
+	int pathlen = strlen(path);
+
+	id = rpc_id++;
+	buf.u.call.id = htonl(id);
+	buf.u.call.type = htonl(MSG_CALL);
+	buf.u.call.rpcvers = htonl(2);	/* use RPC version 2 */
+	buf.u.call.prog = htonl(PROG_MOUNT);
+	buf.u.call.vers = htonl(1);	/* mountd is version 1 */
+	buf.u.call.proc = htonl(MOUNT_ADDENTRY);
+	p = rpc_add_credentials((long *)buf.u.call.data);
+	*p++ = htonl(pathlen);
+	if (pathlen & 3) {
+		*(p + pathlen / 4) = 0;	/* add zero padding */
+	}
+	memcpy(p, path, pathlen);
+	p += (pathlen + 3) / 4;
+	for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
+		long timeout;
+		udp_transmit(arptable[server].ipaddr.s_addr, sport, port,
+			(char *)p - (char *)&buf, &buf);
+		timeout = rfc2131_sleep_interval(TIMEOUT, retries);
+		if (await_reply(await_rpc, sport, &id, timeout)) {
+			rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
+			if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
+			    rpc->u.reply.astatus || rpc->u.reply.data[0]) {
+				rpc_printerror(rpc);
+				if (rpc->u.reply.rstatus) {
+					/* RPC failed, no verifier, data[0] */
+					return -9999;
+				}
+				if (rpc->u.reply.astatus) {
+					/* RPC couldn't decode parameters */
+					return -9998;
+				}
+				return -ntohl(rpc->u.reply.data[0]);
+			} else {
+				fs_mounted = 1;
+				memcpy(fh, rpc->u.reply.data + 1, NFS_FHSIZE);
+				return 0;
+			}
+		}
+	}
+	return -1;
+}
+
+/**************************************************************************
+NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
+**************************************************************************/
+void nfs_umountall(int server)
+{
+	struct rpc_t buf, *rpc;
+	unsigned long id;
+	int retries;
+	long *p;
+
+	if (!arptable[server].ipaddr.s_addr) {
+		/* Haven't sent a single UDP packet to this server */
+		return;
+	}
+	if ((mount_port == -1) || (!fs_mounted)) {
+		/* Nothing mounted, nothing to umount */
+		return;
+	}
+	id = rpc_id++;
+	buf.u.call.id = htonl(id);
+	buf.u.call.type = htonl(MSG_CALL);
+	buf.u.call.rpcvers = htonl(2);	/* use RPC version 2 */
+	buf.u.call.prog = htonl(PROG_MOUNT);
+	buf.u.call.vers = htonl(1);	/* mountd is version 1 */
+	buf.u.call.proc = htonl(MOUNT_UMOUNTALL);
+	p = rpc_add_credentials((long *)buf.u.call.data);
+	for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
+		long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
+		udp_transmit(arptable[server].ipaddr.s_addr, oport, mount_port,
+			(char *)p - (char *)&buf, &buf);
+		if (await_reply(await_rpc, oport, &id, timeout)) {
+			rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
+			if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
+			    rpc->u.reply.astatus) {
+				rpc_printerror(rpc);
+			}
+			fs_mounted = 0;
+			return;
+		}
+	}
+}
+/***************************************************************************
+ * NFS_READLINK (AH 2003-07-14)
+ * This procedure is called when read of the first block fails -
+ * this probably happens when it's a directory or a symlink
+ * In case of successful readlink(), the dirname is manipulated,
+ * so that inside the nfs() function a recursion can be done.
+ **************************************************************************/
+static int nfs_readlink(int server, int port, char *fh, char *path, char *nfh,
+	int sport)
+{
+	struct rpc_t buf, *rpc;
+	unsigned long id;
+	long *p;
+	int retries;
+	int pathlen = strlen(path);
+
+	id = rpc_id++;
+	buf.u.call.id = htonl(id);
+	buf.u.call.type = htonl(MSG_CALL);
+	buf.u.call.rpcvers = htonl(2);	/* use RPC version 2 */
+	buf.u.call.prog = htonl(PROG_NFS);
+	buf.u.call.vers = htonl(2);	/* nfsd is version 2 */
+	buf.u.call.proc = htonl(NFS_READLINK);
+	p = rpc_add_credentials((long *)buf.u.call.data);
+	memcpy(p, nfh, NFS_FHSIZE);
+	p += (NFS_FHSIZE / 4);
+	for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
+		long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
+		udp_transmit(arptable[server].ipaddr.s_addr, sport, port,
+			(char *)p - (char *)&buf, &buf);
+		if (await_reply(await_rpc, sport, &id, timeout)) {
+			rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
+			if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
+			    rpc->u.reply.astatus || rpc->u.reply.data[0]) {
+				rpc_printerror(rpc);
+				if (rpc->u.reply.rstatus) {
+					/* RPC failed, no verifier, data[0] */
+					return -9999;
+				}
+				if (rpc->u.reply.astatus) {
+					/* RPC couldn't decode parameters */
+					return -9998;
+				}
+				return -ntohl(rpc->u.reply.data[0]);
+			} else {
+				// It *is* a link.
+				// If it's a relative link, append everything to dirname, filename TOO!
+				retries = strlen ( (char *)(&(rpc->u.reply.data[2]) ));
+				if ( *((char *)(&(rpc->u.reply.data[2]))) != '/' ) {
+					path[pathlen++] = '/';
+					while ( ( retries + pathlen ) > 298 ) {
+						retries--;
+					}
+					if ( retries > 0 ) {
+						memcpy(path + pathlen, &(rpc->u.reply.data[2]), retries + 1);
+					} else { retries = 0; }
+					path[pathlen + retries] = 0;
+				} else {
+					// Else make it the only path.
+					if ( retries > 298 ) { retries = 298; }
+					memcpy ( path, &(rpc->u.reply.data[2]), retries + 1 );
+					path[retries] = 0;
+				}
+				return 0;
+			}
+		}
+	}
+	return -1;
+}
+/**************************************************************************
+NFS_LOOKUP - Lookup Pathname
+**************************************************************************/
+static int nfs_lookup(int server, int port, char *fh, char *path, char *nfh,
+	int sport)
+{
+	struct rpc_t buf, *rpc;
+	unsigned long id;
+	long *p;
+	int retries;
+	int pathlen = strlen(path);
+
+	id = rpc_id++;
+	buf.u.call.id = htonl(id);
+	buf.u.call.type = htonl(MSG_CALL);
+	buf.u.call.rpcvers = htonl(2);	/* use RPC version 2 */
+	buf.u.call.prog = htonl(PROG_NFS);
+	buf.u.call.vers = htonl(2);	/* nfsd is version 2 */
+	buf.u.call.proc = htonl(NFS_LOOKUP);
+	p = rpc_add_credentials((long *)buf.u.call.data);
+	memcpy(p, fh, NFS_FHSIZE);
+	p += (NFS_FHSIZE / 4);
+	*p++ = htonl(pathlen);
+	if (pathlen & 3) {
+		*(p + pathlen / 4) = 0;	/* add zero padding */
+	}
+	memcpy(p, path, pathlen);
+	p += (pathlen + 3) / 4;
+	for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
+		long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
+		udp_transmit(arptable[server].ipaddr.s_addr, sport, port,
+			(char *)p - (char *)&buf, &buf);
+		if (await_reply(await_rpc, sport, &id, timeout)) {
+			rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
+			if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
+			    rpc->u.reply.astatus || rpc->u.reply.data[0]) {
+				rpc_printerror(rpc);
+				if (rpc->u.reply.rstatus) {
+					/* RPC failed, no verifier, data[0] */
+					return -9999;
+				}
+				if (rpc->u.reply.astatus) {
+					/* RPC couldn't decode parameters */
+					return -9998;
+				}
+				return -ntohl(rpc->u.reply.data[0]);
+			} else {
+				memcpy(nfh, rpc->u.reply.data + 1, NFS_FHSIZE);
+				return 0;
+			}
+		}
+	}
+	return -1;
+}
+
+/**************************************************************************
+NFS_READ - Read File on NFS Server
+**************************************************************************/
+static int nfs_read(int server, int port, char *fh, int offset, int len,
+		    int sport)
+{
+	struct rpc_t buf, *rpc;
+	unsigned long id;
+	int retries;
+	long *p;
+
+	static int tokens=0;
+	/*
+	 * Try to implement something similar to a window protocol in
+	 * terms of response to losses. On successful receive, increment
+	 * the number of tokens by 1 (cap at 256). On failure, halve it.
+	 * When the number of tokens is >= 2, use a very short timeout.
+	 */
+
+	id = rpc_id++;
+	buf.u.call.id = htonl(id);
+	buf.u.call.type = htonl(MSG_CALL);
+	buf.u.call.rpcvers = htonl(2);	/* use RPC version 2 */
+	buf.u.call.prog = htonl(PROG_NFS);
+	buf.u.call.vers = htonl(2);	/* nfsd is version 2 */
+	buf.u.call.proc = htonl(NFS_READ);
+	p = rpc_add_credentials((long *)buf.u.call.data);
+	memcpy(p, fh, NFS_FHSIZE);
+	p += NFS_FHSIZE / 4;
+	*p++ = htonl(offset);
+	*p++ = htonl(len);
+	*p++ = 0;		/* unused parameter */
+	for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
+		long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
+		if (tokens >= 2)
+			timeout = TICKS_PER_SEC/2;
+
+		udp_transmit(arptable[server].ipaddr.s_addr, sport, port,
+			(char *)p - (char *)&buf, &buf);
+		if (await_reply(await_rpc, sport, &id, timeout)) {
+			if (tokens < 256)
+				tokens++;
+			rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
+			if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
+			    rpc->u.reply.astatus || rpc->u.reply.data[0]) {
+				rpc_printerror(rpc);
+				if (rpc->u.reply.rstatus) {
+					/* RPC failed, no verifier, data[0] */
+					return -9999;
+				}
+				if (rpc->u.reply.astatus) {
+					/* RPC couldn't decode parameters */
+					return -9998;
+				}
+				return -ntohl(rpc->u.reply.data[0]);
+			} else {
+				return 0;
+			}
+		} else
+			tokens >>= 1;
+	}
+	return -1;
+}
+
+/**************************************************************************
+NFS - Download extended BOOTP data, or kernel image from NFS server
+**************************************************************************/
+int nfs(const char *name, int (*fnc)(unsigned char *, unsigned int, unsigned int, int))
+{
+	static int recursion = 0;
+	int sport;
+	int err, namelen = strlen(name);
+	char dirname[300], *fname;
+	char dirfh[NFS_FHSIZE];		/* file handle of directory */
+	char filefh[NFS_FHSIZE];	/* file handle of kernel image */
+	unsigned int block;
+	int rlen, size, offs, len;
+	struct rpc_t *rpc;
+
+	rx_qdrain();
+
+	sport = oport++;
+	if (oport > START_OPORT+OPORT_SWEEP) {
+		oport = START_OPORT;
+	}
+	if ( name != dirname ) {
+		memcpy(dirname, name, namelen + 1);
+	}
+	recursion = 0;
+nfssymlink:
+	if ( recursion > NFS_MAXLINKDEPTH ) {
+		printf ( "\nRecursion: More than %d symlinks followed. Abort.\n", NFS_MAXLINKDEPTH );
+		return	0;
+	}
+	recursion++;
+	fname = dirname + (namelen - 1);
+	while (fname >= dirname) {
+		if (*fname == '/') {
+			*fname = '\0';
+			fname++;
+			break;
+		}
+		fname--;
+	}
+	if (fname < dirname) {
+		printf("can't parse file name %s\n", name);
+		return 0;
+	}
+
+	if (mount_port == -1) {
+		mount_port = rpc_lookup(ARP_SERVER, PROG_MOUNT, 1, sport);
+	}
+	if (nfs_port == -1) {
+		nfs_port = rpc_lookup(ARP_SERVER, PROG_NFS, 2, sport);
+	}
+	if (nfs_port == -1 || mount_port == -1) {
+		printf("can't get nfs/mount ports from portmapper\n");
+		return 0;
+	}
+
+
+	err = nfs_mount(ARP_SERVER, mount_port, dirname, dirfh, sport);
+	if (err) {
+		printf("mounting %s: ", dirname);
+		nfs_printerror(err);
+		/* just to be sure... */
+		nfs_umountall(ARP_SERVER);
+		return 0;
+	}
+
+	err = nfs_lookup(ARP_SERVER, nfs_port, dirfh, fname, filefh, sport);
+	if (err) {
+		printf("looking up %s: ", fname);
+		nfs_printerror(err);
+		nfs_umountall(ARP_SERVER);
+		return 0;
+	}
+
+	offs = 0;
+	block = 1;	/* blocks are numbered starting from 1 */
+	size = -1;	/* will be set properly with the first reply */
+	len = NFS_READ_SIZE;	/* first request is always full size */
+	do {
+		err = nfs_read(ARP_SERVER, nfs_port, filefh, offs, len, sport);
+                if ((err <= -NFSERR_ISDIR)&&(err >= -NFSERR_INVAL) && (offs == 0)) {
+			// An error occured. NFS servers tend to sending
+			// errors 21 / 22 when symlink instead of real file
+			// is requested. So check if it's a symlink!
+			block = nfs_readlink(ARP_SERVER, nfs_port, dirfh, dirname,
+			                filefh, sport);
+			if ( 0 == block ) {
+				printf("\nLoading symlink:%s ..",dirname);
+				goto nfssymlink;
+			}
+			nfs_printerror(err);
+			nfs_umountall(ARP_SERVER);
+			return 0;
+		}
+		if (err) {
+			printf("reading at offset %d: ", offs);
+			nfs_printerror(err);
+			nfs_umountall(ARP_SERVER);
+			return 0;
+		}
+
+		rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
+
+		/* size must be found out early to allow EOF detection */
+		if (size == -1) {
+			size = ntohl(rpc->u.reply.data[6]);
+		}
+		rlen = ntohl(rpc->u.reply.data[18]);
+		if (rlen > len) {
+			rlen = len;	/* shouldn't happen...  */
+		}
+
+		err = fnc((char *)&rpc->u.reply.data[19], block, rlen,
+			(offs+rlen == size));
+		if (err <= 0) {
+			nfs_umountall(ARP_SERVER);
+			return err;
+		}
+
+		block++;
+		offs += rlen;
+		/* last request is done with matching requested read size */
+		if (size-offs < NFS_READ_SIZE) {
+			len = size-offs;
+		}
+	} while (len != 0);
+	/* len == 0 means that all the file has been read */
+	return 1;
+}
+
+#endif	/* DOWNLOAD_PROTO_NFS */
diff --git a/src/proto/slam.c b/src/proto/slam.c
new file mode 100644
index 000000000..135384a9c
--- /dev/null
+++ b/src/proto/slam.c
@@ -0,0 +1,541 @@
+#ifdef DOWNLOAD_PROTO_SLAM
+#include "etherboot.h"
+#include "nic.h"
+
+#define SLAM_PORT 10000
+#define SLAM_MULTICAST_IP ((239<<24)|(255<<16)|(1<<8)|(1<<0))
+#define SLAM_MULTICAST_PORT 10000
+#define SLAM_LOCAL_PORT 10000
+
+/* Set the timeout intervals to at least 1 second so
+ * on a 100Mbit ethernet can receive 10000 packets
+ * in one second.  
+ *
+ * The only case that is likely to trigger all of the nodes
+ * firing a nack packet is a slow server.  The odds of this
+ * happening could be reduced being slightly smarter and utilizing 
+ * the multicast channels for nacks.   But that only improves the odds
+ * it doesn't improve the worst case.  So unless this proves to be
+ * a common case having the control data going unicast should increase
+ * the odds of the data not being dropped.  
+ *
+ * When doing exponential backoff we increase just the timeout
+ * interval and not the base to optimize for throughput.  This is only
+ * expected to happen when the server is down.  So having some nodes
+ * pinging immediately should get the transmission restarted quickly after a
+ * server restart.  The host nic won't be to baddly swamped because of
+ * the random distribution of the nodes.
+ *
+ */
+#define SLAM_INITIAL_MIN_TIMEOUT      (TICKS_PER_SEC/3)
+#define SLAM_INITIAL_TIMEOUT_INTERVAL (TICKS_PER_SEC)
+#define SLAM_BASE_MIN_TIMEOUT         (2*TICKS_PER_SEC)
+#define SLAM_BASE_TIMEOUT_INTERVAL    (4*TICKS_PER_SEC)
+#define SLAM_BACKOFF_LIMIT 5
+#define SLAM_MAX_RETRIES 20
+
+/*** Packets Formats ***
+ * Data Packet:
+ *   transaction
+ *   total bytes
+ *   block size
+ *   packet #
+ *   data
+ *
+ * Status Request Packet
+ *   transaction
+ *   total bytes
+ *   block size
+ *
+ * Status Packet
+ *   received packets
+ *   requested packets
+ *   received packets
+ *   requested packets
+ *   ...
+ *   received packets
+ *   requested packtes
+ *   0
+ */
+
+#define MAX_HDR (7 + 7 + 7) /* transaction, total size, block size */
+#define MIN_HDR (1 + 1 + 1) /* transactino, total size, block size */
+
+#define MAX_SLAM_REQUEST MAX_HDR
+#define MIN_SLAM_REQUEST MIN_HDR
+
+#define MIN_SLAM_DATA (MIN_HDR + 1)
+
+static struct slam_nack {
+	struct iphdr ip;
+	struct udphdr udp;
+	unsigned char data[ETH_MAX_MTU - 
+		(sizeof(struct iphdr) + sizeof(struct udphdr))];
+} nack;
+
+struct slam_state {
+	unsigned char hdr[MAX_HDR];
+	unsigned long hdr_len;
+	unsigned long block_size;
+	unsigned long total_bytes;
+	unsigned long total_packets;
+
+	unsigned long received_packets;
+
+	unsigned char *image;
+	unsigned char *bitmap;
+} state;
+
+
+static void init_slam_state(void)
+{
+	state.hdr_len = sizeof(state.hdr);
+	memset(state.hdr, 0, state.hdr_len);
+	state.block_size = 0;
+	state.total_packets = 0;
+
+	state.received_packets = 0;
+
+	state.image = 0;
+	state.bitmap = 0;
+}
+
+struct slam_info {
+	in_addr server_ip;
+	in_addr multicast_ip;
+	in_addr local_ip;
+	uint16_t server_port;
+	uint16_t multicast_port;
+	uint16_t local_port;
+	int (*fnc)(unsigned char *, unsigned int, unsigned int, int);
+	int sent_nack;
+};
+
+#define SLAM_TIMEOUT 0
+#define SLAM_REQUEST 1
+#define SLAM_DATA    2
+static int await_slam(int ival __unused, void *ptr,
+	unsigned short ptype __unused, struct iphdr *ip, struct udphdr *udp)
+{
+	struct slam_info *info = ptr;
+	if (!udp) {
+		return 0;
+	}
+	/* I can receive two kinds of packets here, a multicast data packet,
+	 * or a unicast request for information 
+	 */
+	/* Check for a data request packet */
+	if ((ip->dest.s_addr == arptable[ARP_CLIENT].ipaddr.s_addr) &&
+		(ntohs(udp->dest) == info->local_port) && 
+		(nic.packetlen >= 
+			ETH_HLEN + 
+			sizeof(struct iphdr) + 
+			sizeof(struct udphdr) +
+			MIN_SLAM_REQUEST)) {
+		return SLAM_REQUEST;
+	}
+	/* Check for a multicast data packet */
+	if ((ip->dest.s_addr == info->multicast_ip.s_addr) &&
+		(ntohs(udp->dest) == info->multicast_port) &&
+		(nic.packetlen >= 
+			ETH_HLEN + 
+			sizeof(struct iphdr) + 
+			sizeof(struct udphdr) +
+			MIN_SLAM_DATA)) {
+		return SLAM_DATA;
+	}
+#if 0
+	printf("#");
+	printf("dest: %@ port: %d len: %d\n", 
+		ip->dest.s_addr, ntohs(udp->dest), nic.packetlen);
+#endif
+	return 0;
+		
+}
+
+static int slam_encode(
+	unsigned char **ptr, unsigned char *end, unsigned long value)
+{
+	unsigned char *data = *ptr;
+	int bytes;
+	bytes = sizeof(value);
+	while ((bytes > 0) && ((0xff & (value >> ((bytes -1)<<3))) == 0)) {
+		bytes--;
+	}
+	if (bytes <= 0) {
+		bytes = 1;
+	}
+	if (data + bytes >= end) {
+		return -1;
+	}
+	if ((0xe0 & (value >> ((bytes -1)<<3))) == 0) {
+		/* packed together */
+		*data = (bytes << 5) | (value >> ((bytes -1)<<3));
+	} else {
+		bytes++;
+		*data = (bytes << 5);
+	}
+	bytes--;
+	data++;
+	while(bytes) {
+		*(data++) = 0xff & (value >> ((bytes -1)<<3));
+		bytes--;
+	}
+	*ptr = data;
+	return 0;
+}
+
+static int slam_skip(unsigned char **ptr, unsigned char *end) 
+{
+	int bytes;
+	if (*ptr >= end) {
+		return -1;
+	}
+	bytes = ((**ptr) >> 5) & 7;
+	if (bytes == 0) {
+		return -1;
+	}
+	if (*ptr + bytes >= end) {
+		return -1;
+	}
+	(*ptr) += bytes;
+	return 0;
+	
+}
+
+static unsigned long slam_decode(unsigned char **ptr, unsigned char *end, int *err)
+{
+	unsigned long value;
+	unsigned bytes;
+	if (*ptr >= end) {
+		*err = -1;
+	}
+	bytes = ((**ptr) >> 5) & 7;
+	if ((bytes == 0) || (bytes > sizeof(unsigned long))) {
+		*err = -1;
+		return 0;
+	}
+	if ((*ptr) + bytes >= end) {
+		*err =  -1;
+	}
+	value = (**ptr) & 0x1f;
+	bytes--;
+	(*ptr)++;
+	while(bytes) {
+		value <<= 8;
+		value |= **ptr;
+		(*ptr)++;
+		bytes--;
+	}
+	return value;
+}
+
+
+static long slam_sleep_interval(int exp)
+{
+	long range;
+	long divisor;
+	long interval;
+	range = SLAM_BASE_TIMEOUT_INTERVAL;
+	if (exp < 0) { 
+		divisor = RAND_MAX/SLAM_INITIAL_TIMEOUT_INTERVAL;
+	} else {
+		if (exp > SLAM_BACKOFF_LIMIT) 
+			exp = SLAM_BACKOFF_LIMIT;
+		divisor = RAND_MAX/(range << exp);
+	}
+	interval = random()/divisor;
+	if (exp < 0) {
+		interval += SLAM_INITIAL_MIN_TIMEOUT;
+	} else {
+		interval += SLAM_BASE_MIN_TIMEOUT;
+	}
+	return interval;
+}
+
+
+static unsigned char *reinit_slam_state(
+	unsigned char *header, unsigned char *end)
+{
+	unsigned long total_bytes;
+	unsigned long block_size;
+
+	unsigned long bitmap_len;
+	unsigned long max_packet_len;
+	unsigned char *data;
+	int err;
+
+#if 0
+	printf("reinit\n");
+#endif
+	data = header;
+
+	state.hdr_len = 0;
+	err = slam_skip(&data, end); /* transaction id */
+	total_bytes = slam_decode(&data, end, &err);
+	block_size  = slam_decode(&data, end, &err);
+	if (err) {
+		printf("ALERT: slam size out of range\n");
+		return 0;
+	}
+	state.block_size = block_size;
+	state.total_bytes = total_bytes;
+	state.total_packets = (total_bytes + block_size - 1)/block_size;
+	state.hdr_len = data - header;
+	state.received_packets = 0;
+
+	data = state.hdr;
+	slam_encode(&data, &state.hdr[sizeof(state.hdr)], state.total_packets);
+	max_packet_len = data - state.hdr;
+	memcpy(state.hdr, header, state.hdr_len);
+	
+#if 0
+	printf("block_size:     %ld\n", block_size);
+	printf("total_bytes:    %ld\n", total_bytes);
+	printf("total_packets:  %ld\n", state.total_packets);
+	printf("hdr_len:        %ld\n", state.hdr_len);
+	printf("max_packet_len: %ld\n", max_packet_len);
+#endif
+
+	if (state.block_size > ETH_MAX_MTU - (
+		sizeof(struct iphdr) + sizeof(struct udphdr) +
+		state.hdr_len + max_packet_len)) {
+		printf("ALERT: slam blocksize to large\n");
+		return 0;
+	}
+	if (state.bitmap) {
+		forget(state.bitmap);
+	}
+	bitmap_len   = (state.total_packets + 1 + 7)/8;
+	state.bitmap = allot(bitmap_len);
+	state.image  = allot(total_bytes);
+	if ((unsigned long)state.image < 1024*1024) {
+		printf("ALERT: slam filesize to large for available memory\n");
+		return 0;
+	}
+	memset(state.bitmap, 0, bitmap_len);
+
+	return header + state.hdr_len;
+}
+
+static int slam_recv_data(unsigned char *data)
+{
+	unsigned long packet;
+	unsigned long data_len;
+	int err;
+	struct udphdr *udp;
+	udp = (struct udphdr *)&nic.packet[ETH_HLEN + sizeof(struct iphdr)];
+	err = 0;
+	packet = slam_decode(&data, &nic.packet[nic.packetlen], &err);
+	if (err || (packet > state.total_packets)) {
+		printf("ALERT: Invalid packet number\n");
+		return 0;
+	}
+	/* Compute the expected data length */
+	if (packet != state.total_packets -1) {
+		data_len = state.block_size;
+	} else {
+		data_len = state.total_bytes % state.block_size;
+	}
+	/* If the packet size is wrong drop the packet and then continue */
+	if (ntohs(udp->len) != (data_len + (data - (unsigned char*)udp))) {
+		printf("ALERT: udp packet is not the correct size\n");
+		return 1;
+	}
+	if (nic.packetlen < data_len + (data - nic.packet)) {
+		printf("ALERT: Ethernet packet shorter than data_len\n");
+		return 1;
+	}
+	if (data_len > state.block_size) {
+		data_len = state.block_size;
+	}
+	if (((state.bitmap[packet >> 3] >> (packet & 7)) & 1) == 0) {
+		/* Non duplicate packet */
+		state.bitmap[packet >> 3] |= (1 << (packet & 7));
+		memcpy(state.image + (packet*state.block_size), data, data_len);
+		state.received_packets++;
+	} else {
+#ifdef MDEBUG
+		printf("<DUP>\n");
+#endif
+	}
+	return 1;
+}
+
+static void transmit_nack(unsigned char *ptr, struct slam_info *info)
+{
+	int nack_len;
+	/* Ensure the packet is null terminated */
+	*ptr++ = 0;
+	nack_len = ptr - (unsigned char *)&nack;
+	build_udp_hdr(info->server_ip.s_addr, 
+		info->local_port, info->server_port, 1, nack_len, &nack);
+	ip_transmit(nack_len, &nack);
+#if defined(MDEBUG) && 0
+	printf("Sent NACK to %@ bytes: %d have:%ld/%ld\n", 
+		info->server_ip, nack_len,
+		state.received_packets, state.total_packets);
+#endif
+}
+
+static void slam_send_nack(struct slam_info *info)
+{
+	unsigned char *ptr, *end;
+	/* Either I timed out or I was explicitly 
+	 * asked for a request packet 
+	 */
+	ptr = &nack.data[0];
+	/* Reserve space for the trailling null */
+	end = &nack.data[sizeof(nack.data) -1]; 
+	if (!state.bitmap) {
+		slam_encode(&ptr, end, 0);
+		slam_encode(&ptr, end, 1);
+	}
+	else {
+		/* Walk the bitmap */
+		unsigned long i;
+		unsigned long len;
+		unsigned long max;
+		int value;
+		int last;
+		/* Compute the last bit and store an inverted trailer */
+		max = state.total_packets;
+		value = ((state.bitmap[(max -1) >> 3] >> ((max -1) & 7) ) & 1);
+		value = !value;
+		state.bitmap[max >> 3] &= ~(1 << (max & 7));
+		state.bitmap[max >> 3] |= value << (max & 7);
+
+		len = 0;
+		last = 1; /* Start with the received packets */
+		for(i = 0; i <= max; i++) {
+			value = (state.bitmap[i>>3] >> (i & 7)) & 1;
+			if (value == last) {
+				len++;
+			} else {
+				if (slam_encode(&ptr, end, len))
+					break;
+				last = value;
+				len = 1;
+			}
+		}
+	}
+	info->sent_nack = 1;
+	transmit_nack(ptr, info);
+}
+
+static void slam_send_disconnect(struct slam_info *info)
+{
+	if (info->sent_nack) {
+		/* A disconnect is a packet with just the null terminator */
+		transmit_nack(&nack.data[0], info);
+	}
+	info->sent_nack = 0;
+}
+
+
+static int proto_slam(struct slam_info *info)
+{
+	int retry;
+	long timeout;
+
+	init_slam_state();
+
+	retry = -1;
+	rx_qdrain();
+	/* Arp for my server */
+	if (arptable[ARP_SERVER].ipaddr.s_addr != info->server_ip.s_addr) {
+		arptable[ARP_SERVER].ipaddr.s_addr = info->server_ip.s_addr;
+		memset(arptable[ARP_SERVER].node, 0, ETH_ALEN);
+	}
+	/* If I'm running over multicast join the multicast group */
+	join_group(IGMP_SERVER, info->multicast_ip.s_addr);
+	for(;;) {
+		unsigned char *header;
+		unsigned char *data;
+		int type;
+		header = data = 0;
+
+		timeout = slam_sleep_interval(retry);
+		type = await_reply(await_slam, 0, info, timeout);
+		/* Compute the timeout for next time */
+		if (type == SLAM_TIMEOUT) {
+			/* If I timeouted recompute the next timeout */
+			if (retry++ > SLAM_MAX_RETRIES) {
+				return 0;
+			}
+		} else {
+			retry = 0;
+		}
+		if ((type == SLAM_DATA) || (type == SLAM_REQUEST)) {
+			/* Check the incomming packet and reinit the data 
+			 * structures if necessary.
+			 */
+			header = &nic.packet[ETH_HLEN + 
+				sizeof(struct iphdr) + sizeof(struct udphdr)];
+			data = header + state.hdr_len;
+			if (memcmp(state.hdr, header, state.hdr_len) != 0) {
+				/* Something is fishy reset the transaction */
+				data = reinit_slam_state(header, &nic.packet[nic.packetlen]);
+				if (!data) {
+					return 0;
+				}
+			}
+		}
+		if (type == SLAM_DATA) {
+			if (!slam_recv_data(data)) {
+				return 0;
+			}
+			if (state.received_packets == state.total_packets) {
+				/* We are done get out */
+				break;
+			}
+		}
+		if ((type == SLAM_TIMEOUT) || (type == SLAM_REQUEST)) {
+			/* Either I timed out or I was explicitly 
+			 * asked by a request packet 
+			 */
+			slam_send_nack(info);
+		}
+	}
+	slam_send_disconnect(info);
+
+	/* Leave the multicast group */
+	leave_group(IGMP_SERVER);
+	/* FIXME don't overwrite myself */
+	/* load file to correct location */
+	return info->fnc(state.image, 1, state.total_bytes, 1);
+}
+
+
+int url_slam(const char *name, int (*fnc)(unsigned char *, unsigned int, unsigned int, int))
+{
+	struct slam_info info;
+	/* Set the defaults */
+	info.server_ip.s_addr    = arptable[ARP_SERVER].ipaddr.s_addr;
+	info.server_port         = SLAM_PORT;
+	info.multicast_ip.s_addr = htonl(SLAM_MULTICAST_IP);
+	info.multicast_port      = SLAM_MULTICAST_PORT;
+	info.local_ip.s_addr     = arptable[ARP_CLIENT].ipaddr.s_addr;
+	info.local_port          = SLAM_LOCAL_PORT;
+	info.fnc                 = fnc;
+	info.sent_nack = 0;
+	/* Now parse the url */
+	if (url_port != -1) {
+		info.server_port = url_port;
+	}
+	if (name[0]) {
+		/* multicast ip */
+		name += inet_aton(name, &info.multicast_ip);
+		if (name[0] == ':') {
+			name++;
+			info.multicast_port = strtoul(name, &name, 10);
+		}
+	}
+	if (name[0]) {
+		printf("\nBad url\n");
+		return 0;
+	}
+	return proto_slam(&info);
+}
+
+#endif /* DOWNLOAD_PROTO_SLAM */
diff --git a/src/proto/tftm.c b/src/proto/tftm.c
new file mode 100644
index 000000000..8040fc445
--- /dev/null
+++ b/src/proto/tftm.c
@@ -0,0 +1,491 @@
+/**************************************************************************
+*
+*    proto_tftm.c -- Etherboot Multicast TFTP 
+*    Written 2003-2003 by Timothy Legge <tlegge@rogers.com>
+*
+*    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
+*    (at your option) 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.
+*
+*    This code is based on the DOWNLOAD_PROTO_TFTM section of 
+*    Etherboot 5.3 core/nic.c and:
+*    
+*    Anselm Martin Hoffmeister's previous proto_tftm.c multicast work
+*    Eric Biederman's proto_slam.c
+*
+*    $Revision$
+*    $Author$
+*    $Date$
+*
+*    REVISION HISTORY:
+*    ================
+*    09-07-2003	timlegge	Release Version, Capable of Multicast Booting
+*    08-30-2003	timlegge	Initial version, Assumes consecutive blocks
+*
+*    Indent Options: indent -kr -i8
+***************************************************************************/
+
+#ifdef DOWNLOAD_PROTO_TFTM
+#include "etherboot.h"
+#include "nic.h"
+
+//#define TFTM_DEBUG
+#ifdef TFTM_DEBUG
+#define debug(x) printf x
+#else
+#define debug(x)
+#endif
+struct tftm_info {
+	in_addr server_ip;
+	in_addr multicast_ip;
+	in_addr local_ip;
+	uint16_t server_port;
+	uint16_t multicast_port;
+	uint16_t local_port;
+	int (*fnc) (unsigned char *, unsigned int, unsigned int, int);
+	int sent_nack;
+	const char *name;	/* Filename */
+};
+
+struct tftm_state {
+	unsigned long block_size;
+	unsigned long total_bytes;
+	unsigned long total_packets;
+	char ismaster;
+	unsigned long received_packets;
+	unsigned char *image;
+	unsigned char *bitmap;
+	char recvd_oack;
+} state;
+
+#define TFTM_PORT 1758
+#define TFTM_MIN_PACKET 1024
+
+
+int opt_get_multicast(struct tftp_t *tr, unsigned short *len,
+		      unsigned long *filesize, struct tftm_info *info);
+
+static int await_tftm(int ival, void *ptr, unsigned short ptype __unused,
+		      struct iphdr *ip, struct udphdr *udp)
+{
+	struct tftm_info *info = ptr;
+
+	/* Check for Unicast data being received */
+	if (ip->dest.s_addr == arptable[ARP_CLIENT].ipaddr.s_addr) {
+		if (!udp) {
+			return 0;
+		}
+		if (arptable[ARP_CLIENT].ipaddr.s_addr != ip->dest.s_addr)
+			return 0;
+		if (ntohs(udp->dest) != ival)
+			return 0;
+
+		return 1;	/* Unicast Data Received */
+	}
+
+	/* Also check for Multicast data being received */
+	if ((ip->dest.s_addr == info->multicast_ip.s_addr) &&
+	    (ntohs(udp->dest) == info->multicast_port) &&
+	    (nic.packetlen >= ETH_HLEN + sizeof(struct iphdr) +
+	     sizeof(struct udphdr))) {
+		return 1;	/* Multicast data received */
+	}
+	return 0;
+}
+
+int proto_tftm(struct tftm_info *info)
+{
+	int retry = 0;
+	static unsigned short iport = 2000;
+	unsigned short oport = 0;
+	unsigned short len, block = 0, prevblock = 0;
+	struct tftp_t *tr;
+	struct tftpreq_t tp;
+	unsigned long filesize = 0;
+
+	state.image = 0;
+	state.bitmap = 0;
+
+	rx_qdrain();
+
+	/* Warning: the following assumes the layout of bootp_t.
+	   But that's fixed by the IP, UDP and BOOTP specs. */
+
+	/* Send a tftm-request to the server */
+	tp.opcode = htons(TFTP_RRQ);	/* Const for "\0x0" "\0x1" =^= ReadReQuest */
+	len =
+	    sizeof(tp.ip) + sizeof(tp.udp) + sizeof(tp.opcode) +
+	    sprintf((char *) tp.u.rrq,
+		    "%s%coctet%cmulticast%c%cblksize%c%d%ctsize%c",
+		    info->name, 0, 0, 0, 0, 0, TFTM_MIN_PACKET, 0, 0) + 1;
+
+	if (!udp_transmit(arptable[ARP_SERVER].ipaddr.s_addr, ++iport,
+			  TFTM_PORT, len, &tp))
+		return (0);
+
+	/* loop to listen for packets and to receive the file */
+	for (;;) {
+		long timeout;
+#ifdef	CONGESTED
+		timeout =
+		    rfc2131_sleep_interval(block ? TFTP_REXMT : TIMEOUT,
+					   retry);
+#else
+		timeout = rfc2131_sleep_interval(TIMEOUT, retry);
+#endif
+		/* Calls the await_reply function in nic.c which in turn calls
+		   await_tftm (1st parameter) as above */
+		if (!await_reply(await_tftm, iport, info, timeout)) {
+			if (!block && retry++ < MAX_TFTP_RETRIES) {	/* maybe initial request was lost */
+				if (!udp_transmit
+				    (arptable[ARP_SERVER].ipaddr.s_addr,
+				     ++iport, TFTM_PORT, len, &tp))
+					return (0);
+				continue;
+			}
+#ifdef	CONGESTED
+			if (block && ((retry += TFTP_REXMT) < TFTP_TIMEOUT)) {	/* we resend our last ack */
+#ifdef	MDEBUG
+				printf("<REXMT>\n");
+#endif
+				debug(("Timed out receiving file"));
+				len =
+				    sizeof(tp.ip) + sizeof(tp.udp) +
+				    sizeof(tp.opcode) +
+				    sprintf((char *) tp.u.rrq,
+					    "%s%coctet%cmulticast%c%cblksize%c%d%ctsize%c",
+					    info->name, 0, 0, 0, 0, 0,
+					    TFTM_MIN_PACKET, 0, 0) + 1;
+
+				udp_transmit
+				    (arptable[ARP_SERVER].ipaddr.s_addr,
+				     ++iport, TFTM_PORT, len, &tp);
+					continue;
+			}
+#endif
+			break;	/* timeout */
+		}
+
+		tr = (struct tftp_t *) &nic.packet[ETH_HLEN];
+
+		if (tr->opcode == ntohs(TFTP_ERROR)) {
+			printf("TFTP error %d (%s)\n",
+			       ntohs(tr->u.err.errcode), tr->u.err.errmsg);
+			break;
+		}
+
+		if (tr->opcode == ntohs(TFTP_OACK)) {
+			int i =
+			    opt_get_multicast(tr, &len, &filesize, info);
+
+			if (i == 0 || (i != 7 && !state.recvd_oack)) {	/* Multicast unsupported */
+				/* Transmit an error message to the server to end the transmission */
+				printf
+				    ("TFTM-Server doesn't understand options [blksize tsize multicast]\n");
+				tp.opcode = htons(TFTP_ERROR);
+				tp.u.err.errcode = 8;
+				/*
+				 *      Warning: the following assumes the layout of bootp_t.
+				 *      But that's fixed by the IP, UDP and BOOTP specs.
+				 */
+				len =
+				    sizeof(tp.ip) + sizeof(tp.udp) +
+				    sizeof(tp.opcode) +
+				    sizeof(tp.u.err.errcode) +
+				    /*
+				     *      Normally bad form to omit the format string, but in this case
+				     *      the string we are copying from is fixed. sprintf is just being
+				     *      used as a strcpy and strlen.
+				     */
+				    sprintf((char *) tp.u.err.errmsg,
+					    "RFC2090 error") + 1;
+				udp_transmit(arptable[ARP_SERVER].ipaddr.
+					     s_addr, iport,
+					     ntohs(tr->udp.src), len, &tp);
+				block = tp.u.ack.block = 0;	/* this ensures, that */
+				/* the packet does not get */
+				/* processed as data! */
+				return (0);
+			} else {
+				unsigned long bitmap_len;
+				/* */
+				if (!state.recvd_oack) {
+
+					state.total_packets =
+					    1 + (filesize -
+						 (filesize %
+						  state.block_size)) /
+					    state.block_size;
+					bitmap_len =
+					    (state.total_packets + 7) / 8;
+					if (!state.image) {
+						state.bitmap =
+						    allot(bitmap_len);
+						state.image =
+						    allot(filesize);
+
+						if ((unsigned long) state.
+						    image < 1024 * 1024) {
+							printf
+							    ("ALERT: tftp filesize to large for available memory\n");
+							return 0;
+						}
+						memset(state.bitmap, 0,
+						       bitmap_len);
+					}
+					/* If I'm running over multicast join the multicast group */
+					join_group(IGMP_SERVER,
+						   info->multicast_ip.
+						   s_addr);
+				}
+				state.recvd_oack = 1;
+			}
+
+
+
+		} else if (tr->opcode == htons(TFTP_DATA)) {
+			unsigned long data_len;
+			unsigned char *data;
+			struct udphdr *udp;
+			udp =
+			    (struct udphdr *) &nic.packet[ETH_HLEN +
+							  sizeof(struct
+								 iphdr)];
+			len =
+			    ntohs(tr->udp.len) - sizeof(struct udphdr) - 4;
+			data =
+			    nic.packet + ETH_HLEN + sizeof(struct iphdr) +
+			    sizeof(struct udphdr) + 4;
+
+			if (len > TFTM_MIN_PACKET)	/* shouldn't happen */
+				continue;	/* ignore it */
+
+			block = ntohs(tp.u.ack.block = tr->u.data.block);
+
+			if (block > state.total_packets) {
+				printf("ALERT: Invalid packet number\n");
+				continue;
+			}
+
+			/* Compute the expected data length */
+			if (block != state.total_packets) {
+				data_len = state.block_size;
+			} else {
+				data_len = filesize % state.block_size;
+			}
+			/* If the packet size is wrong drop the packet and then continue */
+			if (ntohs(udp->len) !=
+			    (data_len + (data - (unsigned char *) udp))) {
+				printf
+				    ("ALERT: udp packet is not the correct size: %d\n",
+				     block);
+				continue;
+			}
+			if (nic.packetlen < data_len + (data - nic.packet)) {
+				printf
+				    ("ALERT: Ethernet packet shorter than data_len: %d\n",
+				     block);
+				continue;
+			}
+
+			if (data_len > state.block_size) {
+				data_len = state.block_size;
+			}
+			if (((state.
+			      bitmap[block >> 3] >> (block & 7)) & 1) ==
+			    0) {
+				/* Non duplicate packet */
+				state.bitmap[block >> 3] |=
+				    (1 << (block & 7));
+				memcpy(state.image +
+				       ((block - 1) * state.block_size),
+				       data, data_len);
+				state.received_packets++;
+			} else {
+
+/*				printf("<DUP>\n"); */
+			}
+		}
+
+		else {		/* neither TFTP_OACK, TFTP_DATA nor TFTP_ERROR */
+			break;
+		}
+
+		if (state.received_packets <= state.total_packets) {
+			unsigned long b;
+			unsigned long len;
+			unsigned long max;
+			int value;
+			int last;
+
+			/* Compute the last bit and store an inverted trailer */
+			max = state.total_packets + 1;
+			value =
+			    ((state.
+			      bitmap[(max - 1) >> 3] >> ((max -
+							  1) & 7)) & 1);
+			value = !value;
+			state.bitmap[max >> 3] &= ~(1 << (max & 7));
+			state.bitmap[max >> 3] |= value << (max & 7);
+
+			len = 0;
+			last = 0;	/* Start with the received packets */
+			for (b = 1; b <= max; b++) {
+				value =
+				    (state.bitmap[b >> 3] >> (b & 7)) & 1;
+
+				if (value == 0) {
+					tp.u.ack.block = htons(b - 1);	/* Acknowledge the previous block */
+					break;
+				}
+			}
+		}
+		if (state.ismaster) {
+			tp.opcode = htons(TFTP_ACK);
+			oport = ntohs(tr->udp.src);
+			udp_transmit(arptable[ARP_SERVER].ipaddr.s_addr, iport, oport, TFTP_MIN_PACKET, &tp);	/* ack */
+		}
+		if (state.received_packets == state.total_packets) {
+			/* If the client is finished and not the master,
+			 * ack the last packet */
+			if (!state.ismaster) {
+				tp.opcode = htons(TFTP_ACK);
+				/* Ack Last packet to end xfer */
+				tp.u.ack.block = htons(state.total_packets);
+				oport = ntohs(tr->udp.src);
+				udp_transmit(arptable[ARP_SERVER].ipaddr.s_addr, iport, oport, TFTP_MIN_PACKET, &tp);	/* ack */
+			}
+			/* We are done get out */
+			forget(state.bitmap);
+			break;
+		}
+
+		if ((unsigned short) (block - prevblock) != 1) {
+			/* Retransmission or OACK, don't process via callback
+			 * and don't change the value of prevblock.  */
+			continue;
+		}
+
+		prevblock = block;
+		retry = 0;	/* It's the right place to zero the timer? */
+
+	}
+	/* Leave the multicast group */
+	leave_group(IGMP_SERVER);
+	return info->fnc(state.image, 1, filesize, 1);
+}
+
+int url_tftm(const char *name,
+	     int (*fnc) (unsigned char *, unsigned int, unsigned int, int))
+{
+
+	int ret;
+	struct tftm_info info;
+
+	/* Set the defaults */
+	info.server_ip.s_addr = arptable[ARP_SERVER].ipaddr.s_addr;
+	info.server_port = TFTM_PORT;
+	info.local_ip.s_addr = arptable[ARP_CLIENT].ipaddr.s_addr;
+	info.local_port = TFTM_PORT;	/* Does not matter. So take tftm port too. */
+	info.multicast_ip.s_addr = info.local_ip.s_addr;
+	info.multicast_port = TFTM_PORT;
+	info.fnc = fnc;
+	state.ismaster = 0;
+	info.name = name;
+
+	state.block_size = 0;
+	state.total_bytes = 0;
+	state.total_packets = 0;
+	state.received_packets = 0;
+	state.image = 0;
+	state.bitmap = 0;
+	state.recvd_oack = 0;
+
+	if (name[0] != '/') {
+		/* server ip given, so use it */
+		name += inet_aton(info.name, &info.server_ip);
+		/* No way to specify another port for now */
+	}
+	if (name[0] != '/') {
+		printf("Bad tftm-URI: [%s]\n", info.name);
+		return 0;
+	}
+
+	ret = proto_tftm(&info);
+
+	return ret;
+}
+
+/******************************
+* Parse the multicast options
+*******************************/
+int opt_get_multicast(struct tftp_t *tr, unsigned short *len,
+		      unsigned long *filesize, struct tftm_info *info)
+{
+	const char *p = tr->u.oack.data, *e = 0;
+	int i = 0;
+	*len = ntohs(tr->udp.len) - sizeof(struct udphdr) - 2;
+	if (*len > TFTM_MIN_PACKET)
+		return -1;
+	e = p + *len;
+
+	while (*p != '\0' && p < e) {
+		if (!strcasecmp("tsize", p)) {
+			p += 6;
+			if ((*filesize = strtoul(p, &p, 10)) > 0)
+				i |= 4;
+			debug(("\n"));
+			debug(("tsize=%d\n", *filesize));
+			while (p < e && *p)
+				p++;
+			if (p < e)
+				p++;
+		} else if (!strcasecmp("blksize", p)) {
+			i |= 2;
+			p += 8;
+			state.block_size = strtoul(p, &p, 10);
+			if (state.block_size != TFTM_MIN_PACKET) {
+				printf
+				    ("TFTM-Server rejected required transfer blocksize %d\n",
+				     TFTM_MIN_PACKET);
+				return 0;
+			}
+			debug(("blksize=%d\n", state.block_size));
+			while (p < e && *p)
+				p++;
+			if (p < e)
+				p++;
+		} else if (!strncmp(p, "multicast", 10)) {
+			i |= 1;
+			p += 10;
+			debug(("multicast options: %s\n", p));
+			p += 1 + inet_aton(p, &info->multicast_ip);
+			debug(("multicast ip = %@\n", info->multicast_ip));
+			info->multicast_port = strtoul(p, &p, 10);
+			++p;
+			debug(("multicast port = %d\n",
+			       info->multicast_port));
+			state.ismaster = (*p == '1' ? 1 : 0);
+			debug(("multicast ismaster = %d\n",
+			       state.ismaster));
+			while (p < e && *p)
+				p++;
+			if (p < e)
+				p++;
+		}
+	}
+	if (p > e)
+		return 0;
+	return i;
+}
+#endif				/* DOWNLOAD_PROTO_TFTP */