C++ e i formati di compressione

In C++ la compressione richiede più lavoro che negli altri linguaggi, ma offre in cambio il controllo completo su memoria, buffer e parametri, e l'accesso diretto alle stesse librerie su cui si appoggiano tutti gli altri runtime.

C++ di Gabriele Romanato

A differenza degli altri linguaggi esaminati in questa serie, il C++ non offre alcun supporto alla compressione nella libreria standard. Il lavoro si svolge quindi con le librerie C di riferimento, che sono le stesse usate internamente da Node.js, Python, PHP e dagli altri runtime: zlib per Gzip e DEFLATE, libzstd per Zstandard, la libreria di Google per Brotli e libarchive per gli archivi ZIP e TAR. In questo articolo vediamo come usarle da C++ moderno, avvolgendo le loro API in classi RAII sicure rispetto alle eccezioni e gestendo correttamente streaming, errori e input malevoli.

Configurare il progetto con CMake

Tutte le librerie citate sono disponibili come pacchetti nelle principali distribuzioni Linux (su Debian e Ubuntu: zlib1g-dev, libzstd-dev, libbrotli-dev e libarchive-dev), tramite Homebrew su macOS e tramite vcpkg o Conan su qualsiasi piattaforma. CMake include moduli di ricerca per zlib e libarchive, mentre per zstd e Brotli si usa pkg-config.

