cfg_attribute.h

Go to the documentation of this file.

// Copyright (C) 2020-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 CFG_ATTRIBUTE_H
#define CFG_ATTRIBUTE_H
 
#include <cc/cfg_to_element.h>
#include <cc/data.h>
#include <dhcp/pkt.h>
#include <eval/token.h>
#include <exceptions/exceptions.h>
#include <radius/client_attribute.h>
#include <util/buffer.h>
 
#include <map>
#include <vector>
 
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/shared_ptr.hpp>
 
namespace isc {
namespace radius {

class CfgAttributes : public data::CfgToElement {
public:

    CfgAttributes() : container_() {
    }
 
    // @brief Destructor.
    virtual ~CfgAttributes() {
        clear();
    }

    bool empty() const {
        return (container_.empty());
    }

    size_t size() const {
        return (container_.size());
    }

    void add(const AttrDefPtr& def,
             const ConstAttributePtr& attr,
             const dhcp::ExpressionPtr& expr,
             const std::string& test);

    void add(const AttrDefPtr& def, const ConstAttributePtr& attr) {
        add(def, attr, dhcp::ExpressionPtr(), "");
    }

    bool del(const uint8_t type, const uint32_t vendor = 0);

    void clear() {
        container_.clear();
    }

    size_t count(const uint8_t type, const uint32_t vendor = 0) const {
        return (container_.count(boost::make_tuple(vendor, type)));
    }

    AttrDefPtr getDef(const uint8_t type, const uint32_t vendor = 0) const;

    ConstAttributePtr get(const uint8_t type, const uint32_t vendor = 0) const;

    dhcp::ExpressionPtr getExpr(const uint8_t type,
                                const uint32_t vendor = 0) const;

    std::string getTest(const uint8_t type, const uint32_t vendor = 0) const;

    Attributes getAll() const;

    Attributes getEvalAll(dhcp::Pkt& pkt);

    data::ElementPtr toElement() const override;
 
protected:
    class AttributeValue {
    public:
        AttributeValue(const AttrDefPtr& def,
                       const ConstAttributePtr& attr,
                       const dhcp::ExpressionPtr& expr,
                       const std::string& test)
            : def_(def), attr_(attr), expr_(expr), test_(test) {
            if (!def) {
                isc_throw(BadValue, "no attribute definition");
            }
            if (expr || !test.empty()) {
                if (attr) {
                    isc_throw(BadValue, "once of attribute or test");
                }
                if (!expr || test.empty()) {
                    isc_throw(BadValue, "missing expression or test");
                }
            } else if (!attr) {
                isc_throw(BadValue, "no attribute and test");
            }
        }

        AttrDefPtr def_;

        ConstAttributePtr attr_;

        dhcp::ExpressionPtr expr_;

        std::string test_;

        uint8_t getType() const {
            if (!def_) {
                isc_throw(BadValue, "no attribute definition");
            }
            return (def_->type_);
        }

        uint32_t getVendor() const {
            if (!def_) {
                isc_throw(BadValue, "no attribute definition");
            }
            return (def_->vendor_);
        }
    };

    boost::multi_index_container<
        // This container stores AttributeValue objects.
        AttributeValue,
        // Start specification of indexes here.
        boost::multi_index::indexed_by<
            // Hash index for by vendor and type.
            boost::multi_index::hashed_non_unique<
                boost::multi_index::composite_key<
                    AttributeValue,
                    boost::multi_index::const_mem_fun<
                        AttributeValue, uint32_t, &AttributeValue::getVendor
                    >,
                    boost::multi_index::const_mem_fun<
                        AttributeValue, uint8_t, &AttributeValue::getType
                    >
                >
            >
        >
    > container_;
};
 
} // end of namespace isc::radius
} // end of namespace isc
 
#endif