Add core option: PSX cpu clock (dynarec)
[pcsx_rearmed.git] / deps / gzlib.c
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 /* Forward declarations */
19 z_off_t ZEXPORT gzoffset(gzFile file);
20 int ZEXPORT gzbuffer(gzFile file, unsigned size);
21
22 /* Local functions */
23 local void gz_reset OF((gz_statep));
24 local gzFile gz_open OF((const void *, int, const char *));
25
26 #if defined UNDER_CE
27
28 /* Map the Windows error number in ERROR to a locale-dependent error message
29    string and return a pointer to it.  Typically, the values for ERROR come
30    from GetLastError.
31
32    The string pointed to shall not be modified by the application, but may be
33    overwritten by a subsequent call to gz_strwinerror
34
35    The gz_strwinerror function does not change the current setting of
36    GetLastError. */
37 char ZLIB_INTERNAL *gz_strwinerror (error)
38    DWORD error;
39 {
40    static char buf[1024];
41
42    wchar_t *msgbuf;
43    DWORD lasterr = GetLastError();
44    DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
45          | FORMAT_MESSAGE_ALLOCATE_BUFFER,
46          NULL,
47          error,
48          0, /* Default language */
49          (LPVOID)&msgbuf,
50          0,
51          NULL);
52    if (chars != 0) {
53       /* If there is an \r\n appended, zap it.  */
54       if (chars >= 2
55             && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
56          chars -= 2;
57          msgbuf[chars] = 0;
58       }
59
60       if (chars > sizeof (buf) - 1) {
61          chars = sizeof (buf) - 1;
62          msgbuf[chars] = 0;
63       }
64
65       wcstombs(buf, msgbuf, chars + 1);
66       LocalFree(msgbuf);
67    }
68    else {
69       sprintf(buf, "unknown win32 error (%ld)", error);
70    }
71
72    SetLastError(lasterr);
73    return buf;
74 }
75
76 #endif /* UNDER_CE */
77
78 /* Reset gzip file state */
79 local void gz_reset(gz_statep state)
80 {
81    state->x.have = 0;              /* no output data available */
82    if (state->mode == GZ_READ) {   /* for reading ... */
83       state->eof = 0;             /* not at end of file */
84       state->past = 0;            /* have not read past end yet */
85       state->how = LOOK;          /* look for gzip header */
86    }
87    state->seek = 0;                /* no seek request pending */
88    gz_error(state, Z_OK, NULL);    /* clear error */
89    state->x.pos = 0;               /* no uncompressed data yet */
90    state->strm.avail_in = 0;       /* no input data yet */
91 }
92
93 /* Open a gzip file either by name or file descriptor. */
94 local gzFile gz_open(const void *path, int fd, 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, (const wchar_t*)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, (const wchar_t*)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    strlcpy(state->path, path, sizeof(state->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((const wchar_t*)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(const char *path, const char *mode)
269 {
270    return gz_open(path, -1, mode);
271 }
272
273 /* -- see zlib.h -- */
274 gzFile ZEXPORT gzopen64(const char *path, const char *mode)
275 {
276    return gz_open(path, -1, mode);
277 }
278
279 /* -- see zlib.h -- */
280 gzFile ZEXPORT gzdopen(int fd, const char *mode)
281 {
282    char *path;         /* identifier for error messages */
283    gzFile gz;
284
285    if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
286       return NULL;
287 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
288    snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd); /* for debugging */
289 #else
290    sprintf(path, "<fd:%d>", fd);   /* for debugging */
291 #endif
292    gz = gz_open(path, fd, mode);
293    free(path);
294    return gz;
295 }
296
297 /* -- see zlib.h -- */
298 #ifdef _WIN32
299 gzFile ZEXPORT gzopen_w(const wchar_t *path, const char *mode)
300 {
301    return gz_open(path, -2, mode);
302 }
303 #endif
304
305 /* -- see zlib.h -- */
306 int ZEXPORT gzbuffer(gzFile file, unsigned size)
307 {
308    gz_statep state;
309
310    /* get internal structure and check integrity */
311    if (file == NULL)
312       return -1;
313    state = (gz_statep)file;
314    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
315       return -1;
316
317    /* make sure we haven't already allocated memory */
318    if (state->size != 0)
319       return -1;
320
321    /* check and set requested size */
322    if (size < 2)
323       size = 2;               /* need two bytes to check magic header */
324    state->want = size;
325    return 0;
326 }
327
328 /* -- see zlib.h -- */
329 int ZEXPORT gzrewind(gzFile file)
330 {
331    gz_statep state;
332
333    /* get internal structure */
334    if (file == NULL)
335       return -1;
336    state = (gz_statep)file;
337
338    /* check that we're reading and that there's no error */
339    if (state->mode != GZ_READ ||
340          (state->err != Z_OK && state->err != Z_BUF_ERROR))
341       return -1;
342
343    /* back up and start over */
344    if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
345       return -1;
346    gz_reset(state);
347    return 0;
348 }
349
350 /* -- see zlib.h -- */
351 z_off64_t ZEXPORT gzseek64(gzFile file, z_off64_t offset, int whence)
352 {
353    unsigned n;
354    z_off64_t ret;
355    gz_statep state;
356
357    /* get internal structure and check integrity */
358    if (file == NULL)
359       return -1;
360    state = (gz_statep)file;
361    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
362       return -1;
363
364    /* check that there's no error */
365    if (state->err != Z_OK && state->err != Z_BUF_ERROR)
366       return -1;
367
368    /* can only seek from start or relative to current position */
369    if (whence != SEEK_SET && whence != SEEK_CUR)
370       return -1;
371
372    /* normalize offset to a SEEK_CUR specification */
373    if (whence == SEEK_SET)
374       offset -= state->x.pos;
375    else if (state->seek)
376       offset += state->skip;
377    state->seek = 0;
378
379    /* if within raw area while reading, just go there */
380    if (state->mode == GZ_READ && state->how == MODE_COPY &&
381          state->x.pos + offset >= 0) {
382       ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR);
383       if (ret == -1)
384          return -1;
385       state->x.have = 0;
386       state->eof = 0;
387       state->past = 0;
388       state->seek = 0;
389       gz_error(state, Z_OK, NULL);
390       state->strm.avail_in = 0;
391       state->x.pos += offset;
392       return state->x.pos;
393    }
394
395    /* calculate skip amount, rewinding if needed for back seek when reading */
396    if (offset < 0) {
397       if (state->mode != GZ_READ)         /* writing -- can't go backwards */
398          return -1;
399       offset += state->x.pos;
400       if (offset < 0)                     /* before start of file! */
401          return -1;
402       if (gzrewind(file) == -1)           /* rewind, then skip to offset */
403          return -1;
404    }
405
406    /* if reading, skip what's in output buffer (one less gzgetc() check) */
407    if (state->mode == GZ_READ) {
408       n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?
409          (unsigned)offset : state->x.have;
410       state->x.have -= n;
411       state->x.next += n;
412       state->x.pos += n;
413       offset -= n;
414    }
415
416    /* request skip (if not zero) */
417    if (offset) {
418       state->seek = 1;
419       state->skip = offset;
420    }
421    return state->x.pos + offset;
422 }
423
424 /* -- see zlib.h -- */
425 z_off_t ZEXPORT gzseek(gzFile file, z_off_t offset, int whence)
426 {
427    z_off64_t ret;
428
429    ret = gzseek64(file, (z_off64_t)offset, whence);
430    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
431 }
432
433 /* -- see zlib.h -- */
434 z_off64_t ZEXPORT gztell64(gzFile file)
435 {
436    gz_statep state;
437
438    /* get internal structure and check integrity */
439    if (file == NULL)
440       return -1;
441    state = (gz_statep)file;
442    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
443       return -1;
444
445    /* return position */
446    return state->x.pos + (state->seek ? state->skip : 0);
447 }
448
449 /* -- see zlib.h -- */
450 z_off_t ZEXPORT gztell(gzFile file)
451 {
452    z_off64_t ret;
453
454    ret = gztell64(file);
455    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
456 }
457
458 /* -- see zlib.h -- */
459 z_off64_t ZEXPORT gzoffset64(gzFile file)
460 {
461    z_off64_t offset;
462    gz_statep state;
463
464    /* get internal structure and check integrity */
465    if (file == NULL)
466       return -1;
467    state = (gz_statep)file;
468    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
469       return -1;
470
471    /* compute and return effective offset in file */
472    offset = LSEEK(state->fd, 0, SEEK_CUR);
473    if (offset == -1)
474       return -1;
475    if (state->mode == GZ_READ)             /* reading */
476       offset -= state->strm.avail_in;     /* don't count buffered input */
477    return offset;
478 }
479
480 /* -- see zlib.h -- */
481 z_off_t ZEXPORT gzoffset(gzFile file)
482 {
483    z_off64_t ret = gzoffset64(file);
484    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
485 }
486
487 /* -- see zlib.h -- */
488 int ZEXPORT gzeof(gzFile file)
489 {
490    gz_statep state;
491
492    /* get internal structure and check integrity */
493    if (file == NULL)
494       return 0;
495    state = (gz_statep)file;
496    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
497       return 0;
498
499    /* return end-of-file state */
500    return state->mode == GZ_READ ? state->past : 0;
501 }
502
503 /* -- see zlib.h -- */
504 const char * ZEXPORT gzerror(gzFile file, int *errnum)
505 {
506    gz_statep state;
507
508    /* get internal structure and check integrity */
509    if (file == NULL)
510       return NULL;
511    state = (gz_statep)file;
512    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
513       return NULL;
514
515    /* return error information */
516    if (errnum != NULL)
517       *errnum = state->err;
518    return state->err == Z_MEM_ERROR ? "out of memory" :
519       (state->msg == NULL ? "" : state->msg);
520 }
521
522 /* -- see zlib.h -- */
523 void ZEXPORT gzclearerr(gzFile file)
524 {
525    gz_statep state;
526
527    /* get internal structure and check integrity */
528    if (file == NULL)
529       return;
530    state = (gz_statep)file;
531    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
532       return;
533
534    /* clear error and end-of-file */
535    if (state->mode == GZ_READ) {
536       state->eof = 0;
537       state->past = 0;
538    }
539    gz_error(state, Z_OK, NULL);
540 }
541
542 /* Create an error message in allocated memory and set state->err and
543    state->msg accordingly.  Free any previous error message already there.  Do
544    not try to free or allocate space if the error is Z_MEM_ERROR (out of
545    memory).  Simply save the error message as a static string.  If there is an
546    allocation failure constructing the error message, then convert the error to
547    out of memory. */
548 void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
549 {
550    /* free previously allocated message and clear */
551    if (state->msg != NULL) {
552       if (state->err != Z_MEM_ERROR)
553          free(state->msg);
554       state->msg = NULL;
555    }
556
557    /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */
558    if (err != Z_OK && err != Z_BUF_ERROR)
559       state->x.have = 0;
560
561    /* set error code, and if no message, then done */
562    state->err = err;
563    if (msg == NULL)
564       return;
565
566    /* for an out of memory error, return literal string when requested */
567    if (err == Z_MEM_ERROR)
568       return;
569
570    /* construct error message with path */
571    if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) ==
572          NULL) {
573       state->err = Z_MEM_ERROR;
574       return;
575    }
576 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
577    snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
578          "%s%s%s", state->path, ": ", msg);
579 #else
580    strlcpy(state->msg, state->path, sizeof(state->msg));
581    strlcat(state->msg, ": ", sizeof(state->msg));
582    strlcat(state->msg, msg, sizeof(state->msg));
583 #endif
584    return;
585 }
586
587 #ifndef INT_MAX
588 /* portably return maximum value for an int (when limits.h presumed not
589    available) -- we need to do this to cover cases where 2's complement not
590    used, since C standard permits 1's complement and sign-bit representations,
591    otherwise we could just use ((unsigned)-1) >> 1 */
592 unsigned ZLIB_INTERNAL gz_intmax()
593 {
594    unsigned p, q;
595
596    p = 1;
597    do {
598       q = p;
599       p <<= 1;
600       p++;
601    } while (p > q);
602    return q >> 1;
603 }
604 #endif