cmake_minimum_required(VERSION 3.25)
project(compression_demo LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(ZLIB REQUIRED)
find_package(LibArchive REQUIRED)
find_package(PkgConfig REQUIRED)
pkg_check_modules(ZSTD REQUIRED IMPORTED_TARGET libzstd)
pkg_check_modules(BROTLI REQUIRED IMPORTED_TARGET libbrotlienc libbrotlidec)

add_executable(compression_demo main.cpp)
target_compile_options(compression_demo PRIVATE -Wall -Wextra -Wpedantic)
target_link_libraries(compression_demo PRIVATE
    ZLIB::ZLIB
    LibArchive::LibArchive
    PkgConfig::ZSTD
    PkgConfig::BROTLI
)

Il modello di zlib

L'API di zlib ruota attorno alla struttura z_stream, che contiene puntatori e contatori per il buffer di input (next_in, avail_in) e per quello di output (next_out, avail_out). Si inizializza lo stato con deflateInit2 o inflateInit2, si chiamano ripetutamente deflate o inflate finché tutto l'input è consumato e l'output emesso, e infine si libera lo stato con deflateEnd o inflateEnd.

Il formato del contenitore si sceglie con il parametro windowBits, esattamente come nel modulo zlib di Python, che ne è un sottile involucro:

  • da 8 a 15: formato zlib (RFC 1950);
  • da -8 a -15: DEFLATE raw (RFC 1951);
  • 16 più la finestra, quindi tipicamente 31: formato Gzip (RFC 1952);
  • 32 più la finestra, quindi tipicamente 47, solo in decompressione: rilevamento automatico di zlib e Gzip.

Un wrapper RAII per zlib

Lo stato di zlib alloca memoria che va sempre liberata, anche in presenza di eccezioni. Il modo idiomatico di garantirlo in C++ è una classe che acquisisce la risorsa nel costruttore e la rilascia nel distruttore, disabilitando la copia. L'implementazione seguente offre compressione e decompressione Gzip in memoria, con un limite configurabile sulla dimensione dell'output.

#include <zlib.h>

#include <cstdint>
#include <span>
#include <stdexcept>
#include <string>
#include <vector>

namespace compression {

class ZlibError : public std::runtime_error {
public:
    ZlibError(const std::string& what, int code, const char* msg)
        : std::runtime_error(what + ": " + (msg ? msg : zError(code))) {}
};

enum class Format : int {
    Raw = -15,
    Zlib = 15,
    Gzip = 15 + 16,
    Auto = 15 + 32  // solo in decompressione
};

// Gestisce il ciclo di vita di uno z_stream usato per comprimere
class Deflater {
public:
    explicit Deflater(Format format = Format::Gzip, int level = Z_DEFAULT_COMPRESSION) {
        int rc = deflateInit2(&stream_, level, Z_DEFLATED, static_cast<int>(format), 8, Z_DEFAULT_STRATEGY);
        if (rc != Z_OK) {
            throw ZlibError("deflateInit2", rc, stream_.msg);
        }
    }
    ~Deflater() { deflateEnd(&stream_); }

    Deflater(const Deflater&) = delete;
    Deflater& operator=(const Deflater&) = delete;

    // Comprime un blocco; finish = true chiude il flusso scrivendo il trailer
    void compress(std::span<const std::uint8_t> input, std::vector<std::uint8_t>& output, bool finish) {
        stream_.next_in = const_cast<Bytef*>(input.data());
        stream_.avail_in = static_cast<uInt>(input.size());
        const int flush = finish ? Z_FINISH : Z_NO_FLUSH;

        std::uint8_t buffer[64 * 1024];
        int rc;
        do {
            stream_.next_out = buffer;
            stream_.avail_out = sizeof(buffer);
            rc = deflate(&stream_, flush);
            if (rc == Z_STREAM_ERROR) {
                throw ZlibError("deflate", rc, stream_.msg);
            }
            output.insert(output.end(), buffer, buffer + (sizeof(buffer) - stream_.avail_out));
            // Continuiamo finché zlib riempie completamente il buffer di output
        } while (stream_.avail_out == 0);

        if (finish && rc != Z_STREAM_END) {
            throw ZlibError("deflate", rc, "flusso non terminato");
        }
    }

private:
    z_stream stream_{};
};

// Gestisce il ciclo di vita di uno z_stream usato per decomprimere
class Inflater {
public:
    explicit Inflater(Format format = Format::Auto) {
        int rc = inflateInit2(&stream_, static_cast<int>(format));
        if (rc != Z_OK) {
            throw ZlibError("inflateInit2", rc, stream_.msg);
        }
    }
    ~Inflater() { inflateEnd(&stream_); }

    Inflater(const Inflater&) = delete;
    Inflater& operator=(const Inflater&) = delete;

    // Decomprime un blocco; restituisce true quando il flusso è terminato
    bool decompress(std::span<const std::uint8_t> input, std::vector<std::uint8_t>& output, std::size_t max_output) {
        stream_.next_in = const_cast<Bytef*>(input.data());
        stream_.avail_in = static_cast<uInt>(input.size());

        std::uint8_t buffer[64 * 1024];
        int rc;
        do {
            stream_.next_out = buffer;
            stream_.avail_out = sizeof(buffer);
            rc = inflate(&stream_, Z_NO_FLUSH);
            if (rc == Z_NEED_DICT || rc == Z_DATA_ERROR || rc == Z_MEM_ERROR || rc == Z_STREAM_ERROR) {
                throw ZlibError("inflate", rc, stream_.msg);
            }
            const std::size_t produced = sizeof(buffer) - stream_.avail_out;
            // Limite contro le decompression bomb
            if (output.size() + produced > max_output) {
                throw std::length_error("output decompresso oltre il limite");
            }
            output.insert(output.end(), buffer, buffer + produced);
        } while (stream_.avail_out == 0 && rc != Z_STREAM_END);

        return rc == Z_STREAM_END;
    }

private:
    z_stream stream_{};
};

inline std::vector<std::uint8_t> gzip(std::span<const std::uint8_t> data, int level = Z_DEFAULT_COMPRESSION) {
    std::vector<std::uint8_t> out;
    out.reserve(deflateBound(nullptr, static_cast<uLong>(data.size())) + 18);
    Deflater(Format::Gzip, level).compress(data, out, true);
    return out;
}

inline std::vector<std::uint8_t> gunzip(std::span<const std::uint8_t> data, std::size_t max_output = 64 << 20) {
    std::vector<std::uint8_t> out;
    if (!Inflater(Format::Auto).decompress(data, out, max_output)) {
        throw std::runtime_error("flusso Gzip troncato");
    }
    return out;
}

}  // namespace compression

Il distruttore chiama deflateEnd e inflateEnd anche se il costruttore è andato a buon fine e un'eccezione è stata lanciata più avanti: è questa la garanzia che rende il codice sicuro. Si noti anche che l'interfaccia di zlib usa uInt a 32 bit per le dimensioni dei buffer: per input superiori a 4 GiB bisogna suddividere i dati in blocchi, cosa che la versione in streaming della prossima sezione fa naturalmente.

Streaming di file

Con il wrapper appena scritto, comprimere un file di qualsiasi dimensione si riduce a un ciclo di lettura a blocchi. In alternativa, per i soli file Gzip, zlib offre l'interfaccia semplificata gzopen, gzread e gzwrite, utile quando non serve un controllo fine.

#include "compression.hpp"

#include <zlib.h>

#include <filesystem>
#include <fstream>
#include <iostream>
#include <memory>
#include <string>
#include <string_view>
#include <type_traits>

namespace fs = std::filesystem;

// Comprime un file a blocchi usando il wrapper RAII
void gzip_file(const fs::path& source, const fs::path& destination, int level) {
    std::ifstream in(source, std::ios::binary);
    std::ofstream out(destination, std::ios::binary);
    if (!in || !out) {
        throw std::runtime_error("impossibile aprire i file");
    }

    compression::Deflater deflater(compression::Format::Gzip, level);
    std::vector<std::uint8_t> input(1 << 20);
    std::vector<std::uint8_t> output;

    while (in) {
        in.read(reinterpret_cast<char*>(input.data()), static_cast<std::streamsize>(input.size()));
        const auto count = static_cast<std::size_t>(in.gcount());
        output.clear();
        // L'ultimo blocco chiude il flusso e scrive il trailer
        deflater.compress({input.data(), count}, output, !in);
        out.write(reinterpret_cast<const char*>(output.data()), static_cast<std::streamsize>(output.size()));
    }
}

// Deleter per usare gzFile con unique_ptr
struct GzCloser {
    void operator()(gzFile file) const { gzclose(file); }
};
using GzFilePtr = std::unique_ptr<std::remove_pointer_t<gzFile>, GzCloser>;

// Conta le righe che contengono un testo usando l'interfaccia gz* di zlib
std::size_t count_matching_lines(const fs::path& path, const std::string& needle) {
    GzFilePtr file(gzopen(path.c_str(), "rb"));
    if (!file) {
        throw std::runtime_error("impossibile aprire " + path.string());
    }
    gzbuffer(file.get(), 128 * 1024);

    std::size_t count = 0;
    char line[8192];
    while (gzgets(file.get(), line, sizeof(line)) != nullptr) {
        if (std::string_view(line).find(needle) != std::string_view::npos) {
            ++count;
        }
    }
    return count;
}

int main() {
    try {
        gzip_file("app.log", "app.log.gz", Z_BEST_COMPRESSION);
        std::cout << "Errori: " << count_matching_lines("app.log.gz", " ERROR ") << '\n';
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << '\n';
        return 1;
    }
}

L'uso di std::unique_ptr con un deleter personalizzato è un'alternativa più compatta alla classe dedicata quando la risorsa è un semplice handle, come il gzFile restituito da gzopen.

Zstandard con libzstd

La libreria zstd offre due livelli di API. Le funzioni semplici ZSTD_compress e ZSTD_decompress lavorano in un colpo solo su buffer in memoria; l'API avanzata, basata su un contesto ZSTD_CCtx e sulla funzione ZSTD_compressStream2, permette lo streaming e la configurazione di parametri come il numero di thread o il checksum. Tutte le funzioni che restituiscono una dimensione segnalano gli errori con valori speciali, da verificare con ZSTD_isError.

#include <zstd.h>

#include <cstdint>
#include <fstream>
#include <memory>
#include <span>
#include <stdexcept>
#include <string>
#include <vector>

namespace compression::zstd {

inline std::size_t check(std::size_t result, const char* where) {
    if (ZSTD_isError(result)) {
        throw std::runtime_error(std::string(where) + ": " + ZSTD_getErrorName(result));
    }
    return result;
}

struct CCtxDeleter {
    void operator()(ZSTD_CCtx* ctx) const { ZSTD_freeCCtx(ctx); }
};
struct DCtxDeleter {
    void operator()(ZSTD_DCtx* ctx) const { ZSTD_freeDCtx(ctx); }
};

// Compressione in memoria in un colpo solo
inline std::vector<std::uint8_t> compress(std::span<const std::uint8_t> data, int level = 3) {
    std::vector<std::uint8_t> out(ZSTD_compressBound(data.size()));
    const std::size_t size = check(ZSTD_compress(out.data(), out.size(), data.data(), data.size(), level), "ZSTD_compress");
    out.resize(size);
    return out;
}

// Decompressione in memoria con limite: la dimensione dichiarata nel frame non è affidabile
inline std::vector<std::uint8_t> decompress(std::span<const std::uint8_t> data, std::size_t max_output) {
    const unsigned long long declared = ZSTD_getFrameContentSize(data.data(), data.size());
    if (declared == ZSTD_CONTENTSIZE_ERROR) {
        throw std::runtime_error("dati zstd non validi");
    }
    if (declared != ZSTD_CONTENTSIZE_UNKNOWN && declared > max_output) {
        throw std::length_error("dimensione dichiarata oltre il limite");
    }

    // Il buffer limitato impedisce comunque di superare max_output
    const std::size_t capacity = declared == ZSTD_CONTENTSIZE_UNKNOWN ? max_output : static_cast<std::size_t>(declared);
    std::vector<std::uint8_t> out(capacity);
    const std::size_t size = check(ZSTD_decompress(out.data(), out.size(), data.data(), data.size()), "ZSTD_decompress");
    out.resize(size);
    return out;
}

// Comprime un file in streaming, con checksum e compressione multithread
inline void compress_file(const std::string& source, const std::string& destination, int level, int workers) {
    std::unique_ptr<ZSTD_CCtx, CCtxDeleter> ctx(ZSTD_createCCtx());
    if (!ctx) {
        throw std::bad_alloc();
    }
    check(ZSTD_CCtx_setParameter(ctx.get(), ZSTD_c_compressionLevel, level), "compressionLevel");
    check(ZSTD_CCtx_setParameter(ctx.get(), ZSTD_c_checksumFlag, 1), "checksumFlag");
    // Il multithreading è disponibile solo se libzstd è compilata con il supporto ai thread
    if (workers > 0) {
        check(ZSTD_CCtx_setParameter(ctx.get(), ZSTD_c_nbWorkers, workers), "nbWorkers");
    }

    std::ifstream in(source, std::ios::binary);
    std::ofstream out(destination, std::ios::binary);
    std::vector<char> in_buf(ZSTD_CStreamInSize());
    std::vector<char> out_buf(ZSTD_CStreamOutSize());

    bool last_chunk = false;
    while (!last_chunk) {
        in.read(in_buf.data(), static_cast<std::streamsize>(in_buf.size()));
        const auto count = static_cast<std::size_t>(in.gcount());
        last_chunk = !in;
        const ZSTD_EndDirective mode = last_chunk ? ZSTD_e_end : ZSTD_e_continue;

        ZSTD_inBuffer input{in_buf.data(), count, 0};
        bool finished = false;
        do {
            ZSTD_outBuffer output{out_buf.data(), out_buf.size(), 0};
            const std::size_t remaining = check(ZSTD_compressStream2(ctx.get(), &output, &input, mode), "ZSTD_compressStream2");
            out.write(out_buf.data(), static_cast<std::streamsize>(output.pos));
            // Con ZSTD_e_end il valore restituito indica i byte ancora da emettere
            finished = last_chunk ? remaining == 0 : input.pos == input.size;
        } while (!finished);
    }
}

}  // namespace compression::zstd

Il pattern del ciclo è quello raccomandato dalla documentazione di zstd: con ZSTD_e_continue si chiama la funzione finché tutto l'input è stato consumato; con ZSTD_e_end la si chiama finché il valore restituito non è zero, il che indica che il frame è stato chiuso e tutti i dati sono stati emessi.

Brotli

La libreria Brotli di Google è divisa in encoder e decoder, con header e librerie separate. Come per zstd, esiste un'API in un colpo solo (BrotliEncoderCompress e BrotliDecoderDecompress) e un'API in streaming basata su istanze dell'encoder e del decoder. La funzione BrotliEncoderMaxCompressedSize calcola la dimensione massima dell'output per dimensionare il buffer.

#include <brotli/decode.h>
#include <brotli/encode.h>

#include <cstdint>
#include <memory>
#include <span>
#include <stdexcept>
#include <vector>

namespace compression::brotli {

inline std::vector<std::uint8_t> compress(std::span<const std::uint8_t> data, int quality = BROTLI_DEFAULT_QUALITY,
                                          BrotliEncoderMode mode = BROTLI_MODE_GENERIC) {
    std::size_t size = BrotliEncoderMaxCompressedSize(data.size());
    if (size == 0) {
        throw std::length_error("input troppo grande per Brotli in un colpo solo");
    }
    std::vector<std::uint8_t> out(size);
    if (!BrotliEncoderCompress(quality, BROTLI_DEFAULT_WINDOW, mode, data.size(), data.data(), &size, out.data())) {
        throw std::runtime_error("compressione Brotli fallita");
    }
    out.resize(size);
    return out;
}

struct DecoderDeleter {
    void operator()(BrotliDecoderState* state) const { BrotliDecoderDestroyInstance(state); }
};

// Decompressione in streaming con limite sull'output
inline std::vector<std::uint8_t> decompress(std::span<const std::uint8_t> data, std::size_t max_output) {
    std::unique_ptr<BrotliDecoderState, DecoderDeleter> state(BrotliDecoderCreateInstance(nullptr, nullptr, nullptr));
    if (!state) {
        throw std::bad_alloc();
    }

    std::vector<std::uint8_t> out;
    std::uint8_t buffer[64 * 1024];
    std::size_t available_in = data.size();
    const std::uint8_t* next_in = data.data();

    for (;;) {
        std::size_t available_out = sizeof(buffer);
        std::uint8_t* next_out = buffer;
        const auto result = BrotliDecoderDecompressStream(state.get(), &available_in, &next_in,
                                                          &available_out, &next_out, nullptr);
        const std::size_t produced = sizeof(buffer) - available_out;
        if (out.size() + produced > max_output) {
            throw std::length_error("output Brotli oltre il limite");
        }
        out.insert(out.end(), buffer, buffer + produced);

        if (result == BROTLI_DECODER_RESULT_SUCCESS) {
            return out;
        }
        if (result == BROTLI_DECODER_RESULT_ERROR) {
            throw std::runtime_error(BrotliDecoderErrorString(BrotliDecoderGetErrorCode(state.get())));
        }
        if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
            throw std::runtime_error("flusso Brotli troncato");
        }
        // BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: continuiamo il ciclo con un nuovo buffer
    }
}

}  // namespace compression::brotli

