xNBA/src/core/proto_http.c

#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 */