Quelle  decompress_inflate.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
#ifdef STATIC
#define PREBOOT
/* Pre-boot environment: included */

/* prevent inclusion of _LINUX_KERNEL_H in pre-boot environment: lots
 * errors about console_printk etc... on ARM */
#define _LINUX_KERNEL_H

#include "zlib_inflate/inftrees.c"
#include "zlib_inflate/inffast.c"
#include "zlib_inflate/inflate.c"
#ifdef CONFIG_ZLIB_DFLTCC
#include "zlib_dfltcc/dfltcc.c"
#include "zlib_dfltcc/dfltcc_inflate.c"
#endif

#else /* STATIC */
/* initramfs et al: linked */

#include <linux/zutil.h>

#include "zlib_inflate/inftrees.h"
#include "zlib_inflate/inffast.h"
#include "zlib_inflate/inflate.h"

#include "zlib_inflate/infutil.h"
#include <linux/decompress/inflate.h>

#endif /* STATIC */

#include <linux/decompress/mm.h>

#define GZIP_IOBUF_SIZE (16*1024)

static long INIT nofill(void *buffer, unsigned long len)
{
 return -1;
}

/* Included from initramfs et al code */
static int INIT __gunzip(unsigned char *buf, long len,
         long (*fill)(void*, unsigned long),
         long (*flush)(void*, unsigned long),
         unsigned char *out_buf, long out_len,
         long *pos,
         void(*error)(char *x)) {
 u8 *zbuf;
 struct z_stream_s *strm;
 int rc;

 rc = -1;
 if (flush) {
  out_len = 0x8000; /* 32 K */
  out_buf = malloc(out_len);
 } else {
  if (!out_len)
   out_len = ((size_t)~0) - (size_t)out_buf; /* no limit */
 }
 if (!out_buf) {
  error("Out of memory while allocating output buffer");
  goto gunzip_nomem1;
 }

 if (buf)
  zbuf = buf;
 else {
  zbuf = malloc(GZIP_IOBUF_SIZE);
  len = 0;
 }
 if (!zbuf) {
  error("Out of memory while allocating input buffer");
  goto gunzip_nomem2;
 }

 strm = malloc(sizeof(*strm));
 if (strm == NULL) {
  error("Out of memory while allocating z_stream");
  goto gunzip_nomem3;
 }

 strm->workspace = malloc(flush ? zlib_inflate_workspacesize() :
#ifdef CONFIG_ZLIB_DFLTCC
 /* Always allocate the full workspace for DFLTCC */
     zlib_inflate_workspacesize());
#else
     sizeof(struct inflate_state));
#endif
 if (strm->workspace == NULL) {
  error("Out of memory while allocating workspace");
  goto gunzip_nomem4;
 }

 if (!fill)
  fill = nofill;

 if (len == 0)
  len = fill(zbuf, GZIP_IOBUF_SIZE);

 /* verify the gzip header */
 if (len < 10 ||
    zbuf[0] != 0x1f || zbuf[1] != 0x8b || zbuf[2] != 0x08) {
  if (pos)
   *pos = 0;
  error("Not a gzip file");
  goto gunzip_5;
 }

 /* skip over gzip header (1f,8b,08... 10 bytes total +
 * possible asciz filename)
 */
 strm->next_in = zbuf + 10;
 strm->avail_in = len - 10;
 /* skip over asciz filename */
 if (zbuf[3] & 0x8) {
  do {
   /*
 * If the filename doesn't fit into the buffer,
 * the file is very probably corrupt. Don't try
 * to read more data.
 */
   if (strm->avail_in == 0) {
    error("header error");
    goto gunzip_5;
   }
   --strm->avail_in;
  } while (*strm->next_in++);
 }

 strm->next_out = out_buf;
 strm->avail_out = out_len;

 rc = zlib_inflateInit2(strm, -MAX_WBITS);

#ifdef CONFIG_ZLIB_DFLTCC
 /* Always keep the window for DFLTCC */
#else
 if (!flush) {
  WS(strm)->inflate_state.wsize = 0;
  WS(strm)->inflate_state.window = NULL;
 }
#endif

 while (rc == Z_OK) {
  if (strm->avail_in == 0) {
   /* TODO: handle case where both pos and fill are set */
   len = fill(zbuf, GZIP_IOBUF_SIZE);
   if (len < 0) {
    rc = -1;
    error("read error");
    break;
   }
   strm->next_in = zbuf;
   strm->avail_in = len;
  }
  rc = zlib_inflate(strm, 0);

  /* Write any data generated */
  if (flush && strm->next_out > out_buf) {
   long l = strm->next_out - out_buf;
   if (l != flush(out_buf, l)) {
    rc = -1;
    error("write error");
    break;
   }
   strm->next_out = out_buf;
   strm->avail_out = out_len;
  }

  /* after Z_FINISH, only Z_STREAM_END is "we unpacked it all" */
  if (rc == Z_STREAM_END) {
   rc = 0;
   break;
  } else if (rc != Z_OK) {
   error("uncompression error");
   rc = -1;
  }
 }

 zlib_inflateEnd(strm);
 if (pos)
  /* add + 8 to skip over trailer */
  *pos = strm->next_in - zbuf+8;

gunzip_5:
 free(strm->workspace);
gunzip_nomem4:
 free(strm);
gunzip_nomem3:
 if (!buf)
  free(zbuf);
gunzip_nomem2:
 if (flush)
  free(out_buf);
gunzip_nomem1:
 return rc; /* returns Z_OK (0) if successful */
}

#ifndef PREBOOT
STATIC int INIT gunzip(unsigned char *buf, long len,
         long (*fill)(void*, unsigned long),
         long (*flush)(void*, unsigned long),
         unsigned char *out_buf,
         long *pos,
         void (*error)(char *x))
{
 return __gunzip(buf, len, fill, flush, out_buf, 0, pos, error);
}
#else
STATIC int INIT __decompress(unsigned char *buf, long len,
      long (*fill)(void*, unsigned long),
      long (*flush)(void*, unsigned long),
      unsigned char *out_buf, long out_len,
      long *pos,
      void (*error)(char *x))
{
 return __gunzip(buf, len, fill, flush, out_buf, out_len, pos, error);
}
#endif