release/src/router/zlib/gzlib.c

   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  */
   5
   6 #include "gzguts.h"
   7
   8 #if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
   9 #  define LSEEK lseek64
  10 #else
  11 #  define LSEEK lseek
  12 #endif
  13
  14 /* Local functions */
  15 local void gz_reset OF((gz_statep));
  16 local gzFile gz_open OF((const char *, int, const char *));
  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 (error)
  30      DWORD error;
  31 {
  32     static char buf[1024];
  33
  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         }
  51
  52         if (chars > sizeof (buf) - 1) {
  53             chars = sizeof (buf) - 1;
  54             msgbuf[chars] = 0;
  55         }
  56
  57         wcstombs(buf, msgbuf, chars + 1);
  58         LocalFree(msgbuf);
  59     }
  60     else {
  61         sprintf(buf, "unknown win32 error (%ld)", error);
  62     }
  63
  64     SetLastError(lasterr);
  65     return buf;
  66 }
  67
  68 #endif /* UNDER_CE */
  69
  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 }
  85
  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;
  93
  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 */
 101
 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     }
 143
 144     /* must provide an "r", "w", or "a" */
 145     if (state->mode == GZ_NONE) {
 146         free(state);
 147         return NULL;
 148     }
 149
 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);
 157
 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 */
 181
 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     }
 187
 188     /* initialize stream */
 189     gz_reset(state);
 190
 191     /* return stream */
 192     return (gzFile)state;
 193 }
 194
 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 }
 202
 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 }
 210
 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;
 218
 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 }
 226
 227 /* -- see zlib.h -- */
 228 int ZEXPORT gzbuffer(file, size)
 229     gzFile file;
 230     unsigned size;
 231 {
 232     gz_statep state;
 233
 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;
 240
 241     /* make sure we haven't already allocated memory */
 242     if (state->size != 0)
 243         return -1;
 244
 245     /* check and set requested size */
 246     if (size == 0)
 247         return -1;
 248     state->want = size;
 249     return 0;
 250 }
 251
 252 /* -- see zlib.h -- */
 253 int ZEXPORT gzrewind(file)
 254     gzFile file;
 255 {
 256     gz_statep state;
 257
 258     /* get internal structure */
 259     if (file == NULL)
 260         return -1;
 261     state = (gz_statep)file;
 262
 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;
 266
 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 }
 273
 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;
 283
 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;
 290
 291     /* check that there's no error */
 292     if (state->err != Z_OK)
 293         return -1;
 294
 295     /* can only seek from start or relative to current position */
 296     if (whence != SEEK_SET && whence != SEEK_CUR)
 297         return -1;
 298
 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;
 305
 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     }
 320
 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     }
 331
 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     }
 341
 342     /* request skip (if not zero) */
 343     if (offset) {
 344         state->seek = 1;
 345         state->skip = offset;
 346     }
 347     return state->pos + offset;
 348 }
 349
 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;
 357
 358     ret = gzseek64(file, (z_off64_t)offset, whence);
 359     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 360 }
 361
 362 /* -- see zlib.h -- */
 363 z_off64_t ZEXPORT gztell64(file)
 364     gzFile file;
 365 {
 366     gz_statep state;
 367
 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;
 374
 375     /* return position */
 376     return state->pos + (state->seek ? state->skip : 0);
 377 }
 378
 379 /* -- see zlib.h -- */
 380 z_off_t ZEXPORT gztell(file)
 381     gzFile file;
 382 {
 383     z_off64_t ret;
 384
 385     ret = gztell64(file);
 386     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 387 }
 388
 389 /* -- see zlib.h -- */
 390 z_off64_t ZEXPORT gzoffset64(file)
 391     gzFile file;
 392 {
 393     z_off64_t offset;
 394     gz_statep state;
 395
 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;
 402
 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 }
 411
 412 /* -- see zlib.h -- */
 413 z_off_t ZEXPORT gzoffset(file)
 414     gzFile file;
 415 {
 416     z_off64_t ret;
 417
 418     ret = gzoffset64(file);
 419     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 420 }
 421
 422 /* -- see zlib.h -- */
 423 int ZEXPORT gzeof(file)
 424     gzFile file;
 425 {
 426     gz_statep state;
 427
 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;
 434
 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 }
 439
 440 /* -- see zlib.h -- */
 441 const char * ZEXPORT gzerror(file, errnum)
 442     gzFile file;
 443     int *errnum;
 444 {
 445     gz_statep state;
 446
 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;
 453
 454     /* return error information */
 455     if (errnum != NULL)
 456         *errnum = state->err;
 457     return state->msg == NULL ? "" : state->msg;
 458 }
 459
 460 /* -- see zlib.h -- */
 461 void ZEXPORT gzclearerr(file)
 462     gzFile file;
 463 {
 464     gz_statep state;
 465
 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;
 472
 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 }
 478
 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     }
 496
 497     /* set error code, and if no message, then done */
 498     state->err = err;
 499     if (msg == NULL)
 500         return;
 501
 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     }
 507
 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 }
 519
 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;
 528
 529     p = 1;
 530     do {
 531         q = p;
 532         p <<= 1;
 533         p++;
 534     } while (p > q);
 535     return q >> 1;
 536 }
 537 #endif