1 /* gzlib.c -- zlib functions common to reading and writing gzip files
2 * Copyright (C) 2004-2019 Mark Adler
3 * For conditions of distribution and use, see copyright notice in zlib.h
4 */
5
6 #include "gzguts.h"
7
8 #if defined(_WIN32) && !defined(__BORLANDC__)
9 # define LSEEK _lseeki64
10 #else
11 #if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
12 # define LSEEK lseek64
13 #else
14 # define LSEEK lseek
15 #endif
16 #endif
17
18 /* Local functions */
19 local void gz_reset OF((gz_statep));
20 local gzFile gz_open OF((const void *, int, const char *));
21
22 #if defined UNDER_CE
23
24 /* Map the Windows error number in ERROR to a locale-dependent error message
25 string and return a pointer to it. Typically, the values for ERROR come
26 from GetLastError.
27
28 The string pointed to shall not be modified by the application, but may be
29 overwritten by a subsequent call to gz_strwinerror
30
31 The gz_strwinerror function does not change the current setting of
32 GetLastError. */
33 char ZLIB_INTERNAL *gz_strwinerror (error)
34 DWORD error;
35 {
36 static char buf[1024];
37
38 wchar_t *msgbuf;
39 DWORD lasterr = GetLastError();
40 DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
41 | FORMAT_MESSAGE_ALLOCATE_BUFFER,
42 NULL,
43 error,
44 0, /* Default language */
45 (LPVOID)&msgbuf,
46 0,
47 NULL);
48 if (chars != 0) {
49 /* If there is an \r\n appended, zap it. */
50 if (chars >= 2
51 && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
52 chars -= 2;
53 msgbuf[chars] = 0;
54 }
55
56 if (chars > sizeof (buf) - 1) {
57 chars = sizeof (buf) - 1;
58 msgbuf[chars] = 0;
59 }
60
61 wcstombs(buf, msgbuf, chars + 1);
62 LocalFree(msgbuf);
63 }
64 else {
65 sprintf(buf, "unknown win32 error (%ld)", error);
66 }
67
68 SetLastError(lasterr);
69 return buf;
70 }
71
72 #endif /* UNDER_CE */
73
74 /* Reset gzip file state */
75 local void gz_reset(state)
76 gz_statep state;
77 {
78 state->x.have = 0; /* no output data available */
79 if (state->mode == GZ_READ) { /* for reading ... */
80 state->eof = 0; /* not at end of file */
81 state->past = 0; /* have not read past end yet */
82 state->how = LOOK; /* look for gzip header */
83 }
84 else /* for writing ... */
85 state->reset = 0; /* no deflateReset pending */
86 state->seek = 0; /* no seek request pending */
87 gz_error(state, Z_OK, NULL); /* clear error */
88 state->x.pos = 0; /* no uncompressed data yet */
89 state->strm.avail_in = 0; /* no input data yet */
90 }
91
92 /* Open a gzip file either by name or file descriptor. */
93 local gzFile gz_open(path, fd, mode)
94 const void *path;
95 int fd;
96 const char *mode;
97 {
98 gz_statep state;
99 z_size_t len;
100 int oflag;
101 #ifdef O_CLOEXEC
102 int cloexec = 0;
103 #endif
104 #ifdef O_EXCL
105 int exclusive = 0;
106 #endif
107
108 /* check input */
109 if (path == NULL)
110 return NULL;
111
112 /* allocate gzFile structure to return */
113 state = (gz_statep)malloc(sizeof(gz_state));
114 if (state == NULL)
115 return NULL;
116 state->size = 0; /* no buffers allocated yet */
117 state->want = GZBUFSIZE; /* requested buffer size */
118 state->msg = NULL; /* no error message yet */
119
120 /* interpret mode */
121 state->mode = GZ_NONE;
122 state->level = Z_DEFAULT_COMPRESSION;
123 state->strategy = Z_DEFAULT_STRATEGY;
124 state->direct = 0;
125 while (*mode) {
126 if (*mode >= '0' && *mode <= '9')
127 state->level = *mode - '0';
128 else
129 switch (*mode) {
130 case 'r':
131 state->mode = GZ_READ;
132 break;
133 #ifndef NO_GZCOMPRESS
134 case 'w':
135 state->mode = GZ_WRITE;
136 break;
137 case 'a':
138 state->mode = GZ_APPEND;
139 break;
140 #endif
141 case '+': /* can't read and write at the same time */
142 free(state);
143 return NULL;
144 case 'b': /* ignore -- will request binary anyway */
145 break;
146 #ifdef O_CLOEXEC
147 case 'e':
148 cloexec = 1;
149 break;
150 #endif
151 #ifdef O_EXCL
152 case 'x':
153 exclusive = 1;
154 break;
155 #endif
156 case 'f':
157 state->strategy = Z_FILTERED;
158 break;
159 case 'h':
160 state->strategy = Z_HUFFMAN_ONLY;
161 break;
162 case 'R':
163 state->strategy = Z_RLE;
164 break;
165 case 'F':
166 state->strategy = Z_FIXED;
167 break;
168 case 'T':
169 state->direct = 1;
170 break;
171 default: /* could consider as an error, but just ignore */
172 ;
173 }
174 mode++;
175 }
176
177 /* must provide an "r", "w", or "a" */
178 if (state->mode == GZ_NONE) {
179 free(state);
180 return NULL;
181 }
182
183 /* can't force transparent read */
184 if (state->mode == GZ_READ) {
185 if (state->direct) {
186 free(state);
187 return NULL;
188 }
189 state->direct = 1; /* for empty file */
190 }
191
192 /* save the path name for error messages */
193 #ifdef WIDECHAR
194 if (fd == -2) {
195 len = wcstombs(NULL, path, 0);
196 if (len == (z_size_t)-1)
197 len = 0;
198 }
199 else
200 #endif
201 len = strlen((const char *)path);
202 state->path = (char *)malloc(len + 1);
203 if (state->path == NULL) {
204 free(state);
205 return NULL;
206 }
207 #ifdef WIDECHAR
208 if (fd == -2)
209 if (len)
210 wcstombs(state->path, path, len + 1);
211 else
212 *(state->path) = 0;
213 else
214 #endif
215 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
216 (void)snprintf(state->path, len + 1, "%s", (const char *)path);
217 #else
218 strcpy(state->path, path);
219 #endif
220
221 /* compute the flags for open() */
222 oflag =
223 #ifdef O_LARGEFILE
224 O_LARGEFILE |
225 #endif
226 #ifdef O_BINARY
227 O_BINARY |
228 #endif
229 #ifdef O_CLOEXEC
230 (cloexec ? O_CLOEXEC : 0) |
231 #endif
232 (state->mode == GZ_READ ?
233 O_RDONLY :
234 (O_WRONLY | O_CREAT |
235 #ifdef O_EXCL
236 (exclusive ? O_EXCL : 0) |
237 #endif
238 (state->mode == GZ_WRITE ?
239 O_TRUNC :
240 O_APPEND)));
241
242 /* open the file with the appropriate flags (or just use fd) */
243 state->fd = fd > -1 ? fd : (
244 #ifdef WIDECHAR
245 fd == -2 ? _wopen(path, oflag, 0666) :
246 #endif
247 open((const char *)path, oflag, 0666));
248 if (state->fd == -1) {
249 free(state->path);
250 free(state);
251 return NULL;
252 }
253 if (state->mode == GZ_APPEND) {
254 LSEEK(state->fd, 0, SEEK_END); /* so gzoffset() is correct */
255 state->mode = GZ_WRITE; /* simplify later checks */
256 }
257
258 /* save the current position for rewinding (only if reading) */
259 if (state->mode == GZ_READ) {
260 state->start = LSEEK(state->fd, 0, SEEK_CUR);
261 if (state->start == -1) state->start = 0;
262 }
263
264 /* initialize stream */
265 gz_reset(state);
266
267 /* return stream */
268 return (gzFile)state;
269 }
270
271 /* -- see zlib.h -- */
272 gzFile ZEXPORT gzopen(path, mode)
273 const char *path;
274 const char *mode;
275 {
276 return gz_open(path, -1, mode);
277 }
278
279 /* -- see zlib.h -- */
280 gzFile ZEXPORT gzopen64(path, mode)
281 const char *path;
282 const char *mode;
283 {
284 return gz_open(path, -1, mode);
285 }
286
287 /* -- see zlib.h -- */
288 gzFile ZEXPORT gzdopen(fd, mode)
289 int fd;
290 const char *mode;
291 {
292 char *path; /* identifier for error messages */
293 gzFile gz;
294
295 if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
296 return NULL;
297 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
298 (void)snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd);
299 #else
300 sprintf(path, "<fd:%d>", fd); /* for debugging */
301 #endif
302 gz = gz_open(path, fd, mode);
303 free(path);
304 return gz;
305 }
306
307 /* -- see zlib.h -- */
308 #ifdef WIDECHAR
309 gzFile ZEXPORT gzopen_w(path, mode)
310 const wchar_t *path;
311 const char *mode;
312 {
313 return gz_open(path, -2, mode);
314 }
315 #endif
316
317 /* -- see zlib.h -- */
318 int ZEXPORT gzbuffer(file, size)
319 gzFile file;
320 unsigned size;
321 {
322 gz_statep state;
323
324 /* get internal structure and check integrity */
325 if (file == NULL)
326 return -1;
327 state = (gz_statep)file;
328 if (state->mode != GZ_READ && state->mode != GZ_WRITE)
329 return -1;
330
331 /* make sure we haven't already allocated memory */
332 if (state->size != 0)
333 return -1;
334
335 /* check and set requested size */
336 if ((size << 1) < size)
337 return -1; /* need to be able to double it */
338 if (size < 2)
339 size = 2; /* need two bytes to check magic header */
340 state->want = size;
341 return 0;
342 }
343
344 /* -- see zlib.h -- */
345 int ZEXPORT gzrewind(file)
346 gzFile file;
347 {
348 gz_statep state;
349
350 /* get internal structure */
351 if (file == NULL)
352 return -1;
353 state = (gz_statep)file;
354
355 /* check that we're reading and that there's no error */
356 if (state->mode != GZ_READ ||
357 (state->err != Z_OK && state->err != Z_BUF_ERROR))
358 return -1;
359
360 /* back up and start over */
361 if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
362 return -1;
363 gz_reset(state);
364 return 0;
365 }
366
367 /* -- see zlib.h -- */
368 z_off64_t ZEXPORT gzseek64(file, offset, whence)
369 gzFile file;
370 z_off64_t offset;
371 int whence;
372 {
373 unsigned n;
374 z_off64_t ret;
375 gz_statep state;
376
377 /* get internal structure and check integrity */
378 if (file == NULL)
379 return -1;
380 state = (gz_statep)file;
381 if (state->mode != GZ_READ && state->mode != GZ_WRITE)
382 return -1;
383
384 /* check that there's no error */
385 if (state->err != Z_OK && state->err != Z_BUF_ERROR)
386 return -1;
387
388 /* can only seek from start or relative to current position */
389 if (whence != SEEK_SET && whence != SEEK_CUR)
390 return -1;
391
392 /* normalize offset to a SEEK_CUR specification */
393 if (whence == SEEK_SET)
394 offset -= state->x.pos;
395 else if (state->seek)
396 offset += state->skip;
397 state->seek = 0;
398
399 /* if within raw area while reading, just go there */
400 if (state->mode == GZ_READ && state->how == COPY &&
401 state->x.pos + offset >= 0) {
402 ret = LSEEK(state->fd, offset - (z_off64_t)state->x.have, SEEK_CUR);
403 if (ret == -1)
404 return -1;
405 state->x.have = 0;
406 state->eof = 0;
407 state->past = 0;
408 state->seek = 0;
409 gz_error(state, Z_OK, NULL);
410 state->strm.avail_in = 0;
411 state->x.pos += offset;
412 return state->x.pos;
413 }
414
415 /* calculate skip amount, rewinding if needed for back seek when reading */
416 if (offset < 0) {
417 if (state->mode != GZ_READ) /* writing -- can't go backwards */
418 return -1;
419 offset += state->x.pos;
420 if (offset < 0) /* before start of file! */
421 return -1;
422 if (gzrewind(file) == -1) /* rewind, then skip to offset */
423 return -1;
424 }
425
426 /* if reading, skip what's in output buffer (one less gzgetc() check) */
427 if (state->mode == GZ_READ) {
428 n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?
429 (unsigned)offset : state->x.have;
430 state->x.have -= n;
431 state->x.next += n;
432 state->x.pos += n;
433 offset -= n;
434 }
435
436 /* request skip (if not zero) */
437 if (offset) {
438 state->seek = 1;
439 state->skip = offset;
440 }
441 return state->x.pos + offset;
442 }
443
444 /* -- see zlib.h -- */
445 z_off_t ZEXPORT gzseek(file, offset, whence)
446 gzFile file;
447 z_off_t offset;
448 int whence;
449 {
450 z_off64_t ret;
451
452 ret = gzseek64(file, (z_off64_t)offset, whence);
453 return ret == (z_off_t)ret ? (z_off_t)ret : -1;
454 }
455
456 /* -- see zlib.h -- */
457 z_off64_t ZEXPORT gztell64(file)
458 gzFile file;
459 {
460 gz_statep state;
461
462 /* get internal structure and check integrity */
463 if (file == NULL)
464 return -1;
465 state = (gz_statep)file;
466 if (state->mode != GZ_READ && state->mode != GZ_WRITE)
467 return -1;
468
469 /* return position */
470 return state->x.pos + (state->seek ? state->skip : 0);
471 }
472
473 /* -- see zlib.h -- */
474 z_off_t ZEXPORT gztell(file)
475 gzFile file;
476 {
477 z_off64_t ret;
478
479 ret = gztell64(file);
480 return ret == (z_off_t)ret ? (z_off_t)ret : -1;
481 }
482
483 /* -- see zlib.h -- */
484 z_off64_t ZEXPORT gzoffset64(file)
485 gzFile file;
486 {
487 z_off64_t offset;
488 gz_statep state;
489
490 /* get internal structure and check integrity */
491 if (file == NULL)
492 return -1;
493 state = (gz_statep)file;
494 if (state->mode != GZ_READ && state->mode != GZ_WRITE)
495 return -1;
496
497 /* compute and return effective offset in file */
498 offset = LSEEK(state->fd, 0, SEEK_CUR);
499 if (offset == -1)
500 return -1;
501 if (state->mode == GZ_READ) /* reading */
502 offset -= state->strm.avail_in; /* don't count buffered input */
503 return offset;
504 }
505
506 /* -- see zlib.h -- */
507 z_off_t ZEXPORT gzoffset(file)
508 gzFile file;
509 {
510 z_off64_t ret;
511
512 ret = gzoffset64(file);
513 return ret == (z_off_t)ret ? (z_off_t)ret : -1;
514 }
515
516 /* -- see zlib.h -- */
517 int ZEXPORT gzeof(file)
518 gzFile file;
519 {
520 gz_statep state;
521
522 /* get internal structure and check integrity */
523 if (file == NULL)
524 return 0;
525 state = (gz_statep)file;
526 if (state->mode != GZ_READ && state->mode != GZ_WRITE)
527 return 0;
528
529 /* return end-of-file state */
530 return state->mode == GZ_READ ? state->past : 0;
531 }
532
533 /* -- see zlib.h -- */
534 const char * ZEXPORT gzerror(file, errnum)
535 gzFile file;
536 int *errnum;
537 {
538 gz_statep state;
539
540 /* get internal structure and check integrity */
541 if (file == NULL)
542 return NULL;
543 state = (gz_statep)file;
544 if (state->mode != GZ_READ && state->mode != GZ_WRITE)
545 return NULL;
546
547 /* return error information */
548 if (errnum != NULL)
549 *errnum = state->err;
550 return state->err == Z_MEM_ERROR ? "out of memory" :
551 (state->msg == NULL ? "" : state->msg);
552 }
553
554 /* -- see zlib.h -- */
555 void ZEXPORT gzclearerr(file)
556 gzFile file;
557 {
558 gz_statep state;
559
560 /* get internal structure and check integrity */
561 if (file == NULL)
562 return;
563 state = (gz_statep)file;
564 if (state->mode != GZ_READ && state->mode != GZ_WRITE)
565 return;
566
567 /* clear error and end-of-file */
568 if (state->mode == GZ_READ) {
569 state->eof = 0;
570 state->past = 0;
571 }
572 gz_error(state, Z_OK, NULL);
573 }
574
575 /* Create an error message in allocated memory and set state->err and
576 state->msg accordingly. Free any previous error message already there. Do
577 not try to free or allocate space if the error is Z_MEM_ERROR (out of
578 memory). Simply save the error message as a static string. If there is an
579 allocation failure constructing the error message, then convert the error to
580 out of memory. */
581 void ZLIB_INTERNAL gz_error(state, err, msg)
582 gz_statep state;
583 int err;
584 const char *msg;
585 {
586 /* free previously allocated message and clear */
587 if (state->msg != NULL) {
588 if (state->err != Z_MEM_ERROR)
589 free(state->msg);
590 state->msg = NULL;
591 }
592
593 /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */
594 if (err != Z_OK && err != Z_BUF_ERROR)
595 state->x.have = 0;
596
597 /* set error code, and if no message, then done */
598 state->err = err;
599 if (msg == NULL)
600 return;
601
602 /* for an out of memory error, return literal string when requested */
603 if (err == Z_MEM_ERROR)
604 return;
605
606 /* construct error message with path */
607 if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) ==
608 NULL) {
609 state->err = Z_MEM_ERROR;
610 return;
611 }
612 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
613 (void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
614 "%s%s%s", state->path, ": ", msg);
615 #else
616 strcpy(state->msg, state->path);
617 strcat(state->msg, ": ");
618 strcat(state->msg, msg);
619 #endif
620 }
621
622 #ifndef INT_MAX
623 /* portably return maximum value for an int (when limits.h presumed not
624 available) -- we need to do this to cover cases where 2's complement not
625 used, since C standard permits 1's complement and sign-bit representations,
626 otherwise we could just use ((unsigned)-1) >> 1 */
627 unsigned ZLIB_INTERNAL gz_intmax()
628 {
629 unsigned p, q;
630
631 p = 1;
632 do {
633 q = p;
634 p <<= 1;
635 p++;
636 } while (p > q);
637 return q >> 1;
638 }
639 #endif