flex_option.h

Go to the documentation of this file.

// Copyright (C) 2019-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 FLEX_OPTION_H
#define FLEX_OPTION_H
 
#include <cc/data.h>
#include <cc/simple_parser.h>
#include <dhcp/classify.h>
#include <dhcp/libdhcp++.h>
#include <dhcp/option.h>
#include <dhcp/option_definition.h>
#include <dhcp/option_vendor.h>
#include <dhcp/std_option_defs.h>
#include <eval/evaluate.h>
#include <eval/token.h>
#include <util/str.h>
 
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
 
#include <map>
#include <string>
 
namespace isc {
namespace flex_option {
 
class FlexOptionImpl {
public:
 
    enum Action {
        NONE,
        ADD,
        SUPERSEDE,
        REMOVE
    };
 
    class OptionConfig {
    public:
        OptionConfig(uint16_t code, isc::dhcp::OptionDefinitionPtr def);
 
        virtual ~OptionConfig();
 
        uint16_t getCode() const {
            return (code_);
        }
 
        isc::dhcp::OptionDefinitionPtr getOptionDef() const {
            return (def_);
        }
 
        void setAction(Action action) {
            action_ = action;
        }
 
        Action getAction() const {
            return (action_);
        }
 
        void setText(const std::string& text) {
            text_ = text;
        };
 
        const std::string& getText() const {
            return (text_);
        }
 
        void setExpr(const isc::dhcp::ExpressionPtr& expr) {
            expr_ = expr;
        }
 
        const isc::dhcp::ExpressionPtr& getExpr() const {
            return (expr_);
        }
 
        void setClass(const isc::dhcp::ClientClass& class_name) {
            class_ = class_name;
        }
 
        const isc::dhcp::ClientClass& getClass() const {
            return (class_);
        }
 
    private:
        uint16_t code_;
 
        isc::dhcp::OptionDefinitionPtr def_;
 
        Action action_;
 
        std::string text_;
 
        isc::dhcp::ExpressionPtr expr_;
 
        isc::dhcp::ClientClass class_;
    };
 
    typedef boost::shared_ptr<OptionConfig> OptionConfigPtr;
 
    typedef std::list<OptionConfigPtr> OptionConfigList;
 
    typedef std::map<uint16_t, OptionConfigList> OptionConfigMap;
 
    class SubOptionConfig : public OptionConfig {
    public:
        SubOptionConfig(uint16_t code, isc::dhcp::OptionDefinitionPtr def,
                        OptionConfigPtr container);
 
        virtual ~SubOptionConfig();
 
        void setVendorId(uint32_t vendor_id) {
            vendor_id_ = vendor_id;
        }
 
        uint32_t getVendorId() const {
            return (vendor_id_);
        }
 
        uint16_t getContainerCode() const {
            return (container_->getCode());
        }
 
        isc::dhcp::OptionDefinitionPtr getContainerDef() const {
            return (container_->getOptionDef());
        }
 
        const isc::dhcp::ClientClass& getContainerClass() const {
            return (container_->getClass());
        }
 
        void setContainerAction(Action action) {
            container_action_ = action;
        }
 
        Action getContainerAction() const {
            return (container_action_);
        }
 
    private:
        OptionConfigPtr container_;
 
        uint32_t vendor_id_;
 
        Action container_action_;
    };
 
    typedef boost::shared_ptr<SubOptionConfig> SubOptionConfigPtr;
 
    typedef std::map<uint16_t, SubOptionConfigPtr> SubOptionConfigMap;
 
    typedef std::map<uint16_t, SubOptionConfigMap> SubOptionConfigMapMap;
 
    FlexOptionImpl();
 
    ~FlexOptionImpl();
 
    const OptionConfigMap& getOptionConfigMap() const {
        return (option_config_map_);
    }
 
    const SubOptionConfigMapMap& getSubOptionConfigMap() const {
        return (sub_option_config_map_);
    }
 
    void configure(isc::data::ConstElementPtr options);
 
