zip_source_window.c File Reference

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

Go to the source code of this file.

Classes
struct	window

Functions
static zip_int64_t	window_read (zip_source_t *, void *, void *, zip_uint64_t, zip_source_cmd_t)
ZIP_EXTERN zip_source_t *	zip_source_window_create (zip_source_t *src, zip_uint64_t start, zip_int64_t len, zip_error_t *error)
zip_source_t *	_zip_source_window_new (zip_source_t *src, zip_uint64_t start, zip_int64_t length, zip_stat_t *st, zip_file_attributes_t *attributes, zip_t *source_archive, zip_uint64_t source_index, zip_error_t *error)
int	_zip_source_set_source_archive (zip_source_t *src, zip_t *za)
void	_zip_source_invalidate (zip_source_t *src)
void	_zip_deregister_source (zip_t *za, zip_source_t *src)
int	_zip_register_source (zip_t *za, zip_source_t *src)

Function Documentation

_zip_deregister_source()

void _zip_deregister_source	(	zip_t *	za,
		zip_source_t *	src
	)

Definition at line 306 of file zip_source_window.c.

                                                     {
    unsigned int i;
 
    for (i = 0; i < za->nopen_source; i++) {
        if (za->open_source[i] == src) {
            za->open_source[i] = za->open_source[za->nopen_source - 1];
            za->nopen_source--;
            break;
        }
    }
}

References i, zip::nopen_source, zip::open_source, src, and za.

Referenced by zip_source_free().

_zip_register_source()

int _zip_register_source	(	zip_t *	za,
		zip_source_t *	src
	)

Definition at line 320 of file zip_source_window.c.

                                                   {
    zip_source_t **open_source;
 
    if (za->nopen_source + 1 >= za->nopen_source_alloc) {
        unsigned int n;
        n = za->nopen_source_alloc + 10;
        open_source = (zip_source_t **)realloc(za->open_source, n * sizeof(zip_source_t *));
        if (open_source == NULL) {
            zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
            return -1;
        }
        za->nopen_source_alloc = n;
        za->open_source = open_source;
    }
 
    za->open_source[za->nopen_source++] = src;
 
    return 0;
}

References zip::error, n, zip::nopen_source, zip::nopen_source_alloc, NULL, zip::open_source, realloc(), src, za, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_source_set_source_archive().

_zip_source_invalidate()

void _zip_source_invalidate

(

zip_source_t *

src

)

Definition at line 129 of file zip_source_window.c.

                                          {
    src->source_closed = 1;
 
    if (zip_error_code_zip(&src->error) == ZIP_ER_OK) {
        zip_error_set(&src->error, ZIP_ER_ZIPCLOSED, 0);
    }
}

References src, ZIP_ER_OK, ZIP_ER_ZIPCLOSED, zip_error_code_zip(), and zip_error_set().

Referenced by zip_discard().

_zip_source_set_source_archive()

int _zip_source_set_source_archive	(	zip_source_t *	src,
		zip_t *	za
	)

Definition at line 121 of file zip_source_window.c.

                                                             {
    src->source_archive = za;
    return _zip_register_source(za, src);
}

References _zip_register_source(), src, and za.

Referenced by _zip_source_zip_new().

_zip_source_window_new()

zip_source_t* _zip_source_window_new	(	zip_source_t *	src,
		zip_uint64_t	start,
		zip_int64_t	length,
		zip_stat_t *	st,
		zip_file_attributes_t *	attributes,
		zip_t *	source_archive,
		zip_uint64_t	source_index,
		zip_error_t *	error
	)

