#define memzero(s, n) memset ((s), 0, (n))
-typedef uint8_t uch;
+typedef uint8_t uch;
typedef uint16_t ush;
typedef uint32_t ulg;
-#define WSIZE 0x8000 /* Window size must be at least 32k, */
+#define WSIZE 0x8000 /* Window size must be at least 32k, */
/* and a power of two */
static uch *inbuf; /* input pointer */
static unsigned outcnt; /* bytes in output buffer */
/* gzip flag byte */
-#define ASCII_FLAG 0x01 /* bit 0 set: file probably ASCII text */
-#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
-#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
-#define ORIG_NAME 0x08 /* bit 3 set: original file name present */
-#define COMMENT 0x10 /* bit 4 set: file comment present */
-#define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */
-#define RESERVED 0xC0 /* bit 6,7: reserved */
+#define ASCII_FLAG 0x01 /* bit 0 set: file probably ASCII text */
+#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
+#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
+#define ORIG_NAME 0x08 /* bit 3 set: original file name present */
+#define COMMENT 0x10 /* bit 4 set: file comment present */
+#define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */
+#define RESERVED 0xC0 /* bit 6,7: reserved */
/* Diagnostic functions */
#ifdef DEBUG
# define Tracecv(c,x)
#endif
-static int fill_inbuf(void);
+static int fill_inbuf(void);
static void flush_window(void);
static void error(char *m);
static void gzip_mark(void **);
/* Get byte from input buffer */
static inline uch get_byte(void)
{
- if ( inbytes ) {
- uch b = *inbuf++;
- inbytes--;
- return b;
- } else {
- return fill_inbuf(); /* Input buffer underrun */
- }
+ if (inbytes) {
+ uch b = *inbuf++;
+ inbytes--;
+ return b;
+ } else {
+ return fill_inbuf(); /* Input buffer underrun */
+ }
}
/* Unget byte from input buffer */
static inline void unget_byte(void)
{
- inbytes++;
- inbuf--;
+ inbytes++;
+ inbuf--;
}
static ulg bytes_out = 0; /* Number of bytes output */
static void *malloc(int size)
{
- void *p;
+ void *p;
- if (size < 0) error("malloc error");
+ if (size < 0)
+ error("malloc error");
- free_mem_ptr = (free_mem_ptr + 3) & ~3; /* Align */
+ free_mem_ptr = (free_mem_ptr + 3) & ~3; /* Align */
- p = (void *)free_mem_ptr;
- free_mem_ptr += size;
+ p = (void *)free_mem_ptr;
+ free_mem_ptr += size;
- if (free_mem_ptr >= free_mem_end_ptr)
- error("out of memory");
+ if (free_mem_ptr >= free_mem_end_ptr)
+ error("out of memory");
- return p;
+ return p;
}
static void free(void *where)
{
- /* Don't care */
- (void)where;
+ /* Don't care */
+ (void)where;
}
static void gzip_mark(void **ptr)
{
- *ptr = (void *) free_mem_ptr;
+ *ptr = (void *)free_mem_ptr;
}
static void gzip_release(void **ptr)
{
- free_mem_ptr = (long) *ptr;
+ free_mem_ptr = (long)*ptr;
}
/* ===========================================================================
*/
static int fill_inbuf(void)
{
- /* This should never happen. We have already pointed the algorithm
- to all the data we have. */
- printf("failed\nDecompression error: ran out of input data\n");
- die();
+ /* This should never happen. We have already pointed the algorithm
+ to all the data we have. */
+ printf("failed\nDecompression error: ran out of input data\n");
+ die();
}
/* ===========================================================================
*/
static void flush_window(void)
{
- ulg c = crc; /* temporary variable */
+ ulg c = crc; /* temporary variable */
unsigned n;
uch *in, *out, ch;
- if ( bytes_out+outcnt > output_size )
- error("output buffer overrun");
+ if (bytes_out + outcnt > output_size)
+ error("output buffer overrun");
in = window;
out = output_data;
for (n = 0; n < outcnt; n++) {
- ch = *out++ = *in++;
- c = crc_32_tab[(c ^ ch) & 0xff] ^ (c >> 8);
+ ch = *out++ = *in++;
+ c = crc_32_tab[(c ^ ch) & 0xff] ^ (c >> 8);
}
crc = c;
output_data = out;
- bytes_out += (ulg)outcnt;
+ bytes_out += (ulg) outcnt;
outcnt = 0;
}
static void error(char *x)
{
- printf("failed\nDecompression error: %s\n", x);
- die();
+ printf("failed\nDecompression error: %s\n", x);
+ die();
}
/* GZIP header */
struct gzip_header {
- uint16_t magic;
- uint8_t method;
- uint8_t flags;
- uint32_t timestamp;
- uint8_t extra_flags;
- uint8_t os_type;
+ uint16_t magic;
+ uint8_t method;
+ uint8_t flags;
+ uint32_t timestamp;
+ uint8_t extra_flags;
+ uint8_t os_type;
} __attribute__ ((packed));
/* (followed by optional and variable length "extra", "original name",
and "comment" fields) */
struct gzip_trailer {
- uint32_t crc;
- uint32_t dbytes;
+ uint32_t crc;
+ uint32_t dbytes;
} __attribute__ ((packed));
/* PKZIP header. See
* <http://www.pkware.com/products/enterprise/white_papers/appnote.html>.
*/
struct pkzip_header {
- uint32_t magic;
- uint16_t version;
- uint16_t flags;
- uint16_t method;
- uint16_t modified_time;
- uint16_t modified_date;
- uint32_t crc;
- uint32_t zbytes;
- uint32_t dbytes;
- uint16_t filename_len;
- uint16_t extra_len;
+ uint32_t magic;
+ uint16_t version;
+ uint16_t flags;
+ uint16_t method;
+ uint16_t modified_time;
+ uint16_t modified_date;
+ uint32_t crc;
+ uint32_t zbytes;
+ uint32_t dbytes;
+ uint16_t filename_len;
+ uint16_t extra_len;
} __attribute__ ((packed));
/* (followed by optional and variable length "filename" and "extra"
fields) */
/* gzip flag byte */
-#define ASCII_FLAG 0x01 /* bit 0 set: file probably ASCII text */
-#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
-#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
-#define ORIG_NAME 0x08 /* bit 3 set: original file name present */
-#define COMMENT 0x10 /* bit 4 set: file comment present */
-#define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */
-#define RESERVED 0xC0 /* bit 6,7: reserved */
+#define ASCII_FLAG 0x01 /* bit 0 set: file probably ASCII text */
+#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
+#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
+#define ORIG_NAME 0x08 /* bit 3 set: original file name present */
+#define COMMENT 0x10 /* bit 4 set: file comment present */
+#define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */
+#define RESERVED 0xC0 /* bit 6,7: reserved */
/* pkzip flag byte */
-#define PK_ENCRYPTED 0x01 /* bit 0 set: file is encrypted */
-#define PK_DATADESC 0x08 /* bit 3 set: file has trailing "data
- descriptor" */
-#define PK_UNSUPPORTED 0xFFF0 /* All other bits must be zero */
-
+#define PK_ENCRYPTED 0x01 /* bit 0 set: file is encrypted */
+#define PK_DATADESC 0x08 /* bit 3 set: file has trailing "data
+ descriptor" */
+#define PK_UNSUPPORTED 0xFFF0 /* All other bits must be zero */
/* Return 0 if (indata, size) points to a ZIP file, and fill in
compressed data size, uncompressed data size, CRC, and offset of
data.
If indata is not a ZIP file, return -1. */
-int check_zip(void *indata, uint32_t size, uint32_t *zbytes_p,
- uint32_t *dbytes_p, uint32_t *orig_crc, uint32_t *offset_p) {
- struct gzip_header *gzh = (struct gzip_header *)indata;
- struct pkzip_header *pkzh = (struct pkzip_header *)indata;
- uint32_t offset;
-
- if (gzh->magic == 0x8b1f) {
- struct gzip_trailer *gzt = indata + size - sizeof (struct gzip_trailer);
- /* We only support method #8, DEFLATED */
- if (gzh->method != 8) {
- error("gzip file uses invalid method");
- return -1;
- }
- if (gzh->flags & ENCRYPTED) {
- error("gzip file is encrypted; not supported");
- return -1;
- }
- if (gzh->flags & CONTINUATION) {
- error("gzip file is a continuation file; not supported");
- return -1;
- }
- if (gzh->flags & RESERVED) {
- error("gzip file has unsupported flags");
- return -1;
- }
- offset = sizeof (*gzh);
- if (gzh->flags & EXTRA_FIELD) {
- /* Skip extra field */
- unsigned len = *(unsigned *)(indata + offset);
- offset += 2 + len;
- }
- if (gzh->flags & ORIG_NAME) {
- /* Discard the old name */
- uint8_t *p = indata;
- while (p[offset] != 0 && offset < size) {
- offset++;
- }
- offset++;
- }
-
- if (gzh->flags & COMMENT) {
- /* Discard the comment */
- uint8_t *p = indata;
- while (p[offset] != 0 && offset < size) {
- offset++;
- }
- offset++;
- }
-
- if (offset > size) {
- error ("gzip file corrupt");
- return -1;
- }
- *zbytes_p = size - offset - sizeof (struct gzip_trailer);
- *dbytes_p = gzt->dbytes;
- *orig_crc = gzt->crc;
- *offset_p = offset;
- return 0;
- }
- else if (pkzh->magic == 0x04034b50UL) {
- /* Magic number matches pkzip file. */
-
- offset = sizeof (*pkzh);
- if (pkzh->flags & PK_ENCRYPTED) {
- error("pkzip file is encrypted; not supported");
- return -1;
- }
- if (pkzh->flags & PK_DATADESC) {
- error("pkzip file uses data_descriptor field; not supported");
- return -1;
- }
- if (pkzh->flags & PK_UNSUPPORTED) {
- error("pkzip file has unsupported flags");
- return -1;
- }
-
- /* We only support method #8, DEFLATED */
- if (pkzh->method != 8) {
- error("pkzip file uses invalid method");
- return -1;
- }
- /* skip header */
- offset = sizeof (*pkzh);
- /* skip filename */
- offset += pkzh->filename_len;
- /* skip extra field */
- offset += pkzh->extra_len;
-
- if (offset + pkzh->zbytes > size) {
- error ("pkzip file corrupt");
- return -1;
+int check_zip(void *indata, uint32_t size, uint32_t * zbytes_p,
+ uint32_t * dbytes_p, uint32_t * orig_crc, uint32_t * offset_p)
+{
+ struct gzip_header *gzh = (struct gzip_header *)indata;
+ struct pkzip_header *pkzh = (struct pkzip_header *)indata;
+ uint32_t offset;
+
+ if (gzh->magic == 0x8b1f) {
+ struct gzip_trailer *gzt = indata + size - sizeof(struct gzip_trailer);
+ /* We only support method #8, DEFLATED */
+ if (gzh->method != 8) {
+ error("gzip file uses invalid method");
+ return -1;
+ }
+ if (gzh->flags & ENCRYPTED) {
+ error("gzip file is encrypted; not supported");
+ return -1;
+ }
+ if (gzh->flags & CONTINUATION) {
+ error("gzip file is a continuation file; not supported");
+ return -1;
+ }
+ if (gzh->flags & RESERVED) {
+ error("gzip file has unsupported flags");
+ return -1;
+ }
+ offset = sizeof(*gzh);
+ if (gzh->flags & EXTRA_FIELD) {
+ /* Skip extra field */
+ unsigned len = *(unsigned *)(indata + offset);
+ offset += 2 + len;
+ }
+ if (gzh->flags & ORIG_NAME) {
+ /* Discard the old name */
+ uint8_t *p = indata;
+ while (p[offset] != 0 && offset < size) {
+ offset++;
+ }
+ offset++;
+ }
+
+ if (gzh->flags & COMMENT) {
+ /* Discard the comment */
+ uint8_t *p = indata;
+ while (p[offset] != 0 && offset < size) {
+ offset++;
+ }
+ offset++;
+ }
+
+ if (offset > size) {
+ error("gzip file corrupt");
+ return -1;
+ }
+ *zbytes_p = size - offset - sizeof(struct gzip_trailer);
+ *dbytes_p = gzt->dbytes;
+ *orig_crc = gzt->crc;
+ *offset_p = offset;
+ return 0;
+ } else if (pkzh->magic == 0x04034b50UL) {
+ /* Magic number matches pkzip file. */
+
+ offset = sizeof(*pkzh);
+ if (pkzh->flags & PK_ENCRYPTED) {
+ error("pkzip file is encrypted; not supported");
+ return -1;
+ }
+ if (pkzh->flags & PK_DATADESC) {
+ error("pkzip file uses data_descriptor field; not supported");
+ return -1;
+ }
+ if (pkzh->flags & PK_UNSUPPORTED) {
+ error("pkzip file has unsupported flags");
+ return -1;
+ }
+
+ /* We only support method #8, DEFLATED */
+ if (pkzh->method != 8) {
+ error("pkzip file uses invalid method");
+ return -1;
+ }
+ /* skip header */
+ offset = sizeof(*pkzh);
+ /* skip filename */
+ offset += pkzh->filename_len;
+ /* skip extra field */
+ offset += pkzh->extra_len;
+
+ if (offset + pkzh->zbytes > size) {
+ error("pkzip file corrupt");
+ return -1;
+ }
+
+ *zbytes_p = pkzh->zbytes;
+ *dbytes_p = pkzh->dbytes;
+ *orig_crc = pkzh->crc;
+ *offset_p = offset;
+ return 0;
+ } else {
+ /* Magic number does not match. */
+ return -1;
}
- *zbytes_p = pkzh->zbytes;
- *dbytes_p = pkzh->dbytes;
- *orig_crc = pkzh->crc;
- *offset_p = offset;
- return 0;
- }
- else {
- /* Magic number does not match. */
+ error("Internal error in check_zip");
return -1;
- }
-
- error ("Internal error in check_zip");
- return -1;
}
/*
extern void _end;
void *unzip(void *indata, uint32_t zbytes, uint32_t dbytes,
- uint32_t orig_crc, void *target)
+ uint32_t orig_crc, void *target)
{
- /* Set up the heap; it's the 64K after the bounce buffer */
- free_mem_ptr = (ulg)sys_bounce + 0x10000;
- free_mem_end_ptr = free_mem_ptr + 0x10000;
-
- /* Set up input buffer */
- inbuf = indata;
- /* Sometimes inflate() looks beyond the end of the compressed data,
- but it always backs up before it is done. So we give it 4 bytes
- of slack. */
- insize = inbytes = zbytes + 4;
-
- /* Set up output buffer */
- outcnt = 0;
- output_data = target;
- output_size = dbytes;
- bytes_out = 0;
+ /* Set up the heap; it's the 64K after the bounce buffer */
+ free_mem_ptr = (ulg) sys_bounce + 0x10000;
+ free_mem_end_ptr = free_mem_ptr + 0x10000;
+
+ /* Set up input buffer */
+ inbuf = indata;
+ /* Sometimes inflate() looks beyond the end of the compressed data,
+ but it always backs up before it is done. So we give it 4 bytes
+ of slack. */
+ insize = inbytes = zbytes + 4;
+
+ /* Set up output buffer */
+ outcnt = 0;
+ output_data = target;
+ output_size = dbytes;
+ bytes_out = 0;
- makecrc();
- gunzip();
+ makecrc();
+ gunzip();
- /* Verify that gunzip() consumed the entire input. */
- if (inbytes != 4)
- error("compressed data length error");
+ /* Verify that gunzip() consumed the entire input. */
+ if (inbytes != 4)
+ error("compressed data length error");
- /* Check the uncompressed data length and CRC. */
- if ( bytes_out != dbytes )
- error("uncompressed data length error");
+ /* Check the uncompressed data length and CRC. */
+ if (bytes_out != dbytes)
+ error("uncompressed data length error");
- if (orig_crc != CRC_VALUE)
- error("crc error");
+ if (orig_crc != CRC_VALUE)
+ error("crc error");
- puts("ok\n");
+ puts("ok\n");
- return target;
+ return target;
}
projects / platform / upstream / syslinux.git / commitdiff