La qualità di Brotli va da 0 a 11, con default 11 (BROTLI_DEFAULT_QUALITY), mentre la finestra, espressa come logaritmo in base due, va da 10 a 24 con default 22. Per contenuti testuali come HTML, CSS o JSON, la modalità BROTLI_MODE_TEXT migliora leggermente il risultato.

Un confronto tra i codec

Con i tre wrapper pronti possiamo scrivere un piccolo benchmark che misuri dimensione e tempo di compressione per ciascun codec, usando std::chrono::steady_clock.

#include "brotli.hpp"
#include "compression.hpp"
#include "zstd.hpp"

#include <chrono>
#include <cstdint>
#include <format>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>

using Bytes = std::vector<std::uint8_t>;

void measure(std::string_view label, const Bytes& input, const std::function<Bytes(const Bytes&)>& fn) {
    const auto start = std::chrono::steady_clock::now();
    const Bytes output = fn(input);
    const std::chrono::duration<double, std::milli> elapsed = std::chrono::steady_clock::now() - start;
    const double ratio = 100.0 * static_cast<double>(output.size()) / static_cast<double>(input.size());
    std::cout << std::format("{:<12} {:>10} byte {:>6.1f}% {:>9.2f} ms\n", label, output.size(), ratio, elapsed.count());
}

