client_attribute.h

Go to the documentation of this file.

// Copyright (C) 2023-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 RADIUS_CLIENT_ATTRIBUTE_H
#define RADIUS_CLIENT_ATTRIBUTE_H
 
#include <exceptions/exceptions.h>
#include <cc/cfg_to_element.h>
#include <cc/data.h>
#include <cc/simple_parser.h>
#include <asiolink/io_address.h>
#include <client_dictionary.h>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <string>
#include <vector>
 
namespace isc {
namespace radius {

static constexpr size_t MAX_STRING_LEN = 253;

static constexpr size_t MAX_VSA_DATA_LEN = MAX_STRING_LEN - 4;

using isc::data::TypeError;

class Attribute;
typedef boost::shared_ptr<Attribute> AttributePtr;
typedef boost::shared_ptr<const Attribute> ConstAttributePtr;

class Attribute : public data::CfgToElement {
protected:

    explicit Attribute(const uint8_t type) : type_(type) {
    }
 
public:
    virtual ~Attribute() = default;

    uint8_t getType() const {
        return (type_);
    }

    virtual AttrValueType getValueType() const = 0;


    static AttributePtr fromBytes(const std::vector<uint8_t>& bytes);


    static AttributePtr fromText(const AttrDefPtr& def,
                                 const std::string& value);

    static AttributePtr fromBytes(const AttrDefPtr& def,
                                  const std::vector<uint8_t>& value);


    static AttributePtr fromString(const uint8_t type,
                                   const std::string& value);

    static AttributePtr fromBinary(const uint8_t type,
                                   const std::vector<uint8_t>& value);

    static AttributePtr fromInt(const uint8_t type, const uint32_t value);

    static AttributePtr fromIpAddr(const uint8_t type,
                                   const asiolink::IOAddress& value);

    static AttributePtr fromIpv6Addr(const uint8_t type,
                                     const asiolink::IOAddress& value);

    static AttributePtr fromIpv6Prefix(const uint8_t type,
                                       const uint8_t len,
                                       const asiolink::IOAddress& value);

    static AttributePtr fromVsa(const uint8_t type,
                                const uint32_t vendor,
                                const std::string& value);

    static AttributePtr fromVsa(const uint8_t type,
                                const uint32_t vendor,
                                const std::vector<uint8_t>& value);


    virtual size_t getValueLen() const = 0;

    virtual std::string toText(size_t indent = 0) const = 0;

    virtual std::vector<uint8_t> toBytes() const = 0;


    virtual std::string toString() const;

    virtual std::vector<uint8_t> toBinary() const;

    virtual uint32_t toInt() const;

    virtual asiolink::IOAddress toIpAddr() const;

    virtual asiolink::IOAddress toIpv6Addr() const;

    virtual asiolink::IOAddress toIpv6Prefix() const;

    virtual uint8_t toIpv6PrefixLen() const;

    virtual uint32_t toVendorId() const;

    virtual std::vector<uint8_t> toVsaData() const;

    const uint8_t type_;

 
private:

    static AttributePtr fromText0(const AttrDefPtr& def,
                                  const std::string& value);

    static AttributePtr fromBytes0(const AttrDefPtr& def,
                                   const std::vector<uint8_t>& value);
};


class AttrString : public Attribute {
protected:

    AttrString(const uint8_t type, const std::string& value)
        : Attribute(type), value_(value) {
        if (value.empty()) {
            isc_throw(BadValue, "value is empty");
        }
        if (value.size() > MAX_STRING_LEN) {
            isc_throw(BadValue, "value is too large " << value.size()
                      << " > " << MAX_STRING_LEN);
        }
    }

    AttrString(const uint8_t type, const std::vector<uint8_t>& value);

    static AttributePtr fromText(const uint8_t type, const std::string& repr);

    static AttributePtr fromBytes(const uint8_t type,
                                  const std::vector<uint8_t>& bytes);

