Cppcheck report - cppcheck report: premium/src/hooks/dhcp/cb_cmds/cb_cmds_dhcp4.cc

// Copyright (C) 2018-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Kea Hooks Basic
// Commercial End User License Agreement v2.0. See COPYING file in the premium/
// directory.

#include <config.h>
#include <cb_cmds_dhcp4.h><--- Include file:  not found. Please note: Cppcheck does not need standard library headers to get proper results.
#include <cb_parsers.h><--- Include file:  not found. Please note: Cppcheck does not need standard library headers to get proper results.
#include <dhcpsrv/config_backend_dhcp4_mgr.h>
#include <dhcpsrv/parsers/simple_parser4.h>
#include <hooks/hooks.h>

using namespace isc::config;
using namespace isc::data;
using namespace isc::dhcp;
using namespace isc::db;
using namespace isc::hooks;

namespace isc {
namespace cb {

const SimpleKeywords GLOBAL4_MAP_PARAMETERS = {
    { "compatibility.ignore-dhcp-server-identifier", Element::boolean },
    { "compatibility.ignore-rai-link-selection", Element::boolean },
    { "compatibility.lenient-option-parsing", Element::boolean },
    { "compatibility.exclude-first-last-24", Element::boolean },
    { "dhcp-ddns.enable-updates", Element::boolean },
    { "dhcp-ddns.max-queue-size", Element::integer },
    { "dhcp-ddns.ncr-format", Element::string },
    { "dhcp-ddns.ncr-protocol", Element::string },
    { "dhcp-ddns.sender-ip", Element::string },
    { "dhcp-ddns.sender-port", Element::integer },
    { "dhcp-ddns.server-ip", Element::string },
    { "dhcp-ddns.server-port", Element::integer },
    { "expired-leases-processing.flush-reclaimed-timer-wait-time", Element::integer },
    { "expired-leases-processing.hold-reclaimed-time", Element::integer },
    { "expired-leases-processing.max-reclaim-leases", Element::integer },
    { "expired-leases-processing.max-reclaim-time", Element::integer },
    { "expired-leases-processing.reclaim-timer-wait-time", Element::integer },
    { "expired-leases-processing.unwarned-reclaim-cycles", Element::integer },
    { "multi-threading.enable-multi-threading", Element::boolean },
    { "multi-threading.thread-pool-size", Element::integer },
    { "multi-threading.packet-queue-size", Element::integer },
    { "sanity-checks.lease-checks", Element::string },
    { "sanity-checks.extended-info-checks", Element::string },
    { "dhcp-queue-control.enable-queue", Element::boolean },
    { "dhcp-queue-control.queue-type", Element::string },
    { "dhcp-queue-control.capacity", Element::integer },
    /* not yet supported
    { "interfaces-config.dhcp-socket-type", Element::string },
    { "interfaces-config.outbound-interface", Element::string },
    { "interfaces-config.re-detect", Element::boolean },
    { "interfaces-config.service-sockets-require-all", Element::boolean },
    { "interfaces-config.service-sockets-max-retries", Element::integer },
    { "interfaces-config.service-sockets-retry-wait-time", Element::integer },
    { "lease-database.lfc-interval", Element::integer },
    { "lease-database.max-row-errors", Element::integer },
    { "lease-database.name", Element::string },
    { "lease-database.persist", Element::boolean },
    { "lease-database.type", Element::string },
    { "config-control.config-fetch-wait-time", Element::integer },
    */
};

void
ConfigCmdsDhcp4Impl::setGlobalParameter4(CalloutHandle& callout_handle) {
    auto create_update_fun = [] (const BackendSelector& backend_selector,
                                 const ServerSelector& server_selector,
                                 const StampedValuePtr& stamped_value) {
        ConfigBackendDHCPv4Mgr::instance().getPool()->
        createUpdateGlobalParameter4(backend_selector, server_selector,
                                     stamped_value);
    };
    SimpleKeywords globals = SimpleParser4::GLOBAL4_PARAMETERS;
    // Add supported top level map parameters.
    globals.insert(GLOBAL4_MAP_PARAMETERS.begin(), GLOBAL4_MAP_PARAMETERS.end());
    setGlobalParameter(callout_handle, globals, AF_INET, create_update_fun);
}

void
ConfigCmdsDhcp4Impl::delGlobalParameter4(CalloutHandle& callout_handle) {
    auto delete_fun = [] (const BackendSelector& backend_selector,
                          const ServerSelector& server_selector,
                          const std::string& name) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                deleteGlobalParameter4(backend_selector, server_selector, name));
    };
    SimpleKeywords globals = SimpleParser4::GLOBAL4_PARAMETERS;
    // Add supported top level map parameters.
    globals.insert(GLOBAL4_MAP_PARAMETERS.begin(), GLOBAL4_MAP_PARAMETERS.end());
    delGlobalParameter(callout_handle, globals, AF_INET, delete_fun);
}