int main(int argc, char* argv[]) {
    std::ifstream file(argc > 1 ? argv[1] : "data.json", std::ios::binary);
    const Bytes input{std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()};
    if (input.empty()) {
        std::cerr << "File vuoto o inesistente\n";
        return 1;
    }

    for (int level : {1, 6, 9}) {
        measure(std::format("gzip -{}", level), input, [level](const Bytes& d) { return compression::gzip(d, level); });
    }
    for (int level : {3, 10, 19}) {
        measure(std::format("zstd -{}", level), input, [level](const Bytes& d) { return compression::zstd::compress(d, level); });
    }
    for (int quality : {4, 6, 11}) {
        measure(std::format("brotli q{}", quality), input,
                [quality](const Bytes& d) { return compression::brotli::compress(d, quality, BROTLI_MODE_TEXT); });
    }
}

Su dati testuali il risultato tipico mostra Zstandard al livello 3 più veloce di Gzip al livello 6 e con un rapporto di compressione migliore, Brotli alla qualità 11 come vincitore in termini di dimensione e, soprattutto, una decompressione di zstd molto più rapida di tutte le alternative. È questo profilo a renderlo la scelta preferita per log, backup e comunicazione tra servizi.

Archivi ZIP e TAR con libarchive

Per gli archivi la libreria di riferimento è libarchive, la stessa che implementa il comando bsdtar su FreeBSD, macOS e Windows. Supporta in lettura e scrittura TAR (in tutte le sue varianti), ZIP, 7z, cpio e ISO 9660, combinati con filtri di compressione come Gzip, bzip2, XZ e Zstandard. L'API separa il formato del contenitore dal filtro di compressione, riflettendo la distinzione tra codec e contenitori vista in tutta questa serie.

