Method validateKVD

tools/ktx/validate.cpp:1274–1418

}

void ValidationContext::validateKVD() {
    const auto kvdByteOffset = header.keyValueData.byteOffset;
    const auto kvdByteLength = header.keyValueData.byteLength;

    if (kvdByteOffset == 0 || kvdByteLength == 0)
        return; // There is no KVD block

    const auto buffer = std::make_unique<uint8_t[]>(kvdByteLength);
    read(kvdByteOffset, buffer.get(), kvdByteLength, "the Key/Value Data");
    const auto* ptrKVD = buffer.get();
    const auto* ptrKVDEnd = ptrKVD + kvdByteLength;

    struct KeyValueEntry {
        std::string key;
        const uint8_t* data;
        uint32_t size;

        KeyValueEntry(std::string_view key, const uint8_t* data, uint32_t size) :
                key(key), data(data), size(size) {}
    };
    std::vector<KeyValueEntry> entries;
    std::unordered_set<std::string_view> keys;

    uint32_t numKVEntry = 0;
    // Process Key-Value entries {size, key, \0, value} until the end of the KVD block
    // Where size is an uint32_t, and it equals to: sizeof(key) + 1 + sizeof(value)
    const auto* ptrEntry = ptrKVD;
    while (ptrEntry < ptrKVDEnd) {
        const auto remainingKVDBytes = ptrKVDEnd - ptrEntry;

        if (++numKVEntry > MAX_NUM_KV_ENTRIES) {
            warning(Metadata::TooManyEntries, numKVEntry - 1, remainingKVDBytes);
            ptrEntry = ptrKVDEnd;
            break;
        }

        if (remainingKVDBytes < 6) {
            error(Metadata::NotEnoughDataForAnEntry, remainingKVDBytes);
            ptrEntry = ptrKVDEnd;
            break;
        }

        uint32_t sizeKeyValuePair;
        std::memcpy(&sizeKeyValuePair, ptrEntry, sizeof(uint32_t));

        const auto* ptrKeyValuePair = ptrEntry + sizeof(uint32_t);
        const auto* ptrKey = ptrKeyValuePair;

        if (sizeKeyValuePair < 2) {
            error(Metadata::KeyAndValueByteLengthTooSmall, sizeKeyValuePair);
        } else {
            if (ptrKeyValuePair + sizeKeyValuePair > ptrKVDEnd) {
                const auto bytesLeft = ptrKVDEnd - ptrKeyValuePair;
                error(Metadata::KeyAndValueByteLengthTooLarge, sizeKeyValuePair, bytesLeft);
                sizeKeyValuePair = static_cast<uint32_t>(bytesLeft); // Attempt recovery to read out at least the key
            }

            // Determine key, finding the null terminator