void
ConfigCmdsDhcp4Impl::getGlobalParameter4(CalloutHandle& callout_handle) {
    auto get_fun = [] (const BackendSelector& backend_selector,
                       const ServerSelector& server_selector,
                       const std::string& name) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getGlobalParameter4(backend_selector, server_selector, name));
    };
    SimpleKeywords globals = SimpleParser4::GLOBAL4_PARAMETERS;
    // Add supported top level map parameters.
    globals.insert(GLOBAL4_MAP_PARAMETERS.begin(), GLOBAL4_MAP_PARAMETERS.end());
    getGlobalParameter(callout_handle, globals, AF_INET, get_fun);
}

void
ConfigCmdsDhcp4Impl::getAllGlobalParameters4(CalloutHandle& callout_handle) {
    auto get_all_fun = [] (const BackendSelector& backend_selector,
                           const ServerSelector& server_selector) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getAllGlobalParameters4(backend_selector, server_selector));
    };
    SimpleKeywords globals = SimpleParser4::GLOBAL4_PARAMETERS;
    // Add supported top level map parameters.
    globals.insert(GLOBAL4_MAP_PARAMETERS.begin(), GLOBAL4_MAP_PARAMETERS.end());
    getAllGlobalParameters(callout_handle, globals, AF_INET, get_all_fun);
}

void
ConfigCmdsDhcp4Impl::setSubnet4(CalloutHandle& callout_handle) {
    auto create_update_fun = [] (const BackendSelector& backend_selector,
                                 const ServerSelector& server_selector,
                                 const Subnet4Ptr& subnet) {
        ConfigBackendDHCPv4Mgr::instance().getPool()->
        createUpdateSubnet4(backend_selector, server_selector, subnet);
    };
    setSubnet<Subnet4Ptr, CBSubnet4ConfigParser>(callout_handle,
                                                 AF_INET,
                                                 create_update_fun);
}

void
ConfigCmdsDhcp4Impl::delSubnet4Id(CalloutHandle& callout_handle) {
    auto delete_fun = [] (const BackendSelector& backend_selector,
                          const ServerSelector& server_selector,
                          const SubnetID& subnet_id) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                deleteSubnet4(backend_selector, server_selector, subnet_id));
    };
    delSubnetId(callout_handle, AF_INET, delete_fun);
}

void
ConfigCmdsDhcp4Impl::delSubnet4Prefix(CalloutHandle& callout_handle) {
    auto delete_fun = [] (const BackendSelector& backend_selector,
                          const ServerSelector& server_selector,
                          const std::string& subnet_prefix) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                deleteSubnet4(backend_selector, server_selector, subnet_prefix));
    };
    delSubnetPrefix(callout_handle, AF_INET, delete_fun);
}

void
ConfigCmdsDhcp4Impl::getSubnet4Id(CalloutHandle& callout_handle) {
    auto get_fun = [] (const BackendSelector& backend_selector,
                       const ServerSelector& server_selector,
                       const SubnetID& subnet_id) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getSubnet4(backend_selector, server_selector, subnet_id));
    };
    getSubnetId<Subnet4Ptr>(callout_handle, AF_INET, get_fun);
}

void
ConfigCmdsDhcp4Impl::getSubnet4Prefix(CalloutHandle& callout_handle) {
    auto get_fun = [] (const BackendSelector& backend_selector,
                       const ServerSelector& server_selector,
                       const std::string& subnet_prefix) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getSubnet4(backend_selector, server_selector, subnet_prefix));
    };
    getSubnetPrefix<Subnet4Ptr>(callout_handle, AF_INET, get_fun);
}

