path: root/library/cpp/http/fetch/httpparser.h

#pragma once

#include "httpfsm.h"
#include "httpheader.h"

#include <library/cpp/mime/types/mime.h>
#include <util/system/yassert.h>
#include <library/cpp/http/misc/httpcodes.h>

template <size_t headermax = 100 << 10, size_t bodymax = 1 << 20>
struct TFakeCheck {
    bool Check(THttpHeader* /*header*/) {
        return false;
    }
    void CheckDocPart(void* /*buf*/, size_t /*len*/, THttpHeader* /*header*/) {
    } //for every part of DocumentBody will be called
    void CheckEndDoc(THttpHeader* /*header*/) {
    }
    size_t GetMaxHeaderSize() {
        return headermax;
    }
    size_t GetMaxBodySize(THttpHeader*) {
        return bodymax;
    }
};

class THttpParserBase {
public:
    enum States {
        hp_error,
        hp_eof,
        hp_in_header,
        hp_read_alive,
        hp_read_closed,
        hp_begin_chunk_header,
        hp_chunk_header,
        hp_read_chunk
    };

    States GetState() {
        return State;
    }

    void setAssumeConnectionClosed(int value) {
        AssumeConnectionClosed = value;
    }

    THttpHeader* GetHttpHeader() const {
        return Header;
    }

protected:
    int CheckHeaders() {
        if (Header->http_status < HTTP_OK || Header->http_status == HTTP_NO_CONTENT || Header->http_status == HTTP_NOT_MODIFIED) {
            Header->content_length = 0;
            Header->transfer_chunked = 0;
        }
        if (Header->transfer_chunked < -1) {
            Header->error = HTTP_BAD_ENCODING;
            return 1;
        } else if (Header->transfer_chunked == -1) {
            Header->transfer_chunked = 0;
        }
        if (!Header->transfer_chunked && Header->content_length < -1) {
            Header->error = HTTP_BAD_CONTENT_LENGTH;
            return 1;
        }
        if (Header->http_status == HTTP_OK) {
            if (Header->compression_method != HTTP_COMPRESSION_UNSET &&
                Header->compression_method != HTTP_COMPRESSION_IDENTITY &&
                Header->compression_method != HTTP_COMPRESSION_GZIP &&
                Header->compression_method != HTTP_COMPRESSION_DEFLATE)
            {
                Header->error = HTTP_BAD_CONTENT_ENCODING;
                return 1;
            }
        }
        if (Header->connection_closed == -1)
            Header->connection_closed = (Header->http_minor == 0 ||
                                         AssumeConnectionClosed);
        if (!Header->transfer_chunked && !Header->connection_closed && Header->content_length < 0 && !HeadRequest) {
            Header->error = HTTP_LENGTH_UNKNOWN;
            return 1;
        }
        if (Header->http_time < 0)
            Header->http_time = 0;
        if (Header->mime_type < 0)
            Header->mime_type = MIME_UNKNOWN;
        return 0;
    }

    THttpHeaderParser HeaderParser;
    THttpChunkParser ChunkParser;
    States State;
    long ChunkSize;
    THttpHeader* Header;
    int AssumeConnectionClosed;
    bool HeadRequest;
};

template <int isReader, typename TCheck = TFakeCheck<>>
class THttpParserGeneric: public THttpParserBase, public TCheck {
protected:
    long ParseGeneric(void*& buf, long& size) {
        if (!size) {
            switch (State) {
                case hp_error:
                case hp_eof:
                    break;
                case hp_read_closed:
                    State = hp_eof;
                    break;
                case hp_in_header:
                    Header->error = HTTP_HEADER_EOF;
                    State = hp_error;
                    break;
                case hp_read_alive:
                case hp_read_chunk:
                    if (HeadRequest)
                        State = hp_eof;
                    else {
                        Header->error = HTTP_MESSAGE_EOF;
                        State = hp_error;
                    }
                    break;
                case hp_begin_chunk_header:
                case hp_chunk_header:
                    if (HeadRequest)
                        State = hp_eof;
                    else {
                        Header->error = HTTP_CHUNK_EOF;
                        State = hp_error;
                    }
                    break;
            }
            return 0;
        }
        while (size) {
            int ret;

            switch (State) {
                case hp_error:
                    return 0;

                case hp_eof:
                    return 0;

                case hp_in_header:
                    if ((ret = HeaderParser.Execute(buf, size)) < 0) {
                        Header->error = HTTP_BAD_HEADER_STRING;
                        State = hp_error;
                        return 0;
                    } else if (ret == 2) {
                        Header->header_size += i32(HeaderParser.lastchar - (char*)buf + 1);
                        size -= long(HeaderParser.lastchar - (char*)buf + 1);
                        buf = HeaderParser.lastchar + 1;
                        State = CheckHeaders() ? hp_error
                                               : Header->transfer_chunked ? hp_begin_chunk_header
                                                                          : Header->content_length == 0 ? hp_eof
                                                                                                        : Header->content_length > 0 ? hp_read_alive
                                                                                                                                     : hp_read_closed;
                        if (State == hp_begin_chunk_header) {
                            // unget \n for chunk reader
                            buf = (char*)buf - 1;
                            size++;
                        }
                        if (isReader)
                            return size;
                    } else {
                        Header->header_size += size;
                        size = 0;
                    }
                    break;

                case hp_read_alive:
                    Header->entity_size += size;
                    if (Header->entity_size >= Header->content_length) {
                        State = hp_eof;
                    }

                    TCheck::CheckDocPart(buf, size, Header);
                    if (isReader)
                        return size;
                    size = 0;
                    break;

                case hp_read_closed:
                    Header->entity_size += size;
                    TCheck::CheckDocPart(buf, size, Header);
                    if (isReader)
                        return size;
                    size = 0;
                    break;

                case hp_begin_chunk_header:
                    ChunkParser.Init();
                    State = hp_chunk_header;
                    [[fallthrough]];

                case hp_chunk_header:
                    if ((ret = ChunkParser.Execute(buf, size)) < 0) {
                        Header->error = i16(ret == -2 ? HTTP_CHUNK_TOO_LARGE : HTTP_BAD_CHUNK);
                        State = hp_error;
                        return 0;
                    } else if (ret == 2) {
                        Header->entity_size += i32(ChunkParser.lastchar - (char*)buf + 1);
                        size -= long(ChunkParser.lastchar - (char*)buf + 1);
                        buf = ChunkParser.lastchar + 1;
                        ChunkSize = ChunkParser.chunk_length;
                        Y_ASSERT(ChunkSize >= 0);
                        State = ChunkSize ? hp_read_chunk : hp_eof;
                    } else {
                        Header->entity_size += size;
                        size = 0;
                    }
                    break;

                case hp_read_chunk:
                    if (size >= ChunkSize) {
                        Header->entity_size += ChunkSize;
                        State = hp_begin_chunk_header;
                        TCheck::CheckDocPart(buf, ChunkSize, Header);
                        if (isReader)
                            return ChunkSize;
                        size -= ChunkSize;
                        buf = (char*)buf + ChunkSize;
                    } else {
                        Header->entity_size += size;
                        ChunkSize -= size;
                        TCheck::CheckDocPart(buf, size, Header);
                        if (isReader)
                            return size;
                        size = 0;
                    }
                    break;
            }
        }
        return size;
    }
};

