/* Returns length of decompressed data. */ int cramfs_uncompress_block_gzip(void *dst, int dstlen, void *src, int srclen) { int err; stream.next_in = src; stream.avail_in = srclen; stream.next_out = dst; stream.avail_out = dstlen; err = zlib_inflateReset(&stream); if (err != Z_OK) { printk("zlib_inflateReset error %d\n", err); zlib_inflateEnd(&stream); zlib_inflateInit(&stream); } err = zlib_inflate(&stream, Z_FINISH); if (err != Z_STREAM_END) goto err; return stream.total_out; err: printk("Error %d while decompressing!\n", err); printk("%p(%d)->%p(%d)\n", src, srclen, dst, dstlen); return 0; }
/** * z_decomp_reset - reset a previously-allocated decompressor. * @arg: pointer to private state for the decompressor. * * This clears the history for the decompressor and makes it * ready to receive a new compressed stream. */ static void z_decomp_reset(void *arg) { struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg; state->seqno = 0; zlib_inflateReset(&state->strm); }
int sqlzma_un(struct sqlzma_un *un, struct sized_buf *src, struct sized_buf *dst) { int err, by_lzma = 1; if (un->un_lzma && is_lzma(*src->buf)) { un->un_cmbuf = src->buf; un->un_cmlen = src->sz; un->un_resbuf = dst->buf; un->un_reslen = dst->sz; /* this library is thread-safe */ err = LzmaUncompress(un); goto out; } by_lzma = 0; //#if defined(CONFIG_MIPS_BRCM) #if 1//disable zlib inflate /* The FS is compressed with LZMA for BRCM: do not use zlib */ printk("%s: ZLIB decompression is not supported\n", __func__); err = -EINVAL; #else err = zlib_inflateReset(&un->un_stream); if (unlikely(err != Z_OK)) goto out; un->un_stream.next_in = src->buf; un->un_stream.avail_in = src->sz; un->un_stream.next_out = dst->buf; un->un_stream.avail_out = dst->sz; err = zlib_inflate(&un->un_stream, Z_FINISH); if (err == Z_STREAM_END) err = 0; #endif out: if (unlikely(err)) { #ifdef __KERNEL__ WARN_ON_ONCE(1); #else char a[64] = "ZLIB "; if (by_lzma) { strcpy(a, "LZMA "); #ifdef _REENTRANT strerror_r(err, a + 5, sizeof(a) - 5); #else strncat(a, strerror(err), sizeof(a) - 5); #endif } else strncat(a, zError(err), sizeof(a) - 5); fprintf(stderr, "%s: %.*s\n", __func__, sizeof(a), a); #endif } return err; }
static int zlib_decompress_init(struct crypto_pcomp *tfm) { int ret; struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm)); struct z_stream_s *stream = &dctx->decomp_stream; ret = zlib_inflateReset(stream); if (ret != Z_OK) return -EINVAL; return 0; }
int zlib_inflateSync( z_streamp z ) { uInt n; /* number of bytes to look at */ Byte *p; /* pointer to bytes */ uInt m; /* number of marker bytes found in a row */ uLong r, w; /* temporaries to save total_in and total_out */ /* set up */ if (z == NULL || z->state == NULL) return Z_STREAM_ERROR; if (z->state->mode != I_BAD) { z->state->mode = I_BAD; z->state->sub.marker = 0; } if ((n = z->avail_in) == 0) return Z_BUF_ERROR; p = z->next_in; m = z->state->sub.marker; /* search */ while (n && m < 4) { static const Byte mark[4] = {0, 0, 0xff, 0xff}; if (*p == mark[m]) m++; else if (*p) m = 0; else m = 4 - m; p++, n--; } /* restore */ z->total_in += p - z->next_in; z->next_in = p; z->avail_in = n; z->state->sub.marker = m; /* return no joy or set up to restart on a new block */ if (m != 4) return Z_DATA_ERROR; r = z->total_in; w = z->total_out; zlib_inflateReset(z); z->total_in = r; z->total_out = w; z->state->mode = BLOCKS; return Z_OK; }
int sqlzma_un(struct sqlzma_un *un, struct sized_buf *src, struct sized_buf *dst) { int err, by_lzma = 0; if (un->un_lzma && is_lzma(*src->buf)) { by_lzma = 1; un->un_cmbuf = src->buf; un->un_cmlen = src->sz; un->un_resbuf = dst->buf; un->un_reslen = dst->sz; /* this library is thread-safe */ err = LzmaUncompress(un); goto out; } err = zlib_inflateReset(&un->un_stream); if (unlikely(err != Z_OK)) goto out; un->un_stream.next_in = src->buf; un->un_stream.avail_in = src->sz; un->un_stream.next_out = dst->buf; un->un_stream.avail_out = dst->sz; err = zlib_inflate(&un->un_stream, Z_FINISH); if (err == Z_STREAM_END) err = 0; out: if (err) { #ifdef __KERNEL__ WARN_ON_ONCE(1); #else char a[64] = "ZLIB "; if (by_lzma) { strcpy(a, "LZMA "); #ifdef _REENTRANT strerror_r(err, a + 5, sizeof(a) - 5); #else strncat(a, strerror(err), sizeof(a) - 5); #endif } else strncat(a, zError(err), sizeof(a) - 5); fprintf(stderr, "%s: %.*s\n", __func__, sizeof(a), a); #endif } return err; }
static void gzip1_decompress(coa_t coa, __u8 * src_first, size_t src_len, __u8 * dst_first, size_t *dst_len) { int ret = 0; struct z_stream_s stream; assert("edward-843", coa != NULL); assert("edward-876", src_len != 0); stream.workspace = coa; ret = zlib_inflateInit2(&stream, -GZIP1_DEF_WINBITS); if (ret != Z_OK) { warning("edward-774", "zlib_inflateInit2 returned %d\n", ret); return; } ret = zlib_inflateReset(&stream); if (ret != Z_OK) { warning("edward-775", "zlib_inflateReset returned %d\n", ret); return; } stream.next_in = src_first; stream.avail_in = src_len; stream.next_out = dst_first; stream.avail_out = *dst_len; ret = zlib_inflate(&stream, Z_SYNC_FLUSH); /* * Work around a bug in zlib, which sometimes wants to taste an extra * byte when being used in the (undocumented) raw deflate mode. * (From USAGI). */ if (ret == Z_OK && !stream.avail_in && stream.avail_out) { u8 zerostuff = 0; stream.next_in = &zerostuff; stream.avail_in = 1; ret = zlib_inflate(&stream, Z_FINISH); } if (ret != Z_STREAM_END) { warning("edward-776", "zlib_inflate returned %d\n", ret); return; } *dst_len = stream.total_out; return; }
static int deflate_decompress(struct crypto_tfm *tfm, const u8 *src, unsigned int slen, u8 *dst, unsigned int *dlen) { int ret = 0; struct deflate_ctx *dctx = crypto_tfm_ctx(tfm); struct z_stream_s *stream = &dctx->decomp_stream; ret = zlib_inflateReset(stream); if (ret != Z_OK) { ret = -EINVAL; goto out; } stream->next_in = (u8 *)src; stream->avail_in = slen; stream->next_out = (u8 *)dst; stream->avail_out = *dlen; ret = zlib_inflate(stream, Z_SYNC_FLUSH); /* * Work around a bug in zlib, which sometimes wants to taste an extra * byte when being used in the (undocumented) raw deflate mode. * (From USAGI). */ if (ret == Z_OK && !stream->avail_in && stream->avail_out) { u8 zerostuff = 0; stream->next_in = &zerostuff; stream->avail_in = 1; ret = zlib_inflate(stream, Z_FINISH); } if (ret != Z_STREAM_END) { ret = -EINVAL; goto out; } ret = 0; *dlen = stream->total_out; out: return ret; }
/** * z_decomp_init - initialize a previously-allocated decompressor. * @arg: pointer to the private state for the decompressor * @options: pointer to the CCP option data describing the * compression that was negotiated with the peer * @opt_len: length of the CCP option data at @options * @unit: PPP unit number for diagnostic messages * @hdrlen: ignored (present for backwards compatibility) * @mru: maximum length of decompressed packets * @debug: debug flag; if non-zero, debug messages are printed. * * The CCP options described by @options must match the options * specified when the decompressor was allocated. The decompressor * history is reset. Returns 0 for failure (CCP options don't * match) or 1 for success. */ static int z_decomp_init(void *arg, unsigned char *options, int opt_len, int unit, int hdrlen, int mru, int debug) { struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg; if (opt_len < CILEN_DEFLATE || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) || options[1] != CILEN_DEFLATE || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL || DEFLATE_SIZE(options[2]) != state->w_size || options[3] != DEFLATE_CHK_SEQUENCE) return 0; state->seqno = 0; state->unit = unit; state->debug = debug; state->mru = mru; zlib_inflateReset(&state->strm); return 1; }