    friend class Attribute;
 
public:
    virtual AttrValueType getValueType() const override {
        return (PW_TYPE_STRING);
    }

    virtual size_t getValueLen() const override {
        return (value_.size());
    }

    virtual std::string toText(size_t indent = 0) const override;

    virtual std::vector<uint8_t> toBytes() const override;

    virtual std::string toString() const override {
        return (value_);
    }

    virtual std::vector<uint8_t> toBinary() const override;

    virtual data::ElementPtr toElement() const override;
 
private:
    std::string value_;
};

class AttrInt : public Attribute {
protected:

    AttrInt(const uint8_t type, const int32_t value)
        : Attribute(type), value_(static_cast<uint32_t>(value)) {
    }

    AttrInt(const uint8_t type, const uint32_t value)
        : Attribute(type), value_(value) {
    }

    static AttributePtr fromText(const uint8_t type, const std::string& repr);

    static AttributePtr fromBytes(const uint8_t type,
                                  const std::vector<uint8_t>& bytes);

    friend class Attribute;
 
public:

    virtual AttrValueType getValueType() const override {
        return (PW_TYPE_INTEGER);
    }

    virtual size_t getValueLen() const override {
        return (4);
    }

    virtual std::string toText(size_t indent = 0) const override;

    virtual std::vector<uint8_t> toBytes() const override;

    virtual uint32_t toInt() const override {
        return (value_);
    }

    virtual data::ElementPtr toElement() const override;
 
private:
    const uint32_t value_;
};

class AttrIpAddr : public Attribute {
protected:

    AttrIpAddr(const uint8_t type, const asiolink::IOAddress& value)
        : Attribute(type), value_(value) {
        if (!value.isV4()) {
            isc_throw(BadValue, "not v4 address " << value);
        }
    }

    static AttributePtr fromText(const uint8_t type, const std::string& repr);

    static AttributePtr fromBytes(const uint8_t type,
                                  const std::vector<uint8_t>& bytes);

    friend class Attribute;
 
public:
    virtual AttrValueType getValueType() const override {
        return (PW_TYPE_IPADDR);
    }

    virtual size_t getValueLen() const override {
        return (4);
    }

    virtual std::string toText(size_t indent = 0) const override;

    virtual std::vector<uint8_t> toBytes() const override;

    virtual asiolink::IOAddress toIpAddr() const override {
        return (value_);
    }

    virtual data::ElementPtr toElement() const override;
 
private:
    asiolink::IOAddress value_;
};

class AttrIpv6Addr : public Attribute {
protected:

    AttrIpv6Addr(const uint8_t type, const asiolink::IOAddress& value)
        : Attribute(type), value_(value) {
        if (!value.isV6()) {
            isc_throw(BadValue, "not v6 address " << value);
        }
    }

    static AttributePtr fromText(const uint8_t type, const std::string& repr);

    static AttributePtr fromBytes(const uint8_t type,
                                  const std::vector<uint8_t>& bytes);

    friend class Attribute;
 
public:

    virtual AttrValueType getValueType() const override {
        return (PW_TYPE_IPV6ADDR);
    }

    virtual size_t getValueLen() const override {
        return (16);
    }

    virtual std::string toText(size_t indent = 0) const override;

    virtual std::vector<uint8_t> toBytes() const override;

    virtual asiolink::IOAddress toIpv6Addr() const override {
        return (value_);
    }

    virtual data::ElementPtr toElement() const override;
 
private:
    asiolink::IOAddress value_;
};

class AttrIpv6Prefix : public Attribute {
protected:

    AttrIpv6Prefix(const uint8_t type, const uint8_t len,
                   const asiolink::IOAddress& value)
        : Attribute(type), len_(len), value_(value) {
        if (!value.isV6()) {
            isc_throw(BadValue, "not v6 address " << value);
        }
        if (len > 128) {
            isc_throw(BadValue, "too long prefix "
                      << static_cast<unsigned>(len));
        }
    }

