cb_parsers.h

Go to the documentation of this file.

// Copyright (C) 2026 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 CB_PARSERS_H
#define CB_PARSERS_H
 
#include <cc/stamped_value.h>
#include <cc/server_tag.h>
#include <database/backend_selector.h>
#include <database/server.h>
#include <database/server_selector.h>
#include <dhcpsrv/client_class_def.h>
#include <dhcpsrv/parsers/client_class_def_parser.h>
#include <dhcpsrv/parsers/dhcp_parsers.h>
#include <dhcpsrv/parsers/option_data_parser.h>
#include <dhcpsrv/parsers/shared_network_parser.h>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>

 
namespace isc {
namespace cb {

class GlobalParameterNameParser : public data::SimpleParser {
public:
    GlobalParameterNameParser(const data::SimpleKeywords& keywords)
        : keywords_(keywords) {
    }

    std::string parse(data::ConstElementPtr global_parameter);
 
private:
    const data::SimpleKeywords& keywords_;
};

class GlobalParameterParser : public data::SimpleParser {
public:
    GlobalParameterParser(const data::SimpleKeywords& keywords,
                          const data::SimpleKeywords& list_keywords)
        : keywords_(keywords), list_keywords_(list_keywords) {
    }

    data::StampedValueCollection
    parse(const data::ConstElementPtr& global_parameter_data);
 
private:
    const data::SimpleKeywords& keywords_;

    const data::SimpleKeywords& list_keywords_;
};

class CBOptionDefParser : public data::SimpleParser {
public:
    CBOptionDefParser(const uint16_t address_family)
        : address_family_(address_family) {
    }

    dhcp::OptionDefinitionPtr parse(data::ConstElementPtr option_def);
 
private:
    uint16_t address_family_;
};

class CBOptionPairParser : public data::SimpleParser {
private:
    static data::SimpleRequiredKeywords OPTION_REQUIRED;

    static data::SimpleKeywords OPTION_KEYWORDS;
 
public:
    CBOptionPairParser(const uint16_t address_family)
        : address_family_(address_family) {
    }

    virtual ~CBOptionPairParser() {};

    std::pair<uint16_t, std::string> parse(data::ConstElementPtr option,
                                           bool skip_keywords = false);
 
private:
    uint16_t address_family_;
};

typedef std::tuple<uint16_t, std::string, bool> CBOptionDefDelete;

typedef std::tuple<uint16_t, std::string, ClientClassesPtr> CBOptionTuple;

class CBOptionTupleParser : public CBOptionPairParser {
public:
    CBOptionTupleParser(const uint16_t address_family)
        : CBOptionPairParser(address_family) {
    }

    CBOptionTuple parse(data::ConstElementPtr option);
};

class CBOptionDefDeleteParser : public CBOptionPairParser {
public:
    CBOptionDefDeleteParser(const uint16_t address_family)
        : CBOptionPairParser(address_family) {
    }

    CBOptionDefDelete parse(data::ConstElementPtr option);
};

class CBOptionDataParser : public dhcp::OptionDataParser {
public:

    CBOptionDataParser(const uint16_t address_family,
                       dhcp::CfgOptionDefPtr cfg_option_def,
                       db::BackendSelector& backend_selector,
                       db::ServerSelector& server_selector);
 
protected:

