http_command_config.h

Go to the documentation of this file.

// Copyright (C) 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_COMMAND_CONFIG_H
#define HTTP_COMMAND_CONFIG_H
 
#include <asiolink/io_address.h>
#include <cc/cfg_to_element.h>
#include <cc/user_context.h>
#include <http/auth_config.h>
 
namespace isc {
namespace config {
 
class HttpCommandConfig : public isc::data::UserContext,
                          public isc::data::CfgToElement {
public:
    HttpCommandConfig(isc::data::ConstElementPtr config);
 
    ~HttpCommandConfig() = default;
 
    std::string getSocketType() const {
        return (socket_type_);
    }
 
    void setSocketType(const std::string& socket_type) {
        socket_type_ = socket_type;
    }
 
    isc::asiolink::IOAddress getSocketAddress() const {
        return (socket_address_);
    }
 
    void setSocketAddress(const isc::asiolink::IOAddress& socket_address) {
        socket_address_ = socket_address;
    }
 
    uint16_t getSocketPort() const {
        return (socket_port_);
    }
 
    void setSocketPort(const uint16_t socket_port) {
        socket_port_ = socket_port;
    }
 
    const isc::http::HttpAuthConfigPtr& getAuthConfig() const {
        return (auth_config_);
    }
 
    void setAuthConfig(const isc::http::HttpAuthConfigPtr& auth_config) {
        auth_config_ = auth_config;
    }
 
    std::string getTrustAnchor() const {
        return (trust_anchor_);
    }
 
    void setTrustAnchor(const std::string& ca) {
        trust_anchor_ = ca;
    }
 
    std::string getCertFile() const {
        return (cert_file_);
    }
 
    void setCertFile(const std::string& cert) {
        cert_file_ = cert;
    }
 
    std::string getKeyFile() const {
        return (key_file_);
    }
 
    void setKeyFile(const std::string& key) {
        key_file_ = key;
    }
 
    bool getCertRequired() const {
        return (cert_required_);
    }
 
    void setCertRequired(bool required) {
        cert_required_ = required;
    }
 
    bool getEmulateAgentResponse() const {
        return (emulate_agent_response_);
    }
 
    void setEmulateAgentResponse(const bool emulate_agent_response) {
        emulate_agent_response_ = emulate_agent_response;
    }
 
    virtual isc::data::ElementPtr toElement() const;
 
    static isc::asiolink::IOAddress DEFAULT_SOCKET_ADDRESS;
 
    static uint16_t DEFAULT_SOCKET_PORT;
 
    static std::string DEFAULT_AUTHENTICATION_REALM;
 
private:
    void checkTlsSetup(bool require_tls) const;
 
    std::string socket_type_;
 
    isc::asiolink::IOAddress socket_address_;
 
    uint16_t socket_port_;
 
    isc::http::HttpAuthConfigPtr auth_config_;
 
    std::string trust_anchor_;
 
    std::string cert_file_;
 
    std::string key_file_;
 
    bool cert_required_;
 
    bool emulate_agent_response_;
};
 
typedef boost::shared_ptr<HttpCommandConfig> HttpCommandConfigPtr;
 
} // end of isc::config namespace
} // end of isc namespace
#endif