uuid.hpp

/*
  ANCH Framework: ANother C++ Hack is a C++ framework based on C++11 standard
  Copyright (C) 2012 Vincent Lachenal

  This file is part of ANCH Framework.

  ANCH Framework is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  ANCH Framework is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with ANCH Framework.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _ANCH_UUID_H_
#define _ANCH_UUID_H_

#include <iostream>
#include <iomanip>
#include <sstream>
#include <ctime>
#include <chrono>
#include <limits>
#include <random>
#include <functional>

#include "device/network.hpp"
#include "crypto/hash/md5.hpp"
#include "crypto/hash/sha1.hpp"


namespace anch {

  class Uuid {
  public:
    enum Version {
      MAC_ADDRESS = 1,

      DCE_SECURITY,

      MD5_HASH,

      RANDOM,

      SHA1_HASH
    };

    // Attributes +
  private:
    static const uint64_t TIME_LOW_MASK = 0x00000000FFFFFFFF;

    static const uint64_t TIME_MID_MASK = 0x000000000000FFFF;

    static const uint64_t TIME_HIGH_MASK = 0x0000000000000FFF;

    static const uint32_t SEQ_LOW_MASK = 0x00FF;

    static const uint32_t SEQ_HIGH_MASK = 0x3F00;

    uint32_t _lowTime;

    uint16_t _midTime;

    uint16_t _highTime;

    uint16_t _clockSeqLow;

    uint16_t _clockSeqHighRes;

    uint64_t _node;

    anch::Uuid::Version _version;
    // Attributes -


    // Constructors +
  public:
    Uuid() {
      // Nothing to do
    }

    Uuid(const Uuid& uuid): _lowTime(uuid._lowTime),
                            _midTime(uuid._midTime),
                            _highTime(uuid._highTime),
                            _clockSeqLow(uuid._clockSeqLow),
                            _clockSeqHighRes(uuid._clockSeqHighRes),
                            _node(uuid._node) {
      // Nothing to do
    }
    // Constructors -

    // Destructor +
  public:
    virtual ~Uuid() {
      // Nothing to do
    }
    // Destructor -

    // Methods +
  public:
    static void generateUuid(Uuid& uuid,
                             anch::Uuid::Version version = anch::Uuid::Version::RANDOM,
                             const std::string& data = "") {
      // Initialize random seed +
      std::chrono::time_point<std::chrono::high_resolution_clock> now = std::chrono::high_resolution_clock::now();
      auto epoch = now.time_since_epoch();
      int64_t timestamp = (std::chrono::duration_cast<std::chrono::nanoseconds>(epoch).count());
      getRandomEngine().seed(timestamp);
      // Initialize random seed -

      uuid._version = version;

      switch(version) {
      case Uuid::Version::MAC_ADDRESS:
        generateUuidVersion1(uuid, data);
        break;
      case Uuid::Version::DCE_SECURITY:
        // TODO implements this algorithm version
        break;
      case Uuid::Version::MD5_HASH:
        generateUuidVersion3(uuid,data);
        break;
      case Uuid::Version::RANDOM:
        generateUuidVersion4(uuid);
        break;
      case Uuid::Version::SHA1_HASH:
        generateUuidVersion5(uuid,data);
        break;
      default:
        // Nothing to do
        break;
      }
    }

    static void generateUuidVersion1(Uuid& uuid,
                                     const std::string& macAddress = "") {
      // Timestamp +
      uint64_t timestamp = getUtcTimestamp();
      uuid._lowTime = timestamp & TIME_LOW_MASK;
      uuid._midTime = (timestamp >> 32) & TIME_MID_MASK;
      uuid._highTime = (timestamp >> 48) & TIME_HIGH_MASK;
      // Timestamp -

      // Sequence +
      uint16_t clockSeq = getDistSeq()(getRandomEngine());
      uuid._clockSeqLow = clockSeq & SEQ_LOW_MASK;
      uuid._clockSeqHighRes = (clockSeq & SEQ_HIGH_MASK) >> 8;
      uuid._clockSeqHighRes |= 0x80;
      // Sequence -

      // MAC address +
      std::string macAddr = macAddress;
      if(macAddr == "") {
        for(auto iter : anch::device::Network::getInterfaces()) {
          const anch::device::NetworkInterface iface = iter.second;
          if(!iface.isLocalhost()) {
            macAddr = iface.getMacAddress();
          }
        }
      }
      std::size_t pos = 0;
      std::size_t last = 0;
      std::string macHexStr = "";
      do {
        if(pos != 0) {
          last = pos + 1;
        }
        pos = macAddr.find(':', last);
        macHexStr += macAddr.substr(last, pos - last);
      } while(pos != std::string::npos);
      uuid._node = std::stoull(macHexStr,0,16);
      // MAC address -
    }

    static void generateUuidVersion3(Uuid& uuid, const std::string& data) {
      anch::crypto::MD5 hash(data);
      const std::array<uint8_t,16>& digest = hash.digest();

      // Timestamp +
      uuid._lowTime = digest[0]
        + (static_cast<uint32_t>(digest[1]) << 8)
        + (static_cast<uint32_t>(digest[2]) << 16)
        + (static_cast<uint32_t>(digest[3]) << 24);
      uuid._midTime = digest[4]
        + (static_cast<uint16_t>(digest[5]) << 8);
      uuid._highTime = digest[6]
        + (static_cast<uint16_t>(digest[7]) << 8);
      uuid._highTime = uuid._highTime & TIME_HIGH_MASK;
      // Timestamp -

      // Sequence +
      uuid._clockSeqLow = digest[9];
      uuid._clockSeqHighRes = digest[8];
      uuid._clockSeqHighRes |= 0x80;
      // Sequence -

      // Node +
      uuid._node = digest[10]
        + (static_cast<uint64_t>(digest[11]) << 8)
        + (static_cast<uint64_t>(digest[12]) << 16)
        + (static_cast<uint64_t>(digest[13]) << 24)
        + (static_cast<uint64_t>(digest[14]) << 32)
        + (static_cast<uint64_t>(digest[15]) << 40);
      // Node -
    }

    static void generateUuidVersion4(Uuid& uuid) {
      static std::uniform_int_distribution<uint16_t> dist16;
      static std::uniform_int_distribution<uint32_t> dist32;
      static std::uniform_int_distribution<uint64_t> dist64(0, 0xFFFFFFFFFFFF); // Max 12 hexadecimal digits

      // Timestamp +
      uuid._lowTime = dist32(getRandomEngine());
      uuid._midTime = dist16(getRandomEngine());
      uuid._highTime = dist16(getRandomEngine()) & TIME_HIGH_MASK;
      // Timestamp -

      // Sequence +
      uint16_t clockSeq = getDistSeq()(getRandomEngine());
      uuid._clockSeqLow = clockSeq & SEQ_LOW_MASK;
      uuid._clockSeqHighRes = (clockSeq & SEQ_HIGH_MASK) >> 8;
      uuid._clockSeqHighRes |= 0x80;
      // Sequence -

      // Node +
      uuid._node = dist64(getRandomEngine());
      // Node -
    }

    static void generateUuidVersion5(Uuid& uuid, const std::string& data) {
      anch::crypto::SHA1 hash(data);
      const std::array<uint8_t,20>& digest = hash.digest();

      // Timestamp +
      uuid._lowTime = digest[0]
        + (static_cast<uint32_t>(digest[1]) << 8)
        + (static_cast<uint32_t>(digest[2]) << 16)
        + (static_cast<uint32_t>(digest[3]) << 24);
      uuid._midTime = digest[4]
        + (static_cast<uint16_t>(digest[5]) << 8);
      uuid._highTime = digest[6]
        + (static_cast<uint16_t>(digest[7]) << 8);
      uuid._highTime = uuid._highTime & TIME_HIGH_MASK;
      // Timestamp -

      // Sequence +
      uuid._clockSeqLow = digest[9];
      uuid._clockSeqHighRes = digest[8];
      uuid._clockSeqHighRes |= 0x80;
      // Sequence -

      // Node +
      uuid._node = digest[10]
        + (static_cast<uint64_t>(digest[11]) << 8)
        + (static_cast<uint64_t>(digest[12]) << 16)
        + (static_cast<uint64_t>(digest[13]) << 24)
        + (static_cast<uint64_t>(digest[14]) << 32)
        + (static_cast<uint64_t>(digest[15]) << 40);
      // Node -
    }

  private:
    static uint64_t getUtcTimestamp() {
      static const uint64_t UTC_OFFSET = 0x01B21DD213814000;
      std::chrono::time_point<std::chrono::high_resolution_clock> now = std::chrono::high_resolution_clock::now();
      auto epoch = now.time_since_epoch();
      int64_t timestamp = (std::chrono::duration_cast<std::chrono::nanoseconds>(epoch).count()) / 100;
      return UTC_OFFSET + (uint64_t)timestamp;
    }

    static inline std::mt19937& getRandomEngine() {
      static std::mt19937 engine;
      return engine;
    }

    static inline std::uniform_int_distribution<uint16_t>& getDistSeq() {
      static std::uniform_int_distribution<uint16_t> distSeq(0, SEQ_HIGH_MASK);
      return distSeq;
    }

  public:
    std::string toString() const {
      std::ostringstream out;
      out << std::hex
          << std::setfill('0') << std::setw(8) << _lowTime << '-'
          << std::setfill('0') << std::setw(4) << _midTime << '-'
          << std::setfill('0') << std::setw(1) << _version
          << std::setfill('0') << std::setw(3) << _highTime << '-'
          << std::setfill('0') << std::setw(2) << _clockSeqHighRes
          << std::setfill('0') << std::setw(2) << _clockSeqLow << '-'
          << std::setfill('0') << std::setw(12) << _node;
      return out.str();
    }
    // Methods -


    // Accessors +
  public:
    inline uint32_t getLowTime() const {
      return _lowTime;
    }

    inline uint16_t getMidTime() const {
      return _midTime;
    }

    inline uint16_t getHighTime() const {
      return _highTime;
    }

    inline uint16_t getClockSeqLow() const {
      return _clockSeqLow;
    }

    inline uint16_t getClockSeqHighRes() const {
      return _clockSeqHighRes;
    }

    inline uint64_t getNode() const {
      return _node;
    }

    inline anch::Uuid::Version getVersion() const {
      return _version;
    }
    // Accessors -

  };

}

template<class CharT, class Traits>
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& out, const anch::Uuid& uuid) {
  std::ios_base::fmtflags flags = out.flags(); // Save current flags
  out << std::hex
      << std::setfill('0') << std::setw(8) << uuid.getLowTime() << '-'
      << std::setfill('0') << std::setw(4) << uuid.getMidTime() << '-'
      << std::setfill('0') << std::setw(1) << uuid.getVersion()
      << std::setfill('0') << std::setw(3) << uuid.getHighTime() << '-'
      << std::setfill('0') << std::setw(2) << uuid.getClockSeqHighRes()
      << std::setfill('0') << std::setw(2) << uuid.getClockSeqLow() << '-'
      << std::setfill('0') << std::setw(12) << uuid.getNode();
  out.flags(flags); // Restore flags
  return out;
}

#endif // _ANCH_UUID_H_