http_message_parser_base.h

Go to the documentation of this file.

// Copyright (C) 2017-2020 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef HTTP_MESSAGE_PARSER_BASE_H
#define HTTP_MESSAGE_PARSER_BASE_H

#include <exceptions/exceptions.h>
#include <http/http_message.h>
#include <util/state_model.h>
#include <functional>
#include <string>

namespace isc {
namespace http {

class HttpParseError : public Exception {
public:
    HttpParseError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};

class HttpMessageParserBase : public util::StateModel {
public:



    static const int HTTP_PARSE_OK_ST = SM_DERIVED_STATE_MIN + 1000;

    static const int HTTP_PARSE_FAILED_ST = SM_DERIVED_STATE_MIN + 1001;




    static const int DATA_READ_OK_EVT = SM_DERIVED_EVENT_MIN + 1;

    static const int NEED_MORE_DATA_EVT = SM_DERIVED_EVENT_MIN + 2;

    static const int MORE_DATA_PROVIDED_EVT = SM_DERIVED_EVENT_MIN + 3;

    static const int HTTP_PARSE_OK_EVT = SM_DERIVED_EVENT_MIN + 1000;

    static const int HTTP_PARSE_FAILED_EVT = SM_DERIVED_EVENT_MIN + 1001;


    HttpMessageParserBase(HttpMessage& message);

    void poll();

    bool needData() const;

    bool httpParseOk() const;

    std::string getErrorMessage() const {
        return (error_message_);
    }

    void postBuffer(const void* buf, const size_t buf_size);

    std::string getBufferAsString(const size_t limit = 0) const;

    static std::string logFormatHttpMessage(const std::string& message,
                                            const size_t limit = 0);

private:

    using StateModel::runModel;

protected:

    virtual void defineEvents();

    virtual void verifyEvents();

    virtual void defineStates();

    void stateWithReadHandler(const std::string& handler_name,
                              std::function<void(const char c)>
                              after_read_logic);

    void stateWithMultiReadHandler(const std::string& handler_name,
                                   std::function<void(const std::string&)>
                                   after_read_logic);

    void parseFailure(const std::string& error_msg);

    virtual void onModelFailure(const std::string& explanation);

    void getNextFromBuffer(std::string& bytes, const size_t limit = 1);

    void invalidEventError(const std::string& handler_name,
                           const unsigned int event);

    void parseEndedHandler();

    bool popNextFromBuffer(std::string& next, const size_t limit = 1);

    bool isChar(const char c) const;

    bool isCtl(const char c) const;

    bool isSpecial(const char c) const;

    HttpMessage& message_;

    std::string buffer_;

    size_t buffer_pos_;

    std::string error_message_;
};

} // end of namespace isc::http
} // end of namespace isc

#endif