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