source: cheroxy/trunk/src/CRXHttpResponse.cpp@ 47

/**
 * CRXHttpResponse.cpp
 */
#ifdef _WIN32
# pragma warning (disable:4996)
#endif

#include "CRXHttpResponse.h"

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

#define CONTENT_LENGTH      "Content-Length: "
#define TRANSFER_ENCODING   "Transfer-Encoding: "

CRXHttpResponse::CRXHttpResponse (void)
    : mStatusCode (0),
      mIsChunked (false),
      mContentLength (0)
{
    /*----------------------------------------------------------------*/
    memset (&mContent, 0x00, sizeof (mContent));
    /*----------------------------------------------------------------*/
}

CRXHttpResponse::~CRXHttpResponse (void)
{
    /*----------------------------------------------------------------*/
    Reset ();
    /*----------------------------------------------------------------*/
}

void
CRXHttpResponse::Reset (void)
{
    /*----------------------------------------------------------------*/
    Get ().clear ();
    mContent.clear ();
    /*----------------------------------------------------------------*/
}

void
CRXHttpResponse::SetHeader (const char * aHeader)
{
    /*----------------------------------------------------------------*/
    Set (aHeader);
    /*----------------------------------------------------------------*/
}

std::string
CRXHttpResponse::GetHeader (void) const
{
    /*----------------------------------------------------------------*/
    /*----------------------------------------------------------------*/

    return Get ();
}

void
CRXHttpResponse::Parse (void)
{
    std::string aValue;

    char        aStatusCode[64]     = {0x00, };
    char        aStatusName[64]     = {0x00, };
    char        aHttpVersion[64]    = {0x00, };

    size_t      aBegin      = 0;
    size_t      aOffset     = 0;

    /*----------------------------------------------------------------*/
    aValue = GetHeader ().substr (0, GetHeader ().find (CRLF, 0));

    /*----------------------------------------------------------------
     * 1. separate first line to <METHOD>, <URL> and <VERSION>
     *----------------------------------------------------------------*/
    sscanf (aValue.c_str (), "%[^ ] %[^ ] %[^ ]\r\n", aHttpVersion, aStatusCode, aStatusName);
    mHttpVersion.assign (aHttpVersion);
    mStatusString.assign (aStatusName);
    mStatusCode = atoi (aStatusCode);

    /*----------------------------------------------------------------
     * 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::SetContent (const char * aContent,
                             const int  aLength)
{
    int     aResult = 0;
    int     aSize   = 0;
    char    * aChunkedPtr = NULL;

    /*----------------------------------------------------------------*/
    /*----------------------------------------------------------------
     * 1. check parameter
     *----------------------------------------------------------------*/
    if (aLength < 0)
        return ERROR_HTTP_RESPONSE_INVALID_LENGTH;

    /*----------------------------------------------------------------
     * 2. check content size when is NOT chunked-encoding
     *----------------------------------------------------------------*/
    if (!mIsChunked && mContent.size () >= mContentLength)
        return 0;

    /*----------------------------------------------------------------
     * 3. resize memory and copy
     *----------------------------------------------------------------*/
    aSize = mContent.size ();
    mContent.resize (aSize + aLength);
    memcpy (&mContent[0] + aSize, aContent, aLength);

    /*----------------------------------------------------------------
     * 4. 
     *----------------------------------------------------------------*/
    aResult = mContent.size ();
    if (mIsChunked)
    {
        mContentLength += aLength;
        aSize = mContent.size ();
        if ((unsigned int)aSize > strlen (CRLF) + strlen (CRLF2))
        {
            aChunkedPtr = &mContent[0] + aSize - strlen (CRLF2);
            if (!strncmp (aChunkedPtr, CRLF2, strlen (CRLF2)))
            {
                for ( ; strncmp (aChunkedPtr--, CRLF, strlen (CRLF)) ; );
                aResult = strtol (aChunkedPtr, NULL, 16);
            }
        }
    }
    /*----------------------------------------------------------------*/

    return aResult;
}

int
CRXHttpResponse::GetStatusCode (void) const
{
    /*----------------------------------------------------------------*/
    /*----------------------------------------------------------------*/

    return mStatusCode;
}

bool
CRXHttpResponse::IsChunked (void) const
{
    /*----------------------------------------------------------------*/
    /*----------------------------------------------------------------*/

    return mIsChunked;
}

int
CRXHttpResponse::GetContentLength (void) const
{
    /*----------------------------------------------------------------*/
    /*----------------------------------------------------------------*/

    return mContentLength;
}

const char *
CRXHttpResponse::GetContentBody (void) const
{
    /*----------------------------------------------------------------*/
    /*----------------------------------------------------------------*/

    return mContent.empty () ? "" : &mContent[0];
}