Changeset 24 in cheroxy for trunk/src

Timestamp:

11/14/12 14:00:40 (12 years ago)

Author:

cheese

Message:

#1 change response, threading and proxy work-flow

Location:

trunk/src

Files:

• CRXException.cpp (modified) (1 diff)
• CRXHttpMessage.cpp (modified) (2 diffs)
• CRXHttpRequest.cpp (modified) (4 diffs)
• CRXHttpResponse.cpp (modified) (2 diffs)
• CRXProxy.cpp (modified) (1 diff)
• CRXSocket.cpp (modified) (14 diffs)
• main.cpp (modified) (3 diffs)

trunk/src/CRXException.cpp

@@ -15 +15 @@
 CRXException::CRXException (void)
     : mCode (0)
+{
+    /*----------------------------------------------------------------*/
+    /*----------------------------------------------------------------*/
+}
+
+CRXException::~CRXException (void)
 {
     /*----------------------------------------------------------------*/

trunk/src/CRXHttpMessage.cpp

@@ -9 +9 @@
 
 CRXHttpMessage::CRXHttpMessage (void)
+{
+}
+
+CRXHttpMessage::~CRXHttpMessage (void)
 {
 }
@@ -30 +34 @@
 
 void
+CRXHttpMessage::Reset (void)
+{
+    mHttpMessage.clear ();
+}
+
+void
 CRXHttpMessage::Parse (void)
 {

trunk/src/CRXHttpRequest.cpp

@@ -17 +17 @@
 
 void
-CRXHttpRequest::SetRequest (const char * aHttpRequest)
+CRXHttpRequest::SetHeader (const char * aHttpRequest)
 {
     SetMessage (aHttpRequest);
@@ -23 +23 @@
 
 std::string
-CRXHttpRequest::GetRequest (void) const
+CRXHttpRequest::GetHeader (void) const
 {
     return GetMessage ();
@@ -49 +49 @@
 CRXHttpRequest::operator = (const char * aHttpMessage)
 {
-    SetRequest (aHttpMessage);
+    SetHeader (aHttpMessage);
     return *this;
 }
@@ -69 +69 @@
 
     /*----------------------------------------------------------------*/
-    aHttpRequestUri = GetRequest ().substr (0, mHttpMessage.find ('\r'));
+    aHttpRequestUri = GetHeader ().substr (0, mHttpMessage.find ('\r'));
 
     /*----------------------------------------------------------------

trunk/src/CRXHttpResponse.cpp

@@ -11 +11 @@
 #include <stdlib.h>
 
+#define CRLF                "\r\n"
+#define CRLF2               "\r\n\r\n"  
+
+#define CONTENT_LENGTH      "Content-Length: "
+#define TRANSFER_ENCODING   "Transfer-Encoding: "
+
 CRXHttpResponse::CRXHttpResponse (void)
-    : mStatusCode   (0)
-{
+    : mStatusCode (0),
+      mIsChunked (false),
+      mContentLength (0)
+{
+    memset (&mContent, 0x00, sizeof (mContent));
+}
+
+CRXHttpResponse::~CRXHttpResponse (void)
+{
+    ResetContent ();
 }
 
 void
-CRXHttpResponse::SetResponse (const char * aHttpResponse)
-{
-    SetMessage (aHttpResponse);
-}
-
-std::string
-CRXHttpResponse::GetResponse (void) const
-{
-    return GetMessage ();
+CRXHttpResponse::ResetContent (void)
+{
+    if (mContent.mBody)
+        free (mContent.mBody);
+
+    memset (&mContent, 0x00, sizeof (mContent));
+}
+
+int
+CRXHttpResponse::SetResponse (const char    * aHttpResponse,
+                              const int     aResponseLength)
+{
+    int             aResult = 0;
+
+    const char      * aEndOfHeader = NULL;
+    std::string     aHeader;
+
+    int             aHeaderLength = 0;
+    int             aBodyLength = 0;
+
+    /*----------------------------------------------------------------*/
+    if (aResponseLength <= 0)
+        return ERROR_HTTP_RESPONSE_INVALID_LENGTH;
+
+    if (GetHeader ().length () == 0)
+    {
+        aEndOfHeader = strstr (aHttpResponse, CRLF2);
+        if (aEndOfHeader == NULL)
+            return ERROR_HTTP_RESPONSE_INVALID_FORMAT;
+
+        aEndOfHeader += strlen (CRLF2);
+        aHeaderLength = aEndOfHeader - aHttpResponse;
+        aHeader.assign (aHttpResponse, aHeaderLength);
+
+        SetMessage (aHeader.c_str ());
+    }
+
+    aResult = ParseContent (aHttpResponse + aHeaderLength, aResponseLength - aHeaderLength);
+    if (aResult)
+    {
+        return ERROR_HTTP_RESPONSE_FAILED_TO_PARSE_CONTENT;
+    }
+    /*----------------------------------------------------------------*/
+
+    return aResult;
 }
 
@@ -35 +85 @@
 }
 
+std::string
+CRXHttpResponse::GetHeader (void) const
+{
+    return GetMessage ();
+}
+
+int
+CRXHttpResponse::GetStatusCode (void) const
+{
+    return mStatusCode;
+}
+
+int
+CRXHttpResponse::GetContentLength (void) const
+{
+    return mContentLength;
+}
+
+const char *
+CRXHttpResponse::GetContentBody (void) const
+{
+    return mContent.mBody;
+}
+
 void
 CRXHttpResponse::Parse (void)
 {
-    std::string aHttpStatus     = "";
+    std::string aValue;
 
     char        aStatusCode[64]     = {0x00, };
-    char        aStatusString[64]   = {0x00, };
+    char        aStatusName[64]     = {0x00, };
     char        aHttpVersion[64]    = {0x00, };
 
-    /*----------------------------------------------------------------*/
-    aHttpStatus = GetResponse ().substr (0, mHttpMessage.find ('\r'));
+    size_t      aBegin      = 0;
+    size_t      aOffset     = 0;
+    char        aBuffer[12] = {0x00, };
+
+    /*----------------------------------------------------------------*/
+    aValue = GetHeader ().substr (0, GetHeader ().find (CRLF, 0));
 
     /*----------------------------------------------------------------
      * 1. separate first line to <METHOD>, <URL> and <VERSION>
      *----------------------------------------------------------------*/
-    sscanf (aHttpStatus.c_str (), "%[^ ] %[^ ] %[^ ]\r\n", aHttpVersion, aStatusCode, aStatusString);
+    sscanf (aValue.c_str (), "%[^ ] %[^ ] %[^ ]\r\n", aHttpVersion, aStatusCode, aStatusName);
     mHttpVersion.assign (aHttpVersion);
-    mStatusString.assign (aStatusString);
+    mStatusString.assign (aStatusName);
     mStatusCode = atoi (aStatusCode);
-    /*----------------------------------------------------------------*/
-}
-
-int
-CRXHttpResponse::GetStatusCode (void) const
-{
-    return mStatusCode;
-}
+
+    /*----------------------------------------------------------------
+     * 2. get Content-Length or check is chunked
+     *----------------------------------------------------------------*/
+    aBegin = GetHeader ().find (CONTENT_LENGTH);
+    if (aBegin == std::string::npos)
+    {
+        /* is really chunked encoding ? */
+        aBegin = GetHeader ().find (TRANSFER_ENCODING);
+        if (aBegin == std::string::npos)
+            return ;
+
+        aBegin += strlen (TRANSFER_ENCODING);
+        aOffset = GetHeader ().find (CRLF, aBegin) - aBegin;
+
+        aValue = GetHeader ().substr (aBegin, aOffset);
+        if (aValue == "chunked")
+        {
+            mIsChunked = true;
+            return ;
+        }
+    }
+
+    aBegin += strlen (CONTENT_LENGTH);
+    aOffset = GetHeader ().find (CRLF, aBegin) - aBegin;
+
+    aValue = GetHeader ().substr (aBegin, aOffset);
+    mContentLength = atoi (aValue.c_str ());
+    /*----------------------------------------------------------------*/
+}
+
+int
+CRXHttpResponse::ParseContent (const char   * aContent,
+                               const int    aLength)
+{
+    int     aResult = 0;
+
+    char    * aReallocPtr = NULL;
+
+    /*----------------------------------------------------------------*/
+
+    if (!mIsChunked)
+    {
+        if (mContentLength <= mContent.mLength)
+            return aResult;
+
+        if (mContent.mBody == NULL)
+        {
+            mContent.mBody = static_cast<char *> (calloc (mContentLength, 1));
+            if (mContent.mBody == NULL)
+            {
+                return ERROR_HTTP_RESPONSE_FAILED_TO_MEMORY_ALLOCATION;
+            }
+        }
+    }
+    else
+    {
+        mContentLength += aLength;
+        aReallocPtr = static_cast<char *> (realloc (mContent.mBody, mContentLength));
+        if (aReallocPtr == NULL)
+        {
+            return ERROR_HTTP_RESPONSE_FAILED_TO_MEMORY_ALLOCATION;
+        }
+        mContent.mBody = aReallocPtr;
+    }
+
+    memcpy (mContent.mBody + mContent.mLength, aContent, aLength);
+    mContent.mLength += aLength;
+    /*----------------------------------------------------------------*/
+
+    return aResult;
+}

trunk/src/CRXProxy.cpp

@@ -3 +3 @@
  */
 
-#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        cerr
-#else
-# define PRINT_ERROR
-#endif
-
-#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
-CRXProxyWrapper (void * aThreadArg)
-{
-    int         aResult = 0;
-    CRXProxy    * aProxy = (CRXProxy *) aThreadArg;
+CRXProxy::CRXProxy (void)
+    : mClient (0),
+      mServer (0)
+{
+    /*----------------------------------------------------------------*/
+    /*----------------------------------------------------------------*/
+}
+
+CRXProxy::~CRXProxy (void)
+{
+    /*----------------------------------------------------------------*/
+    Close ();
+    /*----------------------------------------------------------------*/
+}
+
+CRXProxy *
+CRXProxy::GetNewInstance(void)
+{
+    /*----------------------------------------------------------------*/
+    /*----------------------------------------------------------------*/
+
+    return new(std::nothrow) CRXProxy ();
+}
+
+void
+CRXProxy::ReleaseInstance (void)
+{
+    /*----------------------------------------------------------------*/
+    delete this;
+    /*----------------------------------------------------------------*/
+}
+
+void
+CRXProxy::SetClientSocket (const int aSocket)
+{
+    /*----------------------------------------------------------------*/
+    if (aSocket <= 0)
+        return ;
+
+    mClient = aSocket;
+    /*----------------------------------------------------------------*/
+}
+
+void
+CRXProxy::Close (void)
+{
+    /*----------------------------------------------------------------*/
+    mServer.Close ();
+    mClient.Close ();
+    /*----------------------------------------------------------------*/
+}
+
+int
+CRXProxy::GetStatus (void)
+{
+    /*----------------------------------------------------------------*/
+    /*----------------------------------------------------------------*/
+
+    return mProxyStatus;
+}
+
+int
+CRXProxy::Forward (void)
+{
+    int     aResult = 0;
+
+    /*----------------------------------------------------------------*/
+    aResult = ReceiveRequest ();
+    if (aResult < 0)
+    {
+        aResult = ERROR_PROXY_FAILED_TO_RECEIVE_REQUEST;
+        CRX_ERROR (aResult, "Failed to receive from client");
+    }
+
+    aResult = SendRequest ();
+    if (aResult < 0)
+    {
+        aResult = ERROR_PROXY_FAILED_TO_SEND_REQUEST;
+        CRX_ERROR (aResult, "Failed to send to server");
+        return aResult;
+    }
+
+    aResult = ReceiveResponse ();
+    if (aResult < 0)
+    {
+        aResult = ERROR_PROXY_FAILED_TO_RECEIVE_RESPONSE;
+        CRX_ERROR (aResult, "Failed to receive from server");
+    }
+
+    aResult = SendResponse ();
+    if (aResult < 0)
+    {
+        aResult = ERROR_PROXY_FAILED_TO_SEND_RESPONSE;
+        CRX_ERROR (aResult, "Failed to send to client");
+        return aResult;
+    }
+    /*----------------------------------------------------------------*/
+
+    return aResult;
+}
+
+void
+CRXProxy::SetHttpRequest (const char * aHttpRequest)
+{
+    /*----------------------------------------------------------------*/
+    mHttpRequest = aHttpRequest;
+    /*----------------------------------------------------------------*/
+}
+
+char *
+CRXProxy::GetHttpRequest (char      * aBuffer,
+                          const int aBufferSize) const
+{
+    void * aPtr = static_cast<void *> (aBuffer);
+
+    /*----------------------------------------------------------------*/
+    if (aPtr == NULL)
+        return NULL;
     
-    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 = reinterpret_cast<void *> (_beginthreadex (0, 0, CRXProxyWrapper, this, 0, 0));
-    if (aThreadID == NULL)
-    {
-        return -1;
-    }
-
-    CloseHandle (aThreadID);
-
-    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 (aBufferSize > 0)
+        memcpy (aPtr, mHttpRequest.GetHeader ().c_str (), aBufferSize);
+    /*----------------------------------------------------------------*/
+
+    return aBuffer;
+}
+
+int
+CRXProxy::GetHttpRequestLength (void) const
+{
+    /*----------------------------------------------------------------*/
+    /*----------------------------------------------------------------*/
+
+    return mHttpRequest.GetHeader().length ();
+}
+
+void
+CRXProxy::SetHttpResponse (const char * aHttpResponse)
+{
+    /*----------------------------------------------------------------*/
+    mHttpResponse = aHttpResponse;
+    /*----------------------------------------------------------------*/
+}
+
+char *
+CRXProxy::GetHttpResponse (char         * aBuffer,
+                           const int    aBufferSize) const
+{
+    void    * aPtr = static_cast<void *> (aBuffer);
+
+    int     aRemainLength = aBufferSize;
+
+    /*----------------------------------------------------------------*/
+    if (aPtr == NULL)
+        return NULL;
+
+    if (aRemainLength > 0)
+        memcpy (aPtr, mHttpResponse.GetHeader ().c_str (), aRemainLength);
+
+    aRemainLength -= mHttpResponse.GetHeader ().length ();
+
+    if (aRemainLength > 0)
+        memcpy (aPtr, mHttpResponse.GetContentBody (), aRemainLength);
+    /*----------------------------------------------------------------*/
+
+    return aBuffer;
+}
+
+int
+CRXProxy::GetHttpResponseLength (void) const
+{
+    /*----------------------------------------------------------------*/
+    /*----------------------------------------------------------------*/
+
+    return mHttpResponse.GetHeader ().length ()
+         + mHttpResponse.GetContentLength ();
+}
+
+int
+CRXProxy::ReceiveRequest (void)
+{
+    int                 aResult     = 0;
+
+    const unsigned int  aBufferSize = 1024 * 56;
+    char                aBuffer[aBufferSize + 1] = {0x00, };
+
+    /*----------------------------------------------------------------*/
+    aResult = mClient.Receive (aBuffer, aBufferSize);
+    if (aResult < 0)
+    {
+        aResult = ERROR_PROXY_FAILED_TO_RECEIVE_REQUEST;
+        CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
+        CRX_ERROR (aResult, "Failed to receive from client");
+        return aResult;
+    }
+
+    /* parse http request */
+    mHttpRequest = aBuffer;
+    /*----------------------------------------------------------------*/
+
+    return aResult < 0 ? aResult : 0;
+}
+
+int
+CRXProxy::SendRequest (void)
+{
+    int     aResult = 0;
+    int     aSize   = mHttpRequest.GetHeader ().length ();
+
+    /*----------------------------------------------------------------*/
+    if (!mServer)
+    {
+        /* connect */
+        aResult = mServer.Connect (mHttpRequest.GetHost (), mHttpRequest.GetPort (), 1);
         if (aResult < 0)
         {
-            CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
-            CRX_ERROR (aResult, "Failed to receive from browser");
+            aResult = ERROR_PROXY_FAILED_TO_CONNECT_TO_SERVER;
+            CRX_ERROR_ADD (mServer.GetErrorMessage ().c_str ());
+            CRX_ERROR (aResult, "Failed to connect to server <%s>", mHttpRequest.GetURL ().c_str ());
+            return aResult;
+        }
+    }
+
+    aResult = mServer.Send (mHttpRequest.GetHeader ().c_str (), aSize);
+    if (aResult != aSize)
+    {
+        CRX_ERROR_ADD (mServer.GetErrorMessage ().c_str ());
+        CRX_ERROR (aResult, "Failed to send to server <%s>", mHttpRequest.GetURL ().c_str ());
+    }
+    /*----------------------------------------------------------------*/
+
+    return aResult < 0 ? aResult : 0;
+}
+
+int
+CRXProxy::ReceiveResponse (void)
+{
+    int                 aResult         = 0;
+
+    const unsigned int  aBufferSize     = 1024 * 64;
+    char                aBuffer[aBufferSize + 1] = {0x00, };
+
+    std::string         aHttpResponse;
+
+    /*----------------------------------------------------------------*/
+    for (;;)
+    {
+        memset (aBuffer, 0x00, sizeof (aBuffer));
+
+        aResult = mServer.Receive (aBuffer, aBufferSize);
+        if (aResult < 0)
+        {
+            aResult = ERROR_PROXY_FAILED_TO_RECEIVE_REQUEST;
+            CRX_ERROR_ADD (mServer.GetErrorMessage ().c_str ());
+            CRX_ERROR (aResult, "Failed to receive from server");
+            return aResult;
+        }
+        else if (aResult == 0)
+        {
             break;
         }
-        aReceivedSize = aResult;
-
-        /* BROWSER ?--- waiting --- [PROXY] --- connect ---> SERVER */
-        if (!aWebServer)
+
+        aResult = mHttpResponse.SetResponse (aBuffer, aResult);
+        if (aResult)
         {
-            /* 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 ());
+            aResult = ERROR_PROXY_FAILED_TO_SET_RESPONSE;
+            CRX_ERROR (aResult, "Failed to set response");
             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;
-}
+    }
+    /*----------------------------------------------------------------*/
+
+    return aResult < 0 ? aResult : 0;
+}
+
+int
+CRXProxy::SendResponse (void)
+{
+    int     aResult = 0;
+    int     aSize   = 0;
+
+    /*----------------------------------------------------------------*/
+    aSize = mHttpResponse.GetHeader ().length ();;
+    aResult = mClient.Send (mHttpResponse.GetHeader ().c_str (), aSize);
+    if (aResult != aSize)
+    {
+        CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
+        CRX_ERROR (aResult, "Failed to send to client");
+        return aResult;
+    }
+
+    aSize = mHttpResponse.GetContentLength ();
+    aResult = mClient.Send (mHttpResponse.GetContentBody (), aSize);
+    if (aResult != aSize)
+    {
+        CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
+        CRX_ERROR (aResult, "Failed to send to client");
+    }
+    /*----------------------------------------------------------------*/
+
+    return aResult < 0 ? aResult : 0;
+}

trunk/src/CRXSocket.cpp

@@ -18 +18 @@
 {
     /*----------------------------------------------------------------*/
+    CRXSocket::Initialize ();
+
     memset ((void *)&mAddress, 0x0, sizeof (struct sockaddr_in));
-
-    if (!CRXSocket::IsInitialized ())
-        CRXSocket::Initialize ();
     /*----------------------------------------------------------------*/
 }
@@ -81 +80 @@
 
 int
-CRXSocket::Initialize (void)
-{
-    int aResult = 0;
-
-    /*----------------------------------------------------------------*/
-    if (CRXSocket::IsInitialized ())
-        return aResult;
-
-#ifdef WIN32
-    WSADATA aWinSockData;
-    
-    aResult = WSAStartup (MAKEWORD (2, 0), &aWinSockData);
-    if (aResult != 0)
-    {
-        aResult = ERROR_TCPSOCKET_FAILED_TO_INITIALIZE;
-        return aResult;
-    }
-#endif
-
-    mInitialized = true;
-
-    /*----------------------------------------------------------------*/
-    return aResult;
-}
-
-void
-CRXSocket::Finalize (void)
-{
-    /*----------------------------------------------------------------*/
-#ifdef WIN32
-    WSACleanup ();
-#endif
-    /*----------------------------------------------------------------*/
-}
-
-bool
-CRXSocket::IsInitialized (void)
-{
-    /*----------------------------------------------------------------*/
-    /*----------------------------------------------------------------*/
-    return mInitialized;
-}
-
-bool
-CRXSocket::IsReady (void) const
-{
-    /*----------------------------------------------------------------*/
-    /*----------------------------------------------------------------*/
-    return IsInitialized () && IsCreated ();
-}
-
-bool
-CRXSocket::IsCreated (void) const
-{
-    /*----------------------------------------------------------------*/
-    /*----------------------------------------------------------------*/
-    return mSocket > 0 ? true : false;
-}
-
-int
-CRXSocket::CreateSocket (void)
-{
-    int aResult = -1;
-
-    /*----------------------------------------------------------------*/
-    if (!IsInitialized () || IsCreated ())
-    {
-        aResult = ERROR_TCPSOCKET_ALREADY_IN_USE;
-        CRX_ERROR (aResult, "Already in use.");
-        return aResult;
-    }
-
-    aResult = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
-    if (aResult < 0)
-    {
-        aResult = ERROR_TCPSOCKET_FAILED_TO_CREATE_SOCKET;
-        CRX_ERROR (aResult, "Failed to create socket.");
-        return aResult;
-    }
-
-    mSocket = aResult;
-
-    /*----------------------------------------------------------------*/
-    return aResult;
-}
-
-int
-CRXSocket::Connect (const std::string       aUrl,
-                    const unsigned short    aPort,
-                    const int               aTimeout)
-{
-    int             aResult = -1;
-    struct hostent  * aHostEnt;
+CRXSocket::SetTimeout (const int aTimeout)
+{
+    int             aResult = 0;
 
 #ifndef _WIN32
@@ -184 +93 @@
 
     /*----------------------------------------------------------------*/
+    if (!IsReady ())
+        return ERROR_TCPSOCKET_NOT_READY;
+
+    if (aTimeout == TCPSOCKET_NO_TIMEOUT)
+        return 0;
+
+    aResult = setsockopt (mSocket,
+                          SOL_SOCKET,
+                          SO_RCVTIMEO,
+#ifdef _WIN32
+                          (char *) &aTimeMilliSec,
+                          sizeof (aTimeMilliSec));
+#else
+                          &aTimeVal,
+                          (socklen_t) sizeof (aTimeVal));
+#endif
+    if (aResult < 0)
+    {
+        aResult = ERROR_TCPSOCKET_FAILED_TO_SETSOCKOPT;
+        CRX_ERROR (aResult, "Failed to set socket option.");
+    }
+    /*----------------------------------------------------------------*/
+
+    return aResult;
+}
+
+int
+CRXSocket::Initialize (void)
+{
+    int aResult = 0;
+
+    /*----------------------------------------------------------------*/
+    if (CRXSocket::IsInitialized ())
+        return aResult;
+
+#ifdef WIN32
+    WSADATA aWinSockData;
+    
+    aResult = WSAStartup (MAKEWORD (2, 0), &aWinSockData);
+    if (aResult != 0)
+    {
+        aResult = ERROR_TCPSOCKET_FAILED_TO_INITIALIZE;
+        return aResult;
+    }
+#endif
+
+    mInitialized = true;
+
+    /*----------------------------------------------------------------*/
+    return aResult;
+}
+
+void
+CRXSocket::Finalize (void)
+{
+    /*----------------------------------------------------------------*/
+#ifdef WIN32
+    WSACleanup ();
+#endif
+    /*----------------------------------------------------------------*/
+}
+
+bool
+CRXSocket::IsInitialized (void)
+{
+    /*----------------------------------------------------------------*/
+    /*----------------------------------------------------------------*/
+    return mInitialized;
+}
+
+bool
+CRXSocket::IsReady (void) const
+{
+    /*----------------------------------------------------------------*/
+    /*----------------------------------------------------------------*/
+    return IsInitialized () && IsCreated ();
+}
+
+bool
+CRXSocket::IsCreated (void) const
+{
+    /*----------------------------------------------------------------*/
+    /*----------------------------------------------------------------*/
+    return mSocket > 0 ? true : false;
+}
+
+int
+CRXSocket::CreateSocket (void)
+{
+    int aResult = -1;
+
+    /*----------------------------------------------------------------*/
+    if (!IsInitialized () || IsCreated ())
+    {
+        aResult = ERROR_TCPSOCKET_ALREADY_IN_USE;
+        CRX_ERROR (aResult, "Already in use.");
+        return aResult;
+    }
+
+    aResult = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if (aResult < 0)
+    {
+        aResult = ERROR_TCPSOCKET_FAILED_TO_CREATE_SOCKET;
+        CRX_ERROR (aResult, "Failed to create socket(%d).", GetSystemErrorCode ());
+        return aResult;
+    }
+
+    mSocket = aResult;
+
+    /*----------------------------------------------------------------*/
+    return aResult;
+}
+
+int
+CRXSocket::Connect (const std::string       aUrl,
+                    const unsigned short    aPort,
+                    const int               aTimeout)
+{
+    int             aResult = -1;
+    struct hostent  * aHostEnt;
+
+    /*----------------------------------------------------------------*/
     aResult = CreateSocket ();
     if (aResult < 0)
     {
+        aResult = ERROR_TCPSOCKET_FAILED_TO_CREATE_SOCKET;
+        CRX_ERROR (aResult, "Failed to create socket(%d).", GetSystemErrorCode ());
         return aResult;
     }
@@ -207 +240 @@
     }
 
-    if (aTimeout > TCPSOCKET_NO_TIMEOUT)
-    {
-        aResult = setsockopt (mSocket,
-                              SOL_SOCKET,
-                              SO_RCVTIMEO,
-#ifdef _WIN32
-                              (char *) &aTimeMilliSec,
-                              sizeof (aTimeMilliSec));
-#else
-                              &aTimeVal,
-                              (socklen_t) sizeof (aTimeVal));
-#endif
-        if (aResult < 0)
-        {
-            aResult = ERROR_TCPSOCKET_FAILED_TO_SETSOCKOPT;
-            CRX_ERROR (aResult, "Failed to set socket option.");
-            return aResult;
-        }
+    aResult = SetTimeout (aTimeout);
+    if (aResult < 0)
+    {
+        aResult = ERROR_TCPSOCKET_FAILED_TO_SETSOCKOPT;
+        CRX_ERROR (aResult, "Failed to set timeout (%d).", GetSystemErrorCode ());
+        return aResult;
     }
 
@@ -231 +252 @@
     {
         aResult = ERROR_TCPSOCKET_FAILED_TO_CONNECT;
-        CRX_ERROR (aResult, "Failed to connect.");
+        CRX_ERROR (aResult, "Failed to connect (%d).", GetSystemErrorCode ());
     }
 
@@ -249 +270 @@
     if (aResult < 0)
     {
+        aResult = ERROR_TCPSOCKET_FAILED_TO_CREATE_SOCKET;
+        CRX_ERROR (aResult, "Failed to create socket(%d).", GetSystemErrorCode ());
         return aResult;
     }
@@ -260 +283 @@
     {
         aResult = ERROR_TCPSOCKET_FAILED_TO_BIND;
-        CRX_ERROR (aResult, "Failed to bind.");
+        CRX_ERROR (aResult, "Failed to bind(%d).", GetSystemErrorCode ());
         return aResult;
     }
@@ -268 +291 @@
     {
         aResult = ERROR_TCPSOCKET_FAILED_TO_LISTEN;
-        CRX_ERROR (aResult, "Failed to listen.");
+        CRX_ERROR (aResult, "Failed to listen(%d).", GetSystemErrorCode ());
         return aResult;
     }
@@ -292 +315 @@
 
     /*----------------------------------------------------------------*/
-    if (!IsReady ())        return ERROR_TCPSOCKET_NOT_READY;
+    if (!IsReady ())
+        return ERROR_TCPSOCKET_NOT_READY;
 
     aResult = accept (mSocket, (struct sockaddr *) &aAddress, &aLength);
@@ -298 +322 @@
     {
         aResult = ERROR_TCPSOCKET_FAILED_TO_ACCEPT;
-        CRX_ERROR (aResult, "Failed to accept.");
+        CRX_ERROR (aResult, "Failed to accept(%d).", GetSystemErrorCode ());
         return aResult;
     }
@@ -316 +340 @@
 
 int
-CRXSocket::Send (char   * aBuffer,
-                 int    aSize)
+CRXSocket::Send (const char * aBuffer,
+                 int        aSize)
 {
     int aResult = -1;
 
     /*----------------------------------------------------------------*/
-    if (!IsReady ())        return ERROR_TCPSOCKET_NOT_READY;
+    if (!IsReady ())
+        return ERROR_TCPSOCKET_NOT_READY;
 
     aResult = send (mSocket, aBuffer, aSize, 0);
@@ -328 +353 @@
     {
         aResult = ERROR_TCPSOCKET_FAILED_TO_SEND;
-        CRX_ERROR (aResult, "Failed to send.");
+        CRX_ERROR (aResult, "Failed to send(%d).", GetSystemErrorCode ());
         return aResult;
     }
@@ -343 +368 @@
 
     /*----------------------------------------------------------------*/
-    if (!IsReady ())        return ERROR_TCPSOCKET_NOT_READY;
+    if (!IsReady ())
+        return ERROR_TCPSOCKET_NOT_READY;
 
     aResult = recv (mSocket, aBuffer, aSize, 0);
@@ -349 +375 @@
     {
         aResult = ERROR_TCPSOCKET_FAILED_TO_RECEIVE;
-        CRX_ERROR (aResult, "Failed to receive.");
-        return aResult;
-    }
-
-    /*----------------------------------------------------------------*/
-    return aResult;
-}
+        CRX_ERROR (aResult, "Failed to receive(%d).", GetSystemErrorCode ());
+        return aResult;
+    }
+
+    /*----------------------------------------------------------------*/
+    return aResult;
+}

trunk/src/main.cpp

@@ -1 @@
-// LocalProxy.cpp : ÄÜ¼Ö ÀÀ¿ë ÇÁ·Î±×·¥¿¡ ´ëÇÑ ÁøÀÔÁ¡À» Á¤ÀÇÇÕ´Ï´Ù.
-//
-
 #ifdef _WIN32
 # define _CRT_SECURE_NO_WARNINGS
@@ -18 +15 @@
 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 unsigned short    aPort   = 8080;
+    int         aResult = 0;
+    const short aPort   = 8080;
+    const int   aThreadPoolCount = 30;
 
-    CRXSocket               aSocket;
-    CRXProxy                * aProxy = NULL;
+    CRXSocket   aProxySocket;
 
     /*----------------------------------------------------------------*/
-    /*----------------------------------------------------------------
-     * Initialize
-     *----------------------------------------------------------------*/
-    aResult = aSocket.CreateServer (aPort);
+    /* 1. create proxy server */
+    aResult = aProxySocket.CreateServer (aPort);
     if (aResult < 0)
     {
@@ -37 +50 @@
     }
 
+    /* 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;
+
+    /*----------------------------------------------------------------*/
     for (;;)
     {
-        aResult = aSocket.Accept ();
+        aResult = aProxySocket->Accept ();
         if (aResult < 0)
         {
-            cout << "Failed to accept." << endl;
+            cerr << "Failed to accept." << endl;
             break;
         }
 
-        if ((aProxy = CRXProxy::GetNewInstance (aResult)) == NULL)
+        if ((aProxy = CRXProxy::GetNewInstance ()) == NULL)
         {
-            cout << "Failed to get proxy." << endl;
+            cerr << "Failed to get proxy." << endl;
             aResult = -1;
             break;
         }
 
-        aResult = aProxy->ForwardMT ();
+        aProxy->SetClientSocket (aResult);
+
+        aResult = aProxy->Forward ();
         if (aResult < 0)
         {
-            cout << "Failed to forward." << endl;
+            cerr << aProxy->GetErrorMessage () << endl;
+        }
+
+        aProxy->ReleaseInstance ();
+    }
+
+    cerr << " 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;
     }
-
     /*----------------------------------------------------------------*/
-    aSocket.Close ();
 
     return aResult;