option4_dnr.h

Go to the documentation of this file.

// Copyright (C) 2023-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 OPTION4_DNR_H
#define OPTION4_DNR_H
 
#include <asiolink/io_address.h>
#include <boost/assign.hpp>
#include <boost/bimap.hpp>
#include <dhcp/dhcp4.h>
#include <dhcp/dhcp6.h>
#include <dhcp/option.h>
#include <dhcp/option_data_types.h>
#include <dns/name.h>
#include <util/encode/utf8.h>
 
#include <map>
#include <set>
#include <string>
#include <unordered_set>
 
namespace isc {
namespace dhcp {
 
class InvalidOptionDnrDomainName : public Exception {
public:
    InvalidOptionDnrDomainName(const char* file, size_t line, const char* what)
        : isc::Exception(file, line, what) {
    }
};
 
class InvalidOptionDnrSvcParams : public Exception {
public:
    InvalidOptionDnrSvcParams(const char* file, size_t line, const char* what)
        : isc::Exception(file, line, what) {
    }
};
 
class DnrInstance {
public:
    typedef std::vector<isc::asiolink::IOAddress> AddressContainer;
 
    typedef boost::bimap<std::string, uint16_t> SvcParamsMap;
 
    static const uint8_t SERVICE_PRIORITY_SIZE = 2;
 
    static const std::unordered_set<std::string> FORBIDDEN_SVC_PARAMS;
 
    static const SvcParamsMap SVC_PARAMS;
 
    static const std::set<uint8_t> SUPPORTED_SVC_PARAMS;
 
    static const std::unordered_set<std::string> ALPN_IDS;
 
    explicit DnrInstance(Option::Universe universe);
 
    virtual ~DnrInstance() = default;
 
    uint16_t getDnrInstanceDataLength() const {
        return (dnr_instance_data_length_);
    }
 
    uint16_t getServicePriority() const {
        return (service_priority_);
    }
 
    uint16_t getAdnLength() const {
        return (adn_length_);
    }
 
    std::string getAdnAsText() const;
 
    std::string getDnrInstanceAsText() const;
 
    uint16_t getAddrLength() const {
        return (addr_length_);
    }
 
    uint16_t getSvcParamsLength() const {
        return (svc_params_length_);
    }
 
    AddressContainer getAddresses() const {
        return (ip_addresses_);
    }
 
    const OptionBuffer& getSvcParams() const {
        return (svc_params_buf_);
    }
 
    uint8_t getMinimalLength() const {
        return (minimal_length_);
    }
 
    uint8_t getAddrLengthSize() const {
        return (addr_length_size_);
    }
 
    uint8_t getDnrInstanceDataLengthSize() const {
        return (dnr_instance_data_length_size_);
    }
 
    uint8_t getAdnLengthSize() const {
        return (adn_length_size_);
    }
 
    std::string getLogPrefix() const {
        return (log_prefix_);
    }
 
    bool isAdnOnlyMode() const {
        return (adn_only_mode_);
    }
 
    void setAdnOnlyMode(bool adn_only_mode) {
        adn_only_mode_ = adn_only_mode;
    }
 
    void setDnrInstanceDataLength() {
        dnr_instance_data_length_ = dnrInstanceLen();
    }
 
    void packAdn(isc::util::OutputBuffer& buf) const;
 
    virtual void packAddresses(isc::util::OutputBuffer& buf) const;
 
    void packSvcParams(isc::util::OutputBuffer& buf) const;
 
    void unpackDnrInstanceDataLength(OptionBufferConstIter& begin, OptionBufferConstIter end);
 
    void unpackServicePriority(OptionBufferConstIter& begin);
 
    void unpackAdn(OptionBufferConstIter& begin, OptionBufferConstIter end);
 
    virtual void unpackAddresses(OptionBufferConstIter& begin, OptionBufferConstIter end);
 
    void unpackSvcParams(OptionBufferConstIter& begin, OptionBufferConstIter end);
 
    void addIpAddress(const asiolink::IOAddress& ip_address);
 
    void parseDnrInstanceConfigData(const std::string& config_txt);
 
protected:
    Option::Universe universe_;
 
    boost::shared_ptr<isc::dns::Name> adn_;
 
    uint16_t dnr_instance_data_length_;
 
    uint16_t service_priority_;
 
    uint16_t adn_length_;
 
    uint16_t addr_length_;
 
    AddressContainer ip_addresses_;
 
    uint16_t svc_params_length_;
 
    bool adn_only_mode_;
 
    OptionBuffer svc_params_buf_;
 
    std::map<uint16_t, OpaqueDataTuple> svc_params_map_;
 
    uint16_t dnrInstanceLen() const;
 
    bool alpn_http_;
 
private:
    uint8_t dnr_instance_data_length_size_;
 
    uint8_t adn_length_size_;
 
    uint8_t addr_length_size_;
 
    uint8_t minimal_length_;
 
    std::string log_prefix_;
 
    void initMembers();
 
    std::string svcParamValAsText(const std::pair<uint16_t, OpaqueDataTuple>& svc_param) const;
 
    void parseIpAddresses(const std::string& txt_addresses);
 
    void parseSvcParams(const std::string& txt_svc_params);
 
    void parseAlpnSvcParam(const std::string& svc_param_val);
 
    void parsePortSvcParam(const std::string& svc_param_val);
 
    void parseDohpathSvcParam(const std::string& svc_param_val);
};
 
class Option4Dnr : public Option {
public:
    typedef std::vector<DnrInstance> DnrInstanceContainer;
 
    Option4Dnr(OptionBufferConstIter begin,
               OptionBufferConstIter end,
               bool convenient_notation = false);
 
    void addDnrInstance(DnrInstance& dnr_instance);
 
    const DnrInstanceContainer& getDnrInstances() const {
        return (dnr_instances_);
    }
 
    OptionPtr clone() const override;
 
    void pack(util::OutputBuffer& buf, bool check = true) const override;
 
    void unpack(OptionBufferConstIter begin, OptionBufferConstIter end) override;
 
    std::string toText(int indent = 0) const override;
 
    uint16_t len() const override;
 
protected:
    DnrInstanceContainer dnr_instances_;
 
private:
    bool convenient_notation_;
 
    void parseConfigData(const std::string& config_txt);
};
 
typedef boost::shared_ptr<Option4Dnr> Option4DnrPtr;
 
}  // namespace dhcp
}  // namespace isc
 
#endif  // OPTION4_DNR_H