binding_variables.h

Go to the documentation of this file.

// Copyright (C) 2025 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 <boost/scoped_ptr.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.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 {
        QUERY,
        RESPONSE
    };
    enum Source {…};
 
    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 getName() const  {…}
 
    std::string getExpressionStr() const {
        return (expression_str_);
    }
    std::string getExpressionStr() const  {…}
 
    dhcp::ExpressionPtr getExpression() const {
        return (expression_);
    }
    dhcp::ExpressionPtr getExpression() const  {…}
 
    Source getSource() const {
        return (source_);
    }
    Source getSource() const  {…}
 
    uint32_t getFamily() const {
        return (family_);
    }
    uint32_t getFamily() const  {…}
 
    virtual data::ElementPtr toElement() const;
 
private:
 
    std::string name_;
 
    std::string expression_str_;
 
    Source source_;
 
    uint32_t family_;
 
    dhcp::ExpressionPtr expression_;
};
class BindingVariable : public isc::data::CfgToElement {…};
 
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_;
 
};
class BindingVariableCache : public data::BaseStampedElement {…};
 
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_);
    }
    BindingVariableCachePtr getCache() {…}
 
private:
    uint32_t family_;
 
    BindingVariableCachePtr cache_;
};
class BindingVariableMgr {…};
 
typedef boost::shared_ptr<BindingVariableMgr> BindingVariableMgrPtr;
 
 
} // end of namespace lease_cmds
} // end of namespace isc
#endif