quuid.cpp

Go to the documentation of this file.

// Copyright (C) 2020 The Qt Company Ltd.
// Copyright (C) 2017 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Marc Mutz <marc.mutz@kdab.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "quuid.h"
 
#include "qcryptographichash.h"
#include "qdatastream.h"
#include "qdebug.h"
#include "qendian.h"
#include "qrandom.h"
#include "private/qtools_p.h"
 
QT_BEGIN_NAMESPACE
 
// ensure QList of this is efficient
static_assert(QTypeInfo<QUuid::Id128Bytes>::isRelocatable);
 
// 16 bytes (a uint, two shorts and a uchar[8]), each represented by two hex
// digits; plus four dashes and a pair of enclosing brace: 16*2 + 4 + 2 = 38.
enum { MaxStringUuidLength = 38 };
 
template <class Integral>
void _q_toHex(char *&dst, Integral value)
{
    value = qToBigEndian(value);
 
    const char *p = reinterpret_cast<const char *>(&value);
 
    for (uint i = 0; i < sizeof(Integral); ++i, dst += 2) {
        dst[0] = QtMiscUtils::toHexLower((p[i] >> 4) & 0xf);
        dst[1] = QtMiscUtils::toHexLower(p[i] & 0xf);
    }
}
 
template <class Integral>
bool _q_fromHex(const char *&src, Integral &value)
{
    value = 0;
 
    for (uint i = 0; i < sizeof(Integral) * 2; ++i) {
        uint ch = *src++;
        int tmp = QtMiscUtils::fromHex(ch);
        if (tmp == -1)
            return false;
 
        value = value * 16 + tmp;
    }
 
    return true;
}
 
static char *_q_uuidToHex(const QUuid &uuid, char *dst, QUuid::StringFormat mode = QUuid::WithBraces)
{
    if ((mode & QUuid::WithoutBraces) == 0)
        *dst++ = '{';
    _q_toHex(dst, uuid.data1);
    if ((mode & QUuid::Id128) != QUuid::Id128)
        *dst++ = '-';
    _q_toHex(dst, uuid.data2);
    if ((mode & QUuid::Id128) != QUuid::Id128)
        *dst++ = '-';
    _q_toHex(dst, uuid.data3);
    if ((mode & QUuid::Id128) != QUuid::Id128)
        *dst++ = '-';
    for (int i = 0; i < 2; i++)
        _q_toHex(dst, uuid.data4[i]);
    if ((mode & QUuid::Id128) != QUuid::Id128)
        *dst++ = '-';
    for (int i = 2; i < 8; i++)
        _q_toHex(dst, uuid.data4[i]);
    if ((mode & QUuid::WithoutBraces) == 0)
        *dst++ = '}';
    return dst;
}
 
Q_NEVER_INLINE
static QUuid _q_uuidFromHex(const char *src)
{
    uint d1;
    ushort d2, d3;
    uchar d4[8];
 
    if (src) {
        if (*src == '{')
            src++;
        if (Q_LIKELY(   _q_fromHex(src, d1)
                     && *src++ == '-'
                     && _q_fromHex(src, d2)
                     && *src++ == '-'
                     && _q_fromHex(src, d3)
                     && *src++ == '-'
                     && _q_fromHex(src, d4[0])
                     && _q_fromHex(src, d4[1])
                     && *src++ == '-'
                     && _q_fromHex(src, d4[2])
                     && _q_fromHex(src, d4[3])
                     && _q_fromHex(src, d4[4])
                     && _q_fromHex(src, d4[5])
                     && _q_fromHex(src, d4[6])
                     && _q_fromHex(src, d4[7]))) {
            return QUuid(d1, d2, d3, d4[0], d4[1], d4[2], d4[3], d4[4], d4[5], d4[6], d4[7]);
        }
    }
 
    return QUuid();
}
 
