flex_option.h

Go to the documentation of this file.

// Copyright (C) 2019-2021 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 <dhcp/libdhcp++.h>
#include <dhcp/option.h>
#include <dhcp/option_definition.h>
#include <dhcp/std_option_defs.h>
#include <eval/evaluate.h>
#include <eval/token.h>
#include <util/strutil.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_);
        }

    private:
        uint16_t code_;

        isc::dhcp::OptionDefinitionPtr def_;

        Action action_;

        std::string text_;

        isc::dhcp::ExpressionPtr expr_;
    };

    typedef boost::shared_ptr<OptionConfig> OptionConfigPtr;

    typedef std::map<uint16_t, OptionConfigPtr> OptionConfigMap;

    FlexOptionImpl();

    ~FlexOptionImpl();

    const OptionConfigMap& getOptionConfigMap() const {
        return (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 pair : getOptionConfigMap()) {
            const OptionConfigPtr& opt_cfg = pair.second;
            std::string value;
            isc::dhcp::OptionBuffer buffer;
            isc::dhcp::OptionPtr opt = response->getOption(opt_cfg->getCode());
            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;
                }
                value = isc::dhcp::evaluateString(*opt_cfg->getExpr(), *query);
                // Do nothing is the expression evaluates to empty.
                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, opt_cfg->getCode(),
                                             split_vec);
                } else {
                    buffer.assign(value.begin(), value.end());
                    opt.reset(new isc::dhcp::Option(universe,
                                                    opt_cfg->getCode(),
                                                    buffer));
                }
                // Add the option.
                response->addOption(opt);
                logAction(ADD, opt_cfg->getCode(), value);
                break;
            case SUPERSEDE:
                // Do nothing is the expression evaluates to empty.
                value = isc::dhcp::evaluateString(*opt_cfg->getExpr(), *query);
                if (value.empty()) {
                    break;
                }
                // Remove the option if already there.
                while (opt) {
                    response->delOption(opt_cfg->getCode());
                    opt = response->getOption(opt_cfg->getCode());
                }
                // Set the value.
                if (def) {
                    std::vector<std::string> split_vec =
                            isc::util::str::tokens(value, ",", true);
                    opt = def->optionFactory(universe, opt_cfg->getCode(),
                                             split_vec);
                } else {
                    buffer.assign(value.begin(), value.end());
                    opt.reset(new isc::dhcp::Option(universe,
                                                    opt_cfg->getCode(),
                                                    buffer));
                }
                // Add the option.
                response->addOption(opt);
                logAction(SUPERSEDE, opt_cfg->getCode(), 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 (opt) {
                    response->delOption(opt_cfg->getCode());
                    opt = response->getOption(opt_cfg->getCode());
                }
                logAction(REMOVE, opt_cfg->getCode(), "");
                break;
            }
        }
    }

    void logAction(Action action, uint16_t code, const std::string& value) const;

protected:
    OptionConfigMap& getMutableOptionConfigMap() {
        return (option_config_map_);
    }

private:
    OptionConfigMap option_config_map_;

    void parseOptionConfig(isc::data::ConstElementPtr option);

};

typedef boost::shared_ptr<FlexOptionImpl> FlexOptionImplPtr;

} // end of namespace flex_option
} // end of namespace isc
#endif