    static AttributePtr fromText(const uint8_t type, const std::string& repr);

    static AttributePtr fromBytes(const uint8_t type,
                                  const std::vector<uint8_t>& bytes);

    friend class Attribute;
 
public:

    virtual AttrValueType getValueType() const override {
        return (PW_TYPE_IPV6PREFIX);
    }

    virtual size_t getValueLen() const override {
        return (17);
    }

    virtual std::string toText(size_t indent = 0) const override;

    virtual std::vector<uint8_t> toBytes() const override;

    virtual asiolink::IOAddress toIpv6Prefix() const override {
        return (value_);
    }

    virtual uint8_t toIpv6PrefixLen() const override {
        return (len_);
    }

    virtual data::ElementPtr toElement() const override;
 
private:
    const uint8_t len_;

    asiolink::IOAddress value_;
};

class AttrVsa : public Attribute {
protected:

    AttrVsa(const uint8_t type, const uint32_t vendor,
            const std::string& value)
        : Attribute(type), vendor_(vendor), value_(value) {
        if (value.empty()) {
            isc_throw(BadValue, "value is empty");
        }
        if (value.size() > MAX_VSA_DATA_LEN) {
            isc_throw(BadValue, "value is too large " << value.size()
                      << " > " << MAX_VSA_DATA_LEN);
        }
    }

    AttrVsa(const uint8_t type, const uint32_t vendor,
            const std::vector<uint8_t>& value);

    static AttributePtr fromText(const uint8_t type, const std::string& repr);

    static AttributePtr fromBytes(const uint8_t type,
                                  const std::vector<uint8_t>& bytes);

    friend class Attribute;
 
public:

    virtual AttrValueType getValueType() const override {
        return (PW_TYPE_VSA);
    }

    virtual size_t getValueLen() const override {
        return (4 + value_.size());
    }

    virtual std::string toText(size_t indent = 0) const override;

    virtual std::vector<uint8_t> toBytes() const override;

    virtual uint32_t toVendorId() const override {
        return (vendor_);
    }

    virtual std::vector<uint8_t> toVsaData() const override;

    virtual data::ElementPtr toElement() const override;
 
private:
    uint32_t vendor_;

    std::string value_;
};

class Attributes : public data::CfgToElement {
public:

    typedef boost::multi_index_container<
        // This container stores pointers to attributes.
        ConstAttributePtr,
        // Start specification of indexes here.
        boost::multi_index::indexed_by<
            // Sequenced index to keep insert order.
            boost::multi_index::sequenced<>,
            // Hash index for direct retrieval.
            boost::multi_index::hashed_non_unique<
                boost::multi_index::member<
                    Attribute, const uint8_t, &Attribute::type_
                >
            >
        >
    > AttributeContainer;

    Attributes() : container_() {
    }

    virtual ~Attributes() {
        clear();
    }

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

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

    void add(const ConstAttributePtr& attr);

    bool del(const uint8_t type);

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

    void append(const Attributes& other);

    size_t count(const uint8_t type) const;

    ConstAttributePtr get(const uint8_t type) const;

    std::string toText(size_t indent = 0) const;

    data::ElementPtr toElement() const override;

    static Attributes fromElement(const data::ConstElementPtr& attr_list);

    AttributeContainer::iterator begin() {
        return (container_.begin());
    }

    AttributeContainer::const_iterator begin() const {
        return (container_.begin());
    }

    AttributeContainer::const_iterator cbegin() const {
        return (container_.cbegin());
    }

    AttributeContainer::iterator end() {
        return (container_.end());
    }

    AttributeContainer::const_iterator end() const {
        return (container_.end());
    }

    AttributeContainer::const_iterator cend() const {
        return (container_.cend());
    }
 
protected:
    AttributeContainer container_;
};

typedef boost::shared_ptr<Attributes> AttributesPtr;
 
} // end of namespace isc::radius
} // end of namespace isc
 
#endif