usbloadergx/source/network/networkops.cpp

/****************************************************************************
 * Network Operations
 * for USB Loader GX
 *
 * HTTP operations
 * Written by dhewg/bushing modified by dimok
 ****************************************************************************/

#include <stdio.h>
#include <string.h>
#include <ogcsys.h>
#include <ogc/machine/processor.h>

#include "prompts/PromptWindows.h"
#include "language/gettext.h"
#include "settings/cfg.h"
#include "main.h"
#include "http.h"
#include "../svnrev.h"

#define PORT            4299

/*** Incomming filesize ***/
u32 infilesize = 0;

bool updateavailable = false;
s32 connection;
static s32 socket;
static bool updatechecked = false;
static bool networkinitialized = false;
static bool checkincomming = false;
static bool waitforanswer = false;
static char IP[16];
char incommingIP[50];

static lwp_t networkthread = LWP_THREAD_NULL;
static bool networkHalt = true;

/****************************************************************************
 * Initialize_Network
 ***************************************************************************/
void Initialize_Network(void) {

    if (networkinitialized) return;

    s32 result;

    result = if_config(IP, NULL, NULL, true);

    if (result < 0) {
        networkinitialized = false;
        return;
    } else {
        networkinitialized = true;
        return;
    }
}

/****************************************************************************
 * Check if network was initialised
 ***************************************************************************/
bool IsNetworkInit(void) {
    return networkinitialized;
}

/****************************************************************************
 * Get network IP
 ***************************************************************************/
char * GetNetworkIP(void) {
    return IP;
}

/****************************************************************************
 * Get incomming IP
 ***************************************************************************/
char * GetIncommingIP(void) {
    return incommingIP;
}

/****************************************************************************
 * Get network IP
 ***************************************************************************/
bool ShutdownWC24() {
    bool onlinefix = IsNetworkInit();
    if (onlinefix) {
        s32 kd_fd, ret;
        STACK_ALIGN(u8, kd_buf, 0x20, 32);

        kd_fd = IOS_Open("/dev/net/kd/request", 0);
        if (kd_fd >= 0) {
            ret = IOS_Ioctl(kd_fd, 7, NULL, 0, kd_buf, 0x20);
            if (ret >= 0)
                onlinefix = false; // fixed no IOS reload needed
            IOS_Close(kd_fd);
        }
    }
    return onlinefix;
}

s32 network_request(const char * request) {
    char buf[1024];
    char *ptr = NULL;

    u32 cnt, size;
    s32 ret;

    /* Send request */
    ret = net_send(connection, request, strlen(request), 0);
    if (ret < 0)
        return ret;

    /* Clear buffer */
    memset(buf, 0, sizeof(buf));

    /* Read HTTP header */
    for (cnt = 0; !strstr(buf, "\r\n\r\n"); cnt++)
        if (net_recv(connection, buf + cnt, 1, 0) <= 0)
            return -1;

    /* HTTP request OK? */
    if (!strstr(buf, "HTTP/1.1 200 OK"))
        return -1;
    /* Retrieve content size */
    ptr = strstr(buf, "Content-Length:");
    if (!ptr)
        return -1;

    sscanf(ptr, "Content-Length: %u", &size);
    return size;
}

s32 network_read(u8 *buf, u32 len) {
    u32 read = 0;
    s32 ret = -1;

    /* Data to be read */
    while (read < len) {
        /* Read network data */
        ret = net_read(connection, buf + read, len - read);
        if (ret < 0)
            return ret;

        /* Read finished */
        if (!ret)
            break;

        /* Increment read variable */
        read += ret;
    }

    return read;
}

/****************************************************************************
 * Download request
 ***************************************************************************/
s32 download_request(const char * url) {

    //Check if the url starts with "http://", if not it is not considered a valid url
    if (strncmp(url, "http://", strlen("http://")) != 0) {
        return -1;
    }

    //Locate the path part of the url by searching for '/' past "http://"
    char *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) {
        return -1;
    }

    //Extract the domain part out of the url
    int domainlength = path - url - strlen("http://");

    if (domainlength == 0) {
        return -1;
    }

    char domain[domainlength + 1];
    strncpy(domain, url + strlen("http://"), domainlength);
    domain[domainlength] = '\0';

    connection = GetConnection(domain);
    if (connection < 0) {
        return -1;
    }

    //Form a nice request header to send to the webserver
    char header[strlen(path)+strlen(domain)+100];
    sprintf(header, "GET %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n", path, domain);

    s32 filesize = network_request(header);

    return filesize;
}

