Changeset 24 in cheroxy for trunk/src/CRXHttpResponse.cpp

Timestamp:

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

Author:

cheese

Message:

#1 change response, threading and proxy work-flow

File:

• trunk/src/CRXHttpResponse.cpp (modified) (2 diffs)

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;
+}