modules/zlib/src/gzlib.c

   1 /* gzlib.c -- zlib functions common to reading and writing gzip files
   2  * Copyright (C) 2004-2024 Mark Adler
   3  * For conditions of distribution and use, see copyright notice in zlib.h
   4  */
   5
   6 #include "gzguts.h"
   7
   8 #if defined(_WIN32) && !defined(__BORLANDC__)
   9 #  define LSEEK _lseeki64
  10 #else
  11 #if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
  12 #  define LSEEK lseek64
  13 #else
  14 #  define LSEEK lseek
  15 #endif
  16 #endif
  17
  18 #if defined UNDER_CE
  19
  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.
  23
  24    The string pointed to shall not be modified by the application, but may be
  25    overwritten by a subsequent call to gz_strwinerror
  26
  27    The gz_strwinerror function does not change the current setting of
  28    GetLastError. */
  29 char ZLIB_INTERNAL *gz_strwinerror(DWORD error) {
  30     static char buf[1024];
  31
  32     wchar_t *msgbuf;
  33     DWORD lasterr = GetLastError();
  34     DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
  35         | FORMAT_MESSAGE_ALLOCATE_BUFFER,
  36         NULL,
  37         error,
  38         0, /* Default language */
  39         (LPVOID)&msgbuf,
  40         0,
  41         NULL);
  42     if (chars != 0) {
  43         /* If there is an \r\n appended, zap it.  */
  44         if (chars >= 2
  45             && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
  46             chars -= 2;
  47             msgbuf[chars] = 0;
  48         }
  49
  50         if (chars > sizeof (buf) - 1) {
  51             chars = sizeof (buf) - 1;
  52             msgbuf[chars] = 0;
  53         }
  54
  55         wcstombs(buf, msgbuf, chars + 1);
  56         LocalFree(msgbuf);
  57     }
  58     else {
  59         sprintf(buf, "unknown win32 error (%ld)", error);
  60     }
  61
  62     SetLastError(lasterr);
  63     return buf;
  64 }
  65
  66 #endif /* UNDER_CE */
  67
  68 /* Reset gzip file state */
  69 local void gz_reset(gz_statep state) {
  70     state->x.have = 0;              /* no output data available */
  71     if (state->mode == GZ_READ) {   /* for reading ... */
  72         state->eof = 0;             /* not at end of file */
  73         state->past = 0;            /* have not read past end yet */
  74         state->how = LOOK;          /* look for gzip header */
  75     }
  76     else                            /* for writing ... */
  77         state->reset = 0;           /* no deflateReset pending */
  78     state->seek = 0;                /* no seek request pending */
  79     gz_error(state, Z_OK, NULL);    /* clear error */
  80     state->x.pos = 0;               /* no uncompressed data yet */
  81     state->strm.avail_in = 0;       /* no input data yet */
  82 }
  83
  84 /* Open a gzip file either by name or file descriptor. */
  85 local gzFile gz_open(const void *path, int fd, const char *mode) {
  86     gz_statep state;
  87     z_size_t len;
  88     int oflag;
  89 #ifdef O_CLOEXEC
  90     int cloexec = 0;
  91 #endif
  92 #ifdef O_EXCL
  93     int exclusive = 0;
  94 #endif
  95
  96     /* check input */
  97     if (path == NULL)
  98         return NULL;
  99
 100     /* allocate gzFile structure to return */
 101     state = (gz_statep)malloc(sizeof(gz_state));
 102     if (state == NULL)
 103         return NULL;
 104     state->size = 0;            /* no buffers allocated yet */
 105     state->want = GZBUFSIZE;    /* requested buffer size */
 106     state->msg = NULL;          /* no error message yet */
 107
 108     /* interpret mode */
 109     state->mode = GZ_NONE;
 110     state->level = Z_DEFAULT_COMPRESSION;
 111     state->strategy = Z_DEFAULT_STRATEGY;
 112     state->direct = 0;
 113     while (*mode) {
 114         if (*mode >= '0' && *mode <= '9')
 115             state->level = *mode - '0';
 116         else
 117             switch (*mode) {
 118             case 'r':
 119                 state->mode = GZ_READ;
 120                 break;
 121 #ifndef NO_GZCOMPRESS
 122             case 'w':
 123                 state->mode = GZ_WRITE;
 124                 break;
 125             case 'a':
 126                 state->mode = GZ_APPEND;
 127                 break;
 128 #endif
 129             case '+':       /* can't read and write at the same time */
 130                 free(state);
 131                 return NULL;
 132             case 'b':       /* ignore -- will request binary anyway */
 133                 break;
 134 #ifdef O_CLOEXEC
 135             case 'e':
 136                 cloexec = 1;
 137                 break;
 138 #endif
 139 #ifdef O_EXCL
 140             case 'x':
 141                 exclusive = 1;
 142                 break;
 143 #endif
 144             case 'f':
 145                 state->strategy = Z_FILTERED;
 146                 break;
 147             case 'h':
 148                 state->strategy = Z_HUFFMAN_ONLY;
 149                 break;
 150             case 'R':
 151                 state->strategy = Z_RLE;
 152                 break;
 153             case 'F':
 154                 state->strategy = Z_FIXED;
 155                 break;
 156             case 'T':
 157                 state->direct = 1;
 158                 break;
 159             default:        /* could consider as an error, but just ignore */
 160                 ;
 161             }
 162         mode++;
 163     }
 164
 165     /* must provide an "r", "w", or "a" */
 166     if (state->mode == GZ_NONE) {
 167         free(state);
 168         return NULL;
 169     }
 170
 171     /* can't force transparent read */
 172     if (state->mode == GZ_READ) {
 173         if (state->direct) {
 174             free(state);
 175             return NULL;
 176         }
 177         state->direct = 1;      /* for empty file */
 178     }
 179
 180     /* save the path name for error messages */
 181 #ifdef WIDECHAR
 182     if (fd == -2) {
 183         len = wcstombs(NULL, path, 0);
 184         if (len == (z_size_t)-1)
 185             len = 0;
 186     }
 187     else
 188 #endif
 189         len = strlen((const char *)path);
 190     state->path = (char *)malloc(len + 1);
 191     if (state->path == NULL) {
 192         free(state);
 193         return NULL;
 194     }
 195 #ifdef WIDECHAR
 196     if (fd == -2)
 197         if (len)
 198             wcstombs(state->path, path, len + 1);
 199         else
 200             *(state->path) = 0;
 201     else
 202 #endif
 203 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
 204         (void)snprintf(state->path, len + 1, "%s", (const char *)path);
 205 #else
 206         strcpy(state->path, path);
 207 #endif
 208
 209     /* compute the flags for open() */
 210     oflag =
 211 #ifdef O_LARGEFILE
 212         O_LARGEFILE |
 213 #endif
 214 #ifdef O_BINARY
 215         O_BINARY |
 216 #endif
 217 #ifdef O_CLOEXEC
 218         (cloexec ? O_CLOEXEC : 0) |
 219 #endif
 220         (state->mode == GZ_READ ?
 221          O_RDONLY :
 222          (O_WRONLY | O_CREAT |
 223 #ifdef O_EXCL
 224           (exclusive ? O_EXCL : 0) |
 225 #endif
 226           (state->mode == GZ_WRITE ?
 227            O_TRUNC :
 228            O_APPEND)));
 229
 230     /* open the file with the appropriate flags (or just use fd) */
 231     state->fd = fd > -1 ? fd : (
 232 #ifdef WIDECHAR
 233         fd == -2 ? _wopen(path, oflag, 0666) :
 234 #endif
 235         open((const char *)path, oflag, 0666));
 236     if (state->fd == -1) {
 237         free(state->path);
 238         free(state);
 239         return NULL;
 240     }
 241     if (state->mode == GZ_APPEND) {
 242         LSEEK(state->fd, 0, SEEK_END);  /* so gzoffset() is correct */
 243         state->mode = GZ_WRITE;         /* simplify later checks */
 244     }
 245
 246     /* save the current position for rewinding (only if reading) */
 247     if (state->mode == GZ_READ) {
 248         state->start = LSEEK(state->fd, 0, SEEK_CUR);
 249         if (state->start == -1) state->start = 0;
 250     }
 251
 252     /* initialize stream */
 253     gz_reset(state);
 254
 255     /* return stream */
 256     return (gzFile)state;
 257 }
 258
 259 /* -- see zlib.h -- */
 260 gzFile ZEXPORT gzopen(const char *path, const char *mode) {
 261     return gz_open(path, -1, mode);
 262 }
 263
 264 /* -- see zlib.h -- */
 265 gzFile ZEXPORT gzopen64(const char *path, const char *mode) {
 266     return gz_open(path, -1, mode);
 267 }
 268
 269 /* -- see zlib.h -- */
 270 gzFile ZEXPORT gzdopen(int fd, const char *mode) {
 271     char *path;         /* identifier for error messages */
 272     gzFile gz;
 273
 274     if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
 275         return NULL;
 276 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
 277     (void)snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd);
 278 #else
 279     sprintf(path, "<fd:%d>", fd);   /* for debugging */
 280 #endif
 281     gz = gz_open(path, fd, mode);
 282     free(path);
 283     return gz;
 284 }
 285
 286 /* -- see zlib.h -- */
 287 #ifdef WIDECHAR
 288 gzFile ZEXPORT gzopen_w(const wchar_t *path, const char *mode) {
 289     return gz_open(path, -2, mode);
 290 }
 291 #endif
 292
 293 /* -- see zlib.h -- */
 294 int ZEXPORT gzbuffer(gzFile file, unsigned size) {
 295     gz_statep state;
 296
 297     /* get internal structure and check integrity */
 298     if (file == NULL)
 299         return -1;
 300     state = (gz_statep)file;
 301     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 302         return -1;
 303
 304     /* make sure we haven't already allocated memory */
 305     if (state->size != 0)
 306         return -1;
 307
 308     /* check and set requested size */
 309     if ((size << 1) < size)
 310         return -1;              /* need to be able to double it */
 311     if (size < 8)
 312         size = 8;               /* needed to behave well with flushing */
 313     state->want = size;
 314     return 0;
 315 }
 316
 317 /* -- see zlib.h -- */
 318 int ZEXPORT gzrewind(gzFile file) {
 319     gz_statep state;
 320
 321     /* get internal structure */
 322     if (file == NULL)
 323         return -1;
 324     state = (gz_statep)file;
 325
 326     /* check that we're reading and that there's no error */
 327     if (state->mode != GZ_READ ||
 328             (state->err != Z_OK && state->err != Z_BUF_ERROR))
 329         return -1;
 330
 331     /* back up and start over */
 332     if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
 333         return -1;
 334     gz_reset(state);
 335     return 0;
 336 }
 337
 338 /* -- see zlib.h -- */
 339 z_off64_t ZEXPORT gzseek64(gzFile file, z_off64_t offset, int whence) {
 340     unsigned n;
 341     z_off64_t ret;
 342     gz_statep state;
 343
 344     /* get internal structure and check integrity */
 345     if (file == NULL)
 346         return -1;
 347     state = (gz_statep)file;
 348     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 349         return -1;
 350
 351     /* check that there's no error */
 352     if (state->err != Z_OK && state->err != Z_BUF_ERROR)
 353         return -1;
 354
 355     /* can only seek from start or relative to current position */
 356     if (whence != SEEK_SET && whence != SEEK_CUR)
 357         return -1;
 358
 359     /* normalize offset to a SEEK_CUR specification */
 360     if (whence == SEEK_SET)
 361         offset -= state->x.pos;
 362     else if (state->seek)
 363         offset += state->skip;
 364     state->seek = 0;
 365
 366     /* if within raw area while reading, just go there */
 367     if (state->mode == GZ_READ && state->how == COPY &&
 368             state->x.pos + offset >= 0) {
 369         ret = LSEEK(state->fd, offset - (z_off64_t)state->x.have, SEEK_CUR);
 370         if (ret == -1)
 371             return -1;
 372         state->x.have = 0;
 373         state->eof = 0;
 374         state->past = 0;
 375         state->seek = 0;
 376         gz_error(state, Z_OK, NULL);
 377         state->strm.avail_in = 0;
 378         state->x.pos += offset;
 379         return state->x.pos;
 380     }
 381
 382     /* calculate skip amount, rewinding if needed for back seek when reading */
 383     if (offset < 0) {
 384         if (state->mode != GZ_READ)         /* writing -- can't go backwards */
 385             return -1;
 386         offset += state->x.pos;
 387         if (offset < 0)                     /* before start of file! */
 388             return -1;
 389         if (gzrewind(file) == -1)           /* rewind, then skip to offset */
 390             return -1;
 391     }
 392
 393     /* if reading, skip what's in output buffer (one less gzgetc() check) */
 394     if (state->mode == GZ_READ) {
 395         n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?
 396             (unsigned)offset : state->x.have;
 397         state->x.have -= n;
 398         state->x.next += n;
 399         state->x.pos += n;
 400         offset -= n;
 401     }
 402
 403     /* request skip (if not zero) */
 404     if (offset) {
 405         state->seek = 1;
 406         state->skip = offset;
 407     }
 408     return state->x.pos + offset;
 409 }
 410
 411 /* -- see zlib.h -- */
 412 z_off_t ZEXPORT gzseek(gzFile file, z_off_t offset, int whence) {
 413     z_off64_t ret;
 414
 415     ret = gzseek64(file, (z_off64_t)offset, whence);
 416     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 417 }
 418
 419 /* -- see zlib.h -- */
 420 z_off64_t ZEXPORT gztell64(gzFile file) {
 421     gz_statep state;
 422
 423     /* get internal structure and check integrity */
 424     if (file == NULL)
 425         return -1;
 426     state = (gz_statep)file;
 427     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 428         return -1;
 429
 430     /* return position */
 431     return state->x.pos + (state->seek ? state->skip : 0);
 432 }
 433
 434 /* -- see zlib.h -- */
 435 z_off_t ZEXPORT gztell(gzFile file) {
 436     z_off64_t ret;
 437
 438     ret = gztell64(file);
 439     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 440 }
 441
 442 /* -- see zlib.h -- */
 443 z_off64_t ZEXPORT gzoffset64(gzFile file) {
 444     z_off64_t offset;
 445     gz_statep state;
 446
 447     /* get internal structure and check integrity */
 448     if (file == NULL)
 449         return -1;
 450     state = (gz_statep)file;
 451     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 452         return -1;
 453
 454     /* compute and return effective offset in file */
 455     offset = LSEEK(state->fd, 0, SEEK_CUR);
 456     if (offset == -1)
 457         return -1;
 458     if (state->mode == GZ_READ)             /* reading */
 459         offset -= state->strm.avail_in;     /* don't count buffered input */
 460     return offset;
 461 }
 462
 463 /* -- see zlib.h -- */
 464 z_off_t ZEXPORT gzoffset(gzFile file) {
 465     z_off64_t ret;
 466
 467     ret = gzoffset64(file);
 468     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 469 }
 470
 471 /* -- see zlib.h -- */
 472 int ZEXPORT gzeof(gzFile file) {
 473     gz_statep state;
 474
 475     /* get internal structure and check integrity */
 476     if (file == NULL)
 477         return 0;
 478     state = (gz_statep)file;
 479     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 480         return 0;
 481
 482     /* return end-of-file state */
 483     return state->mode == GZ_READ ? state->past : 0;
 484 }
 485
 486 /* -- see zlib.h -- */
 487 const char * ZEXPORT gzerror(gzFile file, int *errnum) {
 488     gz_statep state;
 489
 490     /* get internal structure and check integrity */
 491     if (file == NULL)
 492         return NULL;
 493     state = (gz_statep)file;
 494     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 495         return NULL;
 496
 497     /* return error information */
 498     if (errnum != NULL)
 499         *errnum = state->err;
 500     return state->err == Z_MEM_ERROR ? "out of memory" :
 501                                        (state->msg == NULL ? "" : state->msg);
 502 }
 503
 504 /* -- see zlib.h -- */
 505 void ZEXPORT gzclearerr(gzFile file) {
 506     gz_statep state;
 507
 508     /* get internal structure and check integrity */
 509     if (file == NULL)
 510         return;
 511     state = (gz_statep)file;
 512     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 513         return;
 514
 515     /* clear error and end-of-file */
 516     if (state->mode == GZ_READ) {
 517         state->eof = 0;
 518         state->past = 0;
 519     }
 520     gz_error(state, Z_OK, NULL);
 521 }
 522
 523 /* Create an error message in allocated memory and set state->err and
 524    state->msg accordingly.  Free any previous error message already there.  Do
 525    not try to free or allocate space if the error is Z_MEM_ERROR (out of
 526    memory).  Simply save the error message as a static string.  If there is an
 527    allocation failure constructing the error message, then convert the error to
 528    out of memory. */
 529 void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg) {
 530     /* free previously allocated message and clear */
 531     if (state->msg != NULL) {
 532         if (state->err != Z_MEM_ERROR)
 533             free(state->msg);
 534         state->msg = NULL;
 535     }
 536
 537     /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */
 538     if (err != Z_OK && err != Z_BUF_ERROR)
 539         state->x.have = 0;
 540
 541     /* set error code, and if no message, then done */
 542     state->err = err;
 543     if (msg == NULL)
 544         return;
 545
 546     /* for an out of memory error, return literal string when requested */
 547     if (err == Z_MEM_ERROR)
 548         return;
 549
 550     /* construct error message with path */
 551     if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) ==
 552             NULL) {
 553         state->err = Z_MEM_ERROR;
 554         return;
 555     }
 556 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
 557     (void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
 558                    "%s%s%s", state->path, ": ", msg);
 559 #else
 560     strcpy(state->msg, state->path);
 561     strcat(state->msg, ": ");
 562     strcat(state->msg, msg);
 563 #endif
 564 }
 565
 566 /* portably return maximum value for an int (when limits.h presumed not
 567    available) -- we need to do this to cover cases where 2's complement not
 568    used, since C standard permits 1's complement and sign-bit representations,
 569    otherwise we could just use ((unsigned)-1) >> 1 */
 570 unsigned ZLIB_INTERNAL gz_intmax(void) {
 571 #ifdef INT_MAX
 572     return INT_MAX;
 573 #else
 574     unsigned p = 1, q;
 575     do {
 576         q = p;
 577         p <<= 1;
 578         p++;
 579     } while (p > q);
 580     return q >> 1;
 581 #endif
 582 }