static QUuid createFromName(QUuid ns, QByteArrayView baseData, QCryptographicHash::Algorithm algorithm, int version) noexcept
{
    std::byte buffer[20];
    Q_ASSERT(sizeof buffer >= size_t(QCryptographicHash::hashLength(algorithm)));
    QByteArrayView hashResult
        = QCryptographicHash::hashInto(buffer, {QByteArrayView{ns.toBytes()}, baseData}, algorithm);
    Q_ASSERT(hashResult.size() >= 16);
    hashResult.truncate(16); // Sha1 will be too long
 
    QUuid result = QUuid::fromRfc4122(hashResult);
 
    result.data3 &= 0x0FFF;
    result.data3 |= (version << 12);
    result.data4[0] &= 0x3F;
    result.data4[0] |= 0x80;
 
    return result;
}
 
static QUuid uuidFromString(QStringView text) noexcept
{
    if (text.size() > MaxStringUuidLength)
        text.truncate(MaxStringUuidLength);
 
    char latin1[MaxStringUuidLength + 1];
    char *dst = latin1;
 
    for (QChar ch : text)
        *dst++ = ch.toLatin1();
 
    *dst++ = '\0'; // don't read garbage as potentially valid data
 
    return _q_uuidFromHex(latin1);
}
 
static QUuid uuidFromString(QLatin1StringView text) noexcept
{
    if (Q_UNLIKELY(text.size() < MaxStringUuidLength - 2
                   || (text.front() == '{' && text.size() < MaxStringUuidLength - 1))) {
        // Too short. Don't call _q_uuidFromHex(); QL1Ss need not be NUL-terminated,
        // and we don't want to read trailing garbage as potentially valid data.
        text = QLatin1StringView();
    }
    return _q_uuidFromHex(text.data());
}
 
Q_ALWAYS_INLINE
// can treat UTF-8 the same as Latin-1:
static QUuid uuidFromString(QUtf8StringView text) noexcept
{
    return uuidFromString(QLatin1StringView(text.data(), text.size()));
}
 
QUuid QUuid::fromString(QAnyStringView text) noexcept
{
    return text.visit([] (auto text) { return uuidFromString(text); });
}
 
#ifndef QT_BOOTSTRAPPED
QUuid QUuid::createUuidV3(QUuid ns, QByteArrayView baseData) noexcept
{
    return createFromName(ns, baseData, QCryptographicHash::Md5, 3);
}
#endif
 
QUuid QUuid::createUuidV5(QUuid ns, QByteArrayView baseData) noexcept
{
    return createFromName(ns, baseData, QCryptographicHash::Sha1, 5);
}
 
QUuid QUuid::fromRfc4122(QByteArrayView bytes) noexcept
{
    if (bytes.isEmpty() || bytes.size() != 16)
        return QUuid();
    return fromBytes(bytes.data());
}
 
QString QUuid::toString(QUuid::StringFormat mode) const
{
    char latin1[MaxStringUuidLength];
    const auto end = _q_uuidToHex(*this, latin1, mode);
    return QString::fromLatin1(latin1, end - latin1);
}
 
QByteArray QUuid::toByteArray(QUuid::StringFormat mode) const
{
    QByteArray result(MaxStringUuidLength, Qt::Uninitialized);
    const auto end = _q_uuidToHex(*this, const_cast<char *>(result.constData()), mode);
    result.resize(end - result.constData());
    return result;
}
 
QByteArray QUuid::toRfc4122() const
{
    Id128Bytes bytes = toBytes();
    return QByteArrayView(bytes).toByteArray();
}
 
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &s, const QUuid &id)
{
    constexpr int NumBytes = sizeof(QUuid);
    static_assert(NumBytes == 16, "Change the serialization format when this ever hits");
    char bytes[NumBytes];
    if (s.byteOrder() == QDataStream::BigEndian) {
        const auto id128 = id.toBytes();
        static_assert(sizeof(id128) == NumBytes);
        memcpy(bytes, &id128, NumBytes);
    } else {
        auto *data = bytes;
 
        // for historical reasons, our little-endian serialization format
        // stores each of the UUID fields in little endian, instead of storing
        // a little endian Id128
        qToLittleEndian(id.data1, data);
        data += sizeof(quint32);
        qToLittleEndian(id.data2, data);
        data += sizeof(quint16);
        qToLittleEndian(id.data3, data);
        data += sizeof(quint16);
 
        for (int i = 0; i < 8; ++i) {
            *(data) = id.data4[i];
            data++;
        }
    }
 
    if (s.writeRawData(bytes, NumBytes) != NumBytes)
        s.setStatus(QDataStream::WriteFailed);
 
    return s;
}
 