void
ConfigCmdsDhcp4Impl::listSubnets4(CalloutHandle& callout_handle) {
    auto get_all_fun = [] (const BackendSelector& backend_selector,
                           const ServerSelector& server_selector) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getAllSubnets4(backend_selector, server_selector));
    };
    listSubnets<Subnet4Collection>(callout_handle, AF_INET, get_all_fun);
}

void
ConfigCmdsDhcp4Impl::setSharedNetwork4(CalloutHandle& callout_handle) {
    auto create_update_fun = [] (const BackendSelector& backend_selector,
                                 const ServerSelector& server_selector,
                                 const SharedNetwork4Ptr& shared_network) {
        ConfigBackendDHCPv4Mgr::instance().getPool()->
        createUpdateSharedNetwork4(backend_selector, server_selector, shared_network);
    };
    setSharedNetwork<SharedNetwork4Ptr, CBSharedNetwork4Parser>
        (callout_handle, AF_INET, create_update_fun);
}

void
ConfigCmdsDhcp4Impl::delSharedNetwork4(CalloutHandle& callout_handle) {
    auto delete_fun = [] (const BackendSelector& backend_selector,
                          const ServerSelector& server_selector,
                          const std::string& name) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                deleteSharedNetwork4(backend_selector, server_selector, name));
    };
    auto delete_all_fun = [] (const BackendSelector& backend_selector,
                              const ServerSelector& server_selector,
                              const std::string& name) {
        ConfigBackendDHCPv4Mgr::instance().getPool()->
        deleteSharedNetworkSubnets4(backend_selector, server_selector, name);
    };
    delSharedNetwork(callout_handle, AF_INET, delete_fun, delete_all_fun);
}

void
ConfigCmdsDhcp4Impl::getSharedNetwork4(CalloutHandle& callout_handle) {
    auto get_fun = [] (const BackendSelector& backend_selector,
                       const ServerSelector& server_selector,
                       const std::string& name) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getSharedNetwork4(backend_selector, server_selector, name));

    };
    auto get_all_fun = [] (const BackendSelector& backend_selector,
                           const ServerSelector& server_selector,
                           const std::string& name) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getSharedNetworkSubnets4(backend_selector, server_selector, name));
    };
    getSharedNetwork<SharedNetwork4Ptr, Subnet4Collection>
        (callout_handle, AF_INET, get_fun, get_all_fun);
}

void
ConfigCmdsDhcp4Impl::listSharedNetworks4(CalloutHandle& callout_handle) {
    auto get_all_fun = [] (const BackendSelector& backend_selector,
                           const ServerSelector& server_selector) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getAllSharedNetworks4(backend_selector, server_selector));
    };
    listSharedNetworks<SharedNetwork4Collection>
        (callout_handle, AF_INET, get_all_fun);
}

void
ConfigCmdsDhcp4Impl::setClientClass4(CalloutHandle& callout_handle) {
    auto create_update_fun = [] (const BackendSelector& backend_selector,
                                 const ServerSelector& server_selector,
                                 const ClientClassDefPtr& client_class,
                                 const std::string& follow_class_name) {
        ConfigBackendDHCPv4Mgr::instance().getPool()->
        createUpdateClientClass4(backend_selector, server_selector, client_class,
                                 follow_class_name);
    };
    setClientClass(callout_handle, AF_INET, create_update_fun);
}

void
ConfigCmdsDhcp4Impl::delClientClass4(CalloutHandle& callout_handle) {
    auto delete_fun = [] (const BackendSelector& backend_selector,
                          const ServerSelector& server_selector,
                          const std::string& name) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                deleteClientClass4(backend_selector, server_selector, name));
    };
    delClientClass(callout_handle, AF_INET, delete_fun);
}

void
ConfigCmdsDhcp4Impl::getClientClass4(CalloutHandle& callout_handle) {
    auto get_fun = [] (const BackendSelector& backend_selector,
                       const ServerSelector& server_selector,
                       const std::string& name) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getClientClass4(backend_selector, server_selector, name));

    };
    getClientClass(callout_handle, AF_INET, get_fun);
}

void
ConfigCmdsDhcp4Impl::getAllClientClasses4(CalloutHandle& callout_handle) {
    auto get_all_fun = [] (const BackendSelector& backend_selector,
                           const ServerSelector& server_selector) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getAllClientClasses4(backend_selector, server_selector));
    };
    getAllClientClasses(callout_handle, AF_INET, get_all_fun);
}

