notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
pcsxr-1.9.92
[pcsx_rearmed.git] / win32 / zlib / gzio.c
CommitLineData
ef79bbde
P		 1/* gzio.c -- IO on .gz files
2 * Copyright (C) 1995-2002 Jean-loup Gailly.
3 * For conditions of distribution and use, see copyright notice in zlib.h
4 *
5 * Compile this file with -DNO_DEFLATE to avoid the compression code.
6 */
7
8/* @(#) $Id$ */
9
10#include <stdio.h>
11
12#include "zutil.h"
13
14#ifdef _MSC_VER
15#pragma warning (disable:4996)
16#endif
17
18struct internal_state {int dummy;}; /* for buggy compilers */
19
20#ifndef Z_BUFSIZE
21# ifdef MAXSEG_64K
22# define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
23# else
24# define Z_BUFSIZE 16384
25# endif
26#endif
27#ifndef Z_PRINTF_BUFSIZE
28# define Z_PRINTF_BUFSIZE 4096
29#endif
30
31#define ALLOC(size) malloc(size)
32#define TRYFREE(p) {if (p) free(p);}
33
34static int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
35
36/* gzip flag byte */
37#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
38#define HEAD_CRC 0x02 /* bit 1 set: header CRC present */
39#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
40#define ORIG_NAME 0x08 /* bit 3 set: original file name present */
41#define COMMENT 0x10 /* bit 4 set: file comment present */
42#define RESERVED 0xE0 /* bits 5..7: reserved */
43
44typedef struct gz_stream {
45 z_stream stream;
46 int z_err; /* error code for last stream operation */
47 int z_eof; /* set if end of input file */
48 FILE *file; /* .gz file */
49 Byte *inbuf; /* input buffer */
50 Byte *outbuf; /* output buffer */
51 uLong crc; /* crc32 of uncompressed data */
52 char *msg; /* error message */
53 char *path; /* path name for debugging only */
54 int transparent; /* 1 if input file is not a .gz file */
55 char mode; /* 'w' or 'r' */
56 long startpos; /* start of compressed data in file (header skipped) */
57} gz_stream;
58
59
60local gzFile gz_open OF((const char *path, const char *mode, int fd));
61local int do_flush OF((gzFile file, int flush));
62local int get_byte OF((gz_stream *s));
63local void check_header OF((gz_stream *s));
64local int destroy OF((gz_stream *s));
65local void putLong OF((FILE *file, uLong x));
66local uLong getLong OF((gz_stream *s));
67
68/* ===========================================================================
69 Opens a gzip (.gz) file for reading or writing. The mode parameter
70 is as in fopen ("rb" or "wb"). The file is given either by file descriptor
71 or path name (if fd == -1).
72 gz_open return NULL if the file could not be opened or if there was
73 insufficient memory to allocate the (de)compression state; errno
74 can be checked to distinguish the two cases (if errno is zero, the
75 zlib error is Z_MEM_ERROR).
76*/
77local gzFile gz_open (path, mode, fd)
78 const char *path;
79 const char *mode;
80 int fd;
81{
82 int err;
83 int level = Z_DEFAULT_COMPRESSION; /* compression level */
84 int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
85 char *p = (char*)mode;
86 gz_stream *s;
87 char fmode[80]; /* copy of mode, without the compression level */
88 char *m = fmode;
89
90 if (!path || !mode) return Z_NULL;
91
92 s = (gz_stream *)ALLOC(sizeof(gz_stream));
93 if (!s) return Z_NULL;
94
95 s->stream.zalloc = (alloc_func)0;
96 s->stream.zfree = (free_func)0;
97 s->stream.opaque = (voidpf)0;
98 s->stream.next_in = s->inbuf = Z_NULL;
99 s->stream.next_out = s->outbuf = Z_NULL;
100 s->stream.avail_in = s->stream.avail_out = 0;
101 s->file = NULL;
102 s->z_err = Z_OK;
103 s->z_eof = 0;
104 s->crc = crc32(0L, Z_NULL, 0);
105 s->msg = NULL;
106 s->transparent = 0;
107
108 s->path = (char*)ALLOC(strlen(path)+1);
109 if (s->path == NULL) {
110 return destroy(s), (gzFile)Z_NULL;
111 }
112 strcpy(s->path, path); /* do this early for debugging */
113
114 s->mode = '\0';
115 do {
116 if (*p == 'r') s->mode = 'r';
117 if (*p == 'w' || *p == 'a') s->mode = 'w';
118 if (*p >= '0' && *p <= '9') {
119 level = *p - '0';
120 } else if (*p == 'f') {
121 strategy = Z_FILTERED;
122 } else if (*p == 'h') {
123 strategy = Z_HUFFMAN_ONLY;
124 } else {
125 *m++ = *p; /* copy the mode */
126 }
127 } while (*p++ && m != fmode + sizeof(fmode));
128 if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
129
130 if (s->mode == 'w') {
131#ifdef NO_DEFLATE
132 err = Z_STREAM_ERROR;
133#else
134 err = deflateInit2(&(s->stream), level,
135 Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
136 /* windowBits is passed < 0 to suppress zlib header */
137
138 s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
139#endif
140 if (err != Z_OK || s->outbuf == Z_NULL) {
141 return destroy(s), (gzFile)Z_NULL;
142 }
143 } else {
144 s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
145
146 err = inflateInit2(&(s->stream), -MAX_WBITS);
147 /* windowBits is passed < 0 to tell that there is no zlib header.
148 * Note that in this case inflate *requires* an extra "dummy" byte
149 * after the compressed stream in order to complete decompression and
150 * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
151 * present after the compressed stream.
152 */
153 if (err != Z_OK || s->inbuf == Z_NULL) {
154 return destroy(s), (gzFile)Z_NULL;
155 }
156 }
157 s->stream.avail_out = Z_BUFSIZE;
158
159 errno = 0;
160 s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
161
162 if (s->file == NULL) {
163 return destroy(s), (gzFile)Z_NULL;
164 }
165 if (s->mode == 'w') {
166 /* Write a very simple .gz header:
167 */
168 fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
169 Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
170 s->startpos = 10L;
171 /* We use 10L instead of ftell(s->file) to because ftell causes an
172 * fflush on some systems. This version of the library doesn't use
173 * startpos anyway in write mode, so this initialization is not
174 * necessary.
175 */
176 } else {
177 check_header(s); /* skip the .gz header */
178 s->startpos = (ftell(s->file) - s->stream.avail_in);
179 }
180
181 return (gzFile)s;
182}
183
184/* ===========================================================================
185 Opens a gzip (.gz) file for reading or writing.
186*/
187gzFile ZEXPORT gzopen (path, mode)
188 const char *path;
189 const char *mode;
190{
191 return gz_open (path, mode, -1);
192}
193
194/* ===========================================================================
195 Associate a gzFile with the file descriptor fd. fd is not dup'ed here
196 to mimic the behavio(u)r of fdopen.
197*/
198gzFile ZEXPORT gzdopen (fd, mode)
199 int fd;
200 const char *mode;
201{
202 char name[20];
203
204 if (fd < 0) return (gzFile)Z_NULL;
205 sprintf(name, "<fd:%d>", fd); /* for debugging */
206
207 return gz_open (name, mode, fd);
208}
209
210/* ===========================================================================
211 * Update the compression level and strategy
212 */
213int ZEXPORT gzsetparams (file, level, strategy)
214 gzFile file;
215 int level;
216 int strategy;
217{
218 gz_stream *s = (gz_stream*)file;
219
220 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
221
222 /* Make room to allow flushing */
223 if (s->stream.avail_out == 0) {
224
225 s->stream.next_out = s->outbuf;
226 if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
227 s->z_err = Z_ERRNO;
228 }
229 s->stream.avail_out = Z_BUFSIZE;
230 }
231
232 return deflateParams (&(s->stream), level, strategy);
233}
234
235/* ===========================================================================
236 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
237 for end of file.
238 IN assertion: the stream s has been sucessfully opened for reading.
239*/
240local int get_byte(s)
241 gz_stream *s;
242{
243 if (s->z_eof) return EOF;
244 if (s->stream.avail_in == 0) {
245 errno = 0;
246 s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
247 if (s->stream.avail_in == 0) {
248 s->z_eof = 1;
249 if (ferror(s->file)) s->z_err = Z_ERRNO;
250 return EOF;
251 }
252 s->stream.next_in = s->inbuf;
253 }
254 s->stream.avail_in--;
255 return *(s->stream.next_in)++;
256}
257
258/* ===========================================================================
259 Check the gzip header of a gz_stream opened for reading. Set the stream
260 mode to transparent if the gzip magic header is not present; set s->err
261 to Z_DATA_ERROR if the magic header is present but the rest of the header
262 is incorrect.
263 IN assertion: the stream s has already been created sucessfully;
264 s->stream.avail_in is zero for the first time, but may be non-zero
265 for concatenated .gz files.
266*/
267local void check_header(s)
268 gz_stream *s;
269{
270 int method; /* method byte */
271 int flags; /* flags byte */
272 uInt len;
273 int c;
274
275 /* Check the gzip magic header */
276 for (len = 0; len < 2; len++) {
277 c = get_byte(s);
278 if (c != gz_magic[len]) {
279 if (len != 0) s->stream.avail_in++, s->stream.next_in--;
280 if (c != EOF) {
281 s->stream.avail_in++, s->stream.next_in--;
282 s->transparent = 1;
283 }
284 s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
285 return;
286 }
287 }
288 method = get_byte(s);
289 flags = get_byte(s);
290 if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
291 s->z_err = Z_DATA_ERROR;
292 return;
293 }
294
295 /* Discard time, xflags and OS code: */
296 for (len = 0; len < 6; len++) (void)get_byte(s);
297
298 if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
299 len = (uInt)get_byte(s);
300 len += ((uInt)get_byte(s))<<8;
301 /* len is garbage if EOF but the loop below will quit anyway */
302 while (len-- != 0 && get_byte(s) != EOF) ;
303 }
304 if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
305 while ((c = get_byte(s)) != 0 && c != EOF) ;
306 }
307 if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
308 while ((c = get_byte(s)) != 0 && c != EOF) ;
309 }
310 if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
311 for (len = 0; len < 2; len++) (void)get_byte(s);
312 }
313 s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
314}
315
316 /* ===========================================================================
317 * Cleanup then free the given gz_stream. Return a zlib error code.
318 Try freeing in the reverse order of allocations.
319 */
320local int destroy (s)
321 gz_stream *s;
322{
323 int err = Z_OK;
324
325 if (!s) return Z_STREAM_ERROR;
326
327 TRYFREE(s->msg);
328
329 if (s->stream.state != NULL) {
330 if (s->mode == 'w') {
331#ifdef NO_DEFLATE
332 err = Z_STREAM_ERROR;
333#else
334 err = deflateEnd(&(s->stream));
335#endif
336 } else if (s->mode == 'r') {
337 err = inflateEnd(&(s->stream));
338 }
339 }
340 if (s->file != NULL && fclose(s->file)) {
341#ifdef ESPIPE
342 if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
343#endif
344 err = Z_ERRNO;
345 }
346 if (s->z_err < 0) err = s->z_err;
347
348 TRYFREE(s->inbuf);
349 TRYFREE(s->outbuf);
350 TRYFREE(s->path);
351 TRYFREE(s);
352 return err;
353}
354
355/* ===========================================================================
356 Reads the given number of uncompressed bytes from the compressed file.
357 gzread returns the number of bytes actually read (0 for end of file).
358*/
359int ZEXPORT gzread (file, buf, len)
360 gzFile file;
361 voidp buf;
362 unsigned len;
363{
364 gz_stream *s = (gz_stream*)file;
365 Bytef *start = (Bytef*)buf; /* starting point for crc computation */
366 Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */
367
368 if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
369
370 if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
371 if (s->z_err == Z_STREAM_END) return 0; /* EOF */
372
373 next_out = (Byte*)buf;
374 s->stream.next_out = (Bytef*)buf;
375 s->stream.avail_out = len;
376
377 while (s->stream.avail_out != 0) {
378
379 if (s->transparent) {
380 /* Copy first the lookahead bytes: */
381 uInt n = s->stream.avail_in;
382 if (n > s->stream.avail_out) n = s->stream.avail_out;
383 if (n > 0) {
384 zmemcpy(s->stream.next_out, s->stream.next_in, n);
385 next_out += n;
386 s->stream.next_out = next_out;
387 s->stream.next_in += n;
388 s->stream.avail_out -= n;
389 s->stream.avail_in -= n;
390 }
391 if (s->stream.avail_out > 0) {
392 s->stream.avail_out -= fread(next_out, 1, s->stream.avail_out,
393 s->file);
394 }
395 len -= s->stream.avail_out;
396 s->stream.total_in += (uLong)len;
397 s->stream.total_out += (uLong)len;
398 if (len == 0) s->z_eof = 1;
399 return (int)len;
400 }
401 if (s->stream.avail_in == 0 && !s->z_eof) {
402
403 errno = 0;
404 s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
405 if (s->stream.avail_in == 0) {
406 s->z_eof = 1;
407 if (ferror(s->file)) {
408 s->z_err = Z_ERRNO;
409 break;
410 }
411 }
412 s->stream.next_in = s->inbuf;
413 }
414 s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
415
416 if (s->z_err == Z_STREAM_END) {
417 /* Check CRC and original size */
418 s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
419 start = s->stream.next_out;
420
421 if (getLong(s) != s->crc) {
422 s->z_err = Z_DATA_ERROR;
423 } else {
424 (void)getLong(s);
425 /* The uncompressed length returned by above getlong() may
426 * be different from s->stream.total_out) in case of
427 * concatenated .gz files. Check for such files:
428 */
429 check_header(s);
430 if (s->z_err == Z_OK) {
431 uLong total_in = s->stream.total_in;
432 uLong total_out = s->stream.total_out;
433
434 inflateReset(&(s->stream));
435 s->stream.total_in = total_in;
436 s->stream.total_out = total_out;
437 s->crc = crc32(0L, Z_NULL, 0);
438 }
439 }
440 }
441 if (s->z_err != Z_OK || s->z_eof) break;
442 }
443 s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
444
445 return (int)(len - s->stream.avail_out);
446}
447
448
449/* ===========================================================================
450 Reads one byte from the compressed file. gzgetc returns this byte
451 or -1 in case of end of file or error.
452*/
453int ZEXPORT gzgetc(file)
454 gzFile file;
455{
456 unsigned char c;
457
458 return gzread(file, &c, 1) == 1 ? c : -1;
459}
460
461
462/* ===========================================================================
463 Reads bytes from the compressed file until len-1 characters are
464 read, or a newline character is read and transferred to buf, or an
465 end-of-file condition is encountered. The string is then terminated
466 with a null character.
467 gzgets returns buf, or Z_NULL in case of error.
468
469 The current implementation is not optimized at all.
470*/
471char * ZEXPORT gzgets(file, buf, len)
472 gzFile file;
473 char *buf;
474 int len;
475{
476 char *b = buf;
477 if (buf == Z_NULL || len <= 0) return Z_NULL;
478
479 while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
480 *buf = '\0';
481 return b == buf && len > 0 ? Z_NULL : b;
482}
483
484
485#ifndef NO_DEFLATE
486/* ===========================================================================
487 Writes the given number of uncompressed bytes into the compressed file.
488 gzwrite returns the number of bytes actually written (0 in case of error).
489*/
490int ZEXPORT gzwrite (file, buf, len)
491 gzFile file;
492 const voidp buf;
493 unsigned len;
494{
495 gz_stream *s = (gz_stream*)file;
496
497 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
498
499 s->stream.next_in = (Bytef*)buf;
500 s->stream.avail_in = len;
501
502 while (s->stream.avail_in != 0) {
503
504 if (s->stream.avail_out == 0) {
505
506 s->stream.next_out = s->outbuf;
507 if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
508 s->z_err = Z_ERRNO;
509 break;
510 }
511 s->stream.avail_out = Z_BUFSIZE;
512 }
513 s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
514 if (s->z_err != Z_OK) break;
515 }
516 s->crc = crc32(s->crc, (const Bytef *)buf, len);
517
518 return (int)(len - s->stream.avail_in);
519}
520
521/* ===========================================================================
522 Converts, formats, and writes the args to the compressed file under
523 control of the format string, as in fprintf. gzprintf returns the number of
524 uncompressed bytes actually written (0 in case of error).
525*/
526#ifdef STDC
527#include <stdarg.h>
528
529int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
530{
531 char buf[Z_PRINTF_BUFSIZE];
532 va_list va;
533 int len;
534
535 va_start(va, format);
536#ifdef HAS_vsnprintf
537 (void)vsnprintf(buf, sizeof(buf), format, va);
538#else
539 (void)vsprintf(buf, format, va);
540#endif
541 va_end(va);
542 len = strlen(buf); /* some *sprintf don't return the nb of bytes written */
543 if (len <= 0) return 0;
544
545 return gzwrite(file, buf, (unsigned)len);
546}
547#else /* not ANSI C */
548
549int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
550 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
551 gzFile file;
552 const char *format;
553 int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
554 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
555{
556 char buf[Z_PRINTF_BUFSIZE];
557 int len;
558
559#ifdef HAS_snprintf
560 snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
561 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
562#else
563 sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
564 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
565#endif
566 len = strlen(buf); /* old sprintf doesn't return the nb of bytes written */
567 if (len <= 0) return 0;
568
569 return gzwrite(file, buf, len);
570}
571#endif
572
573/* ===========================================================================
574 Writes c, converted to an unsigned char, into the compressed file.
575 gzputc returns the value that was written, or -1 in case of error.
576*/
577int ZEXPORT gzputc(file, c)
578 gzFile file;
579 int c;
580{
581 unsigned char cc = (unsigned char) c; /* required for big endian systems */
582
583 return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
584}
585
586
587/* ===========================================================================
588 Writes the given null-terminated string to the compressed file, excluding
589 the terminating null character.
590 gzputs returns the number of characters written, or -1 in case of error.
591*/
592int ZEXPORT gzputs(file, s)
593 gzFile file;
594 const char *s;
595{
596 return gzwrite(file, (char*)s, (unsigned)strlen(s));
597}
598
599
600/* ===========================================================================
601 Flushes all pending output into the compressed file. The parameter
602 flush is as in the deflate() function.
603*/
604local int do_flush (file, flush)
605 gzFile file;
606 int flush;
607{
608 uInt len;
609 int done = 0;
610 gz_stream *s = (gz_stream*)file;
611
612 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
613
614 s->stream.avail_in = 0; /* should be zero already anyway */
615
616 for (;;) {
617 len = Z_BUFSIZE - s->stream.avail_out;
618
619 if (len != 0) {
620 if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
621 s->z_err = Z_ERRNO;
622 return Z_ERRNO;
623 }
624 s->stream.next_out = s->outbuf;
625 s->stream.avail_out = Z_BUFSIZE;
626 }
627 if (done) break;
628 s->z_err = deflate(&(s->stream), flush);
629
630 /* Ignore the second of two consecutive flushes: */
631 if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
632
633 /* deflate has finished flushing only when it hasn't used up
634 * all the available space in the output buffer:
635 */
636 done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
637
638 if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
639 }
640 return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
641}
642
643int ZEXPORT gzflush (file, flush)
644 gzFile file;
645 int flush;
646{
647 gz_stream *s = (gz_stream*)file;
648 int err = do_flush (file, flush);
649
650 if (err) return err;
651 fflush(s->file);
652 return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
653}
654#endif /* NO_DEFLATE */
655
656/* ===========================================================================
657 Sets the starting position for the next gzread or gzwrite on the given
658 compressed file. The offset represents a number of bytes in the
659 gzseek returns the resulting offset location as measured in bytes from
660 the beginning of the uncompressed stream, or -1 in case of error.
661 SEEK_END is not implemented, returns error.
662 In this version of the library, gzseek can be extremely slow.
663*/
664z_off_t ZEXPORT gzseek (file, offset, whence)
665 gzFile file;
666 z_off_t offset;
667 int whence;
668{
669 gz_stream *s = (gz_stream*)file;
670
671 if (s == NULL || whence == SEEK_END ||
672 s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
673 return -1L;
674 }
675
676 if (s->mode == 'w') {
677#ifdef NO_DEFLATE
678 return -1L;
679#else
680 if (whence == SEEK_SET) {
681 offset -= s->stream.total_in;
682 }
683 if (offset < 0) return -1L;
684
685 /* At this point, offset is the number of zero bytes to write. */
686 if (s->inbuf == Z_NULL) {
687 s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
688 zmemzero(s->inbuf, Z_BUFSIZE);
689 }
690 while (offset > 0) {
691 uInt size = Z_BUFSIZE;
692 if (offset < Z_BUFSIZE) size = (uInt)offset;
693
694 size = gzwrite(file, s->inbuf, size);
695 if (size == 0) return -1L;
696
697 offset -= size;
698 }
699 return (z_off_t)s->stream.total_in;
700#endif
701 }
702 /* Rest of function is for reading only */
703
704 /* compute absolute position */
705 if (whence == SEEK_CUR) {
706 offset += s->stream.total_out;
707 }
708 if (offset < 0) return -1L;
709
710 if (s->transparent) {
711 /* map to fseek */
712 s->stream.avail_in = 0;
713 s->stream.next_in = s->inbuf;
714 if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
715
716 s->stream.total_in = s->stream.total_out = (uLong)offset;
717 return offset;
718 }
719
720 /* For a negative seek, rewind and use positive seek */
721 if ((uLong)offset >= s->stream.total_out) {
722 offset -= s->stream.total_out;
723 } else if (gzrewind(file) < 0) {
724 return -1L;
725 }
726 /* offset is now the number of bytes to skip. */
727
728 if (offset != 0 && s->outbuf == Z_NULL) {
729 s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
730 }
731 while (offset > 0) {
732 int size = Z_BUFSIZE;
733 if (offset < Z_BUFSIZE) size = (int)offset;
734
735 size = gzread(file, s->outbuf, (uInt)size);
736 if (size <= 0) return -1L;
737 offset -= size;
738 }
739 return (z_off_t)s->stream.total_out;
740}
741
742/* ===========================================================================
743 Rewinds input file.
744*/
745int ZEXPORT gzrewind (file)
746 gzFile file;
747{
748 gz_stream *s = (gz_stream*)file;
749
750 if (s == NULL || s->mode != 'r') return -1;
751
752 s->z_err = Z_OK;
753 s->z_eof = 0;
754 s->stream.avail_in = 0;
755 s->stream.next_in = s->inbuf;
756 s->crc = crc32(0L, Z_NULL, 0);
757
758 if (s->startpos == 0) { /* not a compressed file */
759 rewind(s->file);
760 return 0;
761 }
762
763 (void) inflateReset(&s->stream);
764 return fseek(s->file, s->startpos, SEEK_SET);
765}
766
767/* ===========================================================================
768 Returns the starting position for the next gzread or gzwrite on the
769 given compressed file. This position represents a number of bytes in the
770 uncompressed data stream.
771*/
772z_off_t ZEXPORT gztell (file)
773 gzFile file;
774{
775 return gzseek(file, 0L, SEEK_CUR);
776}
777
778/* ===========================================================================
779 Returns 1 when EOF has previously been detected reading the given
780 input stream, otherwise zero.
781*/
782int ZEXPORT gzeof (file)
783 gzFile file;
784{
785 gz_stream *s = (gz_stream*)file;
786
787 return (s == NULL || s->mode != 'r') ? 0 : s->z_eof;
788}
789
790/* ===========================================================================
791 Outputs a long in LSB order to the given file
792*/
793local void putLong (file, x)
794 FILE *file;
795 uLong x;
796{
797 int n;
798 for (n = 0; n < 4; n++) {
799 fputc((int)(x & 0xff), file);
800 x >>= 8;
801 }
802}
803
804/* ===========================================================================
805 Reads a long in LSB order from the given gz_stream. Sets z_err in case
806 of error.
807*/
808local uLong getLong (s)
809 gz_stream *s;
810{
811 uLong x = (uLong)get_byte(s);
812 int c;
813
814 x += ((uLong)get_byte(s))<<8;
815 x += ((uLong)get_byte(s))<<16;
816 c = get_byte(s);
817 if (c == EOF) s->z_err = Z_DATA_ERROR;
818 x += ((uLong)c)<<24;
819 return x;
820}
821
822/* ===========================================================================
823 Flushes all pending output if necessary, closes the compressed file
824 and deallocates all the (de)compression state.
825*/
826int ZEXPORT gzclose (file)
827 gzFile file;
828{
829 int err;
830 gz_stream *s = (gz_stream*)file;
831
832 if (s == NULL) return Z_STREAM_ERROR;
833
834 if (s->mode == 'w') {
835#ifdef NO_DEFLATE
836 return Z_STREAM_ERROR;
837#else
838 err = do_flush (file, Z_FINISH);
839 if (err != Z_OK) return destroy((gz_stream*)file);
840
841 putLong (s->file, s->crc);
842 putLong (s->file, s->stream.total_in);
843#endif
844 }
845 return destroy((gz_stream*)file);
846}
847
848/* ===========================================================================
849 Returns the error message for the last error which occured on the
850 given compressed file. errnum is set to zlib error number. If an
851 error occured in the file system and not in the compression library,
852 errnum is set to Z_ERRNO and the application may consult errno
853 to get the exact error code.
854*/
855const char* ZEXPORT gzerror (file, errnum)
856 gzFile file;
857 int *errnum;
858{
859 char *m;
860 gz_stream *s = (gz_stream*)file;
861
862 if (s == NULL) {
863 *errnum = Z_STREAM_ERROR;
864 return (const char*)ERR_MSG(Z_STREAM_ERROR);
865 }
866 *errnum = s->z_err;
867 if (*errnum == Z_OK) return (const char*)"";
868
869 m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
870
871 if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
872
873 TRYFREE(s->msg);
874 s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
875 strcpy(s->msg, s->path);
876 strcat(s->msg, ": ");
877 strcat(s->msg, m);
878 return (const char*)s->msg;
879}
ARM optimized PCSX fork