request.h

Go to the documentation of this file.

// Copyright (C) 2016-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_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