TransferEncodingParser.cpp

Go to the documentation of this file.

// TransferEncodingParser.cpp

// Implements the cTransferEncodingParser class and its descendants representing the parsers for the various transfer encodings (chunked etc.)

#include "Globals.h"
#include "TransferEncodingParser.h"
#include "EnvelopeParser.h"





// cChunkedTEParser:

class cChunkedTEParser:
    public cTransferEncodingParser,
    public cEnvelopeParser::cCallbacks
{
    typedef cTransferEncodingParser Super;

public:
    cChunkedTEParser(Super::cCallbacks & a_Callbacks):
        Super(a_Callbacks),
        m_State(psChunkLength),
        m_ChunkDataLengthLeft(0),
        m_TrailerParser(*this)
    {
    }


protected:
    enum eState
    {
        psChunkLength,         
        psChunkLengthTrailer,  
        psChunkLengthLF,       
        psChunkData,           
        psChunkDataCR,         
        psChunkDataLF,         
        psTrailer,             
        psFinished,            
    };

    eState m_State;

    size_t m_ChunkDataLengthLeft;

    cEnvelopeParser m_TrailerParser;


    void Error(const AString & a_ErrorMsg)
    {
        m_State = psFinished;
        m_Callbacks.OnError(a_ErrorMsg);
    }


    size_t ParseChunkLength(const char * a_Data, size_t a_Size)
    {
        // Expected input: <hexnumber>[;<trailer>]<CR><LF>
        // Only the hexnumber is parsed into m_ChunkDataLengthLeft, the rest is postponed into psChunkLengthTrailer or psChunkLengthLF
        for (size_t i = 0; i < a_Size; i++)
        {
            switch (a_Data[i])
            {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                {
                    m_ChunkDataLengthLeft = m_ChunkDataLengthLeft * 16 + static_cast<decltype(m_ChunkDataLengthLeft)>(a_Data[i] - '0');
                    break;
                }
                case 'a':
                case 'b':
                case 'c':
                case 'd':
                case 'e':
                case 'f':
                {
                    m_ChunkDataLengthLeft = m_ChunkDataLengthLeft * 16 + static_cast<decltype(m_ChunkDataLengthLeft)>(a_Data[i] - 'a' + 10);
                    break;
                }
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'F':
                {
                    m_ChunkDataLengthLeft = m_ChunkDataLengthLeft * 16 + static_cast<decltype(m_ChunkDataLengthLeft)>(a_Data[i] - 'A' + 10);
                    break;
                }
                case '\r':
                {
                    m_State = psChunkLengthLF;
                    return i + 1;
                }
                case ';':
                {
                    m_State = psChunkLengthTrailer;
                    return i + 1;
                }
                default:
                {
                    Error(Printf("Invalid character in chunk length line: 0x%x", a_Data[i]));
                    return AString::npos;
                }
            }  // switch (a_Data[i])
        }  // for i - a_Data[]
        return a_Size;
    }


    size_t ParseChunkLengthTrailer(const char * a_Data, size_t a_Size)
    {
        // Expected input: <trailer><CR><LF>
        // The LF itself is not parsed, it is instead postponed into psChunkLengthLF
        for (size_t i = 0; i < a_Size; i++)
        {
            switch (a_Data[i])
            {
                case '\r':
                {
                    m_State = psChunkLengthLF;
                    return i;
                }
                default:
                {
                    if (a_Data[i] < 32)
                    {
                        // Only printable characters are allowed in the trailer
                        Error(Printf("Invalid character in chunk length line: 0x%x", a_Data[i]));
                        return AString::npos;
                    }
                }
            }  // switch (a_Data[i])
        }  // for i - a_Data[]
        return a_Size;
    }


    size_t ParseChunkLengthLF(const char * a_Data, size_t a_Size)
    {
        // Expected input: <LF>
        if (a_Size == 0)
        {
            return 0;
        }
        if (a_Data[0] == '\n')
        {
            if (m_ChunkDataLengthLeft == 0)
            {
                m_State = psTrailer;
            }
            else
            {
                m_State = psChunkData;
            }
            return 1;
        }
        Error(Printf("Invalid character past chunk length's CR: 0x%x", a_Data[0]));
        return AString::npos;
    }


    size_t ParseChunkData(const char * a_Data, size_t a_Size)
    {
        ASSERT(m_ChunkDataLengthLeft > 0);
        auto bytes = std::min(a_Size, m_ChunkDataLengthLeft);
        m_ChunkDataLengthLeft -= bytes;
        m_Callbacks.OnBodyData(a_Data, bytes);
        if (m_ChunkDataLengthLeft == 0)
        {
            m_State = psChunkDataCR;
        }
        return bytes;
    }


    size_t ParseChunkDataCR(const char * a_Data, size_t a_Size)
    {
        // Expected input: <CR>
        if (a_Size == 0)
        {
            return 0;
        }
        if (a_Data[0] == '\r')
        {
            m_State = psChunkDataLF;
            return 1;
        }
        Error(Printf("Invalid character past chunk data: 0x%x", a_Data[0]));
        return AString::npos;
    }




    size_t ParseChunkDataLF(const char * a_Data, size_t a_Size)
    {
        // Expected input: <LF>
        if (a_Size == 0)
        {
            return 0;
        }
        if (a_Data[0] == '\n')
        {
            m_State = psChunkLength;
            return 1;
        }
        Error(Printf("Invalid character past chunk data's CR: 0x%x", a_Data[0]));
        return AString::npos;
    }


    size_t ParseTrailer(const char * a_Data, size_t a_Size)
    {
        auto res = m_TrailerParser.Parse(a_Data, a_Size);
        if (res == AString::npos)
        {
            Error("Error while parsing the trailer");
        }
        if ((res < a_Size) || !m_TrailerParser.IsInHeaders())
        {
            m_Callbacks.OnBodyFinished();
            m_State = psFinished;
        }
        return res;
    }


    // cTransferEncodingParser overrides:
    virtual size_t Parse(const char * a_Data, size_t a_Size) override
    {
        while ((a_Size > 0) && (m_State != psFinished))
        {
            size_t consumed = 0;
            switch (m_State)
            {
                case psChunkLength:        consumed = ParseChunkLength       (a_Data, a_Size); break;
                case psChunkLengthTrailer: consumed = ParseChunkLengthTrailer(a_Data, a_Size); break;
                case psChunkLengthLF:      consumed = ParseChunkLengthLF     (a_Data, a_Size); break;
                case psChunkData:          consumed = ParseChunkData         (a_Data, a_Size); break;
                case psChunkDataCR:        consumed = ParseChunkDataCR       (a_Data, a_Size); break;
                case psChunkDataLF:        consumed = ParseChunkDataLF       (a_Data, a_Size); break;
                case psTrailer:            consumed = ParseTrailer           (a_Data, a_Size); break;
                case psFinished:           consumed = 0;                                       break;  // Not supposed to happen, but Clang complains without it
            }
            if (consumed == AString::npos)
            {
                return AString::npos;
            }
            a_Data += consumed;
            a_Size -= consumed;
        }
        return a_Size;
    }

    virtual void Finish(void) override
    {
        if (m_State != psFinished)
        {
            Error(Printf("ChunkedTransferEncoding: Finish signal received before the data stream ended (state: %d)", m_State));
        }
        m_State = psFinished;
    }


    // cEnvelopeParser::cCallbacks overrides:
    virtual void OnHeaderLine(const AString & a_Key, const AString & a_Value) override
    {
        // Ignored
    }
};





