binding_variables.h

Go to the documentation of this file.

// Copyright (C) 2025-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 BINDING_VARIABLES_H
#define BINDING_VARIABLES_H
 
#include <cc/base_stamped_element.h>
#include <cc/cfg_to_element.h>
#include <cc/data.h>
#include <cc/simple_parser.h>
#include <dhcp/pkt.h>
#include <dhcpsrv/lease.h>
#include <eval/evaluate.h>
#include <eval/token.h>
 
#include <cstdint>
 
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/scoped_ptr.hpp>
 
namespace isc {
namespace lease_cmds {
 
// Forward declaration for pointer.
class BindingVariable;

typedef boost::shared_ptr<BindingVariable> BindingVariablePtr;

class BindingVariable : public isc::data::CfgToElement {
public:
    enum Source : uint16_t {
        QUERY,
        RESPONSE
    };

    static const data::SimpleKeywords CONFIG_KEYWORDS;

    BindingVariable(const std::string& name,
                    const std::string& expression_str,
                    const Source& source,
                    uint32_t family);

    virtual ~BindingVariable() = default;

    static BindingVariablePtr parse(data::ConstElementPtr config, uint16_t family);

    std::string evaluate(dhcp::PktPtr packet) const;

    std::string getName() const {
        return (name_);
    }

    std::string getExpressionStr() const {
        return (expression_str_);
    }

    dhcp::ExpressionPtr getExpression() const {
        return (expression_);
    }

    Source getSource() const {
        return (source_);
    }

    uint32_t getFamily() const {
        return (family_);
    }

    virtual data::ElementPtr toElement() const;
 
private:

    std::string name_;

    std::string expression_str_;

    Source source_;

    uint32_t family_;

    dhcp::ExpressionPtr expression_;
};

typedef std::list<BindingVariablePtr> BindingVariableList;

typedef boost::shared_ptr<BindingVariableList> BindingVariableListPtr;

struct VariableSequenceTag { };

struct VariableNameTag { };

struct VariableSourceTag { };

typedef boost::multi_index_container<
    BindingVariablePtr,
    boost::multi_index::indexed_by<
        // First index is by sequence. -- Do we need this one?
        boost::multi_index::sequenced<
            boost::multi_index::tag<VariableSequenceTag>
        >,
        // Second index is by name.
        boost::multi_index::hashed_unique<
            boost::multi_index::tag<VariableNameTag>,
            boost::multi_index::const_mem_fun<BindingVariable,
                                              std::string,
                                              &BindingVariable::getName>
        >,
        // Third index is by source.
        boost::multi_index::ordered_non_unique<
            boost::multi_index::tag<VariableSourceTag>,
            boost::multi_index::const_mem_fun<BindingVariable,
                                              BindingVariable::Source,
                                              &BindingVariable::getSource>
        >
    >
> BindingVariableContainer;

class BindingVariableCache : public data::BaseStampedElement {
public:
    BindingVariableCache();

    virtual ~BindingVariableCache() = default;

    bool add(BindingVariablePtr variable);

    void clear();

    size_t size();

    boost::posix_time::ptime getLastFlushTime();

    BindingVariableListPtr getAll();

    BindingVariablePtr getByName(const std::string& name);

    BindingVariableListPtr getBySource(const BindingVariable::Source& source);
 
private:
    BindingVariableContainer variables_;

    const boost::scoped_ptr<std::mutex> mutex_;
 
};

typedef boost::shared_ptr<BindingVariableCache> BindingVariableCachePtr;

class BindingVariableMgr {
public:
    explicit BindingVariableMgr(uint32_t family);

    ~BindingVariableMgr() = default;

    void configure(data::ConstElementPtr config);

    bool evaluateVariables(dhcp::PktPtr query, dhcp::PktPtr response,
                           dhcp::LeasePtr lease);

    BindingVariableCachePtr getCache() {
        return(cache_);
    }
 
private:
    uint32_t family_;

    BindingVariableCachePtr cache_;
};

typedef boost::shared_ptr<BindingVariableMgr> BindingVariableMgrPtr;
 
 
} // end of namespace lease_cmds
} // end of namespace isc
#endif