option4_dnr.h

Go to the documentation of this file.

// Copyright (C) 2023 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 <dhcp/dhcp4.h>
#include <dhcp/dhcp6.h>
#include <dhcp/option.h>
#include <dhcp/option_data_types.h>
#include <dns/name.h>
 
#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;
 
    static const uint8_t SERVICE_PRIORITY_SIZE = 2;
 
    static const std::unordered_set<std::string> FORBIDDEN_SVC_PARAMS;
 
    explicit DnrInstance(Option::Universe universe);
 
    DnrInstance(Option::Universe universe,
                uint16_t service_priority,
                const std::string& adn,
                const AddressContainer& ip_addresses,
                const std::string& svc_params);
 
    DnrInstance(Option::Universe universe, uint16_t service_priority, const std::string& adn);
 
    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 std::string& getSvcParams() const {
        return (svc_params_);
    }
 
    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 setAdn(const std::string& adn);
 
    void setAdnOnlyMode(bool adn_only_mode) {
        adn_only_mode_ = adn_only_mode;
    }
 
    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 checkSvcParams(bool from_wire_data = true);
 
    void checkFields();
 
    void addIpAddress(const asiolink::IOAddress& ip_address);
 
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_;
 
    std::string svc_params_;
 
    uint16_t dnrInstanceLen() const;
 
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();
};
 
class Option4Dnr : public Option {
public:
    typedef std::vector<DnrInstance> DnrInstanceContainer;
 
    Option4Dnr(OptionBufferConstIter begin, OptionBufferConstIter end);
 
    Option4Dnr() : Option(V4, DHO_V4_DNR) {}
 
    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_;
};
 
typedef boost::shared_ptr<Option4Dnr> Option4DnrPtr;
 
}  // namespace dhcp
}  // namespace isc
 
#endif  // OPTION4_DNR_H