lz4.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright 2026 Johnson Ogundeji
#pragma once
 
 
#ifdef SIGNET_HAS_LZ4
 
#include "signet/compression/codec.hpp"
 
#include <lz4.h>
 
#include <cstdint>
#include <limits>
#include <string>
#include <vector>
 
namespace signet::forge {
 
class Lz4RawCodec : public CompressionCodec {
public:
    [[nodiscard]] expected<std::vector<uint8_t>> compress(
        const uint8_t* data, size_t size) const override {
 
        if (size == 0) {
            return std::vector<uint8_t>{};
        }
 
        // CWE-190: Integer Overflow (liblz4 uses int for sizes)
        if (size > static_cast<size_t>((std::numeric_limits<int>::max)())) {
            return Error{ErrorCode::INTERNAL_ERROR,
                         "LZ4: input exceeds int32 limit"};
        }
 
        // LZ4_compressBound returns the maximum compressed size.
        int max_compressed = LZ4_compressBound(static_cast<int>(size));
        if (max_compressed <= 0) {
            return Error{ErrorCode::INTERNAL_ERROR,
                         "LZ4: input too large for LZ4_compressBound"};
        }
 
        std::vector<uint8_t> out(static_cast<size_t>(max_compressed));
 
        int compressed_size = LZ4_compress_default(
            reinterpret_cast<const char*>(data),
            reinterpret_cast<char*>(out.data()),
            static_cast<int>(size),
            max_compressed);
 
        if (compressed_size <= 0) {
            return Error{ErrorCode::INTERNAL_ERROR,
                         "LZ4 compress failed (returned " +
                         std::to_string(compressed_size) + ")"};
        }
 
        out.resize(static_cast<size_t>(compressed_size));
        return out;
    }
 
    [[nodiscard]] expected<std::vector<uint8_t>> decompress(
        const uint8_t* data, size_t size,
        size_t uncompressed_size) const override {
 
        static constexpr size_t MAX_DECOMPRESS_SIZE = 256 * 1024 * 1024; // 256 MB
        if (uncompressed_size > MAX_DECOMPRESS_SIZE)
            return Error{ErrorCode::INVALID_ARGUMENT, "Decompression size exceeds 256 MB limit"};
 
        if (uncompressed_size == 0) {
            return std::vector<uint8_t>{};
        }
 
        // CWE-190: Integer Overflow (liblz4 uses int for sizes)
        if (size > static_cast<size_t>((std::numeric_limits<int>::max)())) {
            return Error{ErrorCode::INTERNAL_ERROR,
                         "LZ4: compressed input exceeds int32 limit"};
        }
        // CWE-190: Integer Overflow (liblz4 uses int for sizes)
        if (uncompressed_size > static_cast<size_t>((std::numeric_limits<int>::max)())) {
            return Error{ErrorCode::INTERNAL_ERROR,
                         "LZ4: uncompressed size exceeds int32 limit"};
        }
 
        std::vector<uint8_t> out(uncompressed_size);
 
        int decompressed_size = LZ4_decompress_safe(
            reinterpret_cast<const char*>(data),
            reinterpret_cast<char*>(out.data()),
            static_cast<int>(size),
            static_cast<int>(uncompressed_size));
 
        if (decompressed_size < 0) {
            return Error{ErrorCode::CORRUPT_PAGE,
                         "LZ4 decompress failed (returned " +
                         std::to_string(decompressed_size) + ")"};
        }
 
        if (static_cast<size_t>(decompressed_size) != uncompressed_size) {
            return Error{ErrorCode::CORRUPT_PAGE,
                         "LZ4: decompressed " +
                         std::to_string(decompressed_size) +
                         " bytes but expected " +
                         std::to_string(uncompressed_size)};
        }
 
        return out;
    }
 
 
    [[nodiscard]] Compression codec_type() const override {
        return Compression::LZ4_RAW;
    }
 
    [[nodiscard]] const char* name() const override {
        return "lz4_raw";
    }
 
};
 
// ===========================================================================
// Auto-registration helper
// ===========================================================================
 
inline void register_lz4_codec() {
    CodecRegistry::instance().register_codec(std::make_unique<Lz4RawCodec>());
}
 
} // namespace signet::forge
 
#endif // SIGNET_HAS_LZ4