zip_source_compress.c File Reference

#include <stdlib.h>
#include <string.h>
#include "zipint.h"

Go to the source code of this file.

Classes
struct	context
struct	implementation

Functions
static zip_source_t *	compression_source_new (zip_t *za, zip_source_t *src, zip_int32_t method, bool compress, int compression_flags)
static zip_int64_t	compress_callback (zip_source_t *, void *, void *, zip_uint64_t, zip_source_cmd_t)
static void	context_free (struct context *ctx)
static struct context *	context_new (zip_int32_t method, bool compress, int compression_flags, zip_compression_algorithm_t *algorithm)
static zip_int64_t	compress_read (zip_source_t *, struct context *, void *, zip_uint64_t)
zip_compression_algorithm_t *	_zip_get_compression_algorithm (zip_int32_t method, bool compress)
ZIP_EXTERN int	zip_compression_method_supported (zip_int32_t method, int compress)
zip_source_t *	zip_source_compress (zip_t *za, zip_source_t *src, zip_int32_t method, int compression_flags)
zip_source_t *	zip_source_decompress (zip_t *za, zip_source_t *src, zip_int32_t method)

Variables
static struct implementation	implementations []
static size_t	implementations_size = sizeof(implementations) / sizeof(implementations[0])

Function Documentation

_zip_get_compression_algorithm()

zip_compression_algorithm_t* _zip_get_compression_algorithm	(	zip_int32_t	method,
		bool	compress
	)

Definition at line 93 of file zip_source_compress.c.

                                                                  {
    size_t i;
    zip_uint16_t real_method = ZIP_CM_ACTUAL(method);
 
    for (i = 0; i < implementations_size; i++) {
        if (implementations[i].method == real_method) {
            if (compress) {
                return implementations[i].compress;
            }
            else {
                return implementations[i].decompress;
            }
        }
    }
 
    return NULL;
}

References implementation::compress, compress(), implementation::decompress, i, implementations, implementations_size, context::method, NULL, and ZIP_CM_ACTUAL.

Referenced by add_data(), compression_source_new(), and zip_compression_method_supported().

compress_callback()

static zip_int64_t compress_callback ( zip_source_t *  src, void *  ud, void *  data, zip_uint64_t  len, zip_source_cmd_t  cmd  )

static

Definition at line 305 of file zip_source_compress.c.

                                                                                                   {
    struct context *ctx;
 
    ctx = (struct context *)ud;
 
    switch (cmd) {
    case ZIP_SOURCE_OPEN: {
        zip_stat_t st;
        zip_file_attributes_t attributes;
        
        ctx->size = 0;
        ctx->end_of_input = false;
        ctx->end_of_stream = false;
        ctx->is_stored = false;
        ctx->first_read = -1;
        
        if (zip_source_stat(src, &st) < 0 || zip_source_get_file_attributes(src, &attributes) < 0) {
            _zip_error_set_from_source(&ctx->error, src);
            return -1;
        }
 
        if (!ctx->algorithm->start(ctx->ud, &st, &attributes)) {
            return -1;
        }
 
        return 0;
    }
 
    case ZIP_SOURCE_READ:
        return compress_read(src, ctx, data, len);
 
    case ZIP_SOURCE_CLOSE:
        if (!ctx->algorithm->end(ctx->ud)) {
            return -1;
        }
        return 0;
 
    case ZIP_SOURCE_STAT: {
        zip_stat_t *st;
 
        st = (zip_stat_t *)data;
 
        if (ctx->compress) {
            if (ctx->end_of_stream) {
                st->comp_method = ctx->is_stored ? ZIP_CM_STORE : ZIP_CM_ACTUAL(ctx->method);
                st->comp_size = ctx->size;
                st->valid |= ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD;
            }
            else {
                st->valid &= ~(ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD);
            }
        }
        else {
            st->comp_method = ZIP_CM_STORE;
            st->valid |= ZIP_STAT_COMP_METHOD;
            if (ctx->end_of_stream) {
                st->size = ctx->size;
                st->valid |= ZIP_STAT_SIZE;
            }
        }
    }
        return 0;
 
    case ZIP_SOURCE_ERROR:
        return zip_error_to_data(&ctx->error, data, len);
 
    case ZIP_SOURCE_FREE:
        context_free(ctx);
        return 0;
 
    case ZIP_SOURCE_GET_FILE_ATTRIBUTES: {
        zip_file_attributes_t *attributes = (zip_file_attributes_t *)data;
 
        if (len < sizeof(*attributes)) {
            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
            return -1;
        }
 
        attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED | ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS;
        attributes->version_needed = ctx->algorithm->version_needed;
        attributes->general_purpose_bit_mask = ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK;
        attributes->general_purpose_bit_flags = (ctx->is_stored ? 0 : ctx->algorithm->general_purpose_bit_flags(ctx->ud));
 
        return sizeof(*attributes);
    }
 
    case ZIP_SOURCE_SUPPORTS:
        return ZIP_SOURCE_SUPPORTS_READABLE | zip_source_make_command_bitmap(ZIP_SOURCE_GET_FILE_ATTRIBUTES, -1);
 
    default:
        zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
        return -1;
    }
}

