source: nscp/TCPSocketResponder.cpp @ b0ae738

#include "stdafx.h"
#include "strEx.h"
#include "NSParser.h"
#include "NSClient++.h"
#include "TCPSocketResponder.h"
#include "Settings.h"

extern NSClient mainClient;

/**
 * Default c-tor
 */
TCPSocketResponder::TCPSocketResponder() : running_(false) {
}
/**
 * Return true if the socket is "running".
 * @return true if the socket is spoused to be running
 */
bool TCPSocketResponder::isRunning(void) {
        MutexLock mutex(mutexHandler);
        if (!mutex.hasMutex()) {
                LOG_ERROR_STD("Failed to get Mutex: " + strEx::itos(mutex.getWaitResult()));
                return false;
        }
        return running_;
}
/**
 * Set the running flag to "stop" (will prevent the socket to start waiting again)
 */
void TCPSocketResponder::stopRunning(void) {
        MutexLock mutex(mutexHandler);
        if (!mutex.hasMutex()) {
                LOG_ERROR_STD("Failed to get Mutex!" + strEx::itos(mutex.getWaitResult()));
                return;
        }
        running_ = false;
}
/**
* Set the running flag to "start" (will make the socket wait again)
 */
void TCPSocketResponder::startRunning(void) {
        MutexLock mutex(mutexHandler);
        if (!mutex.hasMutex()) {
                LOG_ERROR_STD("Failed to get Mutex!" + strEx::itos(mutex.getWaitResult()));
                return;
        }
        running_ = true;
}
/**
 * Parse a command string into command, password and arguments. Then the command will be executed bu the core.
 * @param request A request string to parse
 * @return The result (if any) of the executed command.
 */
std::string TCPSocketResponder::parseCommand(char* request) {
        std::list<std::string> args = charEx::split(request, '&');
        if (args.size() < 2) {
                return "Insufficient arguments!";
        }
        std::string password = args.front(); args.pop_front();
        std::string command = args.front(); args.pop_front();
        return mainClient.execute(password, command, args);
}
/**
 * Thread procedure for the socket listener
 * @param lpParameter Potential argument to the thread proc.
 * @return thread exit status
 * @todo This needs to be reworked, possibly completely redone ?
 */
DWORD TCPSocketResponder::threadProc(LPVOID lpParameter)
{
        startRunning();
        WSADATA wsaData;
        sockaddr_in local;
        int wsaret=WSAStartup(0x101,&wsaData);
        if(wsaret!=0) {
                LOG_ERROR_STD("WSA Startup failed: " + strEx::itos(wsaret));
                return 0;
        }

        local.sin_family=AF_INET;
        local.sin_addr.s_addr=INADDR_ANY;
        local.sin_port=htons(static_cast<u_short>(Settings::getInstance()->getInt("generic", "port", DEFAULT_TCP_PORT)));
        server=socket(AF_INET,SOCK_STREAM,0);
        if(server==INVALID_SOCKET) {
                LOG_ERROR_STD("Could not create listening socket: " + strEx::itos(GetLastError()));
                return 0;
        }

        if(bind(server,(sockaddr*)&local,sizeof(local))!=0) {
                LOG_ERROR_STD("Could not bind socket: " + strEx::itos(GetLastError()));
                return 0;
        }

        if(listen(server,10)!=0) {
                LOG_ERROR_STD("Could not open socket: " + strEx::itos(GetLastError()));
                return 0;
        }

        SOCKET client;
        sockaddr_in from;
        int fromlen=sizeof(from);

        while(isRunning()) {
                client=accept(server, (struct sockaddr*)&from,&fromlen);
                if (client != INVALID_SOCKET) {
                        char *buff = new char[RECV_BUFFER_LEN+1];
                        int n=recv(client,buff,RECV_BUFFER_LEN,0);
                        if ((n!=SOCKET_ERROR )&&(n > 0)&&(n < RECV_BUFFER_LEN)) {
                                buff[n] = '\0';
                                LOG_DEBUG("Incoming data: ");
                                LOG_DEBUG(buff);
                                std::string ret = parseCommand(buff);
                                LOG_DEBUG("Outgoing data: ");
                                LOG_DEBUG(ret.c_str());
                                send(client, ret.c_str(), ret.length(), 0);
                        } else {
                                std::string str = "ERROR: Unknown socket error";
                                send(client,str.c_str(),str.length(),0);
                        }
                        delete [] buff;
                        closesocket(client);
                }
        }
        closesocket(server);
        WSACleanup();
        LOG_DEBUG("Socket closed!");
        return 0;
}

/**
 * Exit thread callback proc. 
 * This is called by the thread manager when the thread should initiate a shutdown procedure.
 * The thread manager is responsible for waiting for the actual termination of the thread.
 */
void TCPSocketResponder::exitThread(void) {
        LOG_DEBUG("Requesting shutdown!");
        stopRunning();
        closesocket(server);
}