source: cheroxy/trunk/src/CRXProxy.cpp@ 22

/**
 * CRXProxy.cpp
 */

#include "CRXSocket.h"
#include "CRXHttpRequest.h"
#include "CRXHttpResponse.h"

#include "CRXProxy.h"

#include <string.h>

#ifdef _DEBUG
# include <iostream>
using namespace std;
# define PRINT_ERROR        cout
#else
# define PRINT_ERROR
#endif

#ifdef _WIN32
# include <Windows.h>
# define THREAD_TYPE                            void *
# define THREAD_FUNCTION_RETURN                 DWORD
# define THREAD_FUNCTION_CALLING_CONVENTION     WINAPI
#else
# define THREAD_TYPE                            pthread_t
# define THREAD_FUNCTION_RETURN                 void *
# define THREAD_FUNCTION_CALLING_CONVENTION
#endif

THREAD_FUNCTION_RETURN
THREAD_FUNCTION_CALLING_CONVENTION
CRXProxyWrapper (void * aThreadArg)
{
    int         aResult = 0;
    CRXProxy    * aProxy = (CRXProxy *) aThreadArg;
    
    aResult = aProxy->Forward ();
    if (aResult)
        PRINT_ERROR << aProxy->GetErrorMessage ();

    delete aProxy;
    return (THREAD_FUNCTION_RETURN)0;
}

CRXProxy::CRXProxy (const int aSocket)
{
    /*----------------------------------------------------------------*/
    mClient = aSocket;
    /*----------------------------------------------------------------*/
}

CRXProxy *
CRXProxy::GetNewInstance(const int aSocket)
{
    return new(std::nothrow) CRXProxy (aSocket);
}

int
CRXProxy::ForwardMT (void)
{
    THREAD_TYPE     aThreadID = (THREAD_TYPE)0;
    /*----------------------------------------------------------------*/
#ifdef _WIN32
    aThreadID = CreateThread (0, 0, CRXProxyWrapper, this, 0, 0);
    if (aThreadID == NULL)
    {
        return -1;
    }

    return 0;
#else
    return pthread_create (&aThreadID, NULL, CRXProxyWrapper, this);
#endif
    /*----------------------------------------------------------------*/
}

int
CRXProxy::Forward (void)
{
    int                 aResult         = 0;
    int                 aReceivedSize   = 0;

    const unsigned int  aBufferSize     = 1024 * 16;
    char                aBuffer[aBufferSize] = {0x00, };

    CRXHttpRequest      aHttpRequest;

    CRXSocket           aWebServer;

    bool                aIsMoreRequest  = false;

    /*----------------------------------------------------------------*/
    do
    {
        /* BROWSER --- request ---> [PROXY]                  SERVER */
        aResult = mClient.Receive (aBuffer, aBufferSize);
        if (aResult < 0)
        {
            CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
            CRX_ERROR (aResult, "Failed to receive from browser");
            break;
        }
        aReceivedSize = aResult;

        /* BROWSER ?--- waiting --- [PROXY] --- connect ---> SERVER */
        if (!aWebServer)
        {
            /* parse http request */
            aHttpRequest = aBuffer;

            /* connect */
            aResult = aWebServer.Connect (aHttpRequest.GetHost (), aHttpRequest.GetPort (), 1);
            if (aResult < 0)
            {
                CRX_ERROR_ADD (aWebServer.GetErrorMessage ().c_str ());
                CRX_ERROR (aResult, "Failed to connect to server <%s>", aHttpRequest.GetURL ().c_str ());
                return aResult;
            }
        }

        /* BROWSER ?--- waiting --- [PROXY] --- request ---> SERVER */
        aResult = aWebServer.Send (aBuffer, aReceivedSize);
        if (aResult != aReceivedSize)
        {
            CRX_ERROR_ADD (aWebServer.GetErrorMessage ().c_str ());
            CRX_ERROR (aResult, "Failed to send to server <%s>", aHttpRequest.GetURL ().c_str ());
            return aResult;
        }

        /* BROWSER <--- response--- [PROXY] <--- response--- SERVER */
        for (;;)
        {
            memset (aBuffer, 0x00, aBufferSize);

            aResult = aWebServer.Receive (aBuffer, aBufferSize);
            if (aResult < 0)
            {
                CRX_ERROR_ADD (aWebServer.GetErrorMessage ().c_str ());
                CRX_ERROR (aResult, "Failed to receive <%s>", aHttpRequest.GetURL ().c_str ());
                break;
            }
            else if (aResult == 0)
            {
                break;
            }
            aReceivedSize = aResult;

            aResult = mClient.Send (aBuffer, aReceivedSize);
            if (aResult != aReceivedSize)
            {
                CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
                CRX_ERROR (aResult, "Failed to send <%s>", aHttpRequest.GetURL ().c_str ());
                break;
            }
        }
    } while (aIsMoreRequest);

    /*----------------------------------------------------------------*/
    mClient.Close ();
    aWebServer.Close ();

    return aResult;
}