References _zip_error_set_from_source(), cmd, zip_stat::comp_method, zip_stat::comp_size, ctx::compress, compress_read(), context_free(), ctx::end_of_input, ctx::error, zip_file_attributes::general_purpose_bit_flags, zip_file_attributes::general_purpose_bit_mask, len, ctx::method, zip_stat::size, src, context::ud, zip_stat::valid, zip_file_attributes::valid, zip_file_attributes::version_needed, ZIP_CM_ACTUAL, ZIP_CM_STORE, ZIP_ER_INTERNAL, ZIP_ER_INVAL, zip_error_set(), zip_error_to_data(), ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS, ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK, ZIP_FILE_ATTRIBUTES_VERSION_NEEDED, ZIP_SOURCE_CLOSE, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_GET_FILE_ATTRIBUTES, zip_source_get_file_attributes(), zip_source_make_command_bitmap(), ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_STAT, zip_source_stat(), ZIP_SOURCE_SUPPORTS, ZIP_SOURCE_SUPPORTS_READABLE, ZIP_STAT_COMP_METHOD, ZIP_STAT_COMP_SIZE, and ZIP_STAT_SIZE.

Referenced by compression_source_new().

compress_read()

static zip_int64_t compress_read ( zip_source_t *  src, struct context *  ctx, void *  data, zip_uint64_t  len  )

static

Definition at line 200 of file zip_source_compress.c.

                                                                                    {
    zip_compression_status_t ret;
    bool end;
    zip_int64_t n;
    zip_uint64_t out_offset;
    zip_uint64_t out_len;
 
    if (zip_error_code_zip(&ctx->error) != ZIP_ER_OK) {
        return -1;
    }
 
    if (len == 0 || ctx->end_of_stream) {
        return 0;
    }
 
    out_offset = 0;
 
    end = false;
    while (!end && out_offset < len) {
        out_len = len - out_offset;
        ret = ctx->algorithm->process(ctx->ud, (zip_uint8_t *)data + out_offset, &out_len);
 
        if (ret != ZIP_COMPRESSION_ERROR) {
            out_offset += out_len;
        }
 
        switch (ret) {
        case ZIP_COMPRESSION_END:
            ctx->end_of_stream = true;
 
            if (!ctx->end_of_input) {
                /* TODO: garbage after stream, or compression ended before all data read */
            }
 
            if (ctx->first_read < 0) {
                /* we got end of processed stream before reading any input data */
                zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
                end = true;
                break;
            }
            if (ctx->can_store && (zip_uint64_t)ctx->first_read <= out_offset) {
                ctx->is_stored = true;
                ctx->size = (zip_uint64_t)ctx->first_read;
                memcpy(data, ctx->buffer, ctx->size);
                return (zip_int64_t)ctx->size;
            }
            end = true;
            break;
 
        case ZIP_COMPRESSION_OK:
            break;
 
        case ZIP_COMPRESSION_NEED_DATA:
            if (ctx->end_of_input) {
                /* TODO: error: stream not ended, but no more input */
                end = true;
                break;
            }
 
            if ((n = zip_source_read(src, ctx->buffer, sizeof(ctx->buffer))) < 0) {
                _zip_error_set_from_source(&ctx->error, src);
                end = true;
                break;
            }
            else if (n == 0) {
                ctx->end_of_input = true;
                ctx->algorithm->end_of_input(ctx->ud);
                if (ctx->first_read < 0) {
                    ctx->first_read = 0;
                }
            }
            else {
                if (ctx->first_read >= 0) {
                    /* we overwrote a previously filled ctx->buffer */
                    ctx->can_store = false;
                }
                else {
                    ctx->first_read = n;
                }
 
                ctx->algorithm->input(ctx->ud, ctx->buffer, (zip_uint64_t)n);
            }
            break;
 
        case ZIP_COMPRESSION_ERROR:
            /* error set by algorithm */
            if (zip_error_code_zip(&ctx->error) == ZIP_ER_OK) {
                zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
            }
            end = true;
            break;
        }
    }
 
    if (out_offset > 0) {
        ctx->can_store = false;
        ctx->size += out_offset;
        return (zip_int64_t)out_offset;
    }
 
    return (zip_error_code_zip(&ctx->error) == ZIP_ER_OK) ? 0 : -1;
}

References _zip_error_set_from_source(), test_evm::end, ctx::end_of_input, ctx::error, len, memcpy(), n, src, ZIP_COMPRESSION_END, ZIP_COMPRESSION_ERROR, ZIP_COMPRESSION_NEED_DATA, ZIP_COMPRESSION_OK, ZIP_ER_INTERNAL, ZIP_ER_OK, zip_error_code_zip(), zip_error_set(), and zip_source_read().

