flex_option.h

Go to the documentation of this file.

// Copyright (C) 2019-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 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_);
        }

        void setSource(bool source_is_query) {
            source_is_query_ = source_is_query;
        }

        bool getSource() const {
            return (source_is_query_);
        }

        void setDestination(bool dest_is_response) {
            dest_is_response_ = dest_is_response;
        }

        bool getDestination() const {
            return (dest_is_response_);
        }
 
    private:
        uint16_t code_;

        isc::dhcp::OptionDefinitionPtr def_;

        Action action_;

        std::string text_;

        isc::dhcp::ExpressionPtr expr_;

        isc::dhcp::ClientClass class_;

        bool source_is_query_;

        bool dest_is_response_;
    };

    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) {
        // Handle the case where the source is the response and
        // there is a TokenMember in an expression.
        if (query && response && need_copy_classes_to_response_) {
            response->copyClasses(*query);
        }
        for (auto const& pair : getOptionConfigMap()) {
            for (const OptionConfigPtr& opt_cfg : pair.second) {
                if (!opt_cfg->getDestination() && response) {
                    // Called by send but in a receive entry.
                    continue;
                }
                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;
                    }
                }
                PktType source = (opt_cfg->getSource() ? query : response);
                PktType dest = (opt_cfg->getDestination() ? response : query);
                if (!source || !dest) {
                    continue;
                }
                std::string value;
                isc::dhcp::OptionBuffer buffer;
                uint16_t code = opt_cfg->getCode();
                isc::dhcp::OptionPtr opt = dest->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(),
                                                      *source);
                    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.
                    dest->addOption(opt);
                    logAction(ADD, code, value);
                    break;
                case SUPERSEDE:
                    // Do nothing is the expression evaluates to empty.
                    value = isc::dhcp::evaluateString(*opt_cfg->getExpr(),
                                                      *source);
                    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 (dest->getOption(code)) {
                        dest->delOption(code);
                    }
                    // Add the option.
                    dest->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(), *source)) {
                        break;
                    }
                    // Remove the option.
                    while (dest->getOption(code)) {
                        dest->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;
                if (!sub_cfg->getDestination() && response) {
                    // Called by send but in a receive entry.
                    continue;
                }
                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;
                    }
                }
                PktType source = (sub_cfg->getSource() ? query : response);
                PktType dest = (sub_cfg->getDestination() ? response : query);
                if (!source || !dest) {
                    continue;
                }
                std::string value;
                isc::dhcp::OptionBuffer buffer;
                isc::dhcp::OptionPtr opt = dest->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(),
                                                      *source);
                    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));
                        }
                        dest->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(),
                                                      *source);
                    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));
                        }
                        dest->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(), *source)) {
                        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()) {
                        dest->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_;

    bool need_copy_classes_to_response_;

    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