Geant4 Cross Reference |
1 /* gzread.c -- zlib functions for reading gzip 1 2 * Copyright (C) 2004-2017 Mark Adler 3 * For conditions of distribution and use, see 4 */ 5 6 #include "gzguts.h" 7 8 /* Local functions */ 9 local int gz_load OF((gz_statep, unsigned char 10 local int gz_avail OF((gz_statep)); 11 local int gz_look OF((gz_statep)); 12 local int gz_decomp OF((gz_statep)); 13 local int gz_fetch OF((gz_statep)); 14 local int gz_skip OF((gz_statep, z_off64_t)); 15 local z_size_t gz_read OF((gz_statep, voidp, z 16 17 /* Use read() to load a buffer -- return -1 on 18 state->fd, and update state->eof, state->er 19 This function needs to loop on read(), sinc 20 read the number of bytes requested, dependi 21 local int gz_load(state, buf, len, have) 22 gz_statep state; 23 unsigned char *buf; 24 unsigned len; 25 unsigned *have; 26 { 27 int ret; 28 unsigned get, max = ((unsigned)-1 >> 2) + 29 30 *have = 0; 31 do { 32 get = len - *have; 33 if (get > max) 34 get = max; 35 ret = read(state->fd, buf + *have, get 36 if (ret <= 0) 37 break; 38 *have += (unsigned)ret; 39 } while (*have < len); 40 if (ret < 0) { 41 gz_error(state, Z_ERRNO, zstrerror()); 42 return -1; 43 } 44 if (ret == 0) 45 state->eof = 1; 46 return 0; 47 } 48 49 /* Load up input buffer and set eof flag if la 50 error, 0 otherwise. Note that the eof flag 51 file is reached, even though there may be u 52 that data has been used, no more attempts w 53 If strm->avail_in != 0, then the current da 54 the input buffer, and then the remainder of 55 available data from the input file. */ 56 local int gz_avail(state) 57 gz_statep state; 58 { 59 unsigned got; 60 z_streamp strm = &(state->strm); 61 62 if (state->err != Z_OK && state->err != Z_ 63 return -1; 64 if (state->eof == 0) { 65 if (strm->avail_in) { /* copy wh 66 unsigned char *p = state->in; 67 unsigned const char *q = strm->nex 68 unsigned n = strm->avail_in; 69 do { 70 *p++ = *q++; 71 } while (--n); 72 } 73 if (gz_load(state, state->in + strm->a 74 state->size - strm->avail_ 75 return -1; 76 strm->avail_in += got; 77 strm->next_in = state->in; 78 } 79 return 0; 80 } 81 82 /* Look for gzip header, set up for inflate or 83 If this is the first time in, allocate requ 84 left unchanged if there is no more input da 85 if there is no gzip header and direct copyi 86 be set to GZIP for decompression. If direc 87 data from the input buffer will be copied t 88 case, all further file reads will be direct 89 a user buffer. If decompressing, the infla 90 gz_look() will return 0 on success or -1 on 91 local int gz_look(state) 92 gz_statep state; 93 { 94 z_streamp strm = &(state->strm); 95 96 /* allocate read buffers and inflate memor 97 if (state->size == 0) { 98 /* allocate buffers */ 99 state->in = (unsigned char *)malloc(st 100 state->out = (unsigned char *)malloc(s 101 if (state->in == NULL || state->out == 102 free(state->out); 103 free(state->in); 104 gz_error(state, Z_MEM_ERROR, "out 105 return -1; 106 } 107 state->size = state->want; 108 109 /* allocate inflate memory */ 110 state->strm.zalloc = Z_NULL; 111 state->strm.zfree = Z_NULL; 112 state->strm.opaque = Z_NULL; 113 state->strm.avail_in = 0; 114 state->strm.next_in = Z_NULL; 115 if (inflateInit2(&(state->strm), 15 + 116 free(state->out); 117 free(state->in); 118 state->size = 0; 119 gz_error(state, Z_MEM_ERROR, "out 120 return -1; 121 } 122 } 123 124 /* get at least the magic bytes in the inp 125 if (strm->avail_in < 2) { 126 if (gz_avail(state) == -1) 127 return -1; 128 if (strm->avail_in == 0) 129 return 0; 130 } 131 132 /* look for gzip magic bytes -- if there, 133 a logical dilemma here when considering 134 gzip file, to wit, if a single 31 byte 135 whether this is a single-byte file, or 136 file -- for here we assume that if a gz 137 the header will be written in a single 138 single byte is sufficient indication th 139 if (strm->avail_in > 1 && 140 strm->next_in[0] == 31 && strm->ne 141 inflateReset(strm); 142 state->how = GZIP; 143 state->direct = 0; 144 return 0; 145 } 146 147 /* no gzip header -- if we were decoding g 148 garbage. Ignore the trailing garbage a 149 if (state->direct == 0) { 150 strm->avail_in = 0; 151 state->eof = 1; 152 state->x.have = 0; 153 return 0; 154 } 155 156 /* doing raw i/o, copy any leftover input 157 the output buffer is larger than the in 158 space for gzungetc() */ 159 state->x.next = state->out; 160 memcpy(state->x.next, strm->next_in, strm- 161 state->x.have = strm->avail_in; 162 strm->avail_in = 0; 163 state->how = COPY; 164 state->direct = 1; 165 return 0; 166 } 167 168 /* Decompress from input to the provided next_ 169 On return, state->x.have and state->x.next 170 data. If the gzip stream completes, state- 171 the next gzip stream or raw data, once stat 172 on success, -1 on failure. */ 173 local int gz_decomp(state) 174 gz_statep state; 175 { 176 int ret = Z_OK; 177 unsigned had; 178 z_streamp strm = &(state->strm); 179 180 /* fill output buffer up to end of deflate 181 had = strm->avail_out; 182 do { 183 /* get more input for inflate() */ 184 if (strm->avail_in == 0 && gz_avail(st 185 return -1; 186 if (strm->avail_in == 0) { 187 gz_error(state, Z_BUF_ERROR, "unex 188 break; 189 } 190 191 /* decompress and handle errors */ 192 ret = inflate(strm, Z_NO_FLUSH); 193 if (ret == Z_STREAM_ERROR || ret == Z_ 194 gz_error(state, Z_STREAM_ERROR, 195 "internal error: inflate 196 return -1; 197 } 198 if (ret == Z_MEM_ERROR) { 199 gz_error(state, Z_MEM_ERROR, "out 200 return -1; 201 } 202 if (ret == Z_DATA_ERROR) { 203 gz_error(state, Z_DATA_ERROR, 204 strm->msg == NULL ? "comp 205 return -1; 206 } 207 } while (strm->avail_out && ret != Z_STREA 208 209 /* update available output */ 210 state->x.have = had - strm->avail_out; 211 state->x.next = strm->next_out - state->x. 212 213 /* if the gzip stream completed successful 214 if (ret == Z_STREAM_END) 215 state->how = LOOK; 216 217 /* good decompression */ 218 return 0; 219 } 220 221 /* Fetch data and put it in the output buffer. 222 Data is either copied from the input file o 223 file depending on state->how. If state->ho 224 looked for to determine whether to copy or 225 otherwise 0. gz_fetch() will leave state-> 226 end of the input file has been reached and 227 local int gz_fetch(state) 228 gz_statep state; 229 { 230 z_streamp strm = &(state->strm); 231 232 do { 233 switch(state->how) { 234 case LOOK: /* -> LOOK, COPY (only 235 if (gz_look(state) == -1) 236 return -1; 237 if (state->how == LOOK) 238 return 0; 239 break; 240 case COPY: /* -> COPY */ 241 if (gz_load(state, state->out, sta 242 == -1) 243 return -1; 244 state->x.next = state->out; 245 return 0; 246 case GZIP: /* -> GZIP or LOOK (if 247 strm->avail_out = state->size << 1 248 strm->next_out = state->out; 249 if (gz_decomp(state) == -1) 250 return -1; 251 } 252 } while (state->x.have == 0 && (!state->eo 253 return 0; 254 } 255 256 /* Skip len uncompressed bytes of output. Ret 257 local int gz_skip(state, len) 258 gz_statep state; 259 z_off64_t len; 260 { 261 unsigned n; 262 263 /* skip over len bytes or reach end-of-fil 264 while (len) 265 /* skip over whatever is in output buf 266 if (state->x.have) { 267 n = GT_OFF(state->x.have) || (z_of 268 (unsigned)len : state->x.have; 269 state->x.have -= n; 270 state->x.next += n; 271 state->x.pos += n; 272 len -= n; 273 } 274 275 /* output buffer empty -- return if we 276 else if (state->eof && state->strm.ava 277 break; 278 279 /* need more data to skip -- load up o 280 else { 281 /* get more output, looking for he 282 if (gz_fetch(state) == -1) 283 return -1; 284 } 285 return 0; 286 } 287 288 /* Read len bytes into buf from file, or less 289 input. Return the number of bytes read. I 290 end of file was reached, or there was an er 291 consulted in that case to determine which. 292 local z_size_t gz_read(state, buf, len) 293 gz_statep state; 294 voidp buf; 295 z_size_t len; 296 { 297 z_size_t got; 298 unsigned n; 299 300 /* if len is zero, avoid unnecessary opera 301 if (len == 0) 302 return 0; 303 304 /* process a skip request */ 305 if (state->seek) { 306 state->seek = 0; 307 if (gz_skip(state, state->skip) == -1) 308 return 0; 309 } 310 311 /* get len bytes to buf, or less than len 312 got = 0; 313 do { 314 /* set n to the maximum amount of len 315 n = (unsigned)-1; 316 if (n > len) 317 n = (unsigned)len; 318 319 /* first just try copying data from th 320 if (state->x.have) { 321 if (state->x.have < n) 322 n = state->x.have; 323 memcpy(buf, state->x.next, n); 324 state->x.next += n; 325 state->x.have -= n; 326 } 327 328 /* output buffer empty -- return if we 329 else if (state->eof && state->strm.ava 330 state->past = 1; /* tried t 331 break; 332 } 333 334 /* need output data -- for small len o 335 buffer */ 336 else if (state->how == LOOK || n < (st 337 /* get more output, looking for he 338 if (gz_fetch(state) == -1) 339 return 0; 340 continue; /* no progress yet 341 /* the copy above assures that we 342 output buffer, allowing at leas 343 } 344 345 /* large len -- read directly into use 346 else if (state->how == COPY) { /* 347 if (gz_load(state, (unsigned char 348 return 0; 349 } 350 351 /* large len -- decompress directly in 352 else { /* state->how == GZIP */ 353 state->strm.avail_out = n; 354 state->strm.next_out = (unsigned c 355 if (gz_decomp(state) == -1) 356 return 0; 357 n = state->x.have; 358 state->x.have = 0; 359 } 360 361 /* update progress */ 362 len -= n; 363 buf = (char *)buf + n; 364 got += n; 365 state->x.pos += n; 366 } while (len); 367 368 /* return number of bytes read into user b 369 return got; 370 } 371 372 /* -- see zlib.h -- */ 373 int ZEXPORT gzread(file, buf, len) 374 gzFile file; 375 voidp buf; 376 unsigned len; 377 { 378 gz_statep state; 379 380 /* get internal structure */ 381 if (file == NULL) 382 return -1; 383 state = (gz_statep)file; 384 385 /* check that we're reading and that there 386 if (state->mode != GZ_READ || 387 (state->err != Z_OK && state->err 388 return -1; 389 390 /* since an int is returned, make sure len 391 with an error (this avoids a flaw in th 392 if ((int)len < 0) { 393 gz_error(state, Z_STREAM_ERROR, "reque 394 return -1; 395 } 396 397 /* read len or fewer bytes to buf */ 398 len = (unsigned)gz_read(state, buf, len); 399 400 /* check for an error */ 401 if (len == 0 && state->err != Z_OK && stat 402 return -1; 403 404 /* return the number of bytes read (this i 405 return (int)len; 406 } 407 408 /* -- see zlib.h -- */ 409 z_size_t ZEXPORT gzfread(buf, size, nitems, fi 410 voidp buf; 411 z_size_t size; 412 z_size_t nitems; 413 gzFile file; 414 { 415 z_size_t len; 416 gz_statep state; 417 418 /* get internal structure */ 419 if (file == NULL) 420 return 0; 421 state = (gz_statep)file; 422 423 /* check that we're reading and that there 424 if (state->mode != GZ_READ || 425 (state->err != Z_OK && state->err 426 return 0; 427 428 /* compute bytes to read -- error on overf 429 len = nitems * size; 430 if (size && len / size != nitems) { 431 gz_error(state, Z_STREAM_ERROR, "reque 432 return 0; 433 } 434 435 /* read len or fewer bytes to buf, return 436 return len ? gz_read(state, buf, len) / si 437 } 438 439 /* -- see zlib.h -- */ 440 #ifdef Z_PREFIX_SET 441 # undef z_gzgetc 442 #else 443 # undef gzgetc 444 #endif 445 int ZEXPORT gzgetc(file) 446 gzFile file; 447 { 448 unsigned char buf[1]; 449 gz_statep state; 450 451 /* get internal structure */ 452 if (file == NULL) 453 return -1; 454 state = (gz_statep)file; 455 456 /* check that we're reading and that there 457 if (state->mode != GZ_READ || 458 (state->err != Z_OK && state->err != Z 459 return -1; 460 461 /* try output buffer (no need to check for 462 if (state->x.have) { 463 state->x.have--; 464 state->x.pos++; 465 return *(state->x.next)++; 466 } 467 468 /* nothing there -- try gz_read() */ 469 return gz_read(state, buf, 1) < 1 ? -1 : b 470 } 471 472 int ZEXPORT gzgetc_(file) 473 gzFile file; 474 { 475 return gzgetc(file); 476 } 477 478 /* -- see zlib.h -- */ 479 int ZEXPORT gzungetc(c, file) 480 int c; 481 gzFile file; 482 { 483 gz_statep state; 484 485 /* get internal structure */ 486 if (file == NULL) 487 return -1; 488 state = (gz_statep)file; 489 490 /* check that we're reading and that there 491 if (state->mode != GZ_READ || 492 (state->err != Z_OK && state->err != Z 493 return -1; 494 495 /* process a skip request */ 496 if (state->seek) { 497 state->seek = 0; 498 if (gz_skip(state, state->skip) == -1) 499 return -1; 500 } 501 502 /* can't push EOF */ 503 if (c < 0) 504 return -1; 505 506 /* if output buffer empty, put byte at end 507 if (state->x.have == 0) { 508 state->x.have = 1; 509 state->x.next = state->out + (state->s 510 state->x.next[0] = (unsigned char)c; 511 state->x.pos--; 512 state->past = 0; 513 return c; 514 } 515 516 /* if no room, give up (must have already 517 if (state->x.have == (state->size << 1)) { 518 gz_error(state, Z_DATA_ERROR, "out of 519 return -1; 520 } 521 522 /* slide output data if needed and insert 523 if (state->x.next == state->out) { 524 unsigned char *src = state->out + stat 525 unsigned char *dest = state->out + (st 526 while (src > state->out) 527 *--dest = *--src; 528 state->x.next = dest; 529 } 530 state->x.have++; 531 state->x.next--; 532 state->x.next[0] = (unsigned char)c; 533 state->x.pos--; 534 state->past = 0; 535 return c; 536 } 537 538 /* -- see zlib.h -- */ 539 char * ZEXPORT gzgets(file, buf, len) 540 gzFile file; 541 char *buf; 542 int len; 543 { 544 unsigned left, n; 545 char *str; 546 unsigned char *eol; 547 gz_statep state; 548 549 /* check parameters and get internal struc 550 if (file == NULL || buf == NULL || len < 1 551 return NULL; 552 state = (gz_statep)file; 553 554 /* check that we're reading and that there 555 if (state->mode != GZ_READ || 556 (state->err != Z_OK && state->err != Z 557 return NULL; 558 559 /* process a skip request */ 560 if (state->seek) { 561 state->seek = 0; 562 if (gz_skip(state, state->skip) == -1) 563 return NULL; 564 } 565 566 /* copy output bytes up to new line or len 567 append a terminating zero to the string 568 the contents, let the user worry about 569 str = buf; 570 left = (unsigned)len - 1; 571 if (left) do { 572 /* assure that something is in the out 573 if (state->x.have == 0 && gz_fetch(sta 574 return NULL; /* err 575 if (state->x.have == 0) { /* end 576 state->past = 1; /* rea 577 break; /* ret 578 } 579 580 /* look for end-of-line in current out 581 n = state->x.have > left ? left : stat 582 eol = (unsigned char *)memchr(state->x 583 if (eol != NULL) 584 n = (unsigned)(eol - state->x.next 585 586 /* copy through end-of-line, or remain 587 memcpy(buf, state->x.next, n); 588 state->x.have -= n; 589 state->x.next += n; 590 state->x.pos += n; 591 left -= n; 592 buf += n; 593 } while (left && eol == NULL); 594 595 /* return terminated string, or if nothing 596 if (buf == str) 597 return NULL; 598 buf[0] = 0; 599 return str; 600 } 601 602 /* -- see zlib.h -- */ 603 int ZEXPORT gzdirect(file) 604 gzFile file; 605 { 606 gz_statep state; 607 608 /* get internal structure */ 609 if (file == NULL) 610 return 0; 611 state = (gz_statep)file; 612 613 /* if the state is not known, but we can f 614 mainly for right after a gzopen() or gz 615 if (state->mode == GZ_READ && state->how = 616 (void)gz_look(state); 617 618 /* return 1 if transparent, 0 if processin 619 return state->direct; 620 } 621 622 /* -- see zlib.h -- */ 623 int ZEXPORT gzclose_r(file) 624 gzFile file; 625 { 626 int ret, err; 627 gz_statep state; 628 629 /* get internal structure */ 630 if (file == NULL) 631 return Z_STREAM_ERROR; 632 state = (gz_statep)file; 633 634 /* check that we're reading */ 635 if (state->mode != GZ_READ) 636 return Z_STREAM_ERROR; 637 638 /* free memory and close file */ 639 if (state->size) { 640 inflateEnd(&(state->strm)); 641 free(state->out); 642 free(state->in); 643 } 644 err = state->err == Z_BUF_ERROR ? Z_BUF_ER 645 gz_error(state, Z_OK, NULL); 646 free(state->path); 647 ret = close(state->fd); 648 free(state); 649 return ret ? Z_ERRNO : err; 650 } 651