//Setups SSL with the certificates needed for api.twitter.com
s32 ssl_setup(char * http_host, int socket){
s32 ssl_context;
s32 ret;
ssl_context = ssl_new((u8 *)http_host, 0);
if(ssl_context <= 0){
return ssl_context;
}
ret = ssl_setbuiltinclientcert(ssl_context, 0);
if(ret){
return ret;
}
if(!strcmp(http_host,"www.googleapis.com")){
ret = ssl_setrootca(ssl_context, (void *)ESCA, ESCA_size);
if(ret){
return ret;
}
}else{ //api.twitter.com
ret = ssl_setrootca(ssl_context, (void *)PCA3G2, PCA3G2_size);
if(ret){
return ret;
}
}
ret = ssl_connect(ssl_context, socket);
if(ret){
return ret;
}
ret = ssl_handshake(ssl_context);
if(ret){
return ret;
}
return ssl_context;
}
bool http_request (const char *url, const u32 max_size) {
int linecount;
int sslcontext = -1;
if (!http_split_url(&http_host, &http_path, url)) return false;
if (strncasecmp (url, "http://", 7) == 0)
http_port = 80;
else
http_port = 443;
http_max_size = max_size;
http_status = 404;
content_length = 0;
http_data = NULL;
int s = tcp_connect (http_host, http_port);
if (s < 0) {
result = HTTPR_ERR_CONNECT;
return false;
}
if(http_port == 443)
{
//patched out anyways so just to set something
sslcontext = ssl_new((u8*)http_host,0);
if(sslcontext < 0)
{
gprintf("ssl_new\n");
result = HTTPR_ERR_CONNECT;
net_close (s);
return false;
}
//patched out anyways so just to set something
ssl_setbuiltinclientcert(sslcontext,0);
if(ssl_connect(sslcontext,s) < 0)
{
gprintf("ssl_connect\n");
result = HTTPR_ERR_CONNECT;
ssl_shutdown(sslcontext);
net_close (s);
return false;
}
int ret = ssl_handshake(sslcontext);
if(ret < 0)
{
gprintf("ssl_handshake %i\n", ret);
result = HTTPR_ERR_STATUS;
ssl_shutdown(sslcontext);
net_close (s);
return false;
}
}
char *request = (char *) memalign (32, 1024*2);
snprintf(request, 1024*2,
"GET %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Cache-Control: no-cache\r\n\r\n",
http_path, http_host);
bool b = tcp_write (http_port == 443 ? sslcontext : s, (u8 *) request, strlen (request));
free (request);
linecount = 0;
for (linecount=0; linecount < 32; linecount++) {
char *line = tcp_readln (http_port == 443 ? sslcontext : s, 0xff, gettime(), (u16)HTTP_TIMEOUT);
if (!line) {
http_status = 404;
result = HTTPR_ERR_REQUEST;
break;
}
if (strlen (line) < 1) {
free (line);
line = NULL;
break;
}
sscanf (line, "HTTP/1.%*u %u", &http_status);
sscanf (line, "Content-Length: %u", &content_length);
gprintf(line);
gprintf("\n");
free (line);
line = NULL;
}
if (linecount == 32 || !content_length) http_status = 404;
if (http_status != 200) {
result = HTTPR_ERR_STATUS;
if(http_port == 443)
ssl_shutdown(sslcontext);
net_close (s);
return false;
}
if (content_length > http_max_size) {
result = HTTPR_ERR_TOOBIG;
if(http_port == 443)
ssl_shutdown(sslcontext);
net_close (s);
return false;
}
http_data = (u8 *) memalign (32, content_length);
b = tcp_read (http_port == 443 ? sslcontext : s, &http_data, content_length);
if (!b) {
free (http_data);
http_data = NULL;
result = HTTPR_ERR_RECEIVE;
if(http_port == 443)
ssl_shutdown(sslcontext);
net_close (s);
return false;
}
result = HTTPR_OK;
if(http_port == 443)
ssl_shutdown(sslcontext);
net_close (s);
return true;
}
/**
* Downloads the contents of a URL to memory
* This method is not threadsafe (because networking is not threadsafe on the Wii)
*/
struct block downloadfile(const char *url)
{
int sslcontext = -1;
//Check if the url starts with "http://", if not it is not considered a valid url
if (strncmp(url, "http://", strlen("http://")) == 0)
http_port = 80;
else if(strncmp(url, "https://", strlen("https://")) == 0)
{
http_port = 443;
gprintf("Initializing ssl...\n");
if(ssl_init() < 0)
return emptyblock;
}
else
return emptyblock;
//Locate the path part of the url by searching for '/' past "http://"
char *path = 0;
if(http_port == 443)
path = strchr(url + strlen("https://"), '/');
else
path = strchr(url + strlen("http://"), '/');
//At the very least the url has to end with '/', ending with just a domain is invalid
if (path == NULL)
{
//printf("URL '%s' has no PATH part\n", url);
return emptyblock;
}
//Extract the domain part out of the url
int domainlength = path - url - strlen("http://") - (http_port == 443 ? 1 : 0);
if (domainlength == 0)
{
//printf("No domain part in URL '%s'\n", url);
return emptyblock;
}
char domain[domainlength + 1];
strlcpy(domain, url + strlen("http://") + (http_port == 443 ? 1 : 0), domainlength + 1);
//Parsing of the URL is done, start making an actual connection
u32 ipaddress = getipbynamecached(domain);
if (ipaddress == 0)
{
//printf("\ndomain %s could not be resolved", domain);
return emptyblock;
}
s32 connection = tcp_connect(ipaddress, http_port);
if (connection < 0)
{
//printf("Error establishing connection");
return emptyblock;
}
if(http_port == 443)
{
//patched out anyways so just to set something
sslcontext = ssl_new((u8*)domain,0);
if(sslcontext < 0)
{
//gprintf("ssl_new\n");
result = HTTPR_ERR_CONNECT;
net_close (connection);
return emptyblock;
}
//patched out anyways so just to set something
ssl_setbuiltinclientcert(sslcontext,0);
if(ssl_connect(sslcontext,connection) < 0)
{
//gprintf("ssl_connect\n");
result = HTTPR_ERR_CONNECT;
ssl_shutdown(sslcontext);
net_close (connection);
return emptyblock;
}
int ret = ssl_handshake(sslcontext);
if(ret < 0)
{
//gprintf("ssl_handshake %i\n", ret);
result = HTTPR_ERR_STATUS;
ssl_shutdown(sslcontext);
net_close (connection);
return emptyblock;
}
}
// Remove Referer from the request header for incompatible websites (ex. Cloudflare proxy)
char referer[domainlength + 12];
snprintf(referer, sizeof(referer), "Referer: %s\r\n", domain);
if(strstr(url, "geckocodes"))
{
strcpy(referer, "");
}
//Form a nice request header to send to the webserver
char* headerformat = "GET %s HTTP/1.0\r\nHost: %s\r\n%sUser-Agent: USBLoaderGX r%s\r\n\r\n";
char header[strlen(headerformat) + strlen(path) + strlen(domain) + strlen(referer) + 100];
sprintf(header, headerformat, path, domain, referer, GetRev());
//gprintf("\nHTTP Request:\n");
//gprintf("%s\n",header);
//Do the request and get the response
tcp_write(http_port == 443 ? sslcontext : connection, header);
read_header( http_port == 443 ? sslcontext : connection);
if (http_status >= 400) // Not found
{
//gprintf("HTTP ERROR: %d\n", http_status);
return emptyblock;
}
if(!content_length)
content_length = 0;
// create data buffer to return
struct block response;
response.data = malloc(content_length);
response.size = content_length;
if (response.data == NULL)
{
return emptyblock;
}
if (http_status == 200)
{
if(displayProgressWindow)
{
ProgressCancelEnable(true);
StartProgress(tr("Downloading file..."), tr("Please wait"), 0, false, false);
}
int ret = tcp_readData(http_port == 443 ? sslcontext : connection, &response.data, content_length);
if(!ret)
{
free(response.data);
result = HTTPR_ERR_RECEIVE;
if(http_port == 443)
ssl_shutdown(sslcontext);
net_close (connection);
return emptyblock;
}
}
else if (http_status == 302) // 302 FOUND (redirected link)
{
// close current connection
if(http_port == 443)
ssl_shutdown(sslcontext);
net_close (connection);
// prevent infinite loops
retryloop++;
if(retryloop > 3)
{
retryloop = 0;
return emptyblock;
}
struct block redirected = downloadfile(content_location);
if(redirected.size == 0)
return emptyblock;
// copy the newURL data into the original data
u8 * tmp = realloc(response.data, redirected.size);
if (tmp == NULL)
{
gprintf("Could not allocate enough memory for new URL. Download canceled.\n");
free(response.data);
response.size = 0;
free(redirected.data);
result = HTTPR_ERR_RECEIVE;
if(http_port == 443)
ssl_shutdown(sslcontext);
net_close (connection);
return emptyblock;
}
response.data = tmp;
memcpy(response.data, redirected.data, redirected.size);
free(redirected.data);
response.size = redirected.size;
}
retryloop = 0;
// reset progress window if used
if(displayProgressWindow)
{
ProgressStop();
ProgressCancelEnable(false);
displayProgressWindow = false;
}
return response;
}
