zip_algorithm_xz.c File Reference

#include "zipint.h"
#include <limits.h>
#include <lzma.h>
#include <stdlib.h>
#include <zlib.h>

Go to the source code of this file.

Classes
struct	ctx

Macros
#define	HEADER_BYTES_ZIP   9
#define	HEADER_MAGIC_LENGTH   4
#define	HEADER_MAGIC1_OFFSET   0
#define	HEADER_MAGIC2_OFFSET   2
#define	HEADER_SIZE_OFFSET   9
#define	HEADER_SIZE_LENGTH   8
#define	HEADER_PARAMETERS_LENGTH   5
#define	HEADER_LZMA_ALONE_LENGTH   (HEADER_PARAMETERS_LENGTH + HEADER_SIZE_LENGTH)

Enumerations
enum	header_state { INCOMPLETE , OUTPUT , DONE }

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, zip_uint16_t method)
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 (lzma_ret 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_xz_compress
zip_compression_algorithm_t	zip_algorithm_xz_decompress

Macro Definition Documentation

HEADER_BYTES_ZIP

#define HEADER_BYTES_ZIP   9

Definition at line 44 of file zip_algorithm_xz.c.

HEADER_LZMA_ALONE_LENGTH

#define HEADER_LZMA_ALONE_LENGTH   (HEADER_PARAMETERS_LENGTH + HEADER_SIZE_LENGTH)

Definition at line 51 of file zip_algorithm_xz.c.

HEADER_MAGIC1_OFFSET

#define HEADER_MAGIC1_OFFSET   0

Definition at line 46 of file zip_algorithm_xz.c.

HEADER_MAGIC2_OFFSET

#define HEADER_MAGIC2_OFFSET   2

Definition at line 47 of file zip_algorithm_xz.c.

HEADER_MAGIC_LENGTH

#define HEADER_MAGIC_LENGTH   4

Definition at line 45 of file zip_algorithm_xz.c.

HEADER_PARAMETERS_LENGTH

#define HEADER_PARAMETERS_LENGTH   5

Definition at line 50 of file zip_algorithm_xz.c.

HEADER_SIZE_LENGTH

#define HEADER_SIZE_LENGTH   8

Definition at line 49 of file zip_algorithm_xz.c.

HEADER_SIZE_OFFSET

#define HEADER_SIZE_OFFSET   9

Definition at line 48 of file zip_algorithm_xz.c.

Enumeration Type Documentation

header_state

enum header_state

Enumerator
INCOMPLETE
OUTPUT
DONE

Definition at line 42 of file zip_algorithm_xz.c.

{ INCOMPLETE, OUTPUT, DONE };

Function Documentation

allocate()

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

static

Definition at line 107 of file zip_algorithm_xz.c.

                                                                                        {
    struct ctx *ctx;
 
    if ((ctx = (struct ctx *)malloc(sizeof(*ctx))) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    ctx->error = error;
    ctx->compress = compress;
    if (compression_flags < 0 || compression_flags > 9) {
        ctx->compression_flags = 6; /* default value */
    } else {
    ctx->compression_flags = (zip_uint32_t)compression_flags;
    }
    ctx->compression_flags |= LZMA_PRESET_EXTREME;
    ctx->end_of_input = false;
    memset(ctx->header, 0, sizeof(ctx->header));
    ctx->header_bytes_offset = 0;
    if (ZIP_CM_LZMA) {
        ctx->header_state = INCOMPLETE;
    }
    else {
        ctx->header_state = DONE;
    }
    memset(&ctx->zstr, 0, sizeof(ctx->zstr));
    ctx->method = method;
    return ctx;
}

References ctx::compress, compress(), ctx::compression_flags, DONE, ctx::end_of_input, ctx::error, error(), ctx::header, ctx::header_bytes_offset, ctx::header_state, INCOMPLETE, LZMA_PRESET_EXTREME, malloc(), memset(), ctx::method, NULL, ZIP_CM_LZMA, ZIP_ER_MEMORY, zip_error_set(), and ctx::zstr.

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 139 of file zip_algorithm_xz.c.

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

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

deallocate()

static void deallocate ( void *  ud )

static

Definition at line 151 of file zip_algorithm_xz.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 145 of file zip_algorithm_xz.c.

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

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

end()

static bool end ( void *  ud )

static

Definition at line 240 of file zip_algorithm_xz.c.

              {
    struct ctx *ctx = (struct ctx *)ud;
 
    lzma_end(&ctx->zstr);
    return true;
}

References ctx::zstr.

end_of_input()

static void end_of_input ( void *  ud )

static

Definition at line 306 of file zip_algorithm_xz.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 158 of file zip_algorithm_xz.c.

                                    {
    struct ctx *ctx = (struct ctx *)ud;
 
    if (!ctx->compress) {
        return 0;
    }
 
    if (ctx->method == ZIP_CM_LZMA) {
        /* liblzma always returns an EOS/EOPM marker, see
     * https://sourceforge.net/p/lzmautils/discussion/708858/thread/84c5dbb9/#a5e4/3764 */
    return 1 << 1;
    }
    return 0;
}

References ctx::compress, ctx::method, and ZIP_CM_LZMA.

input()

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

static

Definition at line 249 of file zip_algorithm_xz.c.

                                                        {
    struct ctx *ctx = (struct ctx *)ud;
 
    if (length > UINT_MAX || ctx->zstr.avail_in > 0) {
        zip_error_set(ctx->error, ZIP_ER_INVAL, 0);
        return false;
    }
 
    /* For decompression of LZMA1: Have we read the full "lzma alone" header yet? */
    if (ctx->method == ZIP_CM_LZMA && !ctx->compress && ctx->header_state == INCOMPLETE) {
        /* if not, get more of the data */
        zip_uint8_t got = (zip_uint8_t)ZIP_MIN(HEADER_BYTES_ZIP - ctx->header_bytes_offset, length);
        memcpy(ctx->header + ctx->header_bytes_offset, data, got);
        ctx->header_bytes_offset += got;
        length -= got;
        data += got;
        /* Do we have a complete header now? */
        if (ctx->header_bytes_offset == HEADER_BYTES_ZIP) {
            Bytef empty_buffer[1];
            zip_buffer_t *buffer;
            /* check magic */
            if (ctx->header[HEADER_MAGIC2_OFFSET] != 0x05 || ctx->header[HEADER_MAGIC2_OFFSET + 1] != 0x00) {
                /* magic does not match */
                zip_error_set(ctx->error, ZIP_ER_COMPRESSED_DATA, 0);
                return false;
            }
            /* set size of uncompressed data in "lzma alone" header to "unknown" */
            if ((buffer = _zip_buffer_new(ctx->header + HEADER_SIZE_OFFSET, HEADER_SIZE_LENGTH)) == NULL) {
                zip_error_set(ctx->error, ZIP_ER_MEMORY, 0);
                return false;
            }
            _zip_buffer_put_64(buffer, ctx->uncompresssed_size);
            _zip_buffer_free(buffer);
            /* Feed header into "lzma alone" decoder, for
             * initialization; this should not produce output. */
            ctx->zstr.next_in = (void *)(ctx->header + HEADER_MAGIC_LENGTH);
            ctx->zstr.avail_in = HEADER_LZMA_ALONE_LENGTH;
            ctx->zstr.total_in = 0;
            ctx->zstr.next_out = empty_buffer;
            ctx->zstr.avail_out = sizeof(*empty_buffer);
            ctx->zstr.total_out = 0;
            /* this just initializes the decoder and does not produce output, so it consumes the complete header */
            if (lzma_code(&ctx->zstr, LZMA_RUN) != LZMA_OK || ctx->zstr.total_out > 0) {
                zip_error_set(ctx->error, ZIP_ER_COMPRESSED_DATA, 0);
                return false;
            }
            ctx->header_state = DONE;
        }
    }
    ctx->zstr.avail_in = (uInt)length;
    ctx->zstr.next_in = (Bytef *)data;
 
    return true;
}

References _zip_buffer_free(), _zip_buffer_new(), _zip_buffer_put_64(), ctx::compress, DONE, ctx::error, ctx::header, ctx::header_bytes_offset, HEADER_BYTES_ZIP, HEADER_LZMA_ALONE_LENGTH, HEADER_MAGIC2_OFFSET, HEADER_MAGIC_LENGTH, HEADER_SIZE_LENGTH, HEADER_SIZE_OFFSET, ctx::header_state, INCOMPLETE, length, LZMA_OK, LZMA_RUN, memcpy(), ctx::method, NULL, UINT_MAX, ctx::uncompresssed_size, ZIP_CM_LZMA, ZIP_ER_COMPRESSED_DATA, ZIP_ER_INVAL, ZIP_ER_MEMORY, zip_error_set(), ZIP_MIN, and ctx::zstr.

map_error()

static int map_error ( lzma_ret  ret )

static

Definition at line 174 of file zip_algorithm_xz.c.

                        {
    switch (ret) {
    case LZMA_DATA_ERROR:
    case LZMA_UNSUPPORTED_CHECK:
        return ZIP_ER_COMPRESSED_DATA;
 
    case LZMA_MEM_ERROR:
        return ZIP_ER_MEMORY;
 
    case LZMA_OPTIONS_ERROR:
        return ZIP_ER_INVAL;
 
    default:
        return ZIP_ER_INTERNAL;
    }
}

References LZMA_DATA_ERROR, LZMA_MEM_ERROR, LZMA_OPTIONS_ERROR, LZMA_UNSUPPORTED_CHECK, ZIP_ER_COMPRESSED_DATA, ZIP_ER_INTERNAL, ZIP_ER_INVAL, and ZIP_ER_MEMORY.

Referenced by process(), and start().

maximum_compressed_size()

static zip_uint64_t maximum_compressed_size ( zip_uint64_t  uncompressed_size )

static

Definition at line 86 of file zip_algorithm_xz.c.

                                                        {
    /*
     According to https://sourceforge.net/p/sevenzip/discussion/45797/thread/b6bd62f8/
 
     1) you can use
     outSize = 1.10 * originalSize + 64 KB.
     in most cases outSize is less then 1.02 from originalSize.
     2) You can try LZMA2, where
     outSize can be = 1.001 * originalSize + 1 KB.
     */
    /* 13 bytes added for lzma alone header */
    zip_uint64_t compressed_size = (zip_uint64_t)((double)uncompressed_size * 1.1) + 64 * 1024 + 13;
 
    if (compressed_size < uncompressed_size) {
        return ZIP_UINT64_MAX;
    }
    return compressed_size;
}

References compressed_size, uncompressed_size, and ZIP_UINT64_MAX.

process()

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

static

Definition at line 314 of file zip_algorithm_xz.c.

                                                           {
    struct ctx *ctx = (struct ctx *)ud;
    lzma_ret ret;
    /* for compression of LZMA1 */
    if (ctx->method == ZIP_CM_LZMA && ctx->compress) {
        if (ctx->header_state == INCOMPLETE) {
            /* write magic to output buffer */
            ctx->header[0] = 0x09;
            ctx->header[1] = 0x14;
            ctx->header[2] = 0x05;
            ctx->header[3] = 0x00;
            /* generate lzma parameters into output buffer */
            ctx->zstr.avail_out = HEADER_LZMA_ALONE_LENGTH;
            ctx->zstr.next_out = ctx->header + HEADER_MAGIC_LENGTH;
            ret = lzma_code(&ctx->zstr, LZMA_RUN);
            if (ret != LZMA_OK || ctx->zstr.avail_out != 0) {
                /* assume that the whole header will be provided with the first call to lzma_code */
                return ZIP_COMPRESSION_ERROR;
            }
            ctx->header_state = OUTPUT;
        }
        if (ctx->header_state == OUTPUT) {
            /* write header */
            zip_uint8_t write_len = (zip_uint8_t)ZIP_MIN(HEADER_BYTES_ZIP - ctx->header_bytes_offset, *length);
            memcpy(data, ctx->header + ctx->header_bytes_offset, write_len);
            ctx->header_bytes_offset += write_len;
            *length = write_len;
            if (ctx->header_bytes_offset == HEADER_BYTES_ZIP) {
                ctx->header_state = DONE;
            }
            return ZIP_COMPRESSION_OK;
        }
    }
 
    ctx->zstr.avail_out = (uInt)ZIP_MIN(UINT_MAX, *length);
    ctx->zstr.next_out = (Bytef *)data;
 
    ret = lzma_code(&ctx->zstr, ctx->end_of_input ? LZMA_FINISH : LZMA_RUN);
    *length = *length - ctx->zstr.avail_out;
 
    switch (ret) {
    case LZMA_OK:
        return ZIP_COMPRESSION_OK;
 
    case LZMA_STREAM_END:
        return ZIP_COMPRESSION_END;
 
    case LZMA_BUF_ERROR:
        if (ctx->zstr.avail_in == 0) {
            return ZIP_COMPRESSION_NEED_DATA;
        }
 
        /* fallthrough */
    default:
        zip_error_set(ctx->error, map_error(ret), 0);
        return ZIP_COMPRESSION_ERROR;
    }
}

References ctx::compress, DONE, ctx::end_of_input, ctx::error, ctx::header, ctx::header_bytes_offset, HEADER_BYTES_ZIP, HEADER_LZMA_ALONE_LENGTH, HEADER_MAGIC_LENGTH, ctx::header_state, INCOMPLETE, length, LZMA_BUF_ERROR, LZMA_FINISH, LZMA_OK, LZMA_RUN, LZMA_STREAM_END, map_error(), memcpy(), ctx::method, OUTPUT, UINT_MAX, ZIP_CM_LZMA, ZIP_COMPRESSION_END, ZIP_COMPRESSION_ERROR, ZIP_COMPRESSION_NEED_DATA, ZIP_COMPRESSION_OK, zip_error_set(), ZIP_MIN, and ctx::zstr.

start()

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

static

Definition at line 193 of file zip_algorithm_xz.c.

                                                                   {
    struct ctx *ctx = (struct ctx *)ud;
    lzma_ret ret;
 
    lzma_options_lzma opt_lzma;
    lzma_lzma_preset(&opt_lzma, ctx->compression_flags);
    lzma_filter filters[] = {
        {.id = (ctx->method == ZIP_CM_LZMA ? LZMA_FILTER_LZMA1 : LZMA_FILTER_LZMA2), .options = &opt_lzma},
        {.id = LZMA_VLI_UNKNOWN, .options = NULL},
    };
 
    ctx->zstr.avail_in = 0;
    ctx->zstr.next_in = NULL;
    ctx->zstr.avail_out = 0;
    ctx->zstr.next_out = NULL;
 
    if (ctx->compress) {
        if (ctx->method == ZIP_CM_LZMA)
            ret = lzma_alone_encoder(&ctx->zstr, filters[0].options);
        else
            ret = lzma_stream_encoder(&ctx->zstr, filters, LZMA_CHECK_CRC64);
    }
    else {
        if (ctx->method == ZIP_CM_LZMA)
            ret = lzma_alone_decoder(&ctx->zstr, UINT64_MAX);
        else
            ret = lzma_stream_decoder(&ctx->zstr, UINT64_MAX, LZMA_CONCATENATED);
    }
 
    if (ret != LZMA_OK) {
        zip_error_set(ctx->error, map_error(ret), 0);
        return false;
    }
 
    /* If general purpose bits 1 & 2 are both zero, write real uncompressed size in header. */
    if ((attributes->valid & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS) && (attributes->general_purpose_bit_mask & 0x6) == 0x6 && (attributes->general_purpose_bit_flags & 0x06) == 0 && (st->valid & ZIP_STAT_SIZE)) {
        ctx->uncompresssed_size = st->size;
    }
    else {
        ctx->uncompresssed_size = ZIP_UINT64_MAX;
    }
 
    return true;
}

References ctx::compress, ctx::compression_flags, ctx::error, filters, zip_file_attributes::general_purpose_bit_flags, zip_file_attributes::general_purpose_bit_mask, lzma_filter::id, LZMA_CHECK_CRC64, LZMA_CONCATENATED, LZMA_FILTER_LZMA1, LZMA_FILTER_LZMA2, LZMA_OK, LZMA_VLI_UNKNOWN, map_error(), ctx::method, NULL, opt_lzma, options, lzma_filter::options, zip_stat::size, UINT64_MAX, ctx::uncompresssed_size, zip_stat::valid, zip_file_attributes::valid, ZIP_CM_LZMA, zip_error_set(), ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS, ZIP_STAT_SIZE, ZIP_UINT64_MAX, and ctx::zstr.

Variable Documentation

zip_algorithm_xz_compress

zip_compression_algorithm_t zip_algorithm_xz_compress

Initial value:

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

Definition at line 379 of file zip_algorithm_xz.c.

zip_algorithm_xz_decompress

zip_compression_algorithm_t zip_algorithm_xz_decompress

Initial value:

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

Definition at line 393 of file zip_algorithm_xz.c.