    virtual dhcp::OptionDefinitionPtr
    findOptionDefinition(const std::string& option_space,
                         const util::Optional<uint32_t>& option_code,
                         const util::Optional<std::string>& option_name) const;

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBOptionDataListParser : public dhcp::OptionDataListParser {
public:

    CBOptionDataListParser(const uint16_t address_family,
                           CfgOptionDefPtr cfg_option_def,
                           db::BackendSelector& backend_selector,
                           db::ServerSelector& server_selector);
 
protected:

    virtual boost::shared_ptr<OptionDataParser>
    createOptionDataParser() const;

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBPoolRangeParser : public data::SimpleParser {
private:
    static data::SimpleRequiredKeywords POOL_REQUIRED;

    static data::SimpleKeywords POOL_KEYWORDS;
 
public:
    CBPoolRangeParser(const uint16_t address_family)
        : address_family_(address_family) {
    }

    std::pair<asiolink::IOAddress, asiolink::IOAddress>
    parse(data::ConstElementPtr pool);
 
private:
    uint16_t address_family_;
};

template<typename PoolParser>
class CBPoolParser : public PoolParser {
public:

    CBPoolParser(db::BackendSelector& backend_selector,
                 db::ServerSelector& server_selector)
        : PoolParser(), backend_selector_(backend_selector),
          server_selector_(server_selector) {
    }
 
protected:

    virtual boost::shared_ptr<OptionDataListParser>
    createOptionDataListParser(const uint16_t address_family) const {
        auto parser = boost::make_shared<CBOptionDataListParser>(address_family,
                                                                 dhcp::CfgOptionDefPtr(),
                                                                 backend_selector_,
                                                                 server_selector_);
        return (parser);
    }

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

using CBPool4Parser = CBPoolParser<dhcp::Pool4Parser>;

using CBPool6Parser = CBPoolParser<dhcp::Pool6Parser>;

template<typename PoolsListParser, typename PoolParser>
class CBPoolsListParser : public PoolsListParser {
public:

    CBPoolsListParser(db::BackendSelector& backend_selector,
                      db::ServerSelector& server_selector)
        : backend_selector_(backend_selector), server_selector_(server_selector) {
    }
 
protected:

    virtual boost::shared_ptr<dhcp::PoolParser> createPoolConfigParser() const {
        auto parser = boost::make_shared<PoolParser>(backend_selector_, server_selector_);
        return (parser);
    }

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

using CBPools4ListParser = CBPoolsListParser<dhcp::Pools4ListParser, CBPool4Parser>;

using CBPools6ListParser = CBPoolsListParser<dhcp::Pools6ListParser, CBPool6Parser>;

class CBPdPoolParser : public PdPoolParser {
public:

    CBPdPoolParser(db::BackendSelector& backend_selector,
                   db::ServerSelector& server_selector);
 
protected:

    virtual boost::shared_ptr<OptionDataListParser>
    createOptionDataListParser() const;

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBPdPoolsListParser : public PdPoolsListParser {
public:

    CBPdPoolsListParser(db::BackendSelector& backend_selector,
                        db::ServerSelector& server_selector);
 
protected:

    virtual boost::shared_ptr<PdPoolParser>
    createPdPoolConfigParser() const;

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBPdPoolPrefixParser : public data::SimpleParser {
private:
    static data::SimpleRequiredKeywords PD_POOL_REQUIRED;

    static data::SimpleKeywords PD_POOL_KEYWORDS;
 
public:
    std::pair<asiolink::IOAddress, uint8_t>
    parse(data::ConstElementPtr pd_pool);
};

class CBSubnetIdParser : public data::SimpleParser {
private:
    static data::SimpleRequiredKeywords SUBNET_ID_REQUIRED;

    static data::SimpleKeywords SUBNET_ID_KEYWORDS;
 
public:
    dhcp::SubnetID parse(data::ConstElementPtr subnet);
};

class CBSubnetPrefixParser : public data::SimpleParser {
private:
    static data::SimpleRequiredKeywords SUBNET_PREFIX_REQUIRED;

    static data::SimpleKeywords SUBNET_PREFIX_KEYWORDS;
 
public:
    CBSubnetPrefixParser(const uint16_t address_family)
        : address_family_(address_family) {
    }

    std::string parse(data::ConstElementPtr subnet);
 
private:
    uint16_t address_family_;
};

class CBSubnet4ConfigParser : public Subnet4ConfigParser {
public:
    CBSubnet4ConfigParser(db::BackendSelector& backend_selector,
                          db::ServerSelector& server_selector);

    dhcp::Subnet4Ptr parse(data::ConstElementPtr subnet);
 
protected:

    virtual boost::shared_ptr<OptionDataListParser>
    createOptionDataListParser() const;

    virtual boost::shared_ptr<dhcp::PoolsListParser>
    createPoolsListParser() const;

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBSubnet6ConfigParser : public Subnet6ConfigParser {
public:
    CBSubnet6ConfigParser(db::BackendSelector& backend_selector,
                          db::ServerSelector& server_selector);

    dhcp::Subnet6Ptr parse(data::ConstElementPtr subnet);
 
protected:

    virtual boost::shared_ptr<OptionDataListParser>
    createOptionDataListParser() const;

    virtual boost::shared_ptr<dhcp::PoolsListParser>
    createPoolsListParser() const;

    virtual boost::shared_ptr<dhcp::PdPoolsListParser>
    createPdPoolsListParser() const;

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBSubnets4ListConfigParser : public dhcp::Subnets4ListConfigParser {
public:

    CBSubnets4ListConfigParser(db::BackendSelector& backend_selector,
                               db::ServerSelector& server_selector);
 
protected:

    virtual boost::shared_ptr<Subnet4ConfigParser>
    createSubnetConfigParser() const;

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBSubnets6ListConfigParser : public dhcp::Subnets6ListConfigParser {
public:

    CBSubnets6ListConfigParser(db::BackendSelector& backend_selector,
                               db::ServerSelector& server_selector);
 
protected:

    virtual boost::shared_ptr<Subnet6ConfigParser>
    createSubnetConfigParser() const;

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBSharedNetworkNameParser : public data::SimpleParser {
private:
    static data::SimpleRequiredKeywords SHARED_NETWORK_REQUIRED;

    static data::SimpleKeywords SHARED_NETWORK_KEYWORDS;
 
public:
    std::string parse(data::ConstElementPtr shared_network);
};

class CBSharedNetwork4Parser : public dhcp::SharedNetwork4Parser {
public:
    CBSharedNetwork4Parser(db::BackendSelector& backend_selector,
                           db::ServerSelector& server_selector);

    dhcp::SharedNetwork4Ptr parse(data::ConstElementPtr shared_network);
 
protected:

    virtual boost::shared_ptr<OptionDataListParser>
    createOptionDataListParser() const;

    virtual boost::shared_ptr<Subnets4ListConfigParser>
    createSubnetsListParser() const;

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBSharedNetwork6Parser : public dhcp::SharedNetwork6Parser {
public:
    CBSharedNetwork6Parser(db::BackendSelector& backend_selector,
                           db::ServerSelector& server_selector);

    dhcp::SharedNetwork6Ptr parse(data::ConstElementPtr shared_network);
 
protected:

    virtual boost::shared_ptr<OptionDataListParser>
    createOptionDataListParser() const;

    virtual boost::shared_ptr<Subnets6ListConfigParser>
    createSubnetsListParser() const;

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBClientClassDefParser : public dhcp::ClientClassDefParser {
public:

    CBClientClassDefParser(db::BackendSelector& backend_selector,
                           db::ServerSelector& server_selector);

    virtual boost::shared_ptr<OptionDataListParser>
    createOptionDataListParser(const uint16_t address_family,
                               CfgOptionDefPtr cfg_option_def) const;
 
protected:

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBClientClassParser : public data::SimpleParser {
public:

    CBClientClassParser(uint16_t family,
                        CfgOptionDefPtr cfg_option_def,
                        db::BackendSelector& backend_selector,
                        db::ServerSelector& server_selector);

    std::pair<dhcp::ClientClassDefPtr, std::string>
    parse(data::ConstElementPtr client_class);
 
private:

    uint16_t family_;

    CfgOptionDefPtr cfg_option_def_;

    db::BackendSelector& backend_selector_;

    db::ServerSelector& server_selector_;
};

class CBClientClassNameParser : public data::SimpleParser {
private:
    static data::SimpleRequiredKeywords CLIENT_CLASS_REQUIRED;

    static data::SimpleKeywords CLIENT_CLASS_KEYWORDS;
 
public:
    std::string parse(data::ConstElementPtr client_class);
};

class ServerTagParser : public data::SimpleParser {
private:
    static data::SimpleRequiredKeywords SERVER_TAG_REQUIRED;

    static data::SimpleKeywords SERVER_TAG_KEYWORDS;
 
public:
    data::ServerTag parse(data::ConstElementPtr server);
};

class ServerConfigParser : public data::SimpleParser {
private:
    static data::SimpleRequiredKeywords SERVER_CONFIG_REQUIRED;

    static data::SimpleKeywords SERVER_CONFIG_KEYWORDS;
 
public:
    db::ServerPtr parse(data::ConstElementPtr server);
};
 
} // end of namespace cb
} // end of namespace isc
 
#endif // CB_PARSER_H