GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: lib/libz/gzio.c Lines: 0 368 0.0 %
Date: 2017-11-13 Branches: 0 348 0.0 %

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