#include <archive.h>
#include <archive_entry.h>

#include <filesystem>
#include <fstream>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

namespace fs = std::filesystem;

struct WriteDeleter {
    void operator()(archive* a) const { archive_write_free(a); }
};
struct EntryDeleter {
    void operator()(archive_entry* e) const { archive_entry_free(e); }
};

void check(archive* a, int rc, const char* where) {
    if (rc < ARCHIVE_WARN) {
        throw std::runtime_error(std::string(where) + ": " + archive_error_string(a));
    }
}

// Crea un archivio di una directory; il formato dipende dall'estensione richiesta
void create_archive(const fs::path& source_dir, const fs::path& archive_path) {
    std::unique_ptr<archive, WriteDeleter> a(archive_write_new());
    const std::string name = archive_path.filename().string();

    if (name.ends_with(".zip")) {
        check(a.get(), archive_write_set_format_zip(a.get()), "format zip");
        // Le opzioni permettono di scegliere il livello di DEFLATE delle voci
        check(a.get(), archive_write_set_options(a.get(), "zip:compression-level=9"), "zip options");
    } else if (name.ends_with(".tar.zst")) {
        check(a.get(), archive_write_add_filter_zstd(a.get()), "filter zstd");
        check(a.get(), archive_write_set_format_pax_restricted(a.get()), "format pax");
    } else {
        check(a.get(), archive_write_add_filter_gzip(a.get()), "filter gzip");
        check(a.get(), archive_write_set_format_pax_restricted(a.get()), "format pax");
    }
    check(a.get(), archive_write_open_filename(a.get(), archive_path.c_str()), "open");

    std::vector<char> buffer(64 * 1024);
    for (const auto& item : fs::recursive_directory_iterator(source_dir)) {
        const auto relative = fs::relative(item.path(), source_dir).generic_string();
        std::unique_ptr<archive_entry, EntryDeleter> entry(archive_entry_new());
        archive_entry_set_pathname(entry.get(), relative.c_str());

        if (item.is_directory()) {
            archive_entry_set_filetype(entry.get(), AE_IFDIR);
            archive_entry_set_perm(entry.get(), 0755);
            check(a.get(), archive_write_header(a.get(), entry.get()), "header");
            continue;
        }
        if (!item.is_regular_file()) {
            continue;
        }

        archive_entry_set_filetype(entry.get(), AE_IFREG);
        archive_entry_set_perm(entry.get(), 0644);
        archive_entry_set_size(entry.get(), static_cast<la_int64_t>(item.file_size()));
        check(a.get(), archive_write_header(a.get(), entry.get()), "header");

        std::ifstream in(item.path(), std::ios::binary);
        while (in.read(buffer.data(), static_cast<std::streamsize>(buffer.size())) || in.gcount() > 0) {
            if (archive_write_data(a.get(), buffer.data(), static_cast<std::size_t>(in.gcount())) < 0) {
                throw std::runtime_error(archive_error_string(a.get()));
            }
        }
    }
    // archive_write_close scrive i dati finali (central directory o blocchi di chiusura)
    check(a.get(), archive_write_close(a.get()), "close");
}