Definition at line 68 of file zip_source_window.c.

                                                                                                                                                                                                           {
    struct window *ctx;
 
    if (src == NULL || length < -1 || (source_archive == NULL && source_index != 0)) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }
    
    if (length >= 0) {
        if (start + (zip_uint64_t)length < start) {
            zip_error_set(error, ZIP_ER_INVAL, 0);
            return NULL;
        }
    }
 
    if ((ctx = (struct window *)malloc(sizeof(*ctx))) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    ctx->start = start;
    if (length == -1) {
        ctx->end_valid = false;
    }
    else {
        ctx->end = start + (zip_uint64_t)length;
        ctx->end_valid = true;
    }
    zip_stat_init(&ctx->stat);
    if (attributes != NULL) {
        memcpy(&ctx->attributes, attributes, sizeof(ctx->attributes));
    }
    else {
        zip_file_attributes_init(&ctx->attributes);
    }
    ctx->source_archive = source_archive;
    ctx->source_index = source_index;
    zip_error_init(&ctx->error);
    ctx->supports = (zip_source_supports(src) & ZIP_SOURCE_SUPPORTS_SEEKABLE) | (zip_source_make_command_bitmap(ZIP_SOURCE_GET_FILE_ATTRIBUTES, ZIP_SOURCE_SUPPORTS, ZIP_SOURCE_TELL, -1));
    ctx->needs_seek = (ctx->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_SEEK)) ? true : false;
 
    if (st) {
        if (_zip_stat_merge(&ctx->stat, st, error) < 0) {
            free(ctx);
            return NULL;
        }
    }
    
    return zip_source_layered_create(src, window_read, ctx, error);
}

References _zip_stat_merge(), window::attributes, ctx::error, error(), free(), length, malloc(), memcpy(), NULL, window::source_archive, window::source_index, src, start, window_read(), ZIP_ER_INVAL, ZIP_ER_MEMORY, zip_error_init(), zip_error_set(), zip_file_attributes_init(), ZIP_SOURCE_GET_FILE_ATTRIBUTES, zip_source_layered_create(), zip_source_make_command_bitmap(), ZIP_SOURCE_MAKE_COMMAND_BITMASK, ZIP_SOURCE_SEEK, ZIP_SOURCE_SUPPORTS, zip_source_supports(), ZIP_SOURCE_SUPPORTS_SEEKABLE, ZIP_SOURCE_TELL, and zip_stat_init().

Referenced by _zip_source_zip_new(), add_data(), and zip_source_window_create().

window_read()

static zip_int64_t window_read ( zip_source_t *  src, void *  _ctx, void *  data, zip_uint64_t  len, zip_source_cmd_t  cmd  )

static

