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