void
ConfigCmdsDhcp4Impl::setOptionDef4(CalloutHandle& callout_handle) {
    auto create_update_fun = [] (const BackendSelector& backend_selector,
                                 const ServerSelector& server_selector,
                                 const OptionDefinitionPtr& option_def) {
        ConfigBackendDHCPv4Mgr::instance().getPool()->
        createUpdateOptionDef4(backend_selector, server_selector, option_def);
    };
    setOptionDef(callout_handle, AF_INET, create_update_fun);
}

void
ConfigCmdsDhcp4Impl::delOptionDef4(CalloutHandle& callout_handle) {
    auto delete_fun = [] (const BackendSelector& backend_selector,
                          const ServerSelector& server_selector,
                          const uint16_t code,
                          const std::string& space) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                deleteOptionDef4(backend_selector, server_selector,
                                 code, space));
    };
    delOptionDef(callout_handle, AF_INET, delete_fun);
}

void
ConfigCmdsDhcp4Impl::getOptionDef4(CalloutHandle& callout_handle) {
    auto get_fun = [] (const BackendSelector& backend_selector,
                       const ServerSelector& server_selector,
                       const uint16_t code,
                       const std::string& space) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getOptionDef4(backend_selector, server_selector,
                              code, space));
    };
    getOptionDef(callout_handle, AF_INET, get_fun);
}

void
ConfigCmdsDhcp4Impl::getAllOptionDefs4(CalloutHandle& callout_handle) {
    auto get_all_fun = [] (const BackendSelector& backend_selector,
                           const ServerSelector& server_selector) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getAllOptionDefs4(backend_selector, server_selector));

    };
    getAllOptionDefs(callout_handle, AF_INET, get_all_fun);
}

void
ConfigCmdsDhcp4Impl::setGlobalOption4(CalloutHandle& callout_handle) {
    auto create_update_fun = [] (const BackendSelector& backend_selector,
                                 const ServerSelector& server_selector,
                                 OptionDescriptor option_descriptor) {
        const OptionDescriptorPtr& option =
            OptionDescriptorPtr(new OptionDescriptor(option_descriptor));
        ConfigBackendDHCPv4Mgr::instance().getPool()->
            createUpdateOption4(backend_selector, server_selector, option);
    };
    setGlobalOption(callout_handle, AF_INET, create_update_fun);
}

void
ConfigCmdsDhcp4Impl::delGlobalOption4(CalloutHandle& callout_handle) {
    auto delete_fun = [] (const BackendSelector& backend_selector,
                          const ServerSelector& server_selector,
                          const uint16_t code,
                          const std::string& space) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                deleteOption4(backend_selector, server_selector, code, space));
    };
    delGlobalOption(callout_handle, AF_INET, delete_fun);
}

void
ConfigCmdsDhcp4Impl::getGlobalOption4(CalloutHandle& callout_handle) {
    auto get_fun  = [] (const BackendSelector& backend_selector,
                        const ServerSelector& server_selector,
                        const uint16_t code,
                        const std::string& space) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getOption4(backend_selector, server_selector, code, space));
    };
    getGlobalOption(callout_handle, AF_INET, get_fun);
}

void
ConfigCmdsDhcp4Impl::getAllGlobalOptions4(CalloutHandle& callout_handle) {
    auto get_all_fun  = [] (const BackendSelector& backend_selector,
                            const ServerSelector& server_selector) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getAllOptions4(backend_selector, server_selector));
    };
    getAllGlobalOptions(callout_handle, AF_INET, get_all_fun);
}

void
ConfigCmdsDhcp4Impl::setServer4(CalloutHandle& callout_handle) {
    auto create_update_fun = [] (const BackendSelector& backend_selector,
                                 const ServerPtr& server) {
        ConfigBackendDHCPv4Mgr::instance().getPool()->
            createUpdateServer4(backend_selector, server);
    };
    setServer(callout_handle, AF_INET, create_update_fun);
}

void
ConfigCmdsDhcp4Impl::delServer4(CalloutHandle& callout_handle) {
    auto delete_fun = [] (const BackendSelector& backend_selector,
                          const ServerTag& server_tag) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                deleteServer4(backend_selector, server_tag));
    };
    delServer(callout_handle, AF_INET, delete_fun);
}