template <class TCheck = TFakeCheck<>>
class THttpParser: public THttpParserGeneric<0, TCheck> {
    typedef THttpParserGeneric<0, TCheck> TBaseT; //sorry avoiding gcc 3.4.6 BUG!
public:
    void Init(THttpHeader* H, bool head_request = false) {
        TBaseT::Header = H;
        TBaseT::HeaderParser.Init(TBaseT::Header);
        TBaseT::State = TBaseT::hp_in_header;
        TBaseT::AssumeConnectionClosed = 0;
        TBaseT::HeadRequest = head_request;
    }

    void Parse(void* buf, long size) {
        TBaseT::ParseGeneric(buf, size);
    }
};

class TMemoReader {
public:
    int Init(void* buf, long bufsize) {
        Buf = buf;
        Bufsize = bufsize;
        return 0;
    }
    long Read(void*& buf) {
        Y_ASSERT(Bufsize >= 0);
        if (!Bufsize) {
            Bufsize = -1;
            return 0;
        }
        buf = Buf;
        long ret = Bufsize;
        Bufsize = 0;
        return ret;
    }

protected:
    long Bufsize;
    void* Buf;
};

template <class Reader>
class THttpReader: public THttpParserGeneric<1>, public Reader {
    typedef THttpParserGeneric<1> TBaseT;

public:
    using TBaseT::AssumeConnectionClosed;
    using TBaseT::Header;
    using TBaseT::ParseGeneric;
    using TBaseT::State;

    int Init(THttpHeader* H, int parsHeader, int assumeConnectionClosed = 0, bool headRequest = false) {
        Header = H;
        Eoferr = 1;
        Size = 0;
        AssumeConnectionClosed = assumeConnectionClosed;
        HeadRequest = headRequest;
        return parsHeader ? ParseHeader() : SkipHeader();
    }

    long Read(void*& buf) {
        long Chunk;
        do {
            if (!Size) {
                if (Eoferr != 1)
                    return Eoferr;
                else if ((Size = (long)Reader::Read(Ptr)) < 0) {
                    Header->error = HTTP_CONNECTION_LOST;
                    return Eoferr = -1;
                }
            }
            Chunk = ParseGeneric(Ptr, Size);
            buf = Ptr;
            Ptr = (char*)Ptr + Chunk;
            Size -= Chunk;
            if (State == hp_eof) {
                Size = 0;
                Eoferr = 0;
            } else if (State == hp_error)
                return Eoferr = -1;
        } while (!Chunk);
        return Chunk;
    }

protected:
    int ParseHeader() {
        HeaderParser.Init(Header);
        State = hp_in_header;
        while (State == hp_in_header) {
            if ((Size = (long)Reader::Read(Ptr)) < 0)
                return Eoferr = -1;
            ParseGeneric(Ptr, Size);
        }
        if (State == hp_error)
            return Eoferr = -1;
        if (State == hp_eof)
            Eoferr = 0;
        return 0;
    }

    int SkipHeader() {
        long hdrsize = Header->header_size;
        while (hdrsize) {
            if ((Size = (long)Reader::Read(Ptr)) <= 0)
                return Eoferr = -1;
            if (Size >= hdrsize) {
                Size -= hdrsize;
                Ptr = (char*)Ptr + hdrsize;
                break;
            }
            hdrsize -= Size;
        }
        State = Header->transfer_chunked ? hp_begin_chunk_header
                                         : Header->content_length == 0 ? hp_eof
                                                                       : Header->content_length > 0 ? hp_read_alive
                                                                                                    : hp_read_closed;
        Header->entity_size = 0;
        if (State == hp_eof)
            Eoferr = 0;
        else if (State == hp_begin_chunk_header) {
            // unget \n for chunk reader
            Ptr = (char*)Ptr - 1;
            ++Size;
        }
        return 0;
    }

    void* Ptr;
    long Size;
    int Eoferr;
};