base_network_parser.h

Go to the documentation of this file.

// Copyright (C) 2019-2025 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 BASE_NETWORK_PARSER_H
#define BASE_NETWORK_PARSER_H
 
#include <cc/data.h>
#include <cc/simple_parser.h>
#include <dhcpsrv/cfg_globals.h>
#include <dhcpsrv/network.h>
 
namespace isc {
namespace dhcp {

class BaseNetworkParser : public data::SimpleParser {
protected:

    void parseCommon(const data::ConstElementPtr& network_data,
                     NetworkPtr& network);

    void parseTeePercents(const data::ConstElementPtr& network_data,
                          NetworkPtr& network);

    void parseCacheParams(const data::ConstElementPtr& network_data,
                          NetworkPtr& network);

    void parseDdnsParams(const data::ConstElementPtr& network_data,
                         NetworkPtr& network);

    void parseAllocatorParams(const data::ConstElementPtr& network_data,
                              NetworkPtr& network);

    void parsePdAllocatorParams(const data::ConstElementPtr& network_data,
                                Network6Ptr& network);

    void parseAdaptiveLeaseTimeParam(const data::ConstElementPtr& network_data,
                                     NetworkPtr& network);

    void parseOfferLft(const data::ConstElementPtr& network_data,
                       Network4Ptr& network);
public:
    typedef std::function<void(const isc::dhcp::ClientClass&)> ClassAdderFunc;

    static void getAdditionalClassesElem(data::ConstElementPtr params,
                                         ClassAdderFunc adder_func);

    static void getClientClassesElem(data::ConstElementPtr params,
                                     ClassAdderFunc adder_func);

    template<typename DdnsOwnerTypePtr>
    void parseDdnsParameters(const data::ConstElementPtr& config,
                             DdnsOwnerTypePtr owner) {
 
        if (config->contains("ddns-send-updates")) {
            owner->setDdnsSendUpdates(getBoolean(config, "ddns-send-updates"));
        }
 
        if (config->contains("ddns-override-no-update")) {
            owner->setDdnsOverrideNoUpdate(getBoolean(config, "ddns-override-no-update"));
        }
 
        if (config->contains("ddns-override-client-update")) {
            owner->setDdnsOverrideClientUpdate(getBoolean(config, "ddns-override-client-update"));
        }
 
        if (config->contains("ddns-replace-client-name")) {
            owner->setDdnsReplaceClientNameMode(getAndConvert<D2ClientConfig::ReplaceClientNameMode,
                                                              D2ClientConfig::stringToReplaceClientNameMode>
                                                              (config, "ddns-replace-client-name",
                                                              "ReplaceClientName mode"));
        }
 
        if (config->contains("ddns-generated-prefix")) {
            owner->setDdnsGeneratedPrefix(getString(config, "ddns-generated-prefix"));
        }
 
        if (config->contains("ddns-qualifying-suffix")) {
            owner->setDdnsQualifyingSuffix(getString(config, "ddns-qualifying-suffix"));
        }
 
        std::string hostname_char_set;
        if (config->contains("hostname-char-set")) {
            hostname_char_set = getString(config, "hostname-char-set");
            owner->setHostnameCharSet(hostname_char_set);
        }
 
        std::string hostname_char_replacement;
        if (config->contains("hostname-char-replacement")) {
            hostname_char_replacement = getString(config, "hostname-char-replacement");
            owner->setHostnameCharReplacement(hostname_char_replacement);
        }
 
        // We need to validate sanitizer values here so we can detect problems and
        // cause a configuration.  We don't retain the compilation because it's not
        // something we can inherit.
        if (!hostname_char_set.empty()) {
            try {
                util::str::StringSanitizerPtr sanitizer(
                    new util::str::StringSanitizer(hostname_char_set,
                                                   hostname_char_replacement));
            } catch (const std::exception& ex) {
                isc_throw(BadValue, "hostname-char-set '" << hostname_char_set
                          << "' is not a valid regular expression");
            }
        }
 
        if (config->contains("ddns-update-on-renew")) {
            owner->setDdnsUpdateOnRenew(getBoolean(config, "ddns-update-on-renew"));
        }
 
        bool has_ddns_ttl = false;
        uint32_t ddns_ttl = 0;
        if (config->contains("ddns-ttl")) {
            ddns_ttl = getInteger(config, "ddns-ttl");
            owner->setDdnsTtl(ddns_ttl);
            has_ddns_ttl = true;
        }
 
        if (config->contains("ddns-ttl-percent")) {
            if (has_ddns_ttl) {
                isc_throw(BadValue, "cannot specify both ddns-ttl-percent and ddns-ttl");
            }
 
            owner->setDdnsTtlPercent(getDouble(config, "ddns-ttl-percent"));
        }
 
        uint32_t ddns_ttl_min = 0;
        if (config->contains("ddns-ttl-min")) {
            if (has_ddns_ttl) {
                isc_throw(BadValue, "cannot specify both ddns-ttl-min and ddns-ttl");
            }
 
            ddns_ttl_min = getInteger(config, "ddns-ttl-min");
            owner->setDdnsTtlMin(ddns_ttl_min);
        }
 
        if (config->contains("ddns-ttl-max")) {
            if (has_ddns_ttl) {
                isc_throw(BadValue, "cannot specify both ddns-ttl-max and ddns-ttl");
            }
 
            uint32_t ddns_ttl_max = getInteger(config, "ddns-ttl-max");
            if (ddns_ttl_max < ddns_ttl_min) {
                isc_throw(BadValue, "ddns-ttl-max: " << ddns_ttl_max
                          << " must be greater than ddns-ttl-min: " <<  ddns_ttl_min);
            }
 
            owner->setDdnsTtlMax(ddns_ttl_max);
        }
 
        // For backward compatibility, ddns-conflict-resolution-mode is optional.
        if (config->contains("ddns-conflict-resolution-mode")) {
            owner->setDdnsConflictResolutionMode(getString(config,
                                                           "ddns-conflict-resolution-mode"));
        }
    }
};
 
} // end of namespace isc::dhcp
} // end of namespace isc
 
#endif