dhcp_parsers.h

Go to the documentation of this file.

// Copyright (C) 2013-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 DHCP_PARSERS_H
#define DHCP_PARSERS_H
 
#include <asiolink/io_address.h>
#include <cc/data.h>
#include <dhcp/option_definition.h>
#include <dhcp/option_space_container.h>
#include <dhcpsrv/d2_client_cfg.h>
#include <dhcpsrv/cfg_iface.h>
#include <dhcpsrv/cfg_option.h>
#include <dhcpsrv/network.h>
#include <dhcpsrv/subnet.h>
#include <dhcpsrv/cfg_option_def.h>
#include <dhcpsrv/cfg_mac_source.h>
#include <dhcpsrv/srv_config.h>
#include <dhcpsrv/parsers/base_network_parser.h>
#include <dhcpsrv/parsers/option_data_parser.h>
#include <cc/simple_parser.h>
#include <exceptions/exceptions.h>
#include <util/optional.h>
 
#include <boost/shared_ptr.hpp>
 
#include <stdint.h>
#include <string>
#include <vector>
 
namespace isc {
namespace dhcp {
 
typedef OptionSpaceContainer<OptionContainer, OptionDescriptor,
                             std::string> OptionStorage;
typedef boost::shared_ptr<OptionStorage> OptionStoragePtr;
 
template<typename ValueType>
class ValueStorage {
public:
    void setParam(const std::string& name, const ValueType& value,
                  const data::Element::Position& position) {
        values_[name] = value;
        positions_[name] = position;
    }
 
    ValueType getParam(const std::string& name) const {
        typename std::map<std::string, ValueType>::const_iterator param
            = values_.find(name);
 
        if (param == values_.end()) {
            isc_throw(DhcpConfigError, "Missing parameter '"
                      << name << "'");
        }
 
        return (param->second);
    }
 
    const data::Element::Position&
    getPosition(const std::string& name, const data::ConstElementPtr parent =
                data::ConstElementPtr()) const {
        typename std::map<std::string, data::Element::Position>::const_iterator
            pos = positions_.find(name);
        if (pos == positions_.end()) {
            return (parent ? parent->getPosition() :
                    data::Element::ZERO_POSITION());
        }
 
        return (pos->second);
    }
 
    ValueType getOptionalParam(const std::string& name,
                               const ValueType& default_value) const {
        typename std::map<std::string, ValueType>::const_iterator param
            = values_.find(name);
 
        if (param == values_.end()) {
            return (default_value);
        }
 
        return (param->second);
    }
 
    void delParam(const std::string& name) {
        values_.erase(name);
        positions_.erase(name);
    }
 
    void clear() {
        values_.clear();
        positions_.clear();
    }
 
private:
    std::map<std::string, ValueType> values_;
 
    std::map<std::string, data::Element::Position> positions_;
 
};
 
typedef std::pair<std::string, isc::data::ConstElementPtr> ConfigPair;
 
typedef ValueStorage<uint32_t> Uint32Storage;
typedef boost::shared_ptr<Uint32Storage> Uint32StoragePtr;
 
typedef ValueStorage<std::string> StringStorage;
typedef boost::shared_ptr<StringStorage> StringStoragePtr;
 
typedef ValueStorage<bool> BooleanStorage;
typedef boost::shared_ptr<BooleanStorage> BooleanStoragePtr;
 
class MACSourcesListConfigParser : public isc::data::SimpleParser {
public:
    void parse(CfgMACSource& mac_sources, isc::data::ConstElementPtr value);
};
 
class ControlSocketsParser : public isc::data::SimpleParser {
public:
    void parse(SrvConfig& srv_cfg, isc::data::ConstElementPtr value);
};
 
class OptionDefParser : public isc::data::SimpleParser {
public:
    OptionDefParser(const uint16_t address_family);
 
    OptionDefinitionPtr parse(isc::data::ConstElementPtr option_def);
 
private:
    uint16_t address_family_;
};
 
class OptionDefListParser : public isc::data::SimpleParser {
public:
    OptionDefListParser(const uint16_t address_family);
 
    void parse(CfgOptionDefPtr cfg, isc::data::ConstElementPtr def_list);
 
private:
    uint16_t address_family_;
};
 
typedef std::vector<PoolPtr> PoolStorage;
typedef boost::shared_ptr<PoolStorage> PoolStoragePtr;
 
class PoolParser : public isc::data::SimpleParser {
public:
 
