The Tor Browser: security/nss/lib/zlib/gzlib.c@b8a032363ba2

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     1 /* gzlib.c -- zlib functions common to reading and writing gzip files

     2  * Copyright (C) 2004, 2010 Mark Adler

     3  * For conditions of distribution and use, see copyright notice in zlib.h

     4  */

     6 #include "gzguts.h"

     8 #if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0

     9 #  define LSEEK lseek64

    10 #else

    11 #  define LSEEK lseek

    12 #endif

    14 /* Local functions */

    15 local void gz_reset OF((gz_statep));

    16 local gzFile gz_open OF((const char *, int, const char *));

    18 #if defined UNDER_CE

    20 /* Map the Windows error number in ERROR to a locale-dependent error message

    21    string and return a pointer to it.  Typically, the values for ERROR come

    22    from GetLastError.

    24    The string pointed to shall not be modified by the application, but may be

    25    overwritten by a subsequent call to gz_strwinerror

    27    The gz_strwinerror function does not change the current setting of

    28    GetLastError. */

    29 char ZLIB_INTERNAL *gz_strwinerror (error)

    30      DWORD error;

    31 {

    32     static char buf[1024];

    34     wchar_t *msgbuf;

    35     DWORD lasterr = GetLastError();

    36     DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM

    37         | FORMAT_MESSAGE_ALLOCATE_BUFFER,

    38         NULL,

    39         error,

    40         0, /* Default language */

    41         (LPVOID)&msgbuf,

    42         0,

    43         NULL);

    44     if (chars != 0) {

    45         /* If there is an \r\n appended, zap it.  */

    46         if (chars >= 2

    47             && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {

    48             chars -= 2;

    49             msgbuf[chars] = 0;

    50         }

    52         if (chars > sizeof (buf) - 1) {

    53             chars = sizeof (buf) - 1;

    54             msgbuf[chars] = 0;

    55         }

    57         wcstombs(buf, msgbuf, chars + 1);

    58         LocalFree(msgbuf);

    59     }

    60     else {

    61         sprintf(buf, "unknown win32 error (%ld)", error);

    62     }

    64     SetLastError(lasterr);

    65     return buf;

    66 }

    68 #endif /* UNDER_CE */

    70 /* Reset gzip file state */

    71 local void gz_reset(state)

    72     gz_statep state;

    73 {

    74     if (state->mode == GZ_READ) {   /* for reading ... */

    75         state->have = 0;            /* no output data available */

    76         state->eof = 0;             /* not at end of file */

    77         state->how = LOOK;          /* look for gzip header */

    78         state->direct = 1;          /* default for empty file */

    79     }

    80     state->seek = 0;                /* no seek request pending */

    81     gz_error(state, Z_OK, NULL);    /* clear error */

    82     state->pos = 0;                 /* no uncompressed data yet */

    83     state->strm.avail_in = 0;       /* no input data yet */

    84 }

    86 /* Open a gzip file either by name or file descriptor. */

    87 local gzFile gz_open(path, fd, mode)

    88     const char *path;

    89     int fd;

    90     const char *mode;

    91 {

    92     gz_statep state;

    94     /* allocate gzFile structure to return */

    95     state = malloc(sizeof(gz_state));

    96     if (state == NULL)

    97         return NULL;

    98     state->size = 0;            /* no buffers allocated yet */

    99     state->want = GZBUFSIZE;    /* requested buffer size */

   100     state->msg = NULL;          /* no error message yet */

   102     /* interpret mode */

   103     state->mode = GZ_NONE;

   104     state->level = Z_DEFAULT_COMPRESSION;

   105     state->strategy = Z_DEFAULT_STRATEGY;

   106     while (*mode) {

   107         if (*mode >= '0' && *mode <= '9')

   108             state->level = *mode - '0';

   109         else

   110             switch (*mode) {

   111             case 'r':

   112                 state->mode = GZ_READ;

   113                 break;

   114 #ifndef NO_GZCOMPRESS

   115             case 'w':

   116                 state->mode = GZ_WRITE;

   117                 break;

   118             case 'a':

   119                 state->mode = GZ_APPEND;

   120                 break;

   121 #endif

   122             case '+':       /* can't read and write at the same time */

   123                 free(state);

   124                 return NULL;

   125             case 'b':       /* ignore -- will request binary anyway */

   126                 break;

   127             case 'f':

   128                 state->strategy = Z_FILTERED;

   129                 break;

   130             case 'h':

   131                 state->strategy = Z_HUFFMAN_ONLY;

   132                 break;

   133             case 'R':

   134                 state->strategy = Z_RLE;

   135                 break;

   136             case 'F':

   137                 state->strategy = Z_FIXED;

   138             default:        /* could consider as an error, but just ignore */

   139                 ;

   140             }

   141         mode++;

   142     }

   144     /* must provide an "r", "w", or "a" */

   145     if (state->mode == GZ_NONE) {

   146         free(state);

   147         return NULL;

   148     }

   150     /* save the path name for error messages */

   151     state->path = malloc(strlen(path) + 1);

   152     if (state->path == NULL) {

   153         free(state);

   154         return NULL;

   155     }

   156     strcpy(state->path, path);

   158     /* open the file with the appropriate mode (or just use fd) */

   159     state->fd = fd != -1 ? fd :

   160         open(path,

   161 #ifdef O_LARGEFILE

   162             O_LARGEFILE |

   163 #endif

   164 #ifdef O_BINARY

   165             O_BINARY |

   166 #endif

   167             (state->mode == GZ_READ ?

   168                 O_RDONLY :

   169                 (O_WRONLY | O_CREAT | (

   170                     state->mode == GZ_WRITE ?

   171                         O_TRUNC :

   172                         O_APPEND))),

   173             0666);

   174     if (state->fd == -1) {

   175         free(state->path);

   176         free(state);

   177         return NULL;

   178     }

   179     if (state->mode == GZ_APPEND)

   180         state->mode = GZ_WRITE;         /* simplify later checks */

   182     /* save the current position for rewinding (only if reading) */

   183     if (state->mode == GZ_READ) {

   184         state->start = LSEEK(state->fd, 0, SEEK_CUR);

   185         if (state->start == -1) state->start = 0;

   186     }

   188     /* initialize stream */

   189     gz_reset(state);

   191     /* return stream */

   192     return (gzFile)state;

   193 }

   195 /* -- see zlib.h -- */

   196 gzFile ZEXPORT gzopen(path, mode)

   197     const char *path;

   198     const char *mode;

   199 {

   200     return gz_open(path, -1, mode);

   201 }

   203 /* -- see zlib.h -- */

   204 gzFile ZEXPORT gzopen64(path, mode)

   205     const char *path;

   206     const char *mode;

   207 {

   208     return gz_open(path, -1, mode);

   209 }

   211 /* -- see zlib.h -- */

   212 gzFile ZEXPORT gzdopen(fd, mode)

   213     int fd;

   214     const char *mode;

   215 {

   216     char *path;         /* identifier for error messages */

   217     gzFile gz;

   219     if (fd == -1 || (path = malloc(7 + 3 * sizeof(int))) == NULL)

   220         return NULL;

   221     sprintf(path, "<fd:%d>", fd);   /* for debugging */

   222     gz = gz_open(path, fd, mode);

   223     free(path);

   224     return gz;

   225 }

   227 /* -- see zlib.h -- */

   228 int ZEXPORT gzbuffer(file, size)

   229     gzFile file;

   230     unsigned size;

   231 {

   232     gz_statep state;

   234     /* get internal structure and check integrity */

   235     if (file == NULL)

   236         return -1;

   237     state = (gz_statep)file;

   238     if (state->mode != GZ_READ && state->mode != GZ_WRITE)

   239         return -1;

   241     /* make sure we haven't already allocated memory */

   242     if (state->size != 0)

   243         return -1;

   245     /* check and set requested size */

   246     if (size == 0)

   247         return -1;

   248     state->want = size;

   249     return 0;

   250 }

   252 /* -- see zlib.h -- */

   253 int ZEXPORT gzrewind(file)

   254     gzFile file;

   255 {

   256     gz_statep state;

   258     /* get internal structure */

   259     if (file == NULL)

   260         return -1;

   261     state = (gz_statep)file;

   263     /* check that we're reading and that there's no error */

   264     if (state->mode != GZ_READ || state->err != Z_OK)

   265         return -1;

   267     /* back up and start over */

   268     if (LSEEK(state->fd, state->start, SEEK_SET) == -1)

   269         return -1;

   270     gz_reset(state);

   271     return 0;

   272 }

   274 /* -- see zlib.h -- */

   275 z_off64_t ZEXPORT gzseek64(file, offset, whence)

   276     gzFile file;

   277     z_off64_t offset;

   278     int whence;

   279 {

   280     unsigned n;

   281     z_off64_t ret;

   282     gz_statep state;

   284     /* get internal structure and check integrity */

   285     if (file == NULL)

   286         return -1;

   287     state = (gz_statep)file;

   288     if (state->mode != GZ_READ && state->mode != GZ_WRITE)

   289         return -1;

   291     /* check that there's no error */

   292     if (state->err != Z_OK)

   293         return -1;

   295     /* can only seek from start or relative to current position */

   296     if (whence != SEEK_SET && whence != SEEK_CUR)

   297         return -1;

   299     /* normalize offset to a SEEK_CUR specification */

   300     if (whence == SEEK_SET)

   301         offset -= state->pos;

   302     else if (state->seek)

   303         offset += state->skip;

   304     state->seek = 0;

   306     /* if within raw area while reading, just go there */

   307     if (state->mode == GZ_READ && state->how == COPY &&

   308         state->pos + offset >= state->raw) {

   309         ret = LSEEK(state->fd, offset - state->have, SEEK_CUR);

   310         if (ret == -1)

   311             return -1;

   312         state->have = 0;

   313         state->eof = 0;

   314         state->seek = 0;

   315         gz_error(state, Z_OK, NULL);

   316         state->strm.avail_in = 0;

   317         state->pos += offset;

   318         return state->pos;

   319     }

   321     /* calculate skip amount, rewinding if needed for back seek when reading */

   322     if (offset < 0) {

   323         if (state->mode != GZ_READ)         /* writing -- can't go backwards */

   324             return -1;

   325         offset += state->pos;

   326         if (offset < 0)                     /* before start of file! */

   327             return -1;

   328         if (gzrewind(file) == -1)           /* rewind, then skip to offset */

   329             return -1;

   330     }

   332     /* if reading, skip what's in output buffer (one less gzgetc() check) */

   333     if (state->mode == GZ_READ) {

   334         n = GT_OFF(state->have) || (z_off64_t)state->have > offset ?

   335             (unsigned)offset : state->have;

   336         state->have -= n;

   337         state->next += n;

   338         state->pos += n;

   339         offset -= n;

   340     }

   342     /* request skip (if not zero) */

   343     if (offset) {

   344         state->seek = 1;

   345         state->skip = offset;

   346     }

   347     return state->pos + offset;

   348 }

   350 /* -- see zlib.h -- */

   351 z_off_t ZEXPORT gzseek(file, offset, whence)

   352     gzFile file;

   353     z_off_t offset;

   354     int whence;

   355 {

   356     z_off64_t ret;

   358     ret = gzseek64(file, (z_off64_t)offset, whence);

   359     return ret == (z_off_t)ret ? (z_off_t)ret : -1;

   360 }

   362 /* -- see zlib.h -- */

   363 z_off64_t ZEXPORT gztell64(file)

   364     gzFile file;

   365 {

   366     gz_statep state;

   368     /* get internal structure and check integrity */

   369     if (file == NULL)

   370         return -1;

   371     state = (gz_statep)file;

   372     if (state->mode != GZ_READ && state->mode != GZ_WRITE)

   373         return -1;

   375     /* return position */

   376     return state->pos + (state->seek ? state->skip : 0);

   377 }

   379 /* -- see zlib.h -- */

   380 z_off_t ZEXPORT gztell(file)

   381     gzFile file;

   382 {

   383     z_off64_t ret;

   385     ret = gztell64(file);

   386     return ret == (z_off_t)ret ? (z_off_t)ret : -1;

   387 }

   389 /* -- see zlib.h -- */

   390 z_off64_t ZEXPORT gzoffset64(file)

   391     gzFile file;

   392 {

   393     z_off64_t offset;

   394     gz_statep state;

   396     /* get internal structure and check integrity */

   397     if (file == NULL)

   398         return -1;

   399     state = (gz_statep)file;

   400     if (state->mode != GZ_READ && state->mode != GZ_WRITE)

   401         return -1;

   403     /* compute and return effective offset in file */

   404     offset = LSEEK(state->fd, 0, SEEK_CUR);

   405     if (offset == -1)

   406         return -1;

   407     if (state->mode == GZ_READ)             /* reading */

   408         offset -= state->strm.avail_in;     /* don't count buffered input */

   409     return offset;

   410 }

   412 /* -- see zlib.h -- */

   413 z_off_t ZEXPORT gzoffset(file)

   414     gzFile file;

   415 {

   416     z_off64_t ret;

   418     ret = gzoffset64(file);

   419     return ret == (z_off_t)ret ? (z_off_t)ret : -1;

   420 }

   422 /* -- see zlib.h -- */

   423 int ZEXPORT gzeof(file)

   424     gzFile file;

   425 {

   426     gz_statep state;

   428     /* get internal structure and check integrity */

   429     if (file == NULL)

   430         return 0;

   431     state = (gz_statep)file;

   432     if (state->mode != GZ_READ && state->mode != GZ_WRITE)

   433         return 0;

   435     /* return end-of-file state */

   436     return state->mode == GZ_READ ?

   437         (state->eof && state->strm.avail_in == 0 && state->have == 0) : 0;

   438 }

   440 /* -- see zlib.h -- */

   441 const char * ZEXPORT gzerror(file, errnum)

   442     gzFile file;

   443     int *errnum;

   444 {

   445     gz_statep state;

   447     /* get internal structure and check integrity */

   448     if (file == NULL)

   449         return NULL;

   450     state = (gz_statep)file;

   451     if (state->mode != GZ_READ && state->mode != GZ_WRITE)

   452         return NULL;

   454     /* return error information */

   455     if (errnum != NULL)

   456         *errnum = state->err;

   457     return state->msg == NULL ? "" : state->msg;

   458 }

   460 /* -- see zlib.h -- */

   461 void ZEXPORT gzclearerr(file)

   462     gzFile file;

   463 {

   464     gz_statep state;

   466     /* get internal structure and check integrity */

   467     if (file == NULL)

   468         return;

   469     state = (gz_statep)file;

   470     if (state->mode != GZ_READ && state->mode != GZ_WRITE)

   471         return;

   473     /* clear error and end-of-file */

   474     if (state->mode == GZ_READ)

   475         state->eof = 0;

   476     gz_error(state, Z_OK, NULL);

   477 }

   479 /* Create an error message in allocated memory and set state->err and

   480    state->msg accordingly.  Free any previous error message already there.  Do

   481    not try to free or allocate space if the error is Z_MEM_ERROR (out of

   482    memory).  Simply save the error message as a static string.  If there is an

   483    allocation failure constructing the error message, then convert the error to

   484    out of memory. */

   485 void ZLIB_INTERNAL gz_error(state, err, msg)

   486     gz_statep state;

   487     int err;

   488     const char *msg;

   489 {

   490     /* free previously allocated message and clear */

   491     if (state->msg != NULL) {

   492         if (state->err != Z_MEM_ERROR)

   493             free(state->msg);

   494         state->msg = NULL;

   495     }

   497     /* set error code, and if no message, then done */

   498     state->err = err;

   499     if (msg == NULL)

   500         return;

   502     /* for an out of memory error, save as static string */

   503     if (err == Z_MEM_ERROR) {

   504         state->msg = (char *)msg;

   505         return;

   506     }

   508     /* construct error message with path */

   509     if ((state->msg = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) {

   510         state->err = Z_MEM_ERROR;

   511         state->msg = (char *)"out of memory";

   512         return;

   513     }

   514     strcpy(state->msg, state->path);

   515     strcat(state->msg, ": ");

   516     strcat(state->msg, msg);

   517     return;

   518 }

   520 #ifndef INT_MAX

   521 /* portably return maximum value for an int (when limits.h presumed not

   522    available) -- we need to do this to cover cases where 2's complement not

   523    used, since C standard permits 1's complement and sign-bit representations,

   524    otherwise we could just use ((unsigned)-1) >> 1 */

   525 unsigned ZLIB_INTERNAL gz_intmax()

   526 {

   527     unsigned p, q;

   529     p = 1;

   530     do {

   531         q = p;

   532         p <<= 1;

   533         p++;

   534     } while (p > q);

   535     return q >> 1;

   536 }

   537 #endif

The Tor Browser / file revision

security/nss/lib/zlib/gzlib.c@b8a032363ba2

security/nss/lib/zlib/gzlib.c