EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.10 / Modules / zlib / gzlib.c

/* 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