    virtual ~PoolParser() {
    }
 
    virtual void parse(PoolStoragePtr pools,
                       isc::data::ConstElementPtr pool_structure,
                       const uint16_t address_family,
                       bool encapsulate_options = true);
 
protected:
    virtual PoolPtr poolMaker(isc::asiolink::IOAddress &addr, uint32_t len,
                              int32_t ptype = 0) = 0;
 
    virtual PoolPtr poolMaker(isc::asiolink::IOAddress &min,
                              isc::asiolink::IOAddress &max,
                              int32_t ptype = 0) = 0;
 
    virtual boost::shared_ptr<OptionDataListParser>
    createOptionDataListParser(const uint16_t address_family) const;
};
 
class Pool4Parser : public PoolParser {
protected:
    PoolPtr poolMaker (asiolink::IOAddress &addr, uint32_t len,
                       int32_t ignored);
 
    PoolPtr poolMaker (asiolink::IOAddress &min, asiolink::IOAddress &max,
                       int32_t ignored);
};
 
class PoolsListParser : public isc::data::SimpleParser {
public:
 
    virtual ~PoolsListParser() {
    }
 
    virtual void parse(PoolStoragePtr pools,
                       isc::data::ConstElementPtr pools_list,
                       bool encapsulate_options) = 0;
 
protected:
 
    virtual boost::shared_ptr<PoolParser> createPoolConfigParser() const = 0;
};
 
class Pools4ListParser : public PoolsListParser {
public:
 
    void parse(PoolStoragePtr pools, data::ConstElementPtr pools_list,
               bool encapsulate_options = true);
 
protected:
 
    virtual boost::shared_ptr<PoolParser> createPoolConfigParser() const;
};
 
class RelayInfoParser : public isc::data::SimpleParser {
public:
 
    explicit RelayInfoParser(const isc::dhcp::Option::Universe& family);
 
    void parse(const isc::dhcp::Network::RelayInfoPtr& relay_info,
               isc::data::ConstElementPtr relay_elem);
 
    void addAddress(const std::string& name, const std::string& address_str,
                    isc::data::ConstElementPtr relay_elem,
                    const isc::dhcp::Network::RelayInfoPtr& relay_info);
private:
 
    Option::Universe family_;
};
 
class SubnetConfigParser : public BaseNetworkParser {
public:
 
    explicit SubnetConfigParser(uint16_t family, bool check_iface = true);
 
    virtual ~SubnetConfigParser() { }
 
protected:
    SubnetPtr parse(isc::data::ConstElementPtr subnet,
                    bool encapsulate_options);
 
    virtual void initSubnet(isc::data::ConstElementPtr params,
                            isc::asiolink::IOAddress addr, uint8_t len) = 0;
 
protected:
 
    void createSubnet(isc::data::ConstElementPtr data);
 
    virtual boost::shared_ptr<OptionDataListParser> createOptionDataListParser() const;
 
    virtual boost::shared_ptr<PoolsListParser>
    createPoolsListParser() const = 0;
 
    PoolStoragePtr pools_;
 
    isc::dhcp::SubnetPtr subnet_;
 
    uint16_t address_family_;
 
    isc::dhcp::Network::RelayInfoPtr relay_info_;
 
    bool check_iface_;
};
 
class Subnet4ConfigParser : public SubnetConfigParser {
public:
    Subnet4ConfigParser(bool check_iface = true);
 
    Subnet4Ptr parse(data::ConstElementPtr subnet,
                     bool encapsulate_options = true);
 
protected:
 
    void initSubnet(data::ConstElementPtr params,
                    asiolink::IOAddress addr, uint8_t len);
 
    void validateResv(const Subnet4Ptr& subnet, ConstHostPtr host);
 
    virtual boost::shared_ptr<PoolsListParser>
    createPoolsListParser() const;
};
 
class Subnets4ListConfigParser : public isc::data::SimpleParser {
public:
 
    Subnets4ListConfigParser(bool check_iface = true);
 
    virtual ~Subnets4ListConfigParser() {
    }
 
    size_t parse(SrvConfigPtr cfg, data::ConstElementPtr subnets_list,
                 bool encapsulate_options = true);
 