// cIdentityTEParser:

class cIdentityTEParser:
    public cTransferEncodingParser
{
    typedef cTransferEncodingParser Super;

public:
    cIdentityTEParser(cCallbacks & a_Callbacks, size_t a_ContentLength):
        Super(a_Callbacks),
        m_BytesLeft(a_ContentLength)
    {
    }


protected:
    size_t m_BytesLeft;

    // cTransferEncodingParser overrides:
    virtual size_t Parse(const char * a_Data, size_t a_Size) override
    {
        auto size = std::min(a_Size, m_BytesLeft);
        if (size > 0)
        {
            m_Callbacks.OnBodyData(a_Data, size);
        }
        m_BytesLeft -= size;
        if (m_BytesLeft == 0)
        {
            m_Callbacks.OnBodyFinished();
        }
        return a_Size - size;
    }

    virtual void Finish(void) override
    {
        if (m_BytesLeft > 0)
        {
            m_Callbacks.OnError("IdentityTransferEncoding: body was truncated");
        }
        else
        {
            // BodyFinished has already been called, just bail out
        }
    }
};





// cTransferEncodingParser:

cTransferEncodingParserPtr cTransferEncodingParser::Create(
    cCallbacks & a_Callbacks,
    const AString & a_TransferEncoding,
    size_t a_ContentLength
)
{
    if (a_TransferEncoding == "chunked")
    {
        return std::make_shared<cChunkedTEParser>(a_Callbacks);
    }
    if (a_TransferEncoding == "identity")
    {
        return std::make_shared<cIdentityTEParser>(a_Callbacks, a_ContentLength);
    }
    if (a_TransferEncoding.empty())
    {
        return std::make_shared<cIdentityTEParser>(a_Callbacks, a_ContentLength);
    }
    return nullptr;
}