duid.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 DUID_H
#define DUID_H
 
#include <asiolink/io_address.h>
#include <util/str.h>
 
#include <cstdint>
#include <iomanip>
#include <vector>
 
#include <boost/shared_ptr.hpp>
 
#include <unistd.h>
 
namespace isc {
namespace dhcp {
 
class IdentifierBaseType {
protected:
    virtual ~IdentifierBaseType() = 0;
};
 
typedef boost::shared_ptr<IdentifierBaseType> IdentifierBaseTypePtr;
 
template<size_t min_size, size_t max_size>
class IdentifierType : public IdentifierBaseType {
public:
 
    IdentifierType(const std::vector<uint8_t>& data) {
        if (data.size() < min_size) {
            isc_throw(isc::BadValue, "identifier is too short (" << data.size()
                      << "), at least "<< min_size << " is required");
        }
        if (data.size() > max_size) {
            isc_throw(isc::BadValue, "identifier is too large (" << data.size()
                      << "), at most " << max_size << " is required");
        }
        data_ = data;
    }
 
    IdentifierType(const uint8_t* data, size_t len) {
        if (len < min_size) {
            isc_throw(isc::BadValue, "identifier is too short (" << len
                      << "), at least "<< min_size << " is required");
        }
        if (len > max_size) {
            isc_throw(isc::BadValue, "identifier is too large (" << len
                      << "), at most " << max_size << " is required");
        }
        data_ = std::vector<uint8_t>(data, data + len);
    }
 
    static constexpr size_t getMinSize() {
        return (min_size);
    }
 
    static constexpr size_t getMaxSize() {
        return (max_size);
    }
 
    std::string toText() const {
        std::stringstream tmp;
        tmp << std::hex;
        bool delim = false;
        for (auto const& data : data_) {
            if (delim) {
                tmp << ":";
            }
            tmp << std::setw(2) << std::setfill('0') << static_cast<unsigned int>(data);
            delim = true;
        }
        return (tmp.str());
    }
 
    static std::vector<uint8_t> fromText(const std::string& text) {
        std::vector<uint8_t> binary;
        util::str::decodeFormattedHexString(text, binary);
        return (binary);
    }
 
    bool operator==(const IdentifierType& other) const {
        return (data_ == other.data_);
    }
 
    bool operator!=(const IdentifierType& other) const {
        return (data_ != other.data_);
    }
 
protected:
 
   std::vector<uint8_t> data_;
};
 
class DUID;
typedef boost::shared_ptr<DUID> DuidPtr;
 
class DUID : public IdentifierType<3, 130> {
public:
 
    static constexpr size_t MIN_DUID_LEN = IdentifierType::getMinSize();
 
    static constexpr size_t MAX_DUID_LEN = IdentifierType::getMaxSize();
 
    typedef enum {
        DUID_UNKNOWN = 0, 
        DUID_LLT = 1,     
        DUID_EN = 2,      
        DUID_LL = 3,      
        DUID_UUID = 4,    
        DUID_MAX          
    } DUIDType;
 
    DUID(const std::vector<uint8_t>& data);
 
    DUID(const uint8_t* data, size_t len);
 
    const std::vector<uint8_t>& getDuid() const;
 
    //
    static const DUID& EMPTY();
 
    DUIDType getType() const;
 
    static DUID fromText(const std::string& text);
};
 
class ClientId;
typedef boost::shared_ptr<ClientId> ClientIdPtr;
 
class ClientId : public IdentifierType<2, 255> {
public:
 
    static constexpr size_t MIN_CLIENT_ID_LEN = IdentifierType::getMinSize();
 
    static constexpr size_t MAX_CLIENT_ID_LEN = IdentifierType::getMaxSize();
 
    ClientId(const std::vector<uint8_t>& data);
 
    ClientId(const uint8_t* data, size_t len);
 
    const std::vector<uint8_t>& getClientId() const;
 
    static ClientIdPtr fromText(const std::string& text);
};
 
}  // namespace dhcp
}  // namespace isc
 
#endif /* DUID_H */