    size_t parse(Subnet4Collection& subnets,
                 data::ConstElementPtr subnets_list,
                 bool encapsulate_options = true);
 
protected:
 
    virtual boost::shared_ptr<Subnet4ConfigParser> createSubnetConfigParser() const;
 
    bool check_iface_;
};
 
class Pool6Parser : public PoolParser {
protected:
    PoolPtr poolMaker (asiolink::IOAddress &addr, uint32_t len, int32_t ptype);
 
    PoolPtr poolMaker (asiolink::IOAddress &min, asiolink::IOAddress &max,
                       int32_t ptype);
};
 
class Pools6ListParser : public PoolsListParser {
public:
 
    void parse(PoolStoragePtr pools, data::ConstElementPtr pools_list,
               bool encapsulate_options = true);
 
protected:
 
    virtual boost::shared_ptr<PoolParser> createPoolConfigParser() const;
};
 
class PdPoolParser : public isc::data::SimpleParser {
public:
 
    PdPoolParser();
 
    virtual ~PdPoolParser() {
    }
 
    void parse(PoolStoragePtr pools, data::ConstElementPtr pd_pool_,
               bool encapsulate_options = true);
 
protected:
 
    virtual boost::shared_ptr<OptionDataListParser>
    createOptionDataListParser() const;
 
    isc::dhcp::Pool6Ptr pool_;
 
    isc::data::ConstElementPtr user_context_;
 
    isc::data::ConstElementPtr client_class_;
};
 
class PdPoolsListParser : public isc::data::SimpleParser {
public:
 
    virtual ~PdPoolsListParser() {
    }
 
    void parse(PoolStoragePtr pools, data::ConstElementPtr pd_pool_list);
 
protected:
 
    virtual boost::shared_ptr<PdPoolParser>
    createPdPoolConfigParser() const;
};
 
class Subnet6ConfigParser : public SubnetConfigParser {
public:
 
    Subnet6ConfigParser(bool check_iface = true);
 
    Subnet6Ptr parse(data::ConstElementPtr subnet,
                     bool encapsulate_options = true);
 
protected:
    virtual void duplicateOptionWarning(uint32_t code,
                                        asiolink::IOAddress& addr);
 
    void initSubnet(isc::data::ConstElementPtr params,
                    isc::asiolink::IOAddress addr, uint8_t len);
 
    void validateResvs(const Subnet6Ptr& subnet, ConstHostPtr host);
 
    virtual boost::shared_ptr<PoolsListParser>
    createPoolsListParser() const;
 
    virtual boost::shared_ptr<PdPoolsListParser>
    createPdPoolsListParser() const;
};
 
 
class Subnets6ListConfigParser : public isc::data::SimpleParser {
public:
 
    Subnets6ListConfigParser(bool check_iface = true);
 
    virtual ~Subnets6ListConfigParser() {
    }
 
    size_t parse(SrvConfigPtr cfg, data::ConstElementPtr subnets_list,
                 bool encapsulate_options = true);
 
    size_t parse(Subnet6Collection& subnets,
                 data::ConstElementPtr subnets_list,
                 bool encapsulate_options = true);
 
protected:
 
    virtual boost::shared_ptr<Subnet6ConfigParser> createSubnetConfigParser() const;
 
    bool check_iface_;
};
 
class D2ClientConfigParser : public isc::data::SimpleParser {
public:
 
    D2ClientConfigPtr parse(isc::data::ConstElementPtr d2_client_cfg);
 
    static const isc::data::SimpleDefaults D2_CLIENT_CONFIG_DEFAULTS;
 
    //  to ElementPtr)
    static size_t setAllDefaults(isc::data::ConstElementPtr d2_config);
 
private:
 
    dhcp_ddns::NameChangeProtocol
    getProtocol(isc::data::ConstElementPtr scope, const std::string& name);
 
    dhcp_ddns::NameChangeFormat
    getFormat(isc::data::ConstElementPtr scope, const std::string& name);
 
    D2ClientConfig::ReplaceClientNameMode
    getMode(isc::data::ConstElementPtr scope, const std::string& name);
};
 
class CompatibilityParser : public isc::data::SimpleParser {
public:
    void parse(isc::data::ConstElementPtr cfg, isc::dhcp::SrvConfig& srv_cfg);
};
 
} // end of isc::dhcp namespace
} // end of isc namespace
 
#endif // DHCP_PARSERS_H