QDataStream &operator>>(QDataStream &s, QUuid &id)
{
    std::array<char, 16> bytes;
    if (s.readRawData(bytes.data(), 16) != 16) {
        s.setStatus(QDataStream::ReadPastEnd);
        return s;
    }
 
    if (s.byteOrder() == QDataStream::BigEndian) {
        id = QUuid::fromRfc4122(bytes);
    } else {
        const uchar *data = reinterpret_cast<const uchar *>(bytes.data());
 
        id.data1 = qFromLittleEndian<quint32>(data);
        data += sizeof(quint32);
        id.data2 = qFromLittleEndian<quint16>(data);
        data += sizeof(quint16);
        id.data3 = qFromLittleEndian<quint16>(data);
        data += sizeof(quint16);
 
        for (int i = 0; i < 8; ++i) {
            id.data4[i] = *(data);
            data++;
        }
    }
 
    return s;
}
#endif // QT_NO_DATASTREAM
 
bool QUuid::isNull() const noexcept
{
    return data4[0] == 0 && data4[1] == 0 && data4[2] == 0 && data4[3] == 0 &&
           data4[4] == 0 && data4[5] == 0 && data4[6] == 0 && data4[7] == 0 &&
           data1 == 0 && data2 == 0 && data3 == 0;
}
 
QUuid::Variant QUuid::variant() const noexcept
{
    if (isNull())
        return VarUnknown;
    // Check the 3 MSB of data4[0]
    if ((data4[0] & 0x80) == 0x00) return NCS;
    else if ((data4[0] & 0xC0) == 0x80) return DCE;
    else if ((data4[0] & 0xE0) == 0xC0) return Microsoft;
    else if ((data4[0] & 0xE0) == 0xE0) return Reserved;
    return VarUnknown;
}
 
QUuid::Version QUuid::version() const noexcept
{
    // Check the 4 MSB of data3
    Version ver = (Version)(data3>>12);
    if (isNull()
         || (variant() != DCE)
         || ver < Time
         || ver > Sha1)
        return VerUnknown;
    return ver;
}
 
#if defined(Q_OS_WIN)
 
QT_BEGIN_INCLUDE_NAMESPACE
#include <objbase.h> // For CoCreateGuid
QT_END_INCLUDE_NAMESPACE
 
QUuid QUuid::createUuid()
{
    GUID guid;
    CoCreateGuid(&guid);
    QUuid result = guid;
    return result;
}
 
#elif !defined(QT_BOOTSTRAPPED)
 
QUuid QUuid::createUuid()
{
    QUuid result(Qt::Uninitialized);
    uint *data = &(result.data1);
    enum { AmountToRead = 4 };
    QRandomGenerator::system()->fillRange(data, AmountToRead);
 
    result.data4[0] = (result.data4[0] & 0x3F) | 0x80;        // UV_DCE
    result.data3 = (result.data3 & 0x0FFF) | 0x4000;        // UV_Random
 
    return result;
}
#endif // !Q_OS_WIN && !QT_BOOTSTRAPPED
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QUuid &id)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QUuid(" << id.toString() << ')';
    return dbg;
}
#endif
 
size_t qHash(const QUuid &uuid, size_t seed) noexcept
{
    return uuid.data1 ^ uuid.data2 ^ (uuid.data3 << 16)
            ^ ((uuid.data4[0] << 24) | (uuid.data4[1] << 16) | (uuid.data4[2] << 8) | uuid.data4[3])
            ^ ((uuid.data4[4] << 24) | (uuid.data4[5] << 16) | (uuid.data4[6] << 8) | uuid.data4[7])
            ^ seed;
}
 
 
QT_END_NAMESPACE