1 /*

     2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     3  *

     4  * This code is free software; you can redistribute it and/or modify it

     5  * under the terms of the GNU General Public License version 2 only, as

     6  * published by the Free Software Foundation.  Oracle designates this

     7  * particular file as subject to the "Classpath" exception as provided

     8  * by Oracle in the LICENSE file that accompanied this code.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  */

    24 

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

    26  * Copyright (C) 2004-2017 Mark Adler

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

    28  */

    29 

    30 #include "gzguts.h"

    31 

    32 #if defined(_WIN32) && !defined(__BORLANDC__) && !defined(__MINGW32__)

    33 #  define LSEEK _lseeki64

    34 #else

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

    36 #  define LSEEK lseek64

    37 #else

    38 #  define LSEEK lseek

    39 #endif

    40 #endif

    41 

    42 /* Local functions */

    43 local void gz_reset OF((gz_statep));

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

    45 

    46 #if defined UNDER_CE

    47 

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

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

    50    from GetLastError.

    51 

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

    53    overwritten by a subsequent call to gz_strwinerror

    54 

    55    The gz_strwinerror function does not change the current setting of

    56    GetLastError. */

    57 char ZLIB_INTERNAL *gz_strwinerror (error)

    58      DWORD error;

    59 {

    60     static char buf[1024];

    61 

    62     wchar_t *msgbuf;

    63     DWORD lasterr = GetLastError();

    64     DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM

    65         | FORMAT_MESSAGE_ALLOCATE_BUFFER,

    66         NULL,

    67         error,

    68         0, /* Default language */

    69         (LPVOID)&msgbuf,

    70         0,

    71         NULL);

    72     if (chars != 0) {

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

    74         if (chars >= 2

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

    76             chars -= 2;

    77             msgbuf[chars] = 0;

    78         }

    79 

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

    81             chars = sizeof (buf) - 1;

    82             msgbuf[chars] = 0;

    83         }

    84 

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

    86         LocalFree(msgbuf);

    87     }

    88     else {

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

    90     }

    91 

    92     SetLastError(lasterr);

    93     return buf;

    94 }

    95 

    96 #endif /* UNDER_CE */

    97 

    98 /* Reset gzip file state */

    99 local void gz_reset(state)

   100     gz_statep state;

   101 {

   102     state->x.have = 0;              /* no output data available */

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

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

   105         state->past = 0;            /* have not read past end yet */

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

   107     }

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

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

   110     state->x.pos = 0;               /* no uncompressed data yet */

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

   112 }

   113 

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

   115 local gzFile gz_open(path, fd, mode)

   116     const void *path;

   117     int fd;

   118     const char *mode;

   119 {

   120     gz_statep state;

   121     z_size_t len;

   122     int oflag;

   123 #ifdef O_CLOEXEC

   124     int cloexec = 0;

   125 #endif

   126 #ifdef O_EXCL

   127     int exclusive = 0;

   128 #endif

   129 

   130     /* check input */

   131     if (path == NULL)

   132         return NULL;

   133 

   134     /* allocate gzFile structure to return */

   135     state = (gz_statep)malloc(sizeof(gz_state));

   136     if (state == NULL)

   137         return NULL;

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

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

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

   141 

   142     /* interpret mode */

   143     state->mode = GZ_NONE;

   144     state->level = Z_DEFAULT_COMPRESSION;

   145     state->strategy = Z_DEFAULT_STRATEGY;

   146     state->direct = 0;

   147     while (*mode) {

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

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

   150         else

   151             switch (*mode) {

   152             case 'r':

   153                 state->mode = GZ_READ;

   154                 break;

   155 #ifndef NO_GZCOMPRESS

   156             case 'w':

   157                 state->mode = GZ_WRITE;

   158                 break;

   159             case 'a':

   160                 state->mode = GZ_APPEND;

   161                 break;

   162 #endif

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

   164                 free(state);

   165                 return NULL;

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

   167                 break;

   168 #ifdef O_CLOEXEC

   169             case 'e':

   170                 cloexec = 1;

   171                 break;

   172 #endif

   173 #ifdef O_EXCL

   174             case 'x':

   175                 exclusive = 1;

   176                 break;

   177 #endif

   178             case 'f':

   179                 state->strategy = Z_FILTERED;

   180                 break;

   181             case 'h':

   182                 state->strategy = Z_HUFFMAN_ONLY;

   183                 break;

   184             case 'R':

   185                 state->strategy = Z_RLE;

   186                 break;

   187             case 'F':

   188                 state->strategy = Z_FIXED;

   189                 break;

   190             case 'T':

   191                 state->direct = 1;

   192                 break;

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

   194                 ;

   195             }

   196         mode++;

   197     }

   198 

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

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

   201         free(state);

   202         return NULL;

   203     }

   204 

   205     /* can't force transparent read */

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

   207         if (state->direct) {

   208             free(state);

   209             return NULL;

   210         }

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

   212     }

   213 

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

   215 #ifdef WIDECHAR

   216     if (fd == -2) {

   217         len = wcstombs(NULL, path, 0);

   218         if (len == (z_size_t)-1)

   219             len = 0;

   220     }

   221     else

   222 #endif

   223         len = strlen((const char *)path);

   224     state->path = (char *)malloc(len + 1);

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

   226         free(state);

   227         return NULL;

   228     }

   229 #ifdef WIDECHAR

   230     if (fd == -2)

   231         if (len)

   232             wcstombs(state->path, path, len + 1);

   233         else

   234             *(state->path) = 0;

   235     else

   236 #endif

   237 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)

   238         (void)snprintf(state->path, len + 1, "%s", (const char *)path);

   239 #else

   240         strcpy(state->path, path);

   241 #endif

   242 

   243     /* compute the flags for open() */

   244     oflag =

   245 #ifdef O_LARGEFILE

   246         O_LARGEFILE |

   247 #endif

   248 #ifdef O_BINARY

   249         O_BINARY |

   250 #endif

   251 #ifdef O_CLOEXEC

   252         (cloexec ? O_CLOEXEC : 0) |

   253 #endif

   254         (state->mode == GZ_READ ?

   255          O_RDONLY :

   256          (O_WRONLY | O_CREAT |

   257 #ifdef O_EXCL

   258           (exclusive ? O_EXCL : 0) |

   259 #endif

   260           (state->mode == GZ_WRITE ?

   261            O_TRUNC :

   262            O_APPEND)));

   263 

   264     /* open the file with the appropriate flags (or just use fd) */

   265     state->fd = fd > -1 ? fd : (

   266 #ifdef WIDECHAR

   267         fd == -2 ? _wopen(path, oflag, 0666) :

   268 #endif

   269         open((const char *)path, oflag, 0666));

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

   271         free(state->path);

   272         free(state);

   273         return NULL;

   274     }

   275     if (state->mode == GZ_APPEND) {

   276         LSEEK(state->fd, 0, SEEK_END);  /* so gzoffset() is correct */

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

   278     }

   279 

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

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

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

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

   284     }

   285 

   286     /* initialize stream */

   287     gz_reset(state);

   288 

   289     /* return stream */

   290     return (gzFile)state;

   291 }

   292 

   293 /* -- see zlib.h -- */

   294 gzFile ZEXPORT gzopen(path, mode)

   295     const char *path;

   296     const char *mode;

   297 {

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

   299 }

   300 

   301 /* -- see zlib.h -- */

   302 gzFile ZEXPORT gzopen64(path, mode)

   303     const char *path;

   304     const char *mode;

   305 {

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

   307 }

   308 

   309 /* -- see zlib.h -- */

   310 gzFile ZEXPORT gzdopen(fd, mode)

   311     int fd;

   312     const char *mode;

   313 {

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

   315     gzFile gz;

   316 

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

   318         return NULL;

   319 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)

   320     (void)snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd);

   321 #else

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

   323 #endif

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

   325     free(path);

   326     return gz;

   327 }

   328 

   329 /* -- see zlib.h -- */

   330 #ifdef WIDECHAR

   331 gzFile ZEXPORT gzopen_w(path, mode)

   332     const wchar_t *path;

   333     const char *mode;

   334 {

   335     return gz_open(path, -2, mode);

   336 }

   337 #endif

   338 

   339 /* -- see zlib.h -- */

   340 int ZEXPORT gzbuffer(file, size)

   341     gzFile file;

   342     unsigned size;

   343 {

   344     gz_statep state;

   345 

   346     /* get internal structure and check integrity */

   347     if (file == NULL)

   348         return -1;

   349     state = (gz_statep)file;

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

   351         return -1;

   352 

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

   354     if (state->size != 0)

   355         return -1;

   356 

   357     /* check and set requested size */

   358     if ((size << 1) < size)

   359         return -1;              /* need to be able to double it */

   360     if (size < 2)

   361         size = 2;               /* need two bytes to check magic header */

   362     state->want = size;

   363     return 0;

   364 }

   365 

   366 /* -- see zlib.h -- */

   367 int ZEXPORT gzrewind(file)

   368     gzFile file;

   369 {

   370     gz_statep state;

   371 

   372     /* get internal structure */

   373     if (file == NULL)

   374         return -1;

   375     state = (gz_statep)file;

   376 

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

   378     if (state->mode != GZ_READ ||

   379             (state->err != Z_OK && state->err != Z_BUF_ERROR))

   380         return -1;

   381 

   382     /* back up and start over */

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

   384         return -1;

   385     gz_reset(state);

   386     return 0;

   387 }

   388 

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

   390 z_off64_t ZEXPORT gzseek64(file, offset, whence)

   391     gzFile file;

   392     z_off64_t offset;

   393     int whence;

   394 {

   395     unsigned n;

   396     z_off64_t ret;

   397     gz_statep state;

   398 

   399     /* get internal structure and check integrity */

   400     if (file == NULL)

   401         return -1;

   402     state = (gz_statep)file;

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

   404         return -1;

   405 

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

   407     if (state->err != Z_OK && state->err != Z_BUF_ERROR)

   408         return -1;

   409 

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

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

   412         return -1;

   413 

   414     /* normalize offset to a SEEK_CUR specification */

   415     if (whence == SEEK_SET)

   416         offset -= state->x.pos;

   417     else if (state->seek)

   418         offset += state->skip;

   419     state->seek = 0;

   420 

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

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

   423             state->x.pos + offset >= 0) {

   424         ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR);

   425         if (ret == -1)

   426             return -1;

   427         state->x.have = 0;

   428         state->eof = 0;

   429         state->past = 0;

   430         state->seek = 0;

   431         gz_error(state, Z_OK, NULL);

   432         state->strm.avail_in = 0;

   433         state->x.pos += offset;

   434         return state->x.pos;

   435     }

   436 

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

   438     if (offset < 0) {

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

   440             return -1;

   441         offset += state->x.pos;

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

   443             return -1;

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

   445             return -1;

   446     }

   447 

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

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

   450         n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?

   451             (unsigned)offset : state->x.have;

   452         state->x.have -= n;

   453         state->x.next += n;

   454         state->x.pos += n;

   455         offset -= n;

   456     }

   457 

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

   459     if (offset) {

   460         state->seek = 1;

   461         state->skip = offset;

   462     }

   463     return state->x.pos + offset;

   464 }

   465 

   466 /* -- see zlib.h -- */

   467 z_off_t ZEXPORT gzseek(file, offset, whence)

   468     gzFile file;

   469     z_off_t offset;

   470     int whence;

   471 {

   472     z_off64_t ret;

   473 

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

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

   476 }

   477 

   478 /* -- see zlib.h -- */

   479 z_off64_t ZEXPORT gztell64(file)

   480     gzFile file;

   481 {

   482     gz_statep state;

   483 

   484     /* get internal structure and check integrity */

   485     if (file == NULL)

   486         return -1;

   487     state = (gz_statep)file;

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

   489         return -1;

   490 

   491     /* return position */

   492     return state->x.pos + (state->seek ? state->skip : 0);

   493 }

   494 

   495 /* -- see zlib.h -- */

   496 z_off_t ZEXPORT gztell(file)

   497     gzFile file;

   498 {

   499     z_off64_t ret;

   500 

   501     ret = gztell64(file);

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

   503 }

   504 

   505 /* -- see zlib.h -- */

   506 z_off64_t ZEXPORT gzoffset64(file)

   507     gzFile file;

   508 {

   509     z_off64_t offset;

   510     gz_statep state;

   511 

   512     /* get internal structure and check integrity */

   513     if (file == NULL)

   514         return -1;

   515     state = (gz_statep)file;

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

   517         return -1;

   518 

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

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

   521     if (offset == -1)

   522         return -1;

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

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

   525     return offset;

   526 }

   527 

   528 /* -- see zlib.h -- */

   529 z_off_t ZEXPORT gzoffset(file)

   530     gzFile file;

   531 {

   532     z_off64_t ret;

   533 

   534     ret = gzoffset64(file);

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

   536 }

   537 

   538 /* -- see zlib.h -- */

   539 int ZEXPORT gzeof(file)

   540     gzFile file;

   541 {

   542     gz_statep state;

   543 

   544     /* get internal structure and check integrity */

   545     if (file == NULL)

   546         return 0;

   547     state = (gz_statep)file;

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

   549         return 0;

   550 

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

   552     return state->mode == GZ_READ ? state->past : 0;

   553 }

   554 

   555 /* -- see zlib.h -- */

   556 const char * ZEXPORT gzerror(file, errnum)

   557     gzFile file;

   558     int *errnum;

   559 {

   560     gz_statep state;

   561 

   562     /* get internal structure and check integrity */

   563     if (file == NULL)

   564         return NULL;

   565     state = (gz_statep)file;

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

   567         return NULL;

   568 

   569     /* return error information */

   570     if (errnum != NULL)

   571         *errnum = state->err;

   572     return state->err == Z_MEM_ERROR ? "out of memory" :

   573                                        (state->msg == NULL ? "" : state->msg);

   574 }

   575 

   576 /* -- see zlib.h -- */

   577 void ZEXPORT gzclearerr(file)

   578     gzFile file;

   579 {

   580     gz_statep state;

   581 

   582     /* get internal structure and check integrity */

   583     if (file == NULL)

   584         return;

   585     state = (gz_statep)file;

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

   587         return;

   588 

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

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

   591         state->eof = 0;

   592         state->past = 0;

   593     }

   594     gz_error(state, Z_OK, NULL);

   595 }

   596 

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

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

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

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

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

   602    out of memory. */

   603 void ZLIB_INTERNAL gz_error(state, err, msg)

   604     gz_statep state;

   605     int err;

   606     const char *msg;

   607 {

   608     /* free previously allocated message and clear */

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

   610         if (state->err != Z_MEM_ERROR)

   611             free(state->msg);

   612         state->msg = NULL;

   613     }

   614 

   615     /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */

   616     if (err != Z_OK && err != Z_BUF_ERROR)

   617         state->x.have = 0;

   618 

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

   620     state->err = err;

   621     if (msg == NULL)

   622         return;

   623 

   624     /* for an out of memory error, return literal string when requested */

   625     if (err == Z_MEM_ERROR)

   626         return;

   627 

   628     /* construct error message with path */

   629     if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) ==

   630             NULL) {

   631         state->err = Z_MEM_ERROR;

   632         return;

   633     }

   634 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)

   635     (void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,

   636                    "%s%s%s", state->path, ": ", msg);

   637 #else

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

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

   640     strcat(state->msg, msg);

   641 #endif

   642 }

   643 

   644 #ifndef INT_MAX

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

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

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

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

   649 unsigned ZLIB_INTERNAL gz_intmax()

   650 {

   651     unsigned p, q;

   652 

   653     p = 1;

   654     do {

   655         q = p;

   656         p <<= 1;

   657         p++;

   658     } while (p > q);

   659     return q >> 1;

   660 }

   661 #endif