Changeset 44 in cheroxy


Ignore:
Timestamp:
11/22/12 15:21:02 (11 years ago)
Author:
cheese
Message:

#1 change logic more detail

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/CRXHttpMessage.h

    r31 r44  
    66
    77#include <string>
     8
     9#define CRLF                "\r\n"
     10#define CRLF2               "\r\n\r\n" 
    811
    912class CRXHttpMessage
    … …  
    2629
    2730    void            ResetMessage    (void);
    28 
    29     virtual CRXHttpMessage &    operator =  (const char * aHttpMessage) = 0;
    3031};
    3132

  • trunk/include/CRXHttpRequest.h

    r28 r44  
    3131    std::string         GetHeader           (void) const;
    3232
    33     CRXHttpRequest &    operator =          (const char * aHttpRequest);
    34 
    3533public:
    3634    std::string         GetURL              (void) const;

  • trunk/include/CRXHttpResponse.h

    r26 r44  
    3232private:
    3333    void                Parse               (void);
    34     int                 ParseContent        (const char * aContent,
    35                                              const int  aLength);
    3634    void                Reset               (void);
    3735    void                ResetContent        (void);
    … …  
    4038    int                 GetStatusCode       (void) const;
    4139
    42     int                 SetResponse         (const char * aHttpResponse,
     40    bool                IsChunked           (void) const;
     41    int                 SetResponseAll      (const char * aHttpResponse,
    4342                                             const int  aResponseLength);
     43    void                SetHeader           (const char * aHttpResponse);
    4444    std::string         GetHeader           (void) const;
     45    int                 SetContent          (const char * aContent,
     46                                             const int  aLength);
    4547    const char *        GetContentBody      (void) const;
    4648    int                 GetContentLength    (void) const;
    47 
    48     CRXHttpResponse &   operator =          (const char * aHttpResponse);
    4949};
    5050

  • trunk/include/CRXProxy.h

    r36 r44  
    3838    ~CRXProxy           (void);
    3939
    40     static CRXProxy *   GetNewInstance  (void);
    41 
    4240public:
    4341    /* common utilities */
    44     void    ReleaseInstance             (void);
    45 
    4642    void    SetClientSocket             (const int  aSocket);
    4743    void    SetServerTimeout            (const int  aTimeout = TCPSOCKET_NO_TIMEOUT);

  • trunk/src/CRXHttpRequest.cpp

    r28 r44  
    4848
    4949    return GetMessage ();
    50 }
    51 
    52 CRXHttpRequest &
    53 CRXHttpRequest::operator = (const char * aHttpMessage)
    54 {
    55     /*----------------------------------------------------------------*/
    56     SetHeader (aHttpMessage);
    57     /*----------------------------------------------------------------*/
    58 
    59     return *this;
    6050}
    6151

  • trunk/src/CRXHttpResponse.cpp

    r28 r44  
    1212#include <string.h>
    1313
    14 #define CRLF                "\r\n"
    15 #define CRLF2               "\r\n\r\n" 
    16 
    1714#define CONTENT_LENGTH      "Content-Length: "
    1815#define TRANSFER_ENCODING   "Transfer-Encoding: "
    … …  
    5653
    5754int
    58 CRXHttpResponse::SetResponse (const char    * aHttpResponse,
    59                               const int     aResponseLength)
     55CRXHttpResponse::SetResponseAll (const char * aHttpResponse,
     56                                 const int  aResponseLength)
    6057{
    6158    int             aResult = 0;
    … …  
    7067        return ERROR_HTTP_RESPONSE_INVALID_LENGTH;
    7168
    72     if (GetHeader ().length () == 0)
     69    if (GetHeader ().rfind (CRLF2) == std::string::npos)
    7370    {
    7471        aEndOfHeader = strstr (aHttpResponse, CRLF2);
    … …  
    8077        aHeader.assign (aHttpResponse, aHeaderLength);
    8178
    82         SetMessage (aHeader.c_str ());
    83     }
    84 
    85     aResult = ParseContent (aHttpResponse + aHeaderLength, aResponseLength - aHeaderLength);
     79        SetHeader (aHeader.c_str ());
     80    }
     81
     82    aResult = SetContent (aHttpResponse + aHeaderLength, aResponseLength - aHeaderLength);
    8683    if (aResult)
    8784    {
    88         return ERROR_HTTP_RESPONSE_FAILED_TO_PARSE_CONTENT;
     85        aResult = ERROR_HTTP_RESPONSE_FAILED_TO_PARSE_CONTENT;
    8986    }
    9087    /*----------------------------------------------------------------*/
    … …  
    9390}
    9491
    95 CRXHttpResponse &
    96 CRXHttpResponse::operator = (const char * aHttpMessage)
     92void
     93CRXHttpResponse::SetHeader (const char * aHttpMessage)
    9794{
    9895    /*----------------------------------------------------------------*/
    9996    SetMessage (aHttpMessage);
    10097    /*----------------------------------------------------------------*/
    101 
    102     return *this;
    10398}
    10499
    … …  
    166161
    167162int
    168 CRXHttpResponse::ParseContent (const char   * aContent,
     163CRXHttpResponse::SetContent (const char * aContent,
    169164                               const int    aLength)
    170165{
    … …  
    207202
    208203int             CRXHttpResponse::GetStatusCode      (void) const { return mStatusCode; }
     204bool            CRXHttpResponse::IsChunked          (void) const { return mIsChunked; }
    209205int             CRXHttpResponse::GetContentLength   (void) const { return mContentLength; }
    210206const char *    CRXHttpResponse::GetContentBody     (void) const { return mContent.mBody; }

  • trunk/src/CRXProxy.cpp

    r40 r44  
    2525}
    2626
    27 CRXProxy *
    28 CRXProxy::GetNewInstance (void)
    29 {
    30     /*----------------------------------------------------------------*/
    31     /*----------------------------------------------------------------*/
    32 
    33     return new(std::nothrow) CRXProxy ();
    34 }
    35 
    36 void
    37 CRXProxy::ReleaseInstance (void)
    38 {
    39     /*----------------------------------------------------------------*/
    40     delete this;
    41     /*----------------------------------------------------------------*/
    42 }
    43 
    4427void
    4528CRXProxy::SetClientSocket (const int aSocket)
    … …  
    141124{
    142125    /*----------------------------------------------------------------*/
    143     mHttpRequest = aHttpRequest;
     126    mHttpRequest.SetHeader (aHttpRequest);
    144127    /*----------------------------------------------------------------*/
    145128}
    … …  
    158141    if (aPtr == NULL)
    159142        return NULL;
    160    
     143
    161144    aCopyLength = aRemainLength < aHeaderLength ? aBufferSize : aHeaderLength;
    162145    if (aCopyLength > 0)
    … …  
    180163{
    181164    /*----------------------------------------------------------------*/
    182     mHttpResponse = aHttpResponse;
     165    mHttpResponse.SetHeader (aHttpResponse);
    183166    /*----------------------------------------------------------------*/
    184167}
    … …  
    249232CRXProxy::ReceiveRequest (void)
    250233{
    251     int                 aResult     = 0;
    252 
    253     const unsigned int  aBufferSize = 1024 * 56;
    254     char                aBuffer[aBufferSize + 1] = {0x00, };
    255 
    256     /*----------------------------------------------------------------*/
    257     aResult = mClient.Receive (aBuffer, aBufferSize);
    258     if (aResult < 0)
    259     {
    260         aResult = ERROR_PROXY_FAILED_TO_RECEIVE_REQUEST;
    261         CRX_ADD_SUBCLASS_ERROR (mClient);
    262         CRX_ERROR_SET (aResult, "Failed to receive from client.");
    263         return aResult;
    264     }
    265 
    266     /* parse http request */
    267     mHttpRequest = aBuffer;
     234    int         aResult = 0;
     235    char        aBuffer;
     236
     237    std::string aHttpHeader;
     238    /*----------------------------------------------------------------*/
     239    for (;;)
     240    {
     241        aResult = mClient.Receive (&aBuffer, 1);
     242        if (aResult < 0)
     243        {
     244            aResult = ERROR_PROXY_FAILED_TO_RECEIVE_REQUEST;
     245            CRX_ADD_SUBCLASS_ERROR (mClient);
     246            CRX_ERROR_SET (aResult, "Failed to receive from client.");
     247            return aResult;
     248        }
     249        aHttpHeader += aBuffer;
     250        if (aHttpHeader.rfind (CRLF2) != std::string::npos)
     251            break;
     252    }
     253
     254    mHttpRequest.SetHeader (aHttpHeader.c_str ());
    268255    /*----------------------------------------------------------------*/
    269256
    … …  
    292279            return aResult;
    293280        }
    294 
    295         if (getsockname (mServer, (struct sockaddr *) &aSockName, &aSockLen) == 0)
    296             CRX_DEBUG_TRACE ("Connected on port number (%d)\n", ntohs (aSockName.sin_port));
    297281    }
    298282
    … …  
    315299    const unsigned int  aBufferSize     = 1024 * 64;
    316300    char                aBuffer[aBufferSize + 1] = {0x00, };
    317 
    318     std::string         aHttpResponse;
    319301
    320302    /*----------------------------------------------------------------*/
    … …  
    331313            return aResult;
    332314        }
    333         else if (aResult == 0)
    334         {
    335             break;
    336         }
    337 
    338         aResult = mHttpResponse.SetResponse (aBuffer, aResult);
     315
     316        aResult = mHttpResponse.SetResponseAll (aBuffer, aResult);
    339317        if (aResult)
    340318        {
    … …  
    343321            return aResult;
    344322        }
    345 
    346         if (!CheckRequestFilter (CRX_FILTER_REQUEST_FILE_EXTENSION) &&
    347             mHttpResponse.GetContentLength () > 0)
    348         {
    349             CRX_DEBUG_TRACE_BIN (mHttpResponse.GetContentBody (),
    350                                  mHttpResponse.GetContentLength (),
    351                                  "");
    352         }
    353323    }
    354324    /*----------------------------------------------------------------*/

  • trunk/src/main.cpp

    r36 r44  
    9191        }
    9292
    93         if ((aProxy = CRXProxy::GetNewInstance ()) == NULL)
     93        if ((aProxy = new(std::nothrow) CRXProxy ()) == NULL)
    9494        {
    9595            cerr << "Failed to get proxy." << endl;
    … …  
    114114            aHttpMessageLength = aProxy->GetHttpRequestLength ();
    115115            aHttpMessage = (char *) calloc (aHttpMessageLength + 1, 1);
    116             cout << aProxy->GetHttpRequest (aHttpMessage, aHttpMessageLength) << endl;
     116            aProxy->GetHttpRequest (aHttpMessage, aHttpMessageLength);
     117            CRX_DEBUG_TRACE ("== Request: \n%s\n", aHttpMessage);
    117118            free (aHttpMessage);
    118119
    119120            aHttpMessageLength = aProxy->GetHttpResponseHeaderLength ();
    120121            aHttpMessage = (char *) calloc (aHttpMessageLength + 1, 1);
    121             cout << aProxy->GetHttpResponseHeader (aHttpMessage, aHttpMessageLength) << endl;
     122            aProxy->GetHttpResponseHeader (aHttpMessage, aHttpMessageLength);
     123            CRX_DEBUG_TRACE ("== Response: \n%s\n", aHttpMessage);
     124            free (aHttpMessage);
     125
     126            aHttpMessageLength = aProxy->GetHttpResponseBodyLength ();
     127            aHttpMessage = (char *) calloc (aHttpMessageLength + 1, 1);
     128            aProxy->GetHttpResponseBody (aHttpMessage, aHttpMessageLength);
     129            CRX_DEBUG_TRACE_BIN (aHttpMessage, aHttpMessageLength, "== Content-Body: \n");
    122130            free (aHttpMessage);
    123131        }
    124132
    125         aProxy->ReleaseInstance ();
     133        delete aProxy;
    126134    }
    127135
Note: See TracChangeset for help on using the changeset viewer.