Lines Matching refs:s
79 local int get_byte OF((gz_stream *s));
80 local void check_header OF((gz_stream *s));
81 local int destroy OF((gz_stream *s));
83 local uLong getLong OF((gz_stream *s));
103 gz_stream *s;
109 s = (gz_stream *)ALLOC(sizeof(gz_stream));
110 if (!s) return Z_NULL;
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;
128 s->path = (char*)ALLOC(strlen(path)+1);
129 if (s->path == NULL) {
130 return destroy(s), (gzFile)Z_NULL;
132 strcpy(s->path, path); /* do this early for debugging */
134 s->mode = '\0';
136 if (*p == 'r') s->mode = 'r';
137 if (*p == 'w' || *p == 'a') s->mode = 'w';
150 if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
152 if (s->mode == 'w') {
156 err = deflateInit2(&(s->stream), level,
160 s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
162 if (err != Z_OK || s->outbuf == Z_NULL) {
163 return destroy(s), (gzFile)Z_NULL;
166 s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
168 err = inflateInit2(&(s->stream), -MAX_WBITS);
175 if (err != Z_OK || s->inbuf == Z_NULL) {
176 return destroy(s), (gzFile)Z_NULL;
179 s->stream.avail_out = Z_BUFSIZE;
182 s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
184 if (s->file == NULL) {
185 return destroy(s), (gzFile)Z_NULL;
187 if (s->mode == 'w') {
190 fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
192 s->start = 10L;
193 /* We use 10L instead of ftell(s->file) to because ftell causes an
199 check_header(s); /* skip the .gz header */
200 s->start = ftell(s->file) - s->stream.avail_in;
203 return (gzFile)s;
240 gz_stream *s = (gz_stream*)file;
242 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
245 if (s->stream.avail_out == 0) {
247 s->stream.next_out = s->outbuf;
248 if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
249 s->z_err = Z_ERRNO;
251 s->stream.avail_out = Z_BUFSIZE;
254 return deflateParams (&(s->stream), level, strategy);
260 IN assertion: the stream s has been sucessfully opened for reading.
262 local int get_byte(s)
263 gz_stream *s;
265 if (s->z_eof) return EOF;
266 if (s->stream.avail_in == 0) {
268 s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
269 if (s->stream.avail_in == 0) {
270 s->z_eof = 1;
271 if (ferror(s->file)) s->z_err = Z_ERRNO;
274 s->stream.next_in = s->inbuf;
276 s->stream.avail_in--;
277 return *(s->stream.next_in)++;
282 mode to transparent if the gzip magic header is not present; set s->err
285 IN assertion: the stream s has already been created sucessfully;
286 s->stream.avail_in is zero for the first time, but may be non-zero
289 local void check_header(s)
290 gz_stream *s;
300 len = s->stream.avail_in;
302 if (len) s->inbuf[0] = s->stream.next_in[0];
304 len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
305 if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
306 s->stream.avail_in += len;
307 s->stream.next_in = s->inbuf;
308 if (s->stream.avail_in < 2) {
309 s->transparent = s->stream.avail_in;
315 if (s->stream.next_in[0] != gz_magic[0] ||
316 s->stream.next_in[1] != gz_magic[1]) {
317 s->transparent = 1;
320 s->stream.avail_in -= 2;
321 s->stream.next_in += 2;
324 method = get_byte(s);
325 flags = get_byte(s);
327 s->z_err = Z_DATA_ERROR;
332 for (len = 0; len < 6; len++) (void)get_byte(s);
335 len = (uInt)get_byte(s);
336 len += ((uInt)get_byte(s))<<8;
338 while (len-- != 0 && get_byte(s) != EOF) ;
341 while ((c = get_byte(s)) != 0 && c != EOF) ;
344 while ((c = get_byte(s)) != 0 && c != EOF) ;
347 for (len = 0; len < 2; len++) (void)get_byte(s);
349 s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
356 local int destroy (s)
357 gz_stream *s;
361 if (!s) return Z_STREAM_ERROR;
363 TRYFREE(s->msg);
365 if (s->stream.state != NULL) {
366 if (s->mode == 'w') {
370 err = deflateEnd(&(s->stream));
372 } else if (s->mode == 'r') {
373 err = inflateEnd(&(s->stream));
376 if (s->file != NULL && fclose(s->file)) {
382 if (s->z_err < 0) err = s->z_err;
384 TRYFREE(s->inbuf);
385 TRYFREE(s->outbuf);
386 TRYFREE(s->path);
387 TRYFREE(s);
400 gz_stream *s = (gz_stream*)file;
404 if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
406 if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
407 if (s->z_err == Z_STREAM_END) return 0; /* EOF */
410 s->stream.next_out = (Bytef*)buf;
411 s->stream.avail_out = len;
413 if (s->stream.avail_out && s->back != EOF) {
414 *next_out++ = s->back;
415 s->stream.next_out++;
416 s->stream.avail_out--;
417 s->back = EOF;
418 s->out++;
420 if (s->last) {
421 s->z_err = Z_STREAM_END;
426 while (s->stream.avail_out != 0) {
428 if (s->transparent) {
430 uInt n = s->stream.avail_in;
431 if (n > s->stream.avail_out) n = s->stream.avail_out;
433 zmemcpy(s->stream.next_out, s->stream.next_in, n);
435 s->stream.next_out = next_out;
436 s->stream.next_in += n;
437 s->stream.avail_out -= n;
438 s->stream.avail_in -= n;
440 if (s->stream.avail_out > 0) {
441 s->stream.avail_out -=
442 (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
444 len -= s->stream.avail_out;
445 s->in += len;
446 s->out += len;
447 if (len == 0) s->z_eof = 1;
450 if (s->stream.avail_in == 0 && !s->z_eof) {
453 s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
454 if (s->stream.avail_in == 0) {
455 s->z_eof = 1;
456 if (ferror(s->file)) {
457 s->z_err = Z_ERRNO;
461 s->stream.next_in = s->inbuf;
463 s->in += s->stream.avail_in;
464 s->out += s->stream.avail_out;
465 s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
466 s->in -= s->stream.avail_in;
467 s->out -= s->stream.avail_out;
469 if (s->z_err == Z_STREAM_END) {
471 s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
472 start = s->stream.next_out;
474 if (getLong(s) != s->crc) {
475 s->z_err = Z_DATA_ERROR;
477 (void)getLong(s);
479 * different from s->out in case of concatenated .gz files.
482 check_header(s);
483 if (s->z_err == Z_OK) {
484 inflateReset(&(s->stream));
485 s->crc = crc32(0L, Z_NULL, 0);
489 if (s->z_err != Z_OK || s->z_eof) break;
491 s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
493 if (len == s->stream.avail_out &&
494 (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
496 return (int)(len - s->stream.avail_out);
520 gz_stream *s = (gz_stream*)file;
522 if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
523 s->back = c;
524 s->out--;
525 s->last = (s->z_err == Z_STREAM_END);
526 if (s->last) s->z_err = Z_OK;
527 s->z_eof = 0;
565 gz_stream *s = (gz_stream*)file;
567 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
569 s->stream.next_in = (Bytef*)buf;
570 s->stream.avail_in = len;
572 while (s->stream.avail_in != 0) {
574 if (s->stream.avail_out == 0) {
576 s->stream.next_out = s->outbuf;
577 if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
578 s->z_err = Z_ERRNO;
581 s->stream.avail_out = Z_BUFSIZE;
583 s->in += s->stream.avail_in;
584 s->out += s->stream.avail_out;
585 s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
586 s->in -= s->stream.avail_in;
587 s->out -= s->stream.avail_out;
588 if (s->z_err != Z_OK) break;
590 s->crc = crc32(s->crc, (const Bytef *)buf, len);
592 return (int)(len - s->stream.avail_in);
694 int ZEXPORT gzputs(file, s)
696 const char *s;
698 return gzwrite(file, (char*)s, (unsigned)strlen(s));
712 gz_stream *s = (gz_stream*)file;
714 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
716 s->stream.avail_in = 0; /* should be zero already anyway */
719 len = Z_BUFSIZE - s->stream.avail_out;
722 if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
723 s->z_err = Z_ERRNO;
726 s->stream.next_out = s->outbuf;
727 s->stream.avail_out = Z_BUFSIZE;
730 s->out += s->stream.avail_out;
731 s->z_err = deflate(&(s->stream), flush);
732 s->out -= s->stream.avail_out;
735 if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
740 done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
742 if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
744 return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
751 gz_stream *s = (gz_stream*)file;
755 fflush(s->file);
756 return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
773 gz_stream *s = (gz_stream*)file;
775 if (s == NULL || whence == SEEK_END ||
776 s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
780 if (s->mode == 'w') {
785 offset -= s->in;
790 if (s->inbuf == Z_NULL) {
791 s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
792 if (s->inbuf == Z_NULL) return -1L;
793 zmemzero(s->inbuf, Z_BUFSIZE);
799 size = gzwrite(file, s->inbuf, size);
804 return s->in;
811 offset += s->out;
815 if (s->transparent) {
817 s->back = EOF;
818 s->stream.avail_in = 0;
819 s->stream.next_in = s->inbuf;
820 if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
822 s->in = s->out = offset;
827 if (offset >= s->out) {
828 offset -= s->out;
834 if (offset != 0 && s->outbuf == Z_NULL) {
835 s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
836 if (s->outbuf == Z_NULL) return -1L;
838 if (offset && s->back != EOF) {
839 s->back = EOF;
840 s->out++;
842 if (s->last) s->z_err = Z_STREAM_END;
848 size = gzread(file, s->outbuf, (uInt)size);
852 return s->out;
861 gz_stream *s = (gz_stream*)file;
863 if (s == NULL || s->mode != 'r') return -1;
865 s->z_err = Z_OK;
866 s->z_eof = 0;
867 s->back = EOF;
868 s->stream.avail_in = 0;
869 s->stream.next_in = s->inbuf;
870 s->crc = crc32(0L, Z_NULL, 0);
871 if (!s->transparent) (void)inflateReset(&s->stream);
872 s->in = 0;
873 s->out = 0;
874 return fseek(s->file, s->start, SEEK_SET);
895 gz_stream *s = (gz_stream*)file;
901 if (s == NULL || s->mode != 'r') return 0;
902 if (s->z_eof) return 1;
903 return s->z_err == Z_STREAM_END;
912 gz_stream *s = (gz_stream*)file;
914 if (s == NULL || s->mode != 'r') return 0;
915 return s->transparent;
936 local uLong getLong (s)
937 gz_stream *s;
939 uLong x = (uLong)get_byte(s);
942 x += ((uLong)get_byte(s))<<8;
943 x += ((uLong)get_byte(s))<<16;
944 c = get_byte(s);
945 if (c == EOF) s->z_err = Z_DATA_ERROR;
957 gz_stream *s = (gz_stream*)file;
959 if (s == NULL) return Z_STREAM_ERROR;
961 if (s->mode == 'w') {
968 putLong (s->file, s->crc);
969 putLong (s->file, (uLong)(s->in & 0xffffffff));
993 gz_stream *s = (gz_stream*)file;
995 if (s == NULL) {
999 *errnum = s->z_err;
1002 m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
1004 if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
1006 TRYFREE(s->msg);
1007 s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
1008 if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);
1009 strcpy(s->msg, s->path);
1010 strcat(s->msg, ": ");
1011 strcat(s->msg, m);
1012 return (const char*)s->msg;
1021 gz_stream *s = (gz_stream*)file;
1023 if (s == NULL) return;
1024 if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
1025 s->z_eof = 0;
1026 clearerr(s->file);