Estrazione sicura con libarchive

libarchive offre un'API di estrazione su disco, archive_write_disk, che accetta una serie di flag di sicurezza. Di default, per compatibilità, quasi tutti sono disattivati: è responsabilità del programmatore abilitarli quando l'archivio non è fidato. I tre principali sono ARCHIVE_EXTRACT_SECURE_NODOTDOT, che rifiuta i percorsi contenenti .., ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS, che rifiuta i percorsi assoluti, e ARCHIVE_EXTRACT_SECURE_SYMLINKS, che impedisce di scrivere attraverso link simbolici. Come difesa contro le decompression bomb conviene inoltre contare i byte estratti e rifiutare i tipi di voce diversi da file e directory.

#include <archive.h>
#include <archive_entry.h>

#include <algorithm>
#include <cstdint>
#include <filesystem>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>

namespace fs = std::filesystem;

struct ReadDeleter {
    void operator()(archive* a) const { archive_read_free(a); }
};
struct DiskDeleter {
    void operator()(archive* a) const { archive_write_free(a); }
};

struct ExtractionLimits {
    std::size_t max_entries = 10'000;
    std::int64_t max_total_bytes = std::int64_t{1} << 30;
};

void extract_safely(const fs::path& archive_path, const fs::path& destination, ExtractionLimits limits = {}) {
    std::unique_ptr<archive, ReadDeleter> reader(archive_read_new());
    // Rilevamento automatico di formato e compressione
    archive_read_support_filter_all(reader.get());
    archive_read_support_format_all(reader.get());
    if (archive_read_open_filename(reader.get(), archive_path.c_str(), 64 * 1024) != ARCHIVE_OK) {
        throw std::runtime_error(archive_error_string(reader.get()));
    }

    std::unique_ptr<archive, DiskDeleter> disk(archive_write_disk_new());
    // NOABSOLUTEPATHS non si usa perché i percorsi finali saranno assoluti per costruzione
    archive_write_disk_set_options(disk.get(),
        ARCHIVE_EXTRACT_TIME |
        ARCHIVE_EXTRACT_SECURE_NODOTDOT |
        ARCHIVE_EXTRACT_SECURE_SYMLINKS |
        ARCHIVE_EXTRACT_NO_OVERWRITE);

    // Una destinazione assoluta e normalizzata non contiene componenti ..
    const fs::path root = fs::absolute(destination).lexically_normal();
    fs::create_directories(root);
    std::size_t entries = 0;
    std::int64_t written = 0;
    archive_entry* entry = nullptr;

    while (archive_read_next_header(reader.get(), &entry) == ARCHIVE_OK) {
        if (++entries > limits.max_entries) {
            throw std::runtime_error("troppe voci nell'archivio");
        }
        const char* name = archive_entry_pathname(entry);
        const auto type = archive_entry_filetype(entry);
        // Negli archivi TAR gli hard link hanno tipo AE_IFREG ma un target valorizzato
        if (name == nullptr || (type != AE_IFREG && type != AE_IFDIR) || archive_entry_hardlink(entry) != nullptr) {
            // Link, dispositivi e FIFO vengono saltati
            std::cerr << "Voce ignorata: " << (name ? name : "(senza nome)") << '\n';
            continue;
        }

        // Validiamo il percorso originale prima di riscriverlo sotto la destinazione
        const fs::path original(name);
        const bool escapes = std::ranges::any_of(original, [](const fs::path& part) { return part == ".."; });
        if (original.is_absolute() || original.has_root_name() || escapes) {
            throw std::runtime_error("percorso non sicuro: " + original.string());
        }
        const fs::path target = root / original;
        archive_entry_set_pathname(entry, target.c_str());

        if (archive_write_header(disk.get(), entry) != ARCHIVE_OK) {
            throw std::runtime_error(archive_error_string(disk.get()));
        }

        const void* block = nullptr;
        std::size_t size = 0;
        la_int64_t offset = 0;
        int rc;
        while ((rc = archive_read_data_block(reader.get(), &block, &size, &offset)) == ARCHIVE_OK) {
            // Contiamo i byte reali, non quelli dichiarati nell'intestazione
            written += static_cast<std::int64_t>(size);
            if (written > limits.max_total_bytes) {
                throw std::runtime_error("dimensione estratta oltre il limite");
            }
            if (archive_write_data_block(disk.get(), block, size, offset) != ARCHIVE_OK) {
                throw std::runtime_error(archive_error_string(disk.get()));
            }
        }
        if (rc != ARCHIVE_EOF) {
            throw std::runtime_error(archive_error_string(reader.get()));
        }
        archive_write_finish_entry(disk.get());
    }
    archive_write_close(disk.get());
}

