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