source: cheroxy/trunk/src/main.cpp@ 14

// LocalProxy.cpp : ÄÜ¼Ö ÀÀ¿ë ÇÁ·Î±×·¥¿¡ ´ëÇÑ ÁøÀÔÁ¡À» Á¤ÀÇÇÕ´Ï´Ù.
//

#ifdef _WIN32
# define _CRT_SECURE_NO_WARNINGS
# include <process.h>
#else
# include <errno.h>
#endif

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

#include <iostream>
#include <iomanip>
#include <sstream>

#include <stdio.h>
#include <string.h>

using namespace std;

/*-----------------------------------------------------------------*/
int CRXCreateThread (int (* aThreadFunc) (void *), void * aThreadArg);
int CRXProxyThread  (void * aThreadArg);

/* error */
#ifdef _WIN32
# define CRX_ERROR()        GetLastError ()
# ifndef __func__
#  define __func__          __FUNCTION__
# endif
#else
# define CRX_ERROR()        errno
#endif

#define CRX_PRINT_ERROR(__code, __message)                                                              \
    do {                                                                                                \
        char __error[1024] = {0x00, };                                                                  \
        ostringstream __stream;                                                                         \
        __stream << __message;                                                                          \
        string __string = __stream.str ();                                                              \
        sprintf (__error, "[%s][%d] (%d) %s\n", __func__, __LINE__, __code, __string.c_str ());         \
        cout << __error;                                                                                \
    } while (0)

typedef struct __crx_proxy_thread_argument__
{
    int mSocket;
} CRXProxyThreadArgs;
/*----------------------------------------------------------------*/

int main (int argc, char* argv[])
{
    int                     aResult = 0;
    const unsigned short    aPort   = 8080;

    CRXSocket           aSocket;
    CRXProxyThreadArgs  * aThreadArg;

    /*----------------------------------------------------------------*/
    /*----------------------------------------------------------------
     * Initialize
     *----------------------------------------------------------------*/
    aResult = aSocket.CreateServer (aPort);
    if (aResult < 0)
    {
        CRX_PRINT_ERROR (aResult, "failed to create server");
        return aResult;
    }

    for (;;)
    {
        aResult = aSocket.Accept ();
        if (aResult < 0)
        {
            CRX_PRINT_ERROR (aResult, "failed to accept");
            break;
        }

        if ((aThreadArg = new(std::nothrow) CRXProxyThreadArgs) == NULL)
        {
            aResult = -1;
            break;
        }

        memset (aThreadArg, 0x0, sizeof (CRXProxyThreadArgs));
        aThreadArg->mSocket = aResult;

        aResult = CRXCreateThread (CRXProxyThread, aThreadArg);
        if (aResult < 0)
        {
            aResult = CRX_ERROR ();
            CRX_PRINT_ERROR (aResult, "failed to create thread");
            break;
        }
    }

    /*----------------------------------------------------------------*/
    aSocket.Close ();

    return aResult;
}

int
CRXCreateThread (int (* aThreadFunc) (void *), void * aThreadArg)
{
#ifdef _WIN32
    return _beginthread ((void (*) (void *))aThreadFunc, 0, aThreadArg);
#else
    pthread_t aThreadID = 0;

    return pthread_create (&aThreadID, NULL, (void * (*) (void *))aThreadFunc, aThreadArg);
#endif
}

int
CRXProxyThread (void * aThreadArg)
{
    int                 aResult         = 0;
    int                 aReceivedSize   = 0;
    int                 aSentSize       = 0;

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

    CRXHttpRequest      aHttpRequest;
    CRXHttpResponse     aHttpResponse;
    string              aUrl    = "";
    string              aHost   = "";
    int                 aPort   = 0;

    CRXSocket           aWebServer;
    CRXSocket           aWebBrowser = ((CRXProxyThreadArgs *)aThreadArg)->mSocket;

    bool                aIsMoreRequest = false;
    /*----------------------------------------------------------------*/
    delete (CRXProxyThreadArgs *)aThreadArg;

    do
    {
        /* BROWSER --- request ---> [PROXY]                  SERVER */
        aReceivedSize = aWebBrowser.Receive (aBuffer, aBufferSize);
        if (aReceivedSize < 0)
        {
            CRX_PRINT_ERROR (aReceivedSize, "failed to receive from client (" << CRX_ERROR () << ")");
            return 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_PRINT_ERROR (aResult, "failed to connect to server <" << aHost << ":" << aPort << "> (" << CRX_ERROR () << ")");
                return aResult;
            }
        }

        /* BROWSER ?--- waiting --- [PROXY] --- request ---> SERVER */
        aSentSize = aWebServer.Send (aBuffer, aReceivedSize);
        if (aSentSize != aReceivedSize)
        {
            CRX_PRINT_ERROR (aResult, "failed to send to server (" << CRX_ERROR () << ")");
            return aResult;
        }

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

            aReceivedSize = aWebServer.Receive (aBuffer, aBufferSize);
            if (aReceivedSize < 0)
            {
                CRX_PRINT_ERROR (aReceivedSize, "failed to receive (" << CRX_ERROR () << ")");
                break;
            }
            else if (aReceivedSize == 0)
            {
                aResult = 0;
                break;
            }

            aSentSize = aWebBrowser.Send (aBuffer, aReceivedSize);
            if (aSentSize != aReceivedSize)
            {
                CRX_PRINT_ERROR (aSentSize, "failed to send (" << CRX_ERROR () << ")");
                break;
            }
        }
    } while (aIsMoreRequest);

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

    return aResult;
}