zip_source_t * zip_source_deflate(zip_t *za, zip_source_t *src, zip_int32_t cm, int flags) { struct deflate *ctx; zip_source_t *s2; if (src == NULL || (cm != ZIP_CM_DEFLATE && !ZIP_CM_IS_DEFAULT(cm))) { zip_error_set(&za->error, ZIP_ER_INVAL, 0); return NULL; } if ((ctx=(struct deflate *)malloc(sizeof(*ctx))) == NULL) { zip_error_set(&za->error, ZIP_ER_MEMORY, 0); return NULL; } zip_error_init(&ctx->error); ctx->eof = false; ctx->is_stored = false; ctx->can_store = ZIP_CM_IS_DEFAULT(cm); if (flags & ZIP_CODEC_ENCODE) { ctx->mem_level = MAX_MEM_LEVEL; } if ((s2=zip_source_layered(za, src, ((flags & ZIP_CODEC_ENCODE) ? deflate_compress : deflate_decompress), ctx)) == NULL) { deflate_free(ctx); return NULL; } return s2; }
struct zip_source * zip_source_deflate(struct zip *za, struct zip_source *src, zip_int32_t cm, int flags) { struct deflate *ctx; struct zip_source *s2; if (src == NULL || (cm != ZIP_CM_DEFLATE && !ZIP_CM_IS_DEFAULT(cm))) { _zip_error_set(&za->error, ZIP_ER_INVAL, 0); return NULL; } if ((ctx=(struct deflate *)malloc(sizeof(*ctx))) == NULL) { _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); return NULL; } ctx->e[0] = ctx->e[1] = 0; ctx->eof = 0; if (flags & ZIP_CODEC_ENCODE) { if (zip_get_archive_flag(za, ZIP_AFL_TORRENT, 0)) ctx->mem_level = TORRENT_MEM_LEVEL; else ctx->mem_level = MAX_MEM_LEVEL; } if ((s2=zip_source_layered(za, src, ((flags & ZIP_CODEC_ENCODE) ? deflate_compress : deflate_decompress), ctx)) == NULL) { deflate_free(ctx); return NULL; } return s2; }
static zip_int64_t deflate_compress(zip_source_t *src, void *ud, void *data, zip_uint64_t len, zip_source_cmd_t cmd) { struct deflate *ctx; int ret; ctx = (struct deflate *)ud; switch (cmd) { case ZIP_SOURCE_OPEN: ctx->zstr.zalloc = Z_NULL; ctx->zstr.zfree = Z_NULL; ctx->zstr.opaque = NULL; ctx->zstr.avail_in = 0; ctx->zstr.next_in = NULL; ctx->zstr.avail_out = 0; ctx->zstr.next_out = NULL; /* negative value to tell zlib not to write a header */ if ((ret=deflateInit2(&ctx->zstr, Z_BEST_COMPRESSION, Z_DEFLATED, -MAX_WBITS, ctx->mem_level, Z_DEFAULT_STRATEGY)) != Z_OK) { zip_error_set(&ctx->error, ZIP_ER_ZLIB, ret); return -1; } return 0; case ZIP_SOURCE_READ: return compress_read(src, ctx, data, len); case ZIP_SOURCE_CLOSE: deflateEnd(&ctx->zstr); return 0; case ZIP_SOURCE_STAT: { zip_stat_t *st; st = (zip_stat_t *)data; st->comp_method = ctx->is_stored ? ZIP_CM_STORE : ZIP_CM_DEFLATE; st->valid |= ZIP_STAT_COMP_METHOD; if (ctx->eof) { st->comp_size = ctx->size; st->valid |= ZIP_STAT_COMP_SIZE; } else st->valid &= ~ZIP_STAT_COMP_SIZE; } return 0; case ZIP_SOURCE_ERROR: return zip_error_to_data(&ctx->error, data, len); case ZIP_SOURCE_FREE: deflate_free(ctx); return 0; case ZIP_SOURCE_SUPPORTS: return ZIP_SOURCE_SUPPORTS_READABLE; default: zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0); return -1; } }
static zip_int64_t deflate_compress(struct zip_source *src, void *ud, void *data, zip_uint64_t len, enum zip_source_cmd cmd) { struct deflate *ctx; int ret; ctx = (struct deflate *)ud; switch (cmd) { case ZIP_SOURCE_OPEN: ctx->zstr.zalloc = Z_NULL; ctx->zstr.zfree = Z_NULL; ctx->zstr.opaque = NULL; ctx->zstr.avail_in = 0; ctx->zstr.next_in = NULL; ctx->zstr.avail_out = 0; ctx->zstr.next_out = NULL; /* negative value to tell zlib not to write a header */ if ((ret=deflateInit2(&ctx->zstr, Z_BEST_COMPRESSION, Z_DEFLATED, -MAX_WBITS, ctx->mem_level, Z_DEFAULT_STRATEGY)) != Z_OK) { ctx->e[0] = ZIP_ER_ZLIB; ctx->e[1] = ret; return -1; } return 0; case ZIP_SOURCE_READ: return compress_read(src, ctx, data, len); case ZIP_SOURCE_CLOSE: deflateEnd(&ctx->zstr); return 0; case ZIP_SOURCE_STAT: { struct zip_stat *st; st = (struct zip_stat *)data; st->comp_method = ZIP_CM_DEFLATE; st->valid |= ZIP_STAT_COMP_METHOD; if (ctx->eof) { st->comp_size = ctx->size; st->valid |= ZIP_STAT_COMP_SIZE; } else st->valid &= ~ZIP_STAT_COMP_SIZE; } return 0; case ZIP_SOURCE_ERROR: memcpy(data, ctx->e, sizeof(int)*2); return sizeof(int)*2; case ZIP_SOURCE_FREE: deflate_free(ctx); return 0; default: ctx->e[0] = ZIP_ER_INVAL; ctx->e[1] = 0; return -1; } }