request.h

Go to the documentation of this file.

// Copyright (C) 2016-2022 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_REQUEST_H
#define HTTP_REQUEST_H

#include <hooks/callout_handle_associate.h>
#include <http/basic_auth.h>
#include <http/http_message.h>
#include <http/request_context.h>
#include <boost/shared_ptr.hpp>
#include <cstdint>

namespace isc {
namespace http {

class HttpRequestError : public HttpMessageError {
public:
    HttpRequestError(const char* file, size_t line, const char* what) :
        HttpMessageError(file, line, what) { };
};

class HttpRequest;

typedef boost::shared_ptr<HttpRequest> HttpRequestPtr;

class HttpRequest : public HttpMessage, public hooks::CalloutHandleAssociate {
public:

    enum class Method {
        HTTP_GET,
        HTTP_POST,
        HTTP_HEAD,
        HTTP_PUT,
        HTTP_DELETE,
        HTTP_OPTIONS,
        HTTP_CONNECT,
        HTTP_METHOD_UNKNOWN
    };

    HttpRequest();

    HttpRequest(const Method& method, const std::string& uri, const HttpVersion& version,
                const HostHttpHeader& host_header = HostHttpHeader(),
                const BasicHttpAuthPtr& basic_auth = BasicHttpAuthPtr());

    const HttpRequestContextPtr& context() const {
        return (context_);
    }

    std::string getRemote() const {
        return (remote_);
    }

    void setRemote(const std::string& remote) {
        remote_ = remote;
    }

    void requireHttpMethod(const HttpRequest::Method& method);

    virtual void create();

    virtual void finalize();

    virtual void reset();

    Method getMethod() const;

    std::string getUri() const;


    std::string getBody() const;

    std::string toBriefString() const;

    virtual std::string toString() const;

    bool isPersistent() const;


    bool getTls() const {
        return (tls_);
    }

    void setTls(bool tls) {
        tls_ = tls;
    }

    std::string getSubject() const {
        return (subject_);
    }

    void setSubject(const std::string& subject) {
        subject_ = subject;
    }

    std::string getIssuer() const {
        return (issuer_);
    }

    void setIssuer(const std::string& issuer) {
        issuer_ = issuer;
    }

    std::string getBasicAuth() const {
        return (basic_auth_);
    }

    void setBasicAuth(const std::string& basic_auth) {
        basic_auth_ = basic_auth;
    }

    std::string getCustom() const {
        return (custom_);
    }

    void setCustom(const std::string& custom) {
        custom_ = custom;
    }


    static bool recordSubject_;

    static bool recordIssuer_;

    static bool recordBasicAuth_;

protected:

    Method methodFromString(std::string method) const;

    std::string methodToString(const HttpRequest::Method& method) const;

    std::set<Method> required_methods_;

    Method method_;

    HttpRequestContextPtr context_;

    std::string remote_;

    bool tls_;

    std::string subject_;

    std::string issuer_;

    std::string basic_auth_;

    std::string custom_;
};

}
}

#endif