client_dictionary.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_DICTIONARY_H
#define RADIUS_CLIENT_DICTIONARY_H
 
#include <exceptions/exceptions.h>
#include <client.h>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <istream>
#include <list>
#include <unordered_map>
#include <string>
 
namespace isc {
namespace radius {

enum AttrValueType {
    PW_TYPE_STRING,
    PW_TYPE_INTEGER,
    PW_TYPE_IPADDR,
    PW_TYPE_IPV6ADDR,
    PW_TYPE_IPV6PREFIX
};

std::string attrValueTypeToText(const AttrValueType value);

AttrValueType textToAttrValueType(const std::string& name);

class AttrDef {
public:

    AttrDef(const uint8_t type, const std::string& name,
                 const AttrValueType value_type)
        : type_(type), name_(name), value_type_(value_type) {
    }

    const uint8_t type_;

    const std::string name_;

    const AttrValueType value_type_;
};

typedef boost::shared_ptr<AttrDef> AttrDefPtr;

typedef std::list<AttrDef> AttrDefList;

class IntCstDef {
public:

    IntCstDef(const uint8_t type, const std::string& name,
              const uint32_t value)
        : type_(type), name_(name), value_(value) {
    }

    const uint8_t type_;

    const std::string name_;

    const uint32_t value_;
};

typedef boost::shared_ptr<IntCstDef> IntCstDefPtr;

class AttrDefs : public boost::noncopyable {
public:

    typedef boost::multi_index_container<
        // This container stores pointers to attribute definitions.
        AttrDefPtr,
        // Start specification of indexes here.
        boost::multi_index::indexed_by<
            // Hash index for by type.
            boost::multi_index::hashed_unique<
                boost::multi_index::member<
                    AttrDef, const uint8_t, &AttrDef::type_
                >
            >,
            // Hash index for by name.
            boost::multi_index::hashed_unique<
                boost::multi_index::member<
                    AttrDef, const std::string, &AttrDef::name_
                >
            >
        >
    > AttrDefContainer;

    typedef std::unordered_map<std::string, std::string> AttrDefAliases;

    typedef boost::multi_index_container<
        // This container stores pointers to integer constant definitions.
        IntCstDefPtr,
        // Start specification of indexes here.
        boost::multi_index::indexed_by<
            // Hash index for by type and name.
            boost::multi_index::hashed_unique<
                boost::multi_index::composite_key<
                    IntCstDef,
                    boost::multi_index::member<
                        IntCstDef, const uint8_t, &IntCstDef::type_
                    >,
                    boost::multi_index::member<
                        IntCstDef, const std::string, &IntCstDef::name_
                    >
                >
            >,
            // Hash index for by type and value.
            boost::multi_index::hashed_unique<
                boost::multi_index::composite_key<
                    IntCstDef,
                    boost::multi_index::member<
                        IntCstDef, const uint8_t, &IntCstDef::type_
                    >,
                    boost::multi_index::member<
                        IntCstDef, const uint32_t, &IntCstDef::value_
                    >
                >
            >
        >
    > IntCstDefContainer;

    static AttrDefs& instance();

    AttrDefPtr getByType(const uint8_t type) const;

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

    void add(AttrDefPtr def);

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

    std::string getName(const uint8_t type) const;

    IntCstDefPtr getByName(const uint8_t type, const std::string& name) const;

    IntCstDefPtr getByValue(const uint8_t type, const uint32_t value) const;

    void add(IntCstDefPtr def);

    void readDictionary(const std::string& path);

    void readDictionary(std::istream& is);

    void checkStandardDefs(const AttrDefList& defs) const;
 
protected:
    AttrDefs() : container_(), aliases_(), ic_container_() {
    }

    virtual ~AttrDefs() {
        clear();
    }

    void parseLine(const std::string& line);

    AttrDefContainer container_;

    AttrDefAliases aliases_;

    IntCstDefContainer ic_container_;
};
 
} // end of namespace isc::radius
} // end of namespace isc
 
#endif