controller_patcher/source/utils/TCPServer.cpp

#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <utils/TCPServer.hpp>

#include <network/net.h>
#include <utils/logger.h>

#define wiiu_errno (*__gh_errno_ptr())

TCPServer::TCPServer(int32_t port, int32_t priority) {
    this->port     = port;
    this->sockfd   = -1;
    this->clientfd = -1;
    memset(&(this->sock_addr), 0, sizeof(this->sock_addr));

    pThread = CThread::create(TCPServer::DoTCPThread, (void *) this, CThread::eAttributeAffCore2, priority);
    pThread->resumeThread();
}

TCPServer::~TCPServer() {
    CloseSockets();
    //DEBUG_FUNCTION_LINE("Thread will be closed");
    exitThread = 1;

    ICInvalidateRange((void *) &exitThread, 4);
    DCFlushRange((void *) &exitThread, 4);

    if (pThread != NULL) {
        //DEBUG_FUNCTION_LINE("Deleting it!");
        delete pThread;
    }
    //DEBUG_FUNCTION_LINE("Thread done");
    pThread = NULL;
}

void TCPServer::CloseSockets() {
    if (this->sockfd != -1) {
        close(this->sockfd);
    }
    if (this->clientfd != -1) {
        close(this->clientfd);
    }
    this->sockfd   = -1;
    this->clientfd = -1;
}

void TCPServer::ErrorHandling() {
    CloseSockets();
    OSSleepTicks(OSMicrosecondsToTicks(1000 * 1000 * 2));
}

void TCPServer::DoTCPThreadInternal() {
    int32_t ret;
    socklen_t len;
    connected = false;
    while (1) {
        if (exitThread) {
            break;
        }
        memset(&(this->sock_addr), 0, sizeof(sock_addr));
        sock_addr.sin_family      = AF_INET;
        sock_addr.sin_port        = this->port;
        sock_addr.sin_addr.s_addr = 0;

        this->sockfd = ret = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (ret == -1) {
            ErrorHandling();
            continue;
        }
        int32_t enable = 1;

        setsockopt(this->sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));

        ret = bind(this->sockfd, (sockaddr *) &sock_addr, 16);
        if (ret < 0) {
            ErrorHandling();
            continue;
        }
        ret = listen(this->sockfd, 1);
        if (ret < 0) {
            ErrorHandling();
            continue;
        }

        do {
            DEBUG_FUNCTION_LINE("Waiting for a connection");
            if (exitThread) {
                break;
            }
            len      = 16;
            clientfd = ret = accept(sockfd, (sockaddr *) &(sock_addr), &len);

            if (ret == -1) {
                ErrorHandling();
                break;
            }

            if (!acceptConnection()) {
                ErrorHandling();
                break;
            }

            connected = true;

            DEBUG_FUNCTION_LINE("Connection accepted");

            whileLoop();

            DEBUG_FUNCTION_LINE("Client disconnected");

            if (clientfd != -1) {
                close(clientfd);
            }
            clientfd = -1;
        } while (0);
        DEBUG_FUNCTION_LINE("Closing TCPServer");
        connected = false;
        onConnectionClosed();
        CloseSockets();
        continue;
    }
    DEBUG_FUNCTION_LINE("Ending DoTCPThreadInternal");
}

void TCPServer::DoTCPThread(CThread *thread, void *arg) {
    TCPServer *args = (TCPServer *) arg;
    return args->DoTCPThreadInternal();
}