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

#ifdef _WIN32
# define _CRT_SECURE_NO_WARNINGS
#endif

#include "CRXSocket.h"
#include "CRXProxy.h"

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

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

using namespace std;

#ifdef _WIN32
# include <process.h>
# define THREAD_TYPE                            void *
# define THREAD_FUNCTION_RETURN                 unsigned int
# 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
CRXProxyMTWrapper (void * aThreadArg);

int ThreadPool (CRXSocket   * aProxySocket,
                const int   aThreadPoolCount);

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

    CRXSocket   aProxySocket;

    /*----------------------------------------------------------------*/
    /* 1. create proxy server */
    aResult = aProxySocket.CreateServer (aPort);
    if (aResult < 0)
    {
        cout << "Failed to create server." << endl;
        return aResult;
    }

    /* 2. ready proxy servers */
    aResult = ThreadPool (&aProxySocket, aThreadPoolCount);
    if (aResult)
    {
        cout << "Failed to create thread pool." << endl;
        return aResult;
    }

    /* 3. keep process */
    while (true);

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

    return aResult;
}

THREAD_FUNCTION_RETURN
THREAD_FUNCTION_CALLING_CONVENTION
CRXProxyMTWrapper (void * aThreadArg)
{
    int         aResult = 0;

    CRXSocket   * aProxySocket = (CRXSocket *)aThreadArg;
    CRXProxy    * aProxy = NULL;

    char        aFilterFileExtension[] = "exe|gif|jpg|png|css|js|ico|swf|";
    char        * aHttpMessage = NULL;
    int         aHttpMessageLength = 0;

    /*----------------------------------------------------------------*/
    for (;;)
    {
        aResult = aProxySocket->Accept ();
        if (aResult < 0)
        {
            cerr << "Failed to accept." << endl;
            break;
        }

        if ((aProxy = CRXProxy::GetNewInstance ()) == NULL)
        {
            cerr << "Failed to get proxy." << endl;
            aResult = -1;
            break;
        }

        aProxy->SetClientSocket (aResult);
        aProxy->SetServerTimeout (2);
        aProxy->SetRequestFilter (CRX_FILTER_REQUEST_FILE_EXTENSION,
                                  CRX_FILTER_MATCHED,
                                  aFilterFileExtension);

        aResult = aProxy->Forward ();
        if (aResult < 0)
        {
            cout << aProxy->GetErrorMessage () << endl;
        }

        if (!aProxy->CheckRequestFilter (CRX_FILTER_REQUEST_FILE_EXTENSION))
        {
            aHttpMessageLength = aProxy->GetHttpRequestLength ();
            aHttpMessage = (char *) calloc (aHttpMessageLength + 1, 1);
            cout << aProxy->GetHttpRequest (aHttpMessage, aHttpMessageLength) << endl;
            free (aHttpMessage);

            aHttpMessageLength = aProxy->GetHttpResponseHeaderLength ();
            aHttpMessage = (char *) calloc (aHttpMessageLength + 1, 1);
            cout << aProxy->GetHttpResponseHeader (aHttpMessage, aHttpMessageLength) << endl;
            free (aHttpMessage);
        }

        aProxy->ReleaseInstance ();
    }

    cout << " thread exit." << endl;
    /*----------------------------------------------------------------*/

    return (THREAD_FUNCTION_RETURN)0;
}

int ThreadPool (CRXSocket   * aProxySocket,
                const int   aThreadPoolCount)
{
    int             aResult = 0;
    int             aIter = 0;
    THREAD_TYPE     aThreadID = (THREAD_TYPE)0;

    /*----------------------------------------------------------------*/
    for (aIter = 0 ; aIter < aThreadPoolCount ; aIter++)
    {
#ifdef _WIN32
        aThreadID = (void *)_beginthreadex (0, 0, CRXProxyMTWrapper, aProxySocket, 0, 0);
        if (aThreadID == NULL)
        {
            aResult = -1;
            break;
        }
        CloseHandle (aThreadID);
#else
        aResult = pthread_create (&aThreadID, NULL, CRXProxyMTWrapper, aProxySocket);
        if (aResult < 0)
        {
            break;
        }
#endif
        cout << "Thread(" << aIter + 1 << ") is created successfully." << endl;
    }
    /*----------------------------------------------------------------*/

    return aResult;
}