option_data_types.h

Go to the documentation of this file.

// Copyright (C) 2012-2024 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 OPTION_DATA_TYPES_H
#define OPTION_DATA_TYPES_H
 
#include <asiolink/io_address.h>
#include <dhcp/opaque_data_tuple.h>
#include <dhcp/option.h>
#include <exceptions/exceptions.h>
#include <util/io.h>
 
#include <stdint.h>
#include <utility>
 
namespace isc {
namespace dhcp {
 
class InvalidDataType : public Exception {
public:
    InvalidDataType(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class BadDataTypeCast : public Exception {
public:
    BadDataTypeCast(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
enum OptionDataType {
    OPT_EMPTY_TYPE,
    OPT_BINARY_TYPE,
    OPT_BOOLEAN_TYPE,
    OPT_INT8_TYPE,
    OPT_INT16_TYPE,
    OPT_INT32_TYPE,
    OPT_UINT8_TYPE,
    OPT_UINT16_TYPE,
    OPT_UINT32_TYPE,
    OPT_ANY_ADDRESS_TYPE,
    OPT_IPV4_ADDRESS_TYPE,
    OPT_IPV6_ADDRESS_TYPE,
    OPT_IPV6_PREFIX_TYPE,
    OPT_PSID_TYPE,
    OPT_STRING_TYPE,
    OPT_TUPLE_TYPE,
    OPT_FQDN_TYPE,
    // Type to be used only internally. Allows convenient notation of the option config.
    OPT_INTERNAL_TYPE,
    OPT_RECORD_TYPE,
    OPT_UNKNOWN_TYPE
};
 
struct OptionDefParams {
    const char*             name;           // option name
    uint16_t                code;           // option code
    const char*             space;          // option space
    OptionDataType          type;           // data type
    bool                    array;          // is array
    const OptionDataType*   records;        // record fields
    size_t                  records_size;   // number of fields in a record
    const char*             encapsulates;   // option space encapsulated by the
                                            // particular option.
};
 
struct OptionDefParamsEncapsulation {
    const struct OptionDefParams*   optionDefParams;    // parameters structure
    const int                       size;               // structure size
    const char*                     space;              // option space
};
 
template<typename T>
struct OptionDataTypeTraits {
    static const bool valid = false;
    static const int len = 0;
    static const bool integer_type = false;
    static const OptionDataType type = OPT_UNKNOWN_TYPE;
};
 
template<>
struct OptionDataTypeTraits<OptionBuffer> {
    static const bool valid = true;
    static const int len = 0;
    static const bool integer_type = false;
    static const OptionDataType type = OPT_BINARY_TYPE;
};
 
template<>
struct OptionDataTypeTraits<bool> {
    static const bool valid = true;
    static const int len = sizeof(uint8_t);
    static const bool integer_type = false;
    static const OptionDataType type = OPT_BOOLEAN_TYPE;
};
 
template<>
struct OptionDataTypeTraits<int8_t> {
    static const bool valid = true;
    static const int len = 1;
    static const bool integer_type = true;
    static const OptionDataType type = OPT_INT8_TYPE;
};
 
template<>
struct OptionDataTypeTraits<int16_t> {
    static const bool valid = true;
    static const int len = 2;
    static const bool integer_type = true;
    static const OptionDataType type = OPT_INT16_TYPE;
};
 
template<>
struct OptionDataTypeTraits<int32_t> {
    static const bool valid = true;
    static const int len = 4;
    static const bool integer_type = true;
    static const OptionDataType type = OPT_INT32_TYPE;
};
 
template<>
struct OptionDataTypeTraits<uint8_t> {
    static const bool valid = true;
    static const int len = 1;
    static const bool integer_type = true;
    static const OptionDataType type = OPT_UINT8_TYPE;
};
 
template<>
struct OptionDataTypeTraits<uint16_t> {
    static const bool valid = true;
    static const int len = 2;
    static const bool integer_type = true;
    static const OptionDataType type = OPT_UINT16_TYPE;
};
 
template<>
struct OptionDataTypeTraits<uint32_t> {
    static const bool valid = true;
    static const int len = 4;
    static const bool integer_type = true;
    static const OptionDataType type = OPT_UINT32_TYPE;
};
 
template<>
struct OptionDataTypeTraits<asiolink::IOAddress> {
    static const bool valid = true;
    // The len value is used to determine the size of the data
    // to be written to an option buffer. IOAddress object may
    // either represent an IPv4 or IPv6 addresses which have
    // different lengths. Thus we can't put fixed value here.
    // The length of a data to be written into an option buffer
    // have to be determined in the runtime for a particular
    // IOAddress object. Thus setting len to zero.
    static const int len = 0;
    static const bool integer_type = false;
    static const OptionDataType type = OPT_ANY_ADDRESS_TYPE;
};
 
template<>
struct OptionDataTypeTraits<std::string> {
    static const bool valid = true;
    // The len value is used to determine the size of the data
    // to be written to an option buffer. For strings this
    // size is unknown until we actually deal with the particular
    // string to be written. Thus setting it to zero.
    static const int len = 0;
    static const bool integer_type = false;
    static const OptionDataType type = OPT_STRING_TYPE;
};
 
class PSIDLen {
public:
 
    PSIDLen() : psid_len_(0) { }
 
    explicit PSIDLen(const uint8_t psid_len)
        : psid_len_(psid_len) {
        if (psid_len_ > sizeof(uint16_t) * 8) {
            isc_throw(isc::OutOfRange, "invalid value "
                      << asUnsigned() << " of PSID length");
        }
    }
 
    uint8_t asUint8() const {
        return (psid_len_);
    }
 
    unsigned int asUnsigned() const {
        return (static_cast<unsigned>(psid_len_));
    }
 
private:
 
    uint8_t psid_len_;
};
 
class PSID {
public:
 
    PSID() : psid_(0) { }
 
    explicit PSID(const uint16_t psid)
        : psid_(psid) {
    }
 
    uint16_t asUint16() const {
        return (psid_);
    }
 
private:
 
    uint16_t psid_;
 
};
 
typedef std::pair<PSIDLen, PSID> PSIDTuple;
 
class PrefixLen {
public:
 
    PrefixLen() : prefix_len_(0) { }
 
    explicit PrefixLen(const uint8_t prefix_len)
        : prefix_len_(prefix_len) {
    }
 
    uint8_t asUint8() const {
        return (prefix_len_);
    }
 
    unsigned int asUnsigned() const {
        return (static_cast<unsigned>(prefix_len_));
    }
 
private:
 
    uint8_t prefix_len_;
};
 
typedef std::pair<PrefixLen, asiolink::IOAddress> PrefixTuple;
 
class OptionDataTypeUtil {
public:
 
    static OptionDataType getDataType(const std::string& data_type);
 
    static const std::string& getDataTypeName(const OptionDataType data_type);
 
    static int getDataTypeLen(const OptionDataType data_type);
 
    static asiolink::IOAddress readAddress(const std::vector<uint8_t>& buf,
                                           const short family);
 
    static void writeAddress(const asiolink::IOAddress& address,
                             std::vector<uint8_t>& buf);
 
    static void writeBinary(const std::string& hex_str,
                            std::vector<uint8_t>& buf);
 
    static std::string readTuple(const std::vector<uint8_t>& buf,
                                 OpaqueDataTuple::LengthFieldType lengthfieldtype);
 
    static void readTuple(const std::vector<uint8_t>& buf,
                          OpaqueDataTuple& tuple);
 
    static void writeTuple(const std::string& value,
                           OpaqueDataTuple::LengthFieldType lengthfieldtype,
                           std::vector<uint8_t>& buf);
 
    static void writeTuple(const OpaqueDataTuple& tuple,
                           std::vector<uint8_t>& buf);
 
    static OpaqueDataTuple::LengthFieldType getTupleLenFieldType(Option::Universe u);
 
    static bool readBool(const std::vector<uint8_t>& buf);
 
    static void writeBool(const bool value, std::vector<uint8_t>& buf);
 
    template<typename T>
    static T readInt(const std::vector<uint8_t>& buf) {
        if (!OptionDataTypeTraits<T>::integer_type) {
            isc_throw(isc::dhcp::InvalidDataType, "specified data type to be returned"
                      " by readInteger is unsupported integer type");
        }
 
        if (buf.size() < OptionDataTypeTraits<T>::len) {
            isc_throw(isc::dhcp::BadDataTypeCast,
                      "failed to read an integer value from a buffer"
                      << " - buffer is truncated.");
        }
 
        T value;
        switch (OptionDataTypeTraits<T>::len) {
        case 1:
            value = *(buf.begin());
            break;
        case 2:
            // Calling readUint16 works either for unsigned
            // or signed types.
            value = isc::util::readUint16(&(*buf.begin()), buf.size());
            break;
        case 4:
            // Calling readUint32 works either for unsigned
            // or signed types.
            value = isc::util::readUint32(&(*buf.begin()), buf.size());
            break;
        default:
            // This should not happen because we made checks on data types
            // but it does not hurt to keep throw statement here.
            isc_throw(isc::dhcp::InvalidDataType,
                      "invalid size of the data type to be read as integer.");
        }
        return (value);
    }
 
    template<typename T>
    static void writeInt(const T value,
                         std::vector<uint8_t>& buf) {
        if (!OptionDataTypeTraits<T>::integer_type) {
            isc_throw(InvalidDataType, "provided data type is not the supported.");
        }
        switch (OptionDataTypeTraits<T>::len) {
        case 1:
            buf.push_back(static_cast<uint8_t>(value));
            break;
        case 2:
            buf.resize(buf.size() + 2);
            isc::util::writeUint16(static_cast<uint16_t>(value), &buf[buf.size() - 2], 2);
            break;
        case 4:
            buf.resize(buf.size() + 4);
            isc::util::writeUint32(static_cast<uint32_t>(value), &buf[buf.size() - 4], 4);
            break;
        default:
            // The cases above cover whole range of possible data lengths because
            // we check at the beginning of this function that given data type is
            // a supported integer type which can be only 1,2 or 4 bytes long.
            ;
        }
    }
 
    static std::string readFqdn(const std::vector<uint8_t>& buf);
 
    static void writeFqdn(const std::string& fqdn,
                          std::vector<uint8_t>& buf,
                          const bool downcase = false);
 
    static unsigned int getLabelCount(const std::string& text_name);
 
    static PrefixTuple readPrefix(const std::vector<uint8_t>& buf);
 
    static void writePrefix(const PrefixLen& prefix_len,
                            const asiolink::IOAddress& prefix,
                            std::vector<uint8_t>& buf);
 
    static PSIDTuple readPsid(const std::vector<uint8_t>& buf);
 
    static void writePsid(const PSIDLen& psid_len, const PSID& psid,
                          std::vector<uint8_t>& buf);
 
    static std::string readString(const std::vector<uint8_t>& buf);
 
    static void writeString(const std::string& value,
                            std::vector<uint8_t>& buf);
private:
 
    std::map<std::string, OptionDataType> data_types_;
 
    std::map<OptionDataType, std::string> data_type_names_;
 
    OptionDataTypeUtil();
 
    static OptionDataTypeUtil& instance();
 
    OptionDataType getDataTypeImpl(const std::string& data_type) const;
 
    const std::string& getDataTypeNameImpl(const OptionDataType data_type) const;
};
 
 
} // isc::dhcp namespace
} // isc namespace
 
#endif // OPTION_DATA_TYPES_H