Definition at line 139 of file zip_source_window.c.

                                                                                               {
    struct window *ctx;
    zip_int64_t ret;
    zip_uint64_t n, i;
 
    ctx = (struct window *)_ctx;
 
    switch (cmd) {
    case ZIP_SOURCE_CLOSE:
        return 0;
 
    case ZIP_SOURCE_ERROR:
        return zip_error_to_data(&ctx->error, data, len);
 
    case ZIP_SOURCE_FREE:
        free(ctx);
        return 0;
 
    case ZIP_SOURCE_OPEN:
        if (ctx->source_archive) {
            zip_uint64_t offset;
 
            if ((offset = _zip_file_get_offset(ctx->source_archive, ctx->source_index, &ctx->error)) == 0) {
                return -1;
            }
            if (ctx->end + offset < ctx->end) {
                /* zip archive data claims end of data past zip64 limits */
                zip_error_set(&ctx->error, ZIP_ER_INCONS, MAKE_DETAIL_WITH_INDEX(ZIP_ER_DETAIL_CDIR_ENTRY_INVALID, ctx->source_index));
                return -1;
            }
            ctx->start += offset;
            ctx->end += offset;
            ctx->source_archive = NULL;
        }
 
        if (!ctx->needs_seek) {
            DEFINE_BYTE_ARRAY(b, BUFSIZE);
 
            if (!byte_array_init(b, BUFSIZE)) {
                zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
                return -1;
            }
 
            for (n = 0; n < ctx->start; n += (zip_uint64_t)ret) {
                i = (ctx->start - n > BUFSIZE ? BUFSIZE : ctx->start - n);
                if ((ret = zip_source_read(src, b, i)) < 0) {
                    _zip_error_set_from_source(&ctx->error, src);
                    byte_array_fini(b);
                    return -1;
                }
                if (ret == 0) {
                    zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
                    byte_array_fini(b);
                    return -1;
                }
            }
 
            byte_array_fini(b);
        }
 
        ctx->offset = ctx->start;
        return 0;
 
    case ZIP_SOURCE_READ:
        if (ctx->end_valid && len > ctx->end - ctx->offset) {
            len = ctx->end - ctx->offset;
        }
 
        if (len == 0) {
            return 0;
        }
 
        if (ctx->needs_seek) {
            if (zip_source_seek(src, (zip_int64_t)ctx->offset, SEEK_SET) < 0) {
                _zip_error_set_from_source(&ctx->error, src);
                return -1;
            }
        }
 
        if ((ret = zip_source_read(src, data, len)) < 0) {
            zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
            return -1;
        }
 
        ctx->offset += (zip_uint64_t)ret;
 
        if (ret == 0) {
            if (ctx->end_valid && ctx->offset < ctx->end) {
                zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
                return -1;
            }
        }
        return ret;
 
    case ZIP_SOURCE_SEEK: {
        zip_int64_t new_offset;
        
        if (!ctx->end_valid) {
            zip_source_args_seek_t *args = ZIP_SOURCE_GET_ARGS(zip_source_args_seek_t, data, len, &ctx->error);
            
            if (args == NULL) {
                return -1;
            }
            if (args->whence == SEEK_END) {
                if (zip_source_seek(src, args->offset, args->whence) < 0) {
                    _zip_error_set_from_source(&ctx->error, src);
                    return -1;
                }
                new_offset = zip_source_tell(src);
                if (new_offset < 0) {
                    _zip_error_set_from_source(&ctx->error, src);
                    return -1;
                }
                if ((zip_uint64_t)new_offset < ctx->start) {
                    zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
                    (void)zip_source_seek(src, (zip_int64_t)ctx->offset, SEEK_SET);
                    return -1;
                }
                ctx->offset = (zip_uint64_t)new_offset;
                return 0;
            }
        }
 
        new_offset = zip_source_seek_compute_offset(ctx->offset - ctx->start, ctx->end - ctx->start, data, len, &ctx->error);
        
        if (new_offset < 0) {
            return -1;
        }
        
        ctx->offset = (zip_uint64_t)new_offset + ctx->start;
        return 0;
    }
 
    case ZIP_SOURCE_STAT: {
        zip_stat_t *st;
 
        st = (zip_stat_t *)data;
 
        if (_zip_stat_merge(st, &ctx->stat, &ctx->error) < 0) {
            return -1;
        }
        return 0;
    }
 
    case ZIP_SOURCE_GET_FILE_ATTRIBUTES:
        if (len < sizeof(ctx->attributes)) {
            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
            return -1;
        }
 
        memcpy(data, &ctx->attributes, sizeof(ctx->attributes));
        return sizeof(ctx->attributes);
 
    case ZIP_SOURCE_SUPPORTS:
        return ctx->supports;
 
    case ZIP_SOURCE_TELL:
        return (zip_int64_t)(ctx->offset - ctx->start);
 
    default:
        zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
        return -1;
    }
}

References _zip_error_set_from_source(), _zip_file_get_offset(), _zip_stat_merge(), args, b, BUFSIZE, byte_array_fini, byte_array_init, cmd, DEFINE_BYTE_ARRAY, test_evm::end, ctx::error, free(), i, len, MAKE_DETAIL_WITH_INDEX, memcpy(), n, NULL, SEEK_END, SEEK_SET, src, start, ZIP_ER_DETAIL_CDIR_ENTRY_INVALID, ZIP_ER_EOF, ZIP_ER_INCONS, ZIP_ER_INVAL, ZIP_ER_MEMORY, ZIP_ER_OPNOTSUPP, zip_error_set(), zip_error_to_data(), ZIP_SOURCE_CLOSE, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_GET_ARGS, ZIP_SOURCE_GET_FILE_ATTRIBUTES, ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, zip_source_read(), ZIP_SOURCE_SEEK, zip_source_seek(), zip_source_seek_compute_offset(), ZIP_SOURCE_STAT, ZIP_SOURCE_SUPPORTS, ZIP_SOURCE_TELL, and zip_source_tell().

Referenced by _zip_source_window_new().

zip_source_window_create()

ZIP_EXTERN zip_source_t* zip_source_window_create	(	zip_source_t *	src,
		zip_uint64_t	start,
		zip_int64_t	len,
		zip_error_t *	error
	)

Definition at line 62 of file zip_source_window.c.

                                                                                                     {
    return _zip_source_window_new(src, start, len, NULL, 0, NULL, 0, error);
}

References _zip_source_window_new(), error(), len, NULL, src, and start.

Referenced by _zip_source_zip_new().