Referenced by compress_callback().

compression_source_new()

static zip_source_t * compression_source_new ( zip_t *  za, zip_source_t *  src, zip_int32_t  method, bool  compress, int  compression_flags  )

static

Definition at line 131 of file zip_source_compress.c.

                                                                                                               {
    struct context *ctx;
    zip_source_t *s2;
    zip_compression_algorithm_t *algorithm = NULL;
 
    if (src == NULL) {
        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
        return NULL;
    }
 
    if ((algorithm = _zip_get_compression_algorithm(method, compress)) == NULL) {
        zip_error_set(&za->error, ZIP_ER_COMPNOTSUPP, 0);
        return NULL;
    }
 
    if ((ctx = context_new(method, compress, compression_flags, algorithm)) == NULL) {
        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    if ((s2 = zip_source_layered(za, src, compress_callback, ctx)) == NULL) {
        context_free(ctx);
        return NULL;
    }
 
    return s2;
}

References _zip_get_compression_algorithm(), context::algorithm, compress(), compress_callback(), context_free(), context_new(), zip::error, context::method, NULL, s2, src, za, ZIP_ER_COMPNOTSUPP, ZIP_ER_INVAL, ZIP_ER_MEMORY, zip_error_set(), and zip_source_layered().

Referenced by zip_source_compress(), and zip_source_decompress().

context_free()

static void context_free ( struct context *  ctx )

static

Definition at line 187 of file zip_source_compress.c.

                                  {
    if (ctx == NULL) {
        return;
    }
 
    ctx->algorithm->deallocate(ctx->ud);
    zip_error_fini(&ctx->error);
 
    free(ctx);
}

References ctx::error, free(), NULL, and zip_error_fini().

Referenced by compress_callback(), and compression_source_new().

context_new()

static struct context * context_new ( zip_int32_t  method, bool  compress, int  compression_flags, zip_compression_algorithm_t *  algorithm  )

static

Definition at line 161 of file zip_source_compress.c.

                                                                                                              {
    struct context *ctx;
 
    if ((ctx = (struct context *)malloc(sizeof(*ctx))) == NULL) {
        return NULL;
    }
    zip_error_init(&ctx->error);
    ctx->can_store = compress ? ZIP_CM_IS_DEFAULT(method) : false;
    ctx->algorithm = algorithm;
    ctx->method = method;
    ctx->compress = compress;
    ctx->end_of_input = false;
    ctx->end_of_stream = false;
    ctx->is_stored = false;
 
    if ((ctx->ud = ctx->algorithm->allocate(ZIP_CM_ACTUAL(method), compression_flags, &ctx->error)) == NULL) {
        zip_error_fini(&ctx->error);
        free(ctx);
        return NULL;
    }
 
    return ctx;
}

References context::algorithm, ctx::compress, compress(), ctx::end_of_input, ctx::error, free(), malloc(), ctx::method, context::method, NULL, ZIP_CM_ACTUAL, ZIP_CM_IS_DEFAULT, zip_error_fini(), and zip_error_init().

Referenced by compression_source_new().

zip_compression_method_supported()

ZIP_EXTERN int zip_compression_method_supported	(	zip_int32_t	method,
		int	compress
	)

Definition at line 112 of file zip_source_compress.c.

                                                                   {
    if (method == ZIP_CM_STORE) {
        return 1;
    }
    return _zip_get_compression_algorithm(method, compress) != NULL;
}

References _zip_get_compression_algorithm(), compress(), context::method, NULL, and ZIP_CM_STORE.

Referenced by usage(), and zip_set_file_compression().

zip_source_compress()

zip_source_t* zip_source_compress	(	zip_t *	za,
		zip_source_t *	src,
		zip_int32_t	method,
		int	compression_flags
	)

Definition at line 120 of file zip_source_compress.c.

                                                                                             {
    return compression_source_new(za, src, method, true, compression_flags);
}

References compression_source_new(), context::method, src, and za.

Referenced by add_data().

zip_source_decompress()

zip_source_t* zip_source_decompress	(	zip_t *	za,
		zip_source_t *	src,
		zip_int32_t	method
	)

Definition at line 125 of file zip_source_compress.c.

                                                                        {
    return compression_source_new(za, src, method, false, 0);
}

References compression_source_new(), context::method, src, and za.

Referenced by _zip_source_zip_new(), and add_data().

Variable Documentation

implementations

struct implementation implementations[]

static

Initial value:

= {
    {ZIP_CM_DEFLATE, &zip_algorithm_deflate_compress, &zip_algorithm_deflate_decompress},
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
}

Definition at line 1 of file zip_source_compress.c.

Referenced by _zip_get_compression_algorithm().

implementations_size

size_t implementations_size = sizeof(implementations) / sizeof(implementations[0])

static

Definition at line 84 of file zip_source_compress.c.

Referenced by _zip_get_compression_algorithm().