zip_algorithm_zstd.c File Reference

#include "zipint.h"
#include <limits.h>
#include <stdlib.h>
#include <zstd.h>
#include <zstd_errors.h>

Go to the source code of this file.

Classes
struct	ctx

Functions
static zip_uint64_t	maximum_compressed_size (zip_uint64_t uncompressed_size)
static void *	allocate (bool compress, int compression_flags, zip_error_t *error)
static void *	compress_allocate (zip_uint16_t method, int compression_flags, zip_error_t *error)
static void *	decompress_allocate (zip_uint16_t method, int compression_flags, zip_error_t *error)
static void	deallocate (void *ud)
static zip_uint16_t	general_purpose_bit_flags (void *ud)
static int	map_error (size_t ret)
static bool	start (void *ud, zip_stat_t *st, zip_file_attributes_t *attributes)
static bool	end (void *ud)
static bool	input (void *ud, zip_uint8_t *data, zip_uint64_t length)
static void	end_of_input (void *ud)
static zip_compression_status_t	process (void *ud, zip_uint8_t *data, zip_uint64_t *length)

Variables
zip_compression_algorithm_t	zip_algorithm_zstd_compress
zip_compression_algorithm_t	zip_algorithm_zstd_decompress

Function Documentation

allocate()

static void* allocate ( bool  compress, int  compression_flags, zip_error_t *  error  )

static

Definition at line 59 of file zip_algorithm_zstd.c.

                                                                   {
    struct ctx *ctx;
 
    /* 0: let zstd choose */
    if (compression_flags < ZSTD_minCLevel() || compression_flags > ZSTD_maxCLevel()) {
        compression_flags = 0;
    }
 
    if ((ctx = (struct ctx *)malloc(sizeof(*ctx))) == NULL) {
        return NULL;
    }
 
    ctx->error = error;
    ctx->compress = compress;
    ctx->compression_flags = compression_flags;
    ctx->end_of_input = false;
 
    ctx->zdstream = NULL;
    ctx->zcstream = NULL;
    ctx->in.src = NULL;
    ctx->in.pos = 0;
    ctx->in.size = 0;
    ctx->out.dst = NULL;
    ctx->out.pos = 0;
    ctx->out.size = 0;
 
    return ctx;
}

References ctx::compress, compress(), ctx::compression_flags, ctx::end_of_input, ctx::error, error(), ctx::in, malloc(), NULL, ctx::out, ctx::zcstream, and ctx::zdstream.

Referenced by compress_allocate(), and decompress_allocate().

compress_allocate()

static void* compress_allocate ( zip_uint16_t  method, int  compression_flags, zip_error_t *  error  )

static

Definition at line 90 of file zip_algorithm_zstd.c.

                                                                                  {
    return allocate(true, compression_flags, error);
}

References allocate(), ctx::compression_flags, and error().

deallocate()

static void deallocate ( void *  ud )

static

Definition at line 102 of file zip_algorithm_zstd.c.

                     {
    struct ctx *ctx = (struct ctx *)ud;
    free(ctx);
}

References free().

decompress_allocate()

static void* decompress_allocate ( zip_uint16_t  method, int  compression_flags, zip_error_t *  error  )

static

Definition at line 96 of file zip_algorithm_zstd.c.

                                                                                    {
    return allocate(false, compression_flags, error);
}

References allocate(), ctx::compression_flags, and error().

end()

static bool end ( void *  ud )

static

Definition at line 174 of file zip_algorithm_zstd.c.

              {
    struct ctx *ctx = (struct ctx *)ud;
    size_t ret;
 
    if (ctx->compress) {
        ret = ZSTD_freeCStream(ctx->zcstream);
        ctx->zcstream = NULL;
    }
    else {
        ret = ZSTD_freeDStream(ctx->zdstream);
        ctx->zdstream = NULL;
    }
 
    if (ZSTD_isError(ret)) {
        zip_error_set(ctx->error, map_error(ret), 0);
        return false;
    }
 
    return true;
}

References ctx::compress, ctx::error, map_error(), NULL, ctx::zcstream, ctx::zdstream, and zip_error_set().

end_of_input()

static void end_of_input ( void *  ud )

static

Definition at line 211 of file zip_algorithm_zstd.c.

                       {
    struct ctx *ctx = (struct ctx *)ud;
 
    ctx->end_of_input = true;
}

References ctx::end_of_input.

general_purpose_bit_flags()

static zip_uint16_t general_purpose_bit_flags ( void *  ud )

static

Definition at line 109 of file zip_algorithm_zstd.c.

                                    {
    /* struct ctx *ctx = (struct ctx *)ud; */
    return 0;
}

input()

static bool input ( void *  ud, zip_uint8_t *  data, zip_uint64_t  length  )

static

Definition at line 197 of file zip_algorithm_zstd.c.

                                                        {
    struct ctx *ctx = (struct ctx *)ud;
    if (length > SIZE_MAX || ctx->in.pos != ctx->in.size) {
        zip_error_set(ctx->error, ZIP_ER_INVAL, 0);
        return false;
    }
    ctx->in.src = (const void *)data;
    ctx->in.size = (size_t)length;
    ctx->in.pos = 0;
    return true;
}

References ctx::error, ctx::in, length, SIZE_MAX, ZIP_ER_INVAL, and zip_error_set().

map_error()

static int map_error ( size_t  ret )

static

