cfg_attribute.h

Go to the documentation of this file.

// Copyright (C) 2020-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 CFG_ATTRIBUTE_H
#define CFG_ATTRIBUTE_H
 
#include <client_attribute.h>
#include <exceptions/exceptions.h>
#include <cc/data.h>
#include <cc/cfg_to_element.h>
#include <dhcp/pkt.h>
#include <eval/token.h>
#include <util/buffer.h>
#include <boost/shared_ptr.hpp>
#include <vector>
#include <map>
 
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);

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

    size_t count(const uint8_t type) const {
        return (container_.count(type));
    }

    AttrDefPtr getDef(const uint8_t type) const;

    ConstAttributePtr get(const uint8_t type) const;

    dhcp::ExpressionPtr getExpr(const uint8_t type) const;

    std::string getTest(const uint8_t type) 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_;
    };

    std::multimap<uint8_t, AttributeValue> container_;
};
 
} // end of namespace isc::radius
} // end of namespace isc
 
#endif