+++ /dev/null
-/* gzlib.c -- zlib functions common to reading and writing gzip files\r
- * Copyright (C) 2004, 2010, 2011, 2012, 2013 Mark Adler\r
- * For conditions of distribution and use, see copyright notice in zlib.h\r
- */\r
-\r
-#include "gzguts.h"\r
-\r
-#if defined(_WIN32) && !defined(__BORLANDC__)\r
-# define LSEEK _lseeki64\r
-#else\r
-#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0\r
-# define LSEEK lseek64\r
-#else\r
-# define LSEEK lseek\r
-#endif\r
-#endif\r
-\r
-/* Local functions */\r
-local void gz_reset OF((gz_statep));\r
-local gzFile gz_open OF((const void *, int, const char *));\r
-\r
-#if defined UNDER_CE\r
-\r
-/* Map the Windows error number in ERROR to a locale-dependent error message\r
- string and return a pointer to it. Typically, the values for ERROR come\r
- from GetLastError.\r
-\r
- The string pointed to shall not be modified by the application, but may be\r
- overwritten by a subsequent call to gz_strwinerror\r
-\r
- The gz_strwinerror function does not change the current setting of\r
- GetLastError. */\r
-char ZLIB_INTERNAL *gz_strwinerror (error)\r
- DWORD error;\r
-{\r
- static char buf[1024];\r
-\r
- wchar_t *msgbuf;\r
- DWORD lasterr = GetLastError();\r
- DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM\r
- | FORMAT_MESSAGE_ALLOCATE_BUFFER,\r
- NULL,\r
- error,\r
- 0, /* Default language */\r
- (LPVOID)&msgbuf,\r
- 0,\r
- NULL);\r
- if (chars != 0) {\r
- /* If there is an \r\n appended, zap it. */\r
- if (chars >= 2\r
- && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {\r
- chars -= 2;\r
- msgbuf[chars] = 0;\r
- }\r
-\r
- if (chars > sizeof (buf) - 1) {\r
- chars = sizeof (buf) - 1;\r
- msgbuf[chars] = 0;\r
- }\r
-\r
- wcstombs(buf, msgbuf, chars + 1);\r
- LocalFree(msgbuf);\r
- }\r
- else {\r
- sprintf(buf, "unknown win32 error (%ld)", error);\r
- }\r
-\r
- SetLastError(lasterr);\r
- return buf;\r
-}\r
-\r
-#endif /* UNDER_CE */\r
-\r
-/* Reset gzip file state */\r
-local void gz_reset(state)\r
- gz_statep state;\r
-{\r
- state->x.have = 0; /* no output data available */\r
- if (state->mode == GZ_READ) { /* for reading ... */\r
- state->eof = 0; /* not at end of file */\r
- state->past = 0; /* have not read past end yet */\r
- state->how = LOOK; /* look for gzip header */\r
- }\r
- state->seek = 0; /* no seek request pending */\r
- gz_error(state, Z_OK, NULL); /* clear error */\r
- state->x.pos = 0; /* no uncompressed data yet */\r
- state->strm.avail_in = 0; /* no input data yet */\r
-}\r
-\r
-/* Open a gzip file either by name or file descriptor. */\r
-local gzFile gz_open(path, fd, mode)\r
- const void *path;\r
- int fd;\r
- const char *mode;\r
-{\r
- gz_statep state;\r
- size_t len;\r
- int oflag;\r
-#ifdef O_CLOEXEC\r
- int cloexec = 0;\r
-#endif\r
-#ifdef O_EXCL\r
- int exclusive = 0;\r
-#endif\r
-\r
- /* check input */\r
- if (path == NULL)\r
- return NULL;\r
-\r
- /* allocate gzFile structure to return */\r
- state = (gz_statep)malloc(sizeof(gz_state));\r
- if (state == NULL)\r
- return NULL;\r
- state->size = 0; /* no buffers allocated yet */\r
- state->want = GZBUFSIZE; /* requested buffer size */\r
- state->msg = NULL; /* no error message yet */\r
-\r
- /* interpret mode */\r
- state->mode = GZ_NONE;\r
- state->level = Z_DEFAULT_COMPRESSION;\r
- state->strategy = Z_DEFAULT_STRATEGY;\r
- state->direct = 0;\r
- while (*mode) {\r
- if (*mode >= '0' && *mode <= '9')\r
- state->level = *mode - '0';\r
- else\r
- switch (*mode) {\r
- case 'r':\r
- state->mode = GZ_READ;\r
- break;\r
-#ifndef NO_GZCOMPRESS\r
- case 'w':\r
- state->mode = GZ_WRITE;\r
- break;\r
- case 'a':\r
- state->mode = GZ_APPEND;\r
- break;\r
-#endif\r
- case '+': /* can't read and write at the same time */\r
- free(state);\r
- return NULL;\r
- case 'b': /* ignore -- will request binary anyway */\r
- break;\r
-#ifdef O_CLOEXEC\r
- case 'e':\r
- cloexec = 1;\r
- break;\r
-#endif\r
-#ifdef O_EXCL\r
- case 'x':\r
- exclusive = 1;\r
- break;\r
-#endif\r
- case 'f':\r
- state->strategy = Z_FILTERED;\r
- break;\r
- case 'h':\r
- state->strategy = Z_HUFFMAN_ONLY;\r
- break;\r
- case 'R':\r
- state->strategy = Z_RLE;\r
- break;\r
- case 'F':\r
- state->strategy = Z_FIXED;\r
- break;\r
- case 'T':\r
- state->direct = 1;\r
- break;\r
- default: /* could consider as an error, but just ignore */\r
- ;\r
- }\r
- mode++;\r
- }\r
-\r
- /* must provide an "r", "w", or "a" */\r
- if (state->mode == GZ_NONE) {\r
- free(state);\r
- return NULL;\r
- }\r
-\r
- /* can't force transparent read */\r
- if (state->mode == GZ_READ) {\r
- if (state->direct) {\r
- free(state);\r
- return NULL;\r
- }\r
- state->direct = 1; /* for empty file */\r
- }\r
-\r
- /* save the path name for error messages */\r
-#ifdef _WIN32\r
- if (fd == -2) {\r
- len = wcstombs(NULL, path, 0);\r
- if (len == (size_t)-1)\r
- len = 0;\r
- }\r
- else\r
-#endif\r
- len = strlen((const char *)path);\r
- state->path = (char *)malloc(len + 1);\r
- if (state->path == NULL) {\r
- free(state);\r
- return NULL;\r
- }\r
-#ifdef _WIN32\r
- if (fd == -2)\r
- if (len)\r
- wcstombs(state->path, path, len + 1);\r
- else\r
- *(state->path) = 0;\r
- else\r
-#endif\r
-#if !defined(NO_snprintf) && !defined(NO_vsnprintf)\r
- snprintf(state->path, len + 1, "%s", (const char *)path);\r
-#else\r
- strcpy(state->path, path);\r
-#endif\r
-\r
- /* compute the flags for open() */\r
- oflag =\r
-#ifdef O_LARGEFILE\r
- O_LARGEFILE |\r
-#endif\r
-#ifdef O_BINARY\r
- O_BINARY |\r
-#endif\r
-#ifdef O_CLOEXEC\r
- (cloexec ? O_CLOEXEC : 0) |\r
-#endif\r
- (state->mode == GZ_READ ?\r
- O_RDONLY :\r
- (O_WRONLY | O_CREAT |\r
-#ifdef O_EXCL\r
- (exclusive ? O_EXCL : 0) |\r
-#endif\r
- (state->mode == GZ_WRITE ?\r
- O_TRUNC :\r
- O_APPEND)));\r
-\r
- /* open the file with the appropriate flags (or just use fd) */\r
- state->fd = fd > -1 ? fd : (\r
-#ifdef _WIN32\r
- fd == -2 ? _wopen(path, oflag, 0666) :\r
-#endif\r
- open((const char *)path, oflag, 0666));\r
- if (state->fd == -1) {\r
- free(state->path);\r
- free(state);\r
- return NULL;\r
- }\r
- if (state->mode == GZ_APPEND)\r
- state->mode = GZ_WRITE; /* simplify later checks */\r
-\r
- /* save the current position for rewinding (only if reading) */\r
- if (state->mode == GZ_READ) {\r
- state->start = LSEEK(state->fd, 0, SEEK_CUR);\r
- if (state->start == -1) state->start = 0;\r
- }\r
-\r
- /* initialize stream */\r
- gz_reset(state);\r
-\r
- /* return stream */\r
- return (gzFile)state;\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-gzFile ZEXPORT gzopen(path, mode)\r
- const char *path;\r
- const char *mode;\r
-{\r
- return gz_open(path, -1, mode);\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-gzFile ZEXPORT gzopen64(path, mode)\r
- const char *path;\r
- const char *mode;\r
-{\r
- return gz_open(path, -1, mode);\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-gzFile ZEXPORT gzdopen(fd, mode)\r
- int fd;\r
- const char *mode;\r
-{\r
- char *path; /* identifier for error messages */\r
- gzFile gz;\r
-\r
- if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)\r
- return NULL;\r
-#if !defined(NO_snprintf) && !defined(NO_vsnprintf)\r
- snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd); /* for debugging */\r
-#else\r
- sprintf(path, "<fd:%d>", fd); /* for debugging */\r
-#endif\r
- gz = gz_open(path, fd, mode);\r
- free(path);\r
- return gz;\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-#ifdef _WIN32\r
-gzFile ZEXPORT gzopen_w(path, mode)\r
- const wchar_t *path;\r
- const char *mode;\r
-{\r
- return gz_open(path, -2, mode);\r
-}\r
-#endif\r
-\r
-/* -- see zlib.h -- */\r
-int ZEXPORT gzbuffer(file, size)\r
- gzFile file;\r
- unsigned size;\r
-{\r
- gz_statep state;\r
-\r
- /* get internal structure and check integrity */\r
- if (file == NULL)\r
- return -1;\r
- state = (gz_statep)file;\r
- if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
- return -1;\r
-\r
- /* make sure we haven't already allocated memory */\r
- if (state->size != 0)\r
- return -1;\r
-\r
- /* check and set requested size */\r
- if (size < 2)\r
- size = 2; /* need two bytes to check magic header */\r
- state->want = size;\r
- return 0;\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-int ZEXPORT gzrewind(file)\r
- gzFile file;\r
-{\r
- gz_statep state;\r
-\r
- /* get internal structure */\r
- if (file == NULL)\r
- return -1;\r
- state = (gz_statep)file;\r
-\r
- /* check that we're reading and that there's no error */\r
- if (state->mode != GZ_READ ||\r
- (state->err != Z_OK && state->err != Z_BUF_ERROR))\r
- return -1;\r
-\r
- /* back up and start over */\r
- if (LSEEK(state->fd, state->start, SEEK_SET) == -1)\r
- return -1;\r
- gz_reset(state);\r
- return 0;\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-z_off64_t ZEXPORT gzseek64(file, offset, whence)\r
- gzFile file;\r
- z_off64_t offset;\r
- int whence;\r
-{\r
- unsigned n;\r
- z_off64_t ret;\r
- gz_statep state;\r
-\r
- /* get internal structure and check integrity */\r
- if (file == NULL)\r
- return -1;\r
- state = (gz_statep)file;\r
- if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
- return -1;\r
-\r
- /* check that there's no error */\r
- if (state->err != Z_OK && state->err != Z_BUF_ERROR)\r
- return -1;\r
-\r
- /* can only seek from start or relative to current position */\r
- if (whence != SEEK_SET && whence != SEEK_CUR)\r
- return -1;\r
-\r
- /* normalize offset to a SEEK_CUR specification */\r
- if (whence == SEEK_SET)\r
- offset -= state->x.pos;\r
- else if (state->seek)\r
- offset += state->skip;\r
- state->seek = 0;\r
-\r
- /* if within raw area while reading, just go there */\r
- if (state->mode == GZ_READ && state->how == COPY &&\r
- state->x.pos + offset >= 0) {\r
- ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR);\r
- if (ret == -1)\r
- return -1;\r
- state->x.have = 0;\r
- state->eof = 0;\r
- state->past = 0;\r
- state->seek = 0;\r
- gz_error(state, Z_OK, NULL);\r
- state->strm.avail_in = 0;\r
- state->x.pos += offset;\r
- return state->x.pos;\r
- }\r
-\r
- /* calculate skip amount, rewinding if needed for back seek when reading */\r
- if (offset < 0) {\r
- if (state->mode != GZ_READ) /* writing -- can't go backwards */\r
- return -1;\r
- offset += state->x.pos;\r
- if (offset < 0) /* before start of file! */\r
- return -1;\r
- if (gzrewind(file) == -1) /* rewind, then skip to offset */\r
- return -1;\r
- }\r
-\r
- /* if reading, skip what's in output buffer (one less gzgetc() check) */\r
- if (state->mode == GZ_READ) {\r
- n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?\r
- (unsigned)offset : state->x.have;\r
- state->x.have -= n;\r
- state->x.next += n;\r
- state->x.pos += n;\r
- offset -= n;\r
- }\r
-\r
- /* request skip (if not zero) */\r
- if (offset) {\r
- state->seek = 1;\r
- state->skip = offset;\r
- }\r
- return state->x.pos + offset;\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-z_off_t ZEXPORT gzseek(file, offset, whence)\r
- gzFile file;\r
- z_off_t offset;\r
- int whence;\r
-{\r
- z_off64_t ret;\r
-\r
- ret = gzseek64(file, (z_off64_t)offset, whence);\r
- return ret == (z_off_t)ret ? (z_off_t)ret : -1;\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-z_off64_t ZEXPORT gztell64(file)\r
- gzFile file;\r
-{\r
- gz_statep state;\r
-\r
- /* get internal structure and check integrity */\r
- if (file == NULL)\r
- return -1;\r
- state = (gz_statep)file;\r
- if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
- return -1;\r
-\r
- /* return position */\r
- return state->x.pos + (state->seek ? state->skip : 0);\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-z_off_t ZEXPORT gztell(file)\r
- gzFile file;\r
-{\r
- z_off64_t ret;\r
-\r
- ret = gztell64(file);\r
- return ret == (z_off_t)ret ? (z_off_t)ret : -1;\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-z_off64_t ZEXPORT gzoffset64(file)\r
- gzFile file;\r
-{\r
- z_off64_t offset;\r
- gz_statep state;\r
-\r
- /* get internal structure and check integrity */\r
- if (file == NULL)\r
- return -1;\r
- state = (gz_statep)file;\r
- if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
- return -1;\r
-\r
- /* compute and return effective offset in file */\r
- offset = LSEEK(state->fd, 0, SEEK_CUR);\r
- if (offset == -1)\r
- return -1;\r
- if (state->mode == GZ_READ) /* reading */\r
- offset -= state->strm.avail_in; /* don't count buffered input */\r
- return offset;\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-z_off_t ZEXPORT gzoffset(file)\r
- gzFile file;\r
-{\r
- z_off64_t ret;\r
-\r
- ret = gzoffset64(file);\r
- return ret == (z_off_t)ret ? (z_off_t)ret : -1;\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-int ZEXPORT gzeof(file)\r
- gzFile file;\r
-{\r
- gz_statep state;\r
-\r
- /* get internal structure and check integrity */\r
- if (file == NULL)\r
- return 0;\r
- state = (gz_statep)file;\r
- if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
- return 0;\r
-\r
- /* return end-of-file state */\r
- return state->mode == GZ_READ ? state->past : 0;\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-const char * ZEXPORT gzerror(file, errnum)\r
- gzFile file;\r
- int *errnum;\r
-{\r
- gz_statep state;\r
-\r
- /* get internal structure and check integrity */\r
- if (file == NULL)\r
- return NULL;\r
- state = (gz_statep)file;\r
- if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
- return NULL;\r
-\r
- /* return error information */\r
- if (errnum != NULL)\r
- *errnum = state->err;\r
- return state->err == Z_MEM_ERROR ? "out of memory" :\r
- (state->msg == NULL ? "" : state->msg);\r
-}\r
-\r
-/* -- see zlib.h -- */\r
-void ZEXPORT gzclearerr(file)\r
- gzFile file;\r
-{\r
- gz_statep state;\r
-\r
- /* get internal structure and check integrity */\r
- if (file == NULL)\r
- return;\r
- state = (gz_statep)file;\r
- if (state->mode != GZ_READ && state->mode != GZ_WRITE)\r
- return;\r
-\r
- /* clear error and end-of-file */\r
- if (state->mode == GZ_READ) {\r
- state->eof = 0;\r
- state->past = 0;\r
- }\r
- gz_error(state, Z_OK, NULL);\r
-}\r
-\r
-/* Create an error message in allocated memory and set state->err and\r
- state->msg accordingly. Free any previous error message already there. Do\r
- not try to free or allocate space if the error is Z_MEM_ERROR (out of\r
- memory). Simply save the error message as a static string. If there is an\r
- allocation failure constructing the error message, then convert the error to\r
- out of memory. */\r
-void ZLIB_INTERNAL gz_error(state, err, msg)\r
- gz_statep state;\r
- int err;\r
- const char *msg;\r
-{\r
- /* free previously allocated message and clear */\r
- if (state->msg != NULL) {\r
- if (state->err != Z_MEM_ERROR)\r
- free(state->msg);\r
- state->msg = NULL;\r
- }\r
-\r
- /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */\r
- if (err != Z_OK && err != Z_BUF_ERROR)\r
- state->x.have = 0;\r
-\r
- /* set error code, and if no message, then done */\r
- state->err = err;\r
- if (msg == NULL)\r
- return;\r
-\r
- /* for an out of memory error, return literal string when requested */\r
- if (err == Z_MEM_ERROR)\r
- return;\r
-\r
- /* construct error message with path */\r
- if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) ==\r
- NULL) {\r
- state->err = Z_MEM_ERROR;\r
- return;\r
- }\r
-#if !defined(NO_snprintf) && !defined(NO_vsnprintf)\r
- snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,\r
- "%s%s%s", state->path, ": ", msg);\r
-#else\r
- strcpy(state->msg, state->path);\r
- strcat(state->msg, ": ");\r
- strcat(state->msg, msg);\r
-#endif\r
- return;\r
-}\r
-\r
-#ifndef INT_MAX\r
-/* portably return maximum value for an int (when limits.h presumed not\r
- available) -- we need to do this to cover cases where 2's complement not\r
- used, since C standard permits 1's complement and sign-bit representations,\r
- otherwise we could just use ((unsigned)-1) >> 1 */\r
-unsigned ZLIB_INTERNAL gz_intmax()\r
-{\r
- unsigned p, q;\r
-\r
- p = 1;\r
- do {\r
- q = p;\r
- p <<= 1;\r
- p++;\r
- } while (p > q);\r
- return q >> 1;\r
-}\r
-#endif\r
projects / mirror_edk2.git / blobdiff