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