usbloadergx/source/network/http.c

262 lines
7.8 KiB
C
Raw Normal View History

#include "http.h"
#include "../svnrev.h"
extern char incommingIP[50];
/**
* Emptyblock is a statically defined variable for functions to return if they are unable
* to complete a request
*/
2010-09-24 02:48:03 +02:00
const struct block emptyblock = { 0, NULL };
//The maximum amount of bytes to send per net_write() call
//#define NET_BUFFER_SIZE 1024
#define NET_BUFFER_SIZE 3600
// Write our message to the server
2010-09-24 02:48:03 +02:00
static s32 send_message(s32 server, char *msg)
{
s32 bytes_transferred = 0;
2010-09-24 02:48:03 +02:00
s32 remaining = strlen(msg);
while (remaining)
{
2010-09-24 02:48:03 +02:00
if ((bytes_transferred = net_write(server, msg, remaining > NET_BUFFER_SIZE ? NET_BUFFER_SIZE : remaining)) > 0)
{
remaining -= bytes_transferred;
2010-09-24 02:48:03 +02:00
usleep(20 * 1000);
}
2010-09-24 02:48:03 +02:00
else if (bytes_transferred < 0)
{
return bytes_transferred;
}
else
{
return -ENODATA;
}
}
return 0;
}
/**
* Connect to a remote server via TCP on a specified port
*
* @param u32 ip address of the server to connect to
* @param u32 the port to connect to on the server
* @return s32 The connection to the server (negative number if connection could not be established)
*/
2010-09-24 02:48:03 +02:00
static s32 server_connect(u32 ipaddress, u32 socket_port)
{
//Initialize socket
2010-09-24 02:48:03 +02:00
s32 connection = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (connection < 0) return connection;
struct sockaddr_in connect_addr;
2010-09-24 02:48:03 +02:00
memset(&connect_addr, 0, sizeof(connect_addr));
connect_addr.sin_family = AF_INET;
connect_addr.sin_port = socket_port;
connect_addr.sin_addr.s_addr = ipaddress;
2010-09-24 02:48:03 +02:00
sprintf(incommingIP, "%s", inet_ntoa(connect_addr.sin_addr));
//Attemt to open the socket
2010-09-24 02:48:03 +02:00
if (net_connect(connection, (struct sockaddr*) &connect_addr, sizeof(connect_addr)) == -1)
{
2010-09-24 02:48:03 +02:00
net_close(connection);
return -1;
}
return connection;
}
//The amount of memory in bytes reserved initially to store the HTTP response in
//Be careful in increasing this number, reading from a socket on the Wii
//will fail if you request more than 20k or so
#define HTTP_BUFFER_SIZE 1024 * 5
//The amount of memory the buffer should expanded with if the buffer is full
#define HTTP_BUFFER_GROWTH 1024 * 5
/**
* This function reads all the data from a connection into a buffer which it returns.
* It will return an empty buffer if something doesn't go as planned
*
* @param s32 connection The connection identifier to suck the response out of
* @return block A 'block' struct (see http.h) in which the buffer is located
*/
2010-09-24 02:48:03 +02:00
struct block read_message(s32 connection)
{
//Create a block of memory to put in the response
struct block buffer;
2010-09-24 02:48:03 +02:00
buffer.data = malloc(HTTP_BUFFER_SIZE);
buffer.size = HTTP_BUFFER_SIZE;
2010-09-24 02:48:03 +02:00
if (buffer.data == NULL)
{
return emptyblock;
}
//The offset variable always points to the first byte of memory that is free in the buffer
u32 offset = 0;
2010-09-24 02:48:03 +02:00
while (1)
{
//Fill the buffer with a new batch of bytes from the connection,
//starting from where we left of in the buffer till the end of the buffer
2010-09-24 02:48:03 +02:00
s32 bytes_read = net_read(connection, buffer.data + offset, buffer.size - offset);
//Anything below 0 is an error in the connection
2010-09-24 02:48:03 +02:00
if (bytes_read < 0)
{
//printf("Connection error from net_read() Errorcode: %i\n", bytes_read);
return emptyblock;
}
//No more bytes were read into the buffer,
//we assume this means the HTTP response is done
2010-09-24 02:48:03 +02:00
if (bytes_read == 0)
{
break;
}
offset += bytes_read;
//Check if we have enough buffer left over,
//if not expand it with an additional HTTP_BUFFER_GROWTH worth of bytes
2010-09-24 02:48:03 +02:00
if (offset >= buffer.size)
{
buffer.size += HTTP_BUFFER_GROWTH;
2010-09-24 02:48:03 +02:00
buffer.data = realloc(buffer.data, buffer.size);
2010-09-24 02:48:03 +02:00
if (buffer.data == NULL)
{
return emptyblock;
}
}
}
//At the end of above loop offset should be precisely the amount of bytes that were read from the connection
buffer.size = offset;
//Shrink the size of the buffer so the data fits exactly in it
2010-09-24 02:48:03 +02:00
buffer.data = realloc(buffer.data, buffer.size);
return buffer;
}
/**
* Downloads the contents of a URL to memory
* This method is not threadsafe (because networking is not threadsafe on the Wii)
*/
2010-09-24 02:48:03 +02:00
struct block downloadfile(const char *url)
{
//Check if the url starts with "http://", if not it is not considered a valid url
2010-09-24 02:48:03 +02:00
if (strncmp(url, "http://", strlen("http://")) != 0)
{
//printf("URL '%s' doesn't start with 'http://'\n", url);
return emptyblock;
}
//Locate the path part of the url by searching for '/' past "http://"
2010-09-24 02:48:03 +02:00
char *path = strchr(url + strlen("http://"), '/');
//At the very least the url has to end with '/', ending with just a domain is invalid
2010-09-24 02:48:03 +02:00
if (path == NULL)
{
//printf("URL '%s' has no PATH part\n", url);
return emptyblock;
}
//Extract the domain part out of the url
2010-09-24 02:48:03 +02:00
int domainlength = path - url - strlen("http://");
2010-09-24 02:48:03 +02:00
if (domainlength == 0)
{
//printf("No domain part in URL '%s'\n", url);
return emptyblock;
}
char domain[domainlength + 1];
2010-09-24 02:48:03 +02:00
strlcpy(domain, url + strlen("http://"), domainlength + 1);
//Parsing of the URL is done, start making an actual connection
2010-09-24 02:48:03 +02:00
u32 ipaddress = getipbynamecached(domain);
2010-09-24 02:48:03 +02:00
if (ipaddress == 0)
{
//printf("\ndomain %s could not be resolved", domain);
return emptyblock;
}
2010-09-24 02:48:03 +02:00
s32 connection = server_connect(ipaddress, 80);
2010-09-24 02:48:03 +02:00
if (connection < 0)
{
//printf("Error establishing connection");
return emptyblock;
}
//Form a nice request header to send to the webserver
2010-09-24 02:48:03 +02:00
char* headerformat = "GET %s HTTP/1.0\r\nHost: %s\r\nReferer: %s\r\nUser-Agent: USBLoaderGX r%s\r\n\r\n";
;
char header[strlen(headerformat) + strlen(path) + strlen(domain) + strlen(domain)];
sprintf(header, headerformat, path, domain, domain, GetRev());
//Do the request and get the response
2010-09-24 02:48:03 +02:00
send_message(connection, header);
struct block response = read_message(connection);
net_close(connection);
//Search for the 4-character sequence \r\n\r\n in the response which signals the start of the http payload (file)
unsigned char *filestart = NULL;
u32 filesize = 0;
int i;
2010-09-24 02:48:03 +02:00
for (i = 3; i < response.size; i++)
{
2010-09-24 02:48:03 +02:00
if (response.data[i] == '\n' && response.data[i - 1] == '\r' && response.data[i - 2] == '\n' && response.data[i
- 3] == '\r')
{
filestart = response.data + i + 1;
filesize = response.size - i - 1;
break;
}
}
2010-09-24 02:48:03 +02:00
if (filestart == NULL)
{
//printf("HTTP Response was without a file\n");
2010-09-24 02:48:03 +02:00
free(response.data);
return emptyblock;
}
//Copy the file part of the response into a new memoryblock to return
struct block file;
2010-09-24 02:48:03 +02:00
file.data = malloc(filesize);
file.size = filesize;
2010-09-24 02:48:03 +02:00
if (file.data == NULL)
{
//printf("No more memory to copy file from HTTP response\n");
2010-09-24 02:48:03 +02:00
free(response.data);
return emptyblock;
}
2010-09-24 02:48:03 +02:00
memcpy(file.data, filestart, filesize);
//Dispose of the original response
2010-09-24 02:48:03 +02:00
free(response.data);
return file;
}
2010-09-24 02:48:03 +02:00
s32 GetConnection(char * domain)
{
2010-09-24 02:48:03 +02:00
u32 ipaddress = getipbynamecached(domain);
if (ipaddress == 0)
{
return -1;
}
2010-09-24 02:48:03 +02:00
s32 connection = server_connect(ipaddress, 80);
return connection;
}