zip_source_crc.c File Reference

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

Go to the source code of this file.

Classes
struct	crc_context

Functions
static zip_int64_t	crc_read (zip_source_t *, void *, void *, zip_uint64_t, zip_source_cmd_t)
zip_source_t *	zip_source_crc_create (zip_source_t *src, int validate, zip_error_t *error)

Function Documentation

crc_read()

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

static

Definition at line 80 of file zip_source_crc.c.

                                                                                            {
    struct crc_context *ctx;
    zip_int64_t n;
 
    ctx = (struct crc_context *)_ctx;
 
    switch (cmd) {
    case ZIP_SOURCE_OPEN:
        ctx->position = 0;
        return 0;
 
    case ZIP_SOURCE_READ:
        if ((n = zip_source_read(src, data, len)) < 0) {
            _zip_error_set_from_source(&ctx->error, src);
            return -1;
        }
 
        if (n == 0) {
            if (ctx->crc_position == ctx->position) {
                ctx->crc_complete = 1;
                ctx->size = ctx->position;
 
                if (ctx->validate) {
                    struct zip_stat st;
 
                    if (zip_source_stat(src, &st) < 0) {
                        _zip_error_set_from_source(&ctx->error, src);
                        return -1;
                    }
 
                    if ((st.valid & ZIP_STAT_CRC) && st.crc != ctx->crc) {
                        zip_error_set(&ctx->error, ZIP_ER_CRC, 0);
                        return -1;
                    }
                    if ((st.valid & ZIP_STAT_SIZE) && st.size != ctx->size) {
                        /* We don't have the index here, but the caller should know which file they are reading from. */
                        zip_error_set(&ctx->error, ZIP_ER_INCONS, MAKE_DETAIL_WITH_INDEX(ZIP_ER_DETAIL_INVALID_FILE_LENGTH, MAX_DETAIL_INDEX));
                        return -1;
                    }
                }
            }
        }
        else if (!ctx->crc_complete && ctx->position <= ctx->crc_position) {
            zip_uint64_t i, nn;
 
            for (i = ctx->crc_position - ctx->position; i < (zip_uint64_t)n; i += nn) {
                nn = ZIP_MIN(UINT_MAX, (zip_uint64_t)n - i);
 
                ctx->crc = (zip_uint32_t)crc32(ctx->crc, (const Bytef *)data + i, (uInt)nn);
                ctx->crc_position += nn;
            }
        }
        ctx->position += (zip_uint64_t)n;
        return n;
 
    case ZIP_SOURCE_CLOSE:
        return 0;
 
    case ZIP_SOURCE_STAT: {
        zip_stat_t *st;
 
        st = (zip_stat_t *)data;
 
        if (ctx->crc_complete) {
            /* TODO: Set comp_size, comp_method, encryption_method?
                    After all, this only works for uncompressed data. */
            st->size = ctx->size;
            st->crc = ctx->crc;
            st->comp_size = ctx->size;
            st->comp_method = ZIP_CM_STORE;
            st->encryption_method = ZIP_EM_NONE;
            st->valid |= ZIP_STAT_SIZE | ZIP_STAT_CRC | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_ENCRYPTION_METHOD;
        }
        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_SUPPORTS: {
        zip_int64_t mask = zip_source_supports(src);
 
        if (mask < 0) {
            _zip_error_set_from_source(&ctx->error, src);
            return -1;
        }
 
        return mask & ~zip_source_make_command_bitmap(ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_REMOVE, ZIP_SOURCE_GET_FILE_ATTRIBUTES, -1);
    }
 
    case ZIP_SOURCE_SEEK: {
        zip_int64_t new_position;
        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 (zip_source_seek(src, args->offset, args->whence) < 0 || (new_position = zip_source_tell(src)) < 0) {
            _zip_error_set_from_source(&ctx->error, src);
            return -1;
        }
 
        ctx->position = (zip_uint64_t)new_position;
 
        return 0;
    }
 
    case ZIP_SOURCE_TELL:
        return (zip_int64_t)ctx->position;
 
    default:
        zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
        return -1;
    }
}

References _zip_error_set_from_source(), args, cmd, zip_stat::comp_method, zip_stat::comp_size, zip_stat::crc, crc32(), zip_stat::encryption_method, ctx::error, free(), i, len, MAKE_DETAIL_WITH_INDEX, mask, MAX_DETAIL_INDEX, n, NULL, zip_stat::size, src, UINT_MAX, zip_stat::valid, ZIP_CM_STORE, ZIP_EM_NONE, ZIP_ER_CRC, ZIP_ER_DETAIL_INVALID_FILE_LENGTH, ZIP_ER_INCONS, ZIP_ER_OPNOTSUPP, zip_error_set(), zip_error_to_data(), ZIP_MIN, ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_CLOSE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_GET_ARGS, ZIP_SOURCE_GET_FILE_ATTRIBUTES, zip_source_make_command_bitmap(), ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, zip_source_read(), ZIP_SOURCE_REMOVE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK, zip_source_seek(), ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_STAT, zip_source_stat(), ZIP_SOURCE_SUPPORTS, zip_source_supports(), ZIP_SOURCE_TELL, zip_source_tell(), ZIP_SOURCE_TELL_WRITE, ZIP_STAT_COMP_METHOD, ZIP_STAT_COMP_SIZE, ZIP_STAT_CRC, ZIP_STAT_ENCRYPTION_METHOD, and ZIP_STAT_SIZE.

Referenced by zip_source_crc_create().

zip_source_crc_create()

zip_source_t* zip_source_crc_create	(	zip_source_t *	src,
		int	validate,
		zip_error_t *	error
	)

Definition at line 55 of file zip_source_crc.c.

                                                                           {
    struct crc_context *ctx;
 
    if (src == NULL) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }
 
    if ((ctx = (struct crc_context *)malloc(sizeof(*ctx))) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    zip_error_init(&ctx->error);
    ctx->validate = validate;
    ctx->crc_complete = 0;
    ctx->crc_position = 0;
    ctx->crc = (zip_uint32_t)crc32(0, NULL, 0);
    ctx->size = 0;
 
    return zip_source_layered_create(src, crc_read, ctx, error);
}

References crc32(), crc_read(), ctx::error, error(), malloc(), NULL, src, validate(), ZIP_ER_INVAL, ZIP_ER_MEMORY, zip_error_init(), zip_error_set(), and zip_source_layered_create().

Referenced by _zip_source_zip_new(), and add_data().