int main(int argc, char* argv[]) {
    if (argc != 3) {
        std::cerr << "Uso: " << argv[0] << " archivio destinazione\n";
        return 1;
    }
    try {
        extract_safely(argv[1], argv[2]);
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << '\n';
        return 1;
    }
}

Riscrivere il percorso anteponendo la destinazione, invece di cambiare la directory di lavoro del processo con chdir, rende la funzione utilizzabile anche in programmi multithread. Proprio perché il percorso finale è assoluto, il flag ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS non è utilizzabile: il controllo sui percorsi assoluti e sui componenti .. viene quindi fatto esplicitamente sul nome originale della voce, mentre ARCHIVE_EXTRACT_SECURE_NODOTDOT resta come seconda linea di difesa sul percorso finale e ARCHIVE_EXTRACT_SECURE_SYMLINKS impedisce di scrivere attraverso link simbolici già presenti su disco.

Conclusioni

In C++ la compressione richiede più lavoro che negli altri linguaggi, ma offre in cambio il controllo completo su memoria, buffer e parametri, e l'accesso diretto alle stesse librerie su cui si appoggiano tutti gli altri runtime. La chiave per un codice robusto sta nel C++ moderno: classi RAII o std::unique_ptr con deleter per ogni risorsa delle librerie C, std::span per passare i buffer in modo sicuro, eccezioni per trasformare i codici di errore in condizioni impossibili da ignorare e, come in tutta la serie, limiti espliciti sull'output e validazione dei percorsi quando si trattano dati provenienti dall'esterno.