void CloseConnection() {

    net_close(connection);

    if (waitforanswer) {
        net_close(socket);
        waitforanswer = false;
    }
}

/****************************************************************************
 * NetworkWait
 ***************************************************************************/
int NetworkWait() {

    if (!checkincomming)
        return -3;

    struct sockaddr_in sin;
    struct sockaddr_in client_address;
    socklen_t addrlen = sizeof(client_address);

    //Open socket
    socket = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

    if (socket == INVALID_SOCKET) {
        return socket;
    }

    sin.sin_family = AF_INET;
    sin.sin_port = htons(PORT);
    sin.sin_addr.s_addr = htonl(INADDR_ANY);

    if (net_bind(socket, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
        net_close(socket);
        return -1;
    }

    if (net_listen(socket, 3) < 0) {
        net_close(socket);
        return -1;
    }

    connection = net_accept(socket, (struct sockaddr*)&client_address, &addrlen);

    sprintf(incommingIP, "%s", inet_ntoa(client_address.sin_addr));

    if (connection < 0) {
        net_close(connection);
        net_close(socket);
        return -4;

    } else {

        unsigned char haxx[9];
        //skip haxx
        net_read(connection, &haxx, 8);
        net_read(connection, &infilesize, 4);
        waitforanswer = true;
        checkincomming = false;
        networkHalt = true;
    }

    return 1;
}

/****************************************************************************
 * Update check
 ***************************************************************************/
int CheckUpdate() {
    if (!networkinitialized)
        return -1;

    int revnumber = 0;
    int currentrev = atoi(GetRev());

#ifdef NOTFULLCHANNEL
    struct block file = downloadfile("http://www.techjawa.com/usbloadergx/rev.txt");
#else
    struct block file = downloadfile("http://www.techjawa.com/usbloadergx/wadrev.txt");
#endif
    char revtxt[10];

    u8  i;
    if (file.data != NULL) {
        for (i=0; i<9 || i < file.size; i++)
            revtxt[i] = file.data[i];
        revtxt[i] = 0;
        revnumber = atoi(revtxt);
        free(file.data);
    }

    if (revnumber > currentrev)
        //if(revnumber > 1)//for testing updates
        return revnumber;
    else
        return -1;
}

/****************************************************************************
 * HaltNetwork
 ***************************************************************************/
void HaltNetworkThread() {
    networkHalt = true;
    checkincomming = false;

    if (waitforanswer)
        CloseConnection();

    // wait for thread to finish
    while (!LWP_ThreadIsSuspended(networkthread))
        usleep(100);
}

/****************************************************************************
 * ResumeNetworkThread
 ***************************************************************************/
void ResumeNetworkThread() {
    networkHalt = false;
    LWP_ResumeThread(networkthread);
}

/****************************************************************************
 * Resume NetworkWait
 ***************************************************************************/
void ResumeNetworkWait() {
    networkHalt = true;
    checkincomming = true;
    waitforanswer = true;
    infilesize = 0;
    connection = -1;
    LWP_ResumeThread(networkthread);
}

/*********************************************************************************
 * Networkthread for background network initialize and update check with idle prio
 *********************************************************************************/
static void * networkinitcallback(void *arg) {
    while (1) {

        if (!checkincomming && networkHalt)
            LWP_SuspendThread(networkthread);

        Initialize_Network();

        if (networkinitialized == true && updatechecked == false) {

            if (CheckUpdate() > 0)
                updateavailable = true;

            //suspend thread
            updatechecked = true;
            networkHalt = true;
            checkincomming = false;
        }

        if (checkincomming)
            NetworkWait();
    }
    return NULL;
}

/****************************************************************************
 * InitNetworkThread with priority 0 (idle)
 ***************************************************************************/
void InitNetworkThread() {
    LWP_CreateThread (&networkthread, networkinitcallback, NULL, NULL, 0, 0);
}

/****************************************************************************
 * ShutdownThread
 ***************************************************************************/
void ShutdownNetworkThread() {
    LWP_JoinThread (networkthread, NULL);
    networkthread = LWP_THREAD_NULL;
}