    template <typename PktType>
    void process(isc::dhcp::Option::Universe universe,
                 PktType query, PktType response) {
        for (auto const& pair : getOptionConfigMap()) {
            for (const OptionConfigPtr& opt_cfg : pair.second) {
                const isc::dhcp::ClientClass& client_class =
                    opt_cfg->getClass();
                if (!client_class.empty()) {
                    if (!query->inClass(client_class)) {
                        logClass(client_class, opt_cfg->getCode());
                        continue;
                    }
                }
                std::string value;
                isc::dhcp::OptionBuffer buffer;
                uint16_t code = opt_cfg->getCode();
                isc::dhcp::OptionPtr opt = response->getOption(code);
                isc::dhcp::OptionDefinitionPtr def = opt_cfg->getOptionDef();
                switch (opt_cfg->getAction()) {
                case NONE:
                    break;
                case ADD:
                    // Don't add if option is already there.
                    if (opt) {
                        break;
                    }
                    // Do nothing is the expression evaluates to empty.
                    value = isc::dhcp::evaluateString(*opt_cfg->getExpr(),
                                                      *query);
                    if (value.empty()) {
                        break;
                    }
                    // Set the value.
                    if (def) {
                        std::vector<std::string> split_vec =
                            isc::util::str::tokens(value, ",", true);
                        opt = def->optionFactory(universe, code, split_vec);
                    } else {
                        buffer.assign(value.begin(), value.end());
                        opt.reset(new isc::dhcp::Option(universe, code,
                                                        buffer));
                    }
                    // Add the option.
                    response->addOption(opt);
                    logAction(ADD, code, value);
                    break;
                case SUPERSEDE:
                    // Do nothing is the expression evaluates to empty.
                    value = isc::dhcp::evaluateString(*opt_cfg->getExpr(),
                                                      *query);
                    if (value.empty()) {
                        break;
                    }
                    // Set the value.
                    if (def) {
                        std::vector<std::string> split_vec =
                            isc::util::str::tokens(value, ",", true);
                        opt = def->optionFactory(universe, code,
                                                 split_vec);
                    } else {
                        buffer.assign(value.begin(), value.end());
                        opt.reset(new isc::dhcp::Option(universe,
                                                        code,
                                                        buffer));
                    }
                    // Remove the option if already there.
                    while (response->getOption(code)) {
                        response->delOption(code);
                    }
                    // Add the option.
                    response->addOption(opt);
                    logAction(SUPERSEDE, code, value);
                    break;
                case REMOVE:
                    // Nothing to remove if option is not present.
                    if (!opt) {
                        break;
                    }
                    // Do nothing is the expression evaluates to false.
                    if (!isc::dhcp::evaluateBool(*opt_cfg->getExpr(), *query)) {
                        break;
                    }
                    // Remove the option.
                    while (response->getOption(code)) {
                        response->delOption(code);
                    }
                    logAction(REMOVE, code, "");
                    break;
                }
            }
        }
        for (auto const& pair : getSubOptionConfigMap()) {
            for (auto const& sub_pair : pair.second) {
                const SubOptionConfigPtr& sub_cfg = sub_pair.second;
                uint16_t sub_code = sub_cfg->getCode();
                uint16_t opt_code = sub_cfg->getContainerCode();
                const isc::dhcp::ClientClass& opt_class =
                    sub_cfg->getContainerClass();
                if (!opt_class.empty()) {
                    if (!query->inClass(opt_class)) {
                        logClass(opt_class, opt_code);
                        continue;
                    }
                }
                const isc::dhcp::ClientClass& sub_class =
                    sub_cfg->getClass();
                if (!sub_class.empty()) {
                    if (!query->inClass(sub_class)) {
                        logSubClass(sub_class, sub_code, opt_code);
                        continue;
                    }
                }
                std::string value;
                isc::dhcp::OptionBuffer buffer;
                isc::dhcp::OptionPtr opt = response->getOption(opt_code);
                isc::dhcp::OptionPtr sub;
                isc::dhcp::OptionDefinitionPtr def = sub_cfg->getOptionDef();
                uint32_t vendor_id = sub_cfg->getVendorId();
                switch (sub_cfg->getAction()) {
                case NONE:
                    break;
                case ADD:
                    // If no container and no magic add return
                    if (!opt && (sub_cfg->getContainerAction() != ADD)) {
                        break;
                    }
                    // Do nothing is the expression evaluates to empty.
                    value = isc::dhcp::evaluateString(*sub_cfg->getExpr(),
                                                      *query);
                    if (value.empty()) {
                        break;
                    }
                    // Check vendor id mismatch.
                    if (opt && vendor_id && !checkVendor(opt, vendor_id)) {
                        break;
                    }
                    // Don't add if sub-option is already there.
                    if (opt && opt->getOption(sub_code)) {
                        break;
                    }
                    // Set the value.
                    if (def) {
                        std::vector<std::string> split_vec =
                            isc::util::str::tokens(value, ",", true);
                        sub = def->optionFactory(universe, sub_code,
                                                 split_vec);
                    } else {
                        buffer.assign(value.begin(), value.end());
                        sub.reset(new isc::dhcp::Option(universe, sub_code,
                                                        buffer));
                    }
                    // If the container does not exist add it.
                    if (!opt) {
                        if (!vendor_id) {
                            opt.reset(new isc::dhcp::Option(universe,
                                                            opt_code));
                        } else {
                            opt.reset(new isc::dhcp::OptionVendor(universe,
                                                                  vendor_id));
                        }
                        response->addOption(opt);
                        if (vendor_id) {
                            logAction(ADD, opt_code, vendor_id);
                        } else {
                            logAction(ADD, opt_code, "");
                        }
                    }
                    // Add the sub-option.
                    opt->addOption(sub);
                    logSubAction(ADD, sub_code, opt_code, value);
                    break;
                case SUPERSEDE:
                    // If no container and no magic add return
                    if (!opt && (sub_cfg->getContainerAction() != ADD)) {
                        break;
                    }
                    // Do nothing is the expression evaluates to empty.
                    value = isc::dhcp::evaluateString(*sub_cfg->getExpr(),
                                                      *query);
                    if (value.empty()) {
                        break;
                    }
                    // Check vendor id mismatch.
                    if (opt && vendor_id && !checkVendor(opt, vendor_id)) {
                        break;
                    }
                    // Set the value.
                    if (def) {
                        std::vector<std::string> split_vec =
                            isc::util::str::tokens(value, ",", true);
                        sub = def->optionFactory(universe, sub_code,
                                                 split_vec);
                    } else {
                        buffer.assign(value.begin(), value.end());
                        sub.reset(new isc::dhcp::Option(universe, sub_code,
                                                        buffer));
                    }
                    // Remove the sub-option if already there.
                    if (opt) {
                        while (opt->getOption(sub_code)) {
                            opt->delOption(sub_code);
                        }
                    }
                    // If the container does not exist add it.
                    if (!opt) {
                        if (!vendor_id) {
                            opt.reset(new isc::dhcp::Option(universe,
                                                            opt_code));
                        } else {
                            opt.reset(new isc::dhcp::OptionVendor(universe,
                                                                  vendor_id));
                        }
                        response->addOption(opt);
                        if (vendor_id) {
                            logAction(ADD, opt_code, vendor_id);
                        } else {
                            logAction(ADD, opt_code, "");
                        }
                    }
                    // Add the sub-option.
                    opt->addOption(sub);
                    logSubAction(SUPERSEDE, sub_code, opt_code, value);
                    break;
                case REMOVE:
                    // Nothing to remove if container is not present.
                    if (!opt) {
                        break;
                    }
                    sub = opt->getOption(sub_code);
                    // Nothing to remove if sub-option is not present.
                    if (!sub) {
                        break;
                    }
                    // Do nothing is the expression evaluates to false.
                    if (!isc::dhcp::evaluateBool(*sub_cfg->getExpr(), *query)) {
                        break;
                    }
                    // Check vendor id mismatch.
                    if (opt && vendor_id && !checkVendor(opt, vendor_id)) {
                        break;
                    }
                    // Remove the sub-option.
                    while (opt->getOption(sub_code)) {
                        opt->delOption(sub_code);
                    }
                    logSubAction(REMOVE, sub_code, opt_code, "");
                    // Remove the empty container when wanted.
                    if ((sub_cfg->getContainerAction() == REMOVE) &&
                        opt->getOptions().empty()) {
                        response->delOption(opt_code);
                        logAction(REMOVE, opt_code, "");
                    }
                    break;
                }
            }
        }
    }
 
 
    static void logClass(const isc::dhcp::ClientClass &client_class,
                         uint16_t code);
 
