← Back to branch summary

~maria-captains/mariadb-native-client/trunk

« back to all changes in this revision

Viewing changes to zlib/gzlib.c

  • Committer: ghost
  • Date: 2011-10-10 11:01:17 UTC
  • Revision ID: ghost@work-20111010110117-a2zv9mgwavp0iw0a
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
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