Definition at line 115 of file zip_algorithm_zstd.c.

                      {
    switch (ret) {
    case ZSTD_error_no_error:
        return ZIP_ER_OK;
 
    case ZSTD_error_corruption_detected:
    case ZSTD_error_checksum_wrong:
    case ZSTD_error_dictionary_corrupted:
    case ZSTD_error_dictionary_wrong:
        return ZIP_ER_COMPRESSED_DATA;
 
    case ZSTD_error_memory_allocation:
        return ZIP_ER_MEMORY;
 
    case ZSTD_error_parameter_unsupported:
    case ZSTD_error_parameter_outOfBound:
        return ZIP_ER_INVAL;
 
    default:
        return ZIP_ER_INTERNAL;
    }
}

References ZIP_ER_COMPRESSED_DATA, ZIP_ER_INTERNAL, ZIP_ER_INVAL, ZIP_ER_MEMORY, and ZIP_ER_OK.

Referenced by end(), process(), and start().

maximum_compressed_size()

static zip_uint64_t maximum_compressed_size ( zip_uint64_t  uncompressed_size )

static

Definition at line 53 of file zip_algorithm_zstd.c.

                                                        {
    return ZSTD_compressBound(uncompressed_size);
}

References uncompressed_size.

process()

static zip_compression_status_t process ( void *  ud, zip_uint8_t *  data, zip_uint64_t *  length  )

static

Definition at line 219 of file zip_algorithm_zstd.c.

                                                           {
    struct ctx *ctx = (struct ctx *)ud;
 
    size_t ret;
 
    if (ctx->in.pos == ctx->in.size && !ctx->end_of_input) {
        *length = 0;
        return ZIP_COMPRESSION_NEED_DATA;
    }
 
    ctx->out.dst = data;
    ctx->out.pos = 0;
    ctx->out.size = ZIP_MIN(SIZE_MAX, *length);
 
    if (ctx->compress) {
        if (ctx->in.pos == ctx->in.size && ctx->end_of_input) {
            ret = ZSTD_endStream(ctx->zcstream, &ctx->out);
            if (ret == 0) {
                *length = ctx->out.pos;
                return ZIP_COMPRESSION_END;
            }
        }
        else {
            ret = ZSTD_compressStream(ctx->zcstream, &ctx->out, &ctx->in);
        }
    }
    else {
        ret = ZSTD_decompressStream(ctx->zdstream, &ctx->out, &ctx->in);
    }
    if (ZSTD_isError(ret)) {
        zip_error_set(ctx->error, map_error(ret), 0);
        return ZIP_COMPRESSION_ERROR;
    }
 
    *length = ctx->out.pos;
    if (ctx->in.pos == ctx->in.size) {
        return ZIP_COMPRESSION_NEED_DATA;
    }
 
    return ZIP_COMPRESSION_OK;
}

References ctx::compress, ctx::end_of_input, ctx::error, ctx::in, length, map_error(), ctx::out, SIZE_MAX, ctx::zcstream, ctx::zdstream, ZIP_COMPRESSION_END, ZIP_COMPRESSION_ERROR, ZIP_COMPRESSION_NEED_DATA, ZIP_COMPRESSION_OK, zip_error_set(), and ZIP_MIN.

start()

static bool start ( void *  ud, zip_stat_t *  st, zip_file_attributes_t *  attributes  )

static

Definition at line 140 of file zip_algorithm_zstd.c.

                                                                   {
    struct ctx *ctx = (struct ctx *)ud;
    ctx->in.src = NULL;
    ctx->in.pos = 0;
    ctx->in.size = 0;
    ctx->out.dst = NULL;
    ctx->out.pos = 0;
    ctx->out.size = 0;
    if (ctx->compress) {
        size_t ret;
        ctx->zcstream = ZSTD_createCStream();
        if (ctx->zcstream == NULL) {
            zip_error_set(ctx->error, ZIP_ER_MEMORY, 0);
            return false;
        }
        ret = ZSTD_initCStream(ctx->zcstream, ctx->compression_flags);
        if (ZSTD_isError(ret)) {
            zip_error_set(ctx->error, ZIP_ER_ZLIB, map_error(ret));
            return false;
        }
    }
    else {
        ctx->zdstream = ZSTD_createDStream();
        if (ctx->zdstream == NULL) {
            zip_error_set(ctx->error, ZIP_ER_MEMORY, 0);
            return false;
        }
    }
 
    return true;
}

References ctx::compress, ctx::compression_flags, ctx::error, ctx::in, map_error(), NULL, ctx::out, ctx::zcstream, ctx::zdstream, ZIP_ER_MEMORY, ZIP_ER_ZLIB, and zip_error_set().

Variable Documentation

zip_algorithm_zstd_compress

zip_compression_algorithm_t zip_algorithm_zstd_compress

Initial value:

= {
    maximum_compressed_size,
    compress_allocate,
    deallocate,
    general_purpose_bit_flags,
    20,
    start,
    end,
    input,
    end_of_input,
    process
}

Definition at line 267 of file zip_algorithm_zstd.c.

zip_algorithm_zstd_decompress

zip_compression_algorithm_t zip_algorithm_zstd_decompress

Initial value:

= {
    maximum_compressed_size,
    decompress_allocate,
    deallocate,
    general_purpose_bit_flags,
    20,
    start,
    end,
    input,
    end_of_input,
    process
}

Definition at line 281 of file zip_algorithm_zstd.c.