    static void logAction(Action action, uint16_t code,
                          const std::string& value);
 
    static void logAction(Action action, uint16_t code, uint32_t vendor_id);
 
    static void logSubClass(const isc::dhcp::ClientClass &client_class,
                            uint16_t code, uint16_t container_code);
 
    static void logSubAction(Action action, uint16_t code,
                             uint16_t container_code,
                             const std::string& value);
 
    static bool checkVendor(isc::dhcp::OptionPtr opt, uint32_t vendor_id);
 
protected:
    OptionConfigMap& getMutableOptionConfigMap() {
        return (option_config_map_);
    }
 
    SubOptionConfigMapMap& getMutableSubOptionConfigMap() {
        return (sub_option_config_map_);
    }
 
private:
    static const data::SimpleKeywords OPTION_PARAMETERS;
 
    static const data::SimpleKeywords SUB_OPTION_PARAMETERS;
 
    OptionConfigMap option_config_map_;
 
    SubOptionConfigMapMap sub_option_config_map_;
 
    void parseOptionConfig(isc::data::ConstElementPtr option);
 
    void parseSubOption(isc::data::ConstElementPtr sub_option,
                        OptionConfigPtr opt_cfg,
                        isc::dhcp::Option::Universe universe);
 
    void parseSubOptions(isc::data::ConstElementPtr sub_options,
                         OptionConfigPtr opt_cfg,
                         isc::dhcp::Option::Universe universe);
};
 
typedef boost::shared_ptr<FlexOptionImpl> FlexOptionImplPtr;
 
} // end of namespace flex_option
} // end of namespace isc
#endif