14 #define _POSIX_C_SOURCE 1
22 # define NO_GZCOMPRESS
31 # define Z_BUFSIZE 4096
33 # define Z_BUFSIZE 16384
36 #ifndef Z_PRINTF_BUFSIZE
37 # define Z_PRINTF_BUFSIZE 4096
41 # pragma map (fdopen , "\174\174FDOPEN")
42 FILE *fdopen(
int,
const char *);
46 extern voidp malloc
OF((uInt size));
47 extern void free
OF((voidpf ptr));
50 #define ALLOC(size) malloc(size)
51 #define TRYFREE(p) {if (p) free(p);}
54 static int gz_magic_old[2] = {0x1f, 0x8b};
55 static int gz_magic_new[2] = {0x1e, 0x8c};
58 #define ASCII_FLAG 0x01
60 #define EXTRA_FIELD 0x04
61 #define ORIG_NAME 0x08
108 int level = Z_DEFAULT_COMPRESSION;
109 int strategy = Z_DEFAULT_STRATEGY;
110 const char *p = mode;
115 if (!path || !mode)
return Z_NULL;
118 if (!
s)
return Z_NULL;
120 s->stream.zalloc = (alloc_func)0;
121 s->stream.zfree = (free_func)0;
122 s->stream.opaque = (voidpf)0;
123 s->stream.next_in =
s->inbuf = Z_NULL;
124 s->stream.next_out =
s->outbuf = Z_NULL;
125 s->stream.avail_in =
s->stream.avail_out = 0;
132 s->crc = crc32(0L, Z_NULL, 0);
136 s->path = (
char*)
ALLOC(strlen(path)+1);
137 if (
s->path == NULL) {
140 strcpy(
s->path, path);
144 if (*p ==
'r')
s->mode =
'r';
145 if (*p ==
'w' || *p ==
'a')
s->mode =
'w';
146 if (*p >=
'0' && *p <=
'9') {
148 }
else if (*p ==
'f') {
149 strategy = Z_FILTERED;
150 }
else if (*p ==
'h') {
151 strategy = Z_HUFFMAN_ONLY;
152 }
else if (*p ==
'R') {
157 }
while (*p++ && m != fmode +
sizeof(fmode));
158 if (
s->mode ==
'\0')
return destroy(
s), (gzFile)Z_NULL;
160 if (
s->mode ==
'w') {
162 err = Z_STREAM_ERROR;
164 err = deflateInit2(&(
s->stream), level,
170 if (err != Z_OK ||
s->outbuf == Z_NULL) {
176 err = inflateInit2(&(
s->stream), -MAX_WBITS);
183 if (err != Z_OK ||
s->inbuf == Z_NULL) {
190 s->file = fd < 0 ?
F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
192 if (
s->file == NULL) {
195 if (
s->mode ==
'w') {
198 fprintf(
s->file,
"%c%c%c%c%c%c%c%c%c%c", gz_magic_new[0], gz_magic_new[1],
199 Z_DEFLATED, 0 , 0,0,0,0 , 0 , 0x0b );
208 s->start = ftell(
s->file) -
s->stream.avail_in;
221 return gz_open (path, mode, -1);
234 if (fd < 0)
return (gzFile)Z_NULL;
237 return gz_open (name, mode, fd);
250 if (
s == NULL ||
s->mode !=
'w')
return Z_STREAM_ERROR;
253 if (
s->stream.avail_out == 0) {
255 s->stream.next_out =
s->outbuf;
262 return deflateParams (&(
s->stream), level, strategy);
273 if (
s->z_eof)
return EOF;
274 if (
s->stream.avail_in == 0) {
276 s->stream.avail_in = (uInt)fread(
s->inbuf, 1,
Z_BUFSIZE,
s->file);
277 if (
s->stream.avail_in == 0) {
279 if (ferror(
s->file))
s->z_err = Z_ERRNO;
282 s->stream.next_in =
s->inbuf;
284 s->stream.avail_in--;
285 return *(
s->stream.next_in)++;
308 len =
s->stream.avail_in;
310 if (len)
s->inbuf[0] =
s->stream.next_in[0];
312 len = (uInt)fread(
s->inbuf + len, 1,
Z_BUFSIZE >> len,
s->file);
313 if (len == 0 && ferror(
s->file))
s->z_err = Z_ERRNO;
314 s->stream.avail_in += len;
315 s->stream.next_in =
s->inbuf;
316 if (
s->stream.avail_in < 2) {
317 s->transparent =
s->stream.avail_in;
323 if ((
s->stream.next_in[0] != gz_magic_old[0] ||
324 s->stream.next_in[1] != gz_magic_old[1]) &&
325 (
s->stream.next_in[0] != gz_magic_new[0] ||
326 s->stream.next_in[1] != gz_magic_new[1])) {
330 s->stream.avail_in -= 2;
331 s->stream.next_in += 2;
336 if (method != Z_DEFLATED || (flags &
RESERVED) != 0) {
337 s->z_err = Z_DATA_ERROR;
342 for (len = 0; len < 6; len++) (
void)
get_byte(
s);
348 while (len-- != 0 &&
get_byte(
s) != EOF) ;
351 while ((c =
get_byte(
s)) != 0 && c != EOF) ;
354 while ((c =
get_byte(
s)) != 0 && c != EOF) ;
357 for (len = 0; len < 2; len++) (
void)
get_byte(
s);
359 s->z_err =
s->z_eof ? Z_DATA_ERROR : Z_OK;
371 if (!
s)
return Z_STREAM_ERROR;
375 if (
s->stream.state != NULL) {
376 if (
s->mode ==
'w') {
378 err = Z_STREAM_ERROR;
380 err = deflateEnd(&(
s->stream));
382 }
else if (
s->mode ==
'r') {
383 err = inflateEnd(&(
s->stream));
386 if (
s->file != NULL && fclose(
s->file)) {
392 if (
s->z_err < 0) err =
s->z_err;
411 Bytef *start = (Bytef*)buf;
414 if (
s == NULL ||
s->mode !=
'r')
return Z_STREAM_ERROR;
416 if (
s->z_err == Z_DATA_ERROR ||
s->z_err == Z_ERRNO)
return -1;
417 if (
s->z_err == Z_STREAM_END)
return 0;
419 next_out = (Byte*)buf;
420 s->stream.next_out = (Bytef*)buf;
421 s->stream.avail_out = len;
423 if (
s->stream.avail_out &&
s->back != EOF) {
424 *next_out++ =
s->back;
425 s->stream.next_out++;
426 s->stream.avail_out--;
431 s->z_err = Z_STREAM_END;
436 while (
s->stream.avail_out != 0) {
438 if (
s->transparent) {
440 uInt n =
s->stream.avail_in;
441 if (n >
s->stream.avail_out) n =
s->stream.avail_out;
443 zmemcpy(
s->stream.next_out,
s->stream.next_in, n);
445 s->stream.next_out = next_out;
446 s->stream.next_in += n;
447 s->stream.avail_out -= n;
448 s->stream.avail_in -= n;
450 if (
s->stream.avail_out > 0) {
451 s->stream.avail_out -=
452 (uInt)fread(next_out, 1,
s->stream.avail_out,
s->file);
454 len -=
s->stream.avail_out;
457 if (len == 0)
s->z_eof = 1;
460 if (
s->stream.avail_in == 0 && !
s->z_eof) {
463 s->stream.avail_in = (uInt)fread(
s->inbuf, 1,
Z_BUFSIZE,
s->file);
464 if (
s->stream.avail_in == 0) {
466 if (ferror(
s->file)) {
471 s->stream.next_in =
s->inbuf;
473 s->in +=
s->stream.avail_in;
474 s->out +=
s->stream.avail_out;
475 s->z_err = inflate(&(
s->stream), Z_NO_FLUSH);
476 s->in -=
s->stream.avail_in;
477 s->out -=
s->stream.avail_out;
479 if (
s->z_err == Z_STREAM_END) {
481 s->crc = crc32(
s->crc, start, (uInt)(
s->stream.next_out - start));
482 start =
s->stream.next_out;
485 s->z_err = Z_DATA_ERROR;
493 if (
s->z_err == Z_OK) {
494 inflateReset(&(
s->stream));
495 s->crc = crc32(0L, Z_NULL, 0);
499 if (
s->z_err != Z_OK ||
s->z_eof)
break;
501 s->crc = crc32(
s->crc, start, (uInt)(
s->stream.next_out - start));
503 if (len ==
s->stream.avail_out &&
504 (
s->z_err == Z_DATA_ERROR ||
s->z_err == Z_ERRNO))
506 return (
int)(len -
s->stream.avail_out);
519 return gzread(file, &c, 1) == 1 ? c : -1;
532 if (
s == NULL ||
s->mode !=
'r' || c == EOF ||
s->back != EOF)
return EOF;
535 s->last = (
s->z_err == Z_STREAM_END);
536 if (
s->last)
s->z_err = Z_OK;
557 if (buf == Z_NULL || len <= 0)
return Z_NULL;
559 while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ !=
'\n') ;
561 return b == buf && len > 0 ? Z_NULL :
b;
565 #ifndef NO_GZCOMPRESS
577 if (
s == NULL ||
s->mode !=
'w')
return Z_STREAM_ERROR;
579 s->stream.next_in = *(Bytef**)(
void*)&buf;
580 s->stream.avail_in = len;
582 while (
s->stream.avail_in != 0) {
584 if (
s->stream.avail_out == 0) {
586 s->stream.next_out =
s->outbuf;
593 s->in +=
s->stream.avail_in;
594 s->out +=
s->stream.avail_out;
595 s->z_err = deflate(&(
s->stream), Z_NO_FLUSH);
596 s->in -=
s->stream.avail_in;
597 s->out -=
s->stream.avail_out;
598 if (
s->z_err != Z_OK)
break;
600 s->crc = crc32(
s->crc, (
const Bytef *)buf, len);
602 return (
int)(len -
s->stream.avail_in);
614 int ZEXPORTVA
c4_gzprintf (gzFile file,
const char *format, ...)
620 buf[
sizeof(buf) - 1] = 0;
621 va_start(va, format);
623 # ifdef HAS_vsprintf_void
624 (void)vsprintf(buf, format, va);
626 for (len = 0; len <
sizeof(buf); len++)
627 if (buf[len] == 0)
break;
629 len = vsprintf(buf, format, va);
633 # ifdef HAS_vsnprintf_void
634 (void)vsnprintf(buf,
sizeof(buf), format, va);
638 len = vsnprintf(buf,
sizeof(buf), format, va);
642 if (len <= 0 || len >= (
int)
sizeof(buf) || buf[
sizeof(buf) - 1] != 0)
644 return gzwrite(file, buf, (
unsigned)len);
648 int ZEXPORTVA
c4_gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
649 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
652 int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
653 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
658 buf[
sizeof(buf) - 1] = 0;
660 # ifdef HAS_sprintf_void
661 sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
662 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
663 for (len = 0; len <
sizeof(buf); len++)
664 if (buf[len] == 0)
break;
666 len =
sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
667 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
670 # ifdef HAS_snprintf_void
671 snprintf(buf,
sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
672 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
675 len = snprintf(buf,
sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
676 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
679 if (len <= 0 || len >=
sizeof(buf) || buf[
sizeof(buf) - 1] != 0)
681 return gzwrite(file, buf, len);
693 unsigned char cc = (
unsigned char) c;
695 return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
708 return gzwrite(file,
s, (
unsigned)strlen(
s));
724 if (
s == NULL ||
s->mode !=
'w')
return Z_STREAM_ERROR;
726 s->stream.avail_in = 0;
732 if ((uInt)fwrite(
s->outbuf, 1, len,
s->file) != len) {
736 s->stream.next_out =
s->outbuf;
740 s->out +=
s->stream.avail_out;
741 s->z_err = deflate(&(
s->stream), flush);
742 s->out -=
s->stream.avail_out;
745 if (len == 0 &&
s->z_err == Z_BUF_ERROR)
s->z_err = Z_OK;
750 done = (
s->stream.avail_out != 0 ||
s->z_err == Z_STREAM_END);
752 if (
s->z_err != Z_OK &&
s->z_err != Z_STREAM_END)
break;
754 return s->z_err == Z_STREAM_END ? Z_OK :
s->z_err;
766 return s->z_err == Z_STREAM_END ? Z_OK :
s->z_err;
785 if (
s == NULL || whence == SEEK_END ||
786 s->z_err == Z_ERRNO ||
s->z_err == Z_DATA_ERROR) {
790 if (
s->mode ==
'w') {
794 if (whence == SEEK_SET) {
797 if (offset < 0)
return -1L;
800 if (
s->inbuf == Z_NULL) {
802 if (
s->inbuf == Z_NULL)
return -1L;
807 if (offset <
Z_BUFSIZE) size = (uInt)offset;
809 size = gzwrite(file,
s->inbuf, size);
810 if (size == 0)
return -1L;
820 if (whence == SEEK_CUR) {
823 if (offset < 0)
return -1L;
825 if (
s->transparent) {
828 s->stream.avail_in = 0;
829 s->stream.next_in =
s->inbuf;
830 if (fseek(
s->file, offset, SEEK_SET) < 0)
return -1L;
832 s->in =
s->out = offset;
837 if (offset >=
s->out) {
839 }
else if (gzrewind(file) < 0) {
844 if (offset != 0 &&
s->outbuf == Z_NULL) {
846 if (
s->outbuf == Z_NULL)
return -1L;
848 if (offset &&
s->back != EOF) {
852 if (
s->last)
s->z_err = Z_STREAM_END;
856 if (offset <
Z_BUFSIZE) size = (int)offset;
858 size = gzread(file,
s->outbuf, (uInt)size);
859 if (size <= 0)
return -1L;
873 if (
s == NULL ||
s->mode !=
'r')
return -1;
878 s->stream.avail_in = 0;
879 s->stream.next_in =
s->inbuf;
880 s->crc = crc32(0L, Z_NULL, 0);
881 if (!
s->transparent) (void)inflateReset(&
s->stream);
884 return fseek(
s->file,
s->start, SEEK_SET);
895 return gzseek(file, 0L, SEEK_CUR);
911 if (
s == NULL ||
s->mode !=
'r')
return 0;
912 if (
s->z_eof)
return 1;
913 return s->z_err == Z_STREAM_END;
924 if (
s == NULL ||
s->mode !=
'r')
return 0;
925 return s->transparent;
936 for (n = 0; n < 4; n++) {
937 fputc((
int)(x & 0xff), file);
955 if (c == EOF)
s->z_err = Z_DATA_ERROR;
969 if (
s == NULL)
return Z_STREAM_ERROR;
971 if (
s->mode ==
'w') {
973 return Z_STREAM_ERROR;
975 if (
do_flush (file, Z_FINISH) != Z_OK)
979 putLong (
s->file, (uLong)(
s->in & 0xffffffff));
986 # define zstrerror(errnum) strerror(errnum)
988 # define zstrerror(errnum) ""
999 const char * ZEXPORT c4_gzerror (file, errnum)
1007 *errnum = Z_STREAM_ERROR;
1008 return (
const char*)
ERR_MSG(Z_STREAM_ERROR);
1011 if (*errnum == Z_OK)
return (
const char*)
"";
1013 m = (
char*)(*errnum == Z_ERRNO ?
zstrerror(errno) :
s->stream.msg);
1015 if (m == NULL || *m ==
'\0') m = (
char*)
ERR_MSG(
s->z_err);
1018 s->msg = (
char*)
ALLOC(strlen(
s->path) + strlen(m) + 3);
1019 if (
s->msg == Z_NULL)
return (
const char*)
ERR_MSG(Z_MEM_ERROR);
1020 strcpy(
s->msg,
s->path);
1021 strcat(
s->msg,
": ");
1023 return (
const char*)
s->msg;
1035 if (
s == NULL)
return;
1036 if (
s->z_err != Z_STREAM_END)
s->z_err = Z_OK;
void check_header(gz_stream *s)
int ZEXPORTVA c4_gzprintf(gzFile file, const char *format, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, int a11, int a12, int a13, int a14, int a15, int a16, int a17, int a18, int a19, int a20)
gzFile ZEXPORT c4_gzopen(char *path, const char *mode) const
void putLong(FILE *file, uLong x)
int destroy(gz_stream *s)
struct gz_stream gz_stream
int ZEXPORT c4_gzputc(gzFile file, int c)
int do_flush(gzFile file, int flush)
#define zstrerror(errnum)
int ZEXPORT c4_gzgetc(gzFile file)
int ZEXPORT c4_gzflush(gzFile file, int flush)
int ZEXPORT c4_gzread(gzFile file, voidp buf, unsigned len)
gzFile gz_open(char *path, const char *mode, int fd) const
int ZEXPORT c4_gzdirect(gzFile file)
int ZEXPORT c4_gzputs(gzFile file, const char *s)
void ZEXPORT c4_gzclearerr(gzFile file)
int ZEXPORT c4_gzeof(gzFile file)
int ZEXPORT c4_gzungetc(int c, gzFile file)
gzFile ZEXPORT c4_gzdopen(int fd, const char *mode)
z_off_t ZEXPORT c4_gzseek(gzFile file, z_off_t offset, int whence)
int ZEXPORT c4_gzsetparams(gzFile file, int level, int strategy)
int ZEXPORT c4_gzrewind(gzFile file)
voidp malloc OF((uInt size))
uLong getLong(gz_stream *s)
int ZEXPORT c4_gzclose(gzFile file)
z_off_t ZEXPORT c4_gztell(gzFile file)
int ZEXPORT c4_gzwrite(gzFile file, voidpc buf, unsigned len)
char *ZEXPORT c4_gzgets(gzFile file, char *buf, int len)
int get_byte(gz_stream *s)
#define F_OPEN(name, mode)