http_message_parser_base.h

Go to the documentation of this file.

// Copyright (C) 2017-2024 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() override ;
 
    virtual void verifyEvents() override;
 
    virtual void defineStates() override;
 
    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) override;
 
    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 signed char c) const;
 
    bool isCtl(const signed char c) const;
 
    bool isSpecial(const signed 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