void
ConfigCmdsDhcp4Impl::getServer4(CalloutHandle& callout_handle) {
    auto get_fun  = [] (const BackendSelector& backend_selector,
                        const ServerTag& server_tag) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getServer4(backend_selector, server_tag));
    };
    getServer(callout_handle, AF_INET, get_fun);
}

void
ConfigCmdsDhcp4Impl::getAllServers4(CalloutHandle& callout_handle) {
    auto get_all_fun  = [] (const BackendSelector& backend_selector) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                getAllServers4(backend_selector));
    };
    getAllServers(callout_handle, AF_INET, get_all_fun);
}

void
ConfigCmdsDhcp4Impl::setSharedNetworkOption4(CalloutHandle& callout_handle) {
    auto create_update_fun = [] (const BackendSelector& backend_selector,
                                 const ServerSelector& server_selector,
                                 const std::string& shared_network_name,
                                 OptionDescriptor option_descriptor) {
        const OptionDescriptorPtr& option =
            OptionDescriptorPtr(new OptionDescriptor(option_descriptor));
        ConfigBackendDHCPv4Mgr::instance().getPool()->
            createUpdateOption4(backend_selector, server_selector,
                                shared_network_name, option);
    };
    setSharedNetworkOption(callout_handle, AF_INET, create_update_fun);
}

void
ConfigCmdsDhcp4Impl::delSharedNetworkOption4(CalloutHandle& callout_handle) {
    auto delete_fun = [] (const BackendSelector& backend_selector,
                          const ServerSelector& server_selector,
                          const std::string& shared_network_name,
                          const uint16_t code,
                          const std::string& space) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                deleteOption4(backend_selector, server_selector,
                              shared_network_name, code, space));
    };
    delSharedNetworkOption(callout_handle, AF_INET, delete_fun);
}

void
ConfigCmdsDhcp4Impl::setSubnetOption4(CalloutHandle& callout_handle) {
    auto create_update_fun = [] (const BackendSelector& backend_selector,
                                 const ServerSelector& server_selector,
                                 const SubnetID& subnet_id,
                                 OptionDescriptor option_descriptor) {
        const OptionDescriptorPtr& option =
            OptionDescriptorPtr(new OptionDescriptor(option_descriptor));
        ConfigBackendDHCPv4Mgr::instance().getPool()->
            createUpdateOption4(backend_selector, server_selector,
                                subnet_id, option);
    };
    setSubnetOption(callout_handle, AF_INET, create_update_fun);
}

void
ConfigCmdsDhcp4Impl::delSubnetOption4(CalloutHandle& callout_handle) {
    auto delete_fun = [] (const BackendSelector& backend_selector,
                          const ServerSelector& server_selector,
                          const SubnetID& subnet_id,
                          const uint16_t code,
                          const std::string& space) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                deleteOption4(backend_selector, server_selector,
                              subnet_id, code, space));
    };
    delSubnetOption(callout_handle, AF_INET, delete_fun);
}

void
ConfigCmdsDhcp4Impl::setPoolOption4(CalloutHandle& callout_handle) {
    auto create_update_fun = [] (const BackendSelector& backend_selector,
                                 const ServerSelector& server_selector,
                                 const asiolink::IOAddress& pool_start_address,
                                 const asiolink::IOAddress& pool_end_address,
                                 OptionDescriptor option_descriptor) {
        const OptionDescriptorPtr& option =
            OptionDescriptorPtr(new OptionDescriptor(option_descriptor));
        ConfigBackendDHCPv4Mgr::instance().getPool()->
            createUpdateOption4(backend_selector, server_selector,
                                pool_start_address, pool_end_address,
                                option);
    };
    setPoolOption(callout_handle, AF_INET, create_update_fun);
}

void
ConfigCmdsDhcp4Impl::delPoolOption4(CalloutHandle& callout_handle) {
    auto delete_fun = [] (const BackendSelector& backend_selector,
                          const ServerSelector& server_selector,
                          const asiolink::IOAddress& pool_start_address,
                          const asiolink::IOAddress& pool_end_address,
                          const uint16_t code,
                          const std::string& space) {
        return (ConfigBackendDHCPv4Mgr::instance().getPool()->
                deleteOption4(backend_selector, server_selector,
                              pool_start_address, pool_end_address,
                              code, space));
    };
    delPoolOption(callout_handle, AF_INET, delete_fun);
}

} // end of namespace isc::cb
} // end of namespace isc