← Back to branch summary

~ubuntu-branches/ubuntu/utopic/critcl/utopic

« back to all changes in this revision

Viewing changes to examples/zlibwrap/zlib/gzwrite.c

  • Committer: Package Import Robot
  • Author(s): Andrew Shadura
  • Date: 2013-05-11 00:08:06 UTC
  • Revision ID: package-import@ubuntu.com-20130511000806-7hq1zc3fnn0gat79
Tags: upstream-3.1.9
Import upstream version 3.1.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/zlibwrap/zlib/gzwrite.c
 
1
/* gzwrite.c -- zlib functions for writing gzip files
 
2
 * Copyright (C) 2004, 2005, 2010 Mark Adler
 
3
 * For conditions of distribution and use, see copyright notice in zlib.h
 
4
 */
 
5
 
 
6
#include "gzguts.h"
 
7
 
 
8
/* Local functions */
 
9
local int gz_init OF((gz_statep));
 
10
local int gz_comp OF((gz_statep, int));
 
11
local int gz_zero OF((gz_statep, z_off64_t));
 
12
 
 
13
/* Initialize state for writing a gzip file.  Mark initialization by setting
 
14
   state->size to non-zero.  Return -1 on failure or 0 on success. */
 
15
local int gz_init(state)
 
16
    gz_statep state;
 
17
{
 
18
    int ret;
 
19
    z_streamp strm = &(state->strm);
 
20
 
 
21
    /* allocate input and output buffers */
 
22
    state->in = malloc(state->want);
 
23
    state->out = malloc(state->want);
 
24
    if (state->in == NULL || state->out == NULL) {
 
25
        if (state->out != NULL)
 
26
            free(state->out);
 
27
        if (state->in != NULL)
 
28
            free(state->in);
 
29
        gz_error(state, Z_MEM_ERROR, "out of memory");
 
30
        return -1;
 
31
    }
 
32
 
 
33
    /* allocate deflate memory, set up for gzip compression */
 
34
    strm->zalloc = Z_NULL;
 
35
    strm->zfree = Z_NULL;
 
36
    strm->opaque = Z_NULL;
 
37
    ret = deflateInit2(strm, state->level, Z_DEFLATED,
 
38
                       15 + 16, 8, state->strategy);
 
39
    if (ret != Z_OK) {
 
40
        free(state->in);
 
41
        gz_error(state, Z_MEM_ERROR, "out of memory");
 
42
        return -1;
 
43
    }
 
44
 
 
45
    /* mark state as initialized */
 
46
    state->size = state->want;
 
47
 
 
48
    /* initialize write buffer */
 
49
    strm->avail_out = state->size;
 
50
    strm->next_out = state->out;
 
51
    state->next = strm->next_out;
 
52
    return 0;
 
53
}
 
54
 
 
55
/* Compress whatever is at avail_in and next_in and write to the output file.
 
56
   Return -1 if there is an error writing to the output file, otherwise 0.
 
57
   flush is assumed to be a valid deflate() flush value.  If flush is Z_FINISH,
 
58
   then the deflate() state is reset to start a new gzip stream. */
 
59
local int gz_comp(state, flush)
 
60
    gz_statep state;
 
61
    int flush;
 
62
{
 
63
    int ret, got;
 
64
    unsigned have;
 
65
    z_streamp strm = &(state->strm);
 
66
 
 
67
    /* allocate memory if this is the first time through */
 
68
    if (state->size == 0 && gz_init(state) == -1)
 
69
        return -1;
 
70
 
 
71
    /* run deflate() on provided input until it produces no more output */
 
72
    ret = Z_OK;
 
73
    do {
 
74
        /* write out current buffer contents if full, or if flushing, but if
 
75
           doing Z_FINISH then don't write until we get to Z_STREAM_END */
 
76
        if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
 
77
            (flush != Z_FINISH || ret == Z_STREAM_END))) {
 
78
            have = (unsigned)(strm->next_out - state->next);
 
79
            if (have && ((got = write(state->fd, state->next, have)) < 0 ||
 
80
                         (unsigned)got != have)) {
 
81
                gz_error(state, Z_ERRNO, zstrerror());
 
82
                return -1;
 
83
            }
 
84
            if (strm->avail_out == 0) {
 
85
                strm->avail_out = state->size;
 
86
                strm->next_out = state->out;
 
87
            }
 
88
            state->next = strm->next_out;
 
89
        }
 
90
 
 
91
        /* compress */
 
92
        have = strm->avail_out;
 
93
        ret = deflate(strm, flush);
 
94
        if (ret == Z_STREAM_ERROR) {
 
95
            gz_error(state, Z_STREAM_ERROR,
 
96
                      "internal error: deflate stream corrupt");
 
97
            return -1;
 
98
        }
 
99
        have -= strm->avail_out;
 
100
    } while (have);
 
101
 
 
102
    /* if that completed a deflate stream, allow another to start */
 
103
    if (flush == Z_FINISH)
 
104
        deflateReset(strm);
 
105
 
 
106
    /* all done, no errors */
 
107
    return 0;
 
108
}
 
109
 
 
110
/* Compress len zeros to output.  Return -1 on error, 0 on success. */
 
111
local int gz_zero(state, len)
 
112
    gz_statep state;
 
113
    z_off64_t len;
 
114
{
 
115
    int first;
 
116
    unsigned n;
 
117
    z_streamp strm = &(state->strm);
 
118
 
 
119
    /* consume whatever's left in the input buffer */
 
120
    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
 
121
        return -1;
 
122
 
 
123
    /* compress len zeros (len guaranteed > 0) */
 
124
    first = 1;
 
125
    while (len) {
 
126
        n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
 
127
            (unsigned)len : state->size;
 
128
        if (first) {
 
129
            memset(state->in, 0, n);
 
130
            first = 0;
 
131
        }
 
132
        strm->avail_in = n;
 
133
        strm->next_in = state->in;
 
134
        state->pos += n;
 
135
        if (gz_comp(state, Z_NO_FLUSH) == -1)
 
136
            return -1;
 
137
        len -= n;
 
138
    }
 
139
    return 0;
 
140
}
 
141
 
 
142
/* -- see zlib.h -- */
 
143
int ZEXPORT gzwrite(file, buf, len)
 
144
    gzFile file;
 
145
    voidpc buf;
 
146
    unsigned len;
 
147
{
 
148
    unsigned put = len;
 
149
    unsigned n;
 
150
    gz_statep state;
 
151
    z_streamp strm;
 
152
 
 
153
    /* get internal structure */
 
154
    if (file == NULL)
 
155
        return 0;
 
156
    state = (gz_statep)file;
 
157
    strm = &(state->strm);
 
158
 
 
159
    /* check that we're writing and that there's no error */
 
160
    if (state->mode != GZ_WRITE || state->err != Z_OK)
 
161
        return 0;
 
162
 
 
163
    /* since an int is returned, make sure len fits in one, otherwise return
 
164
       with an error (this avoids the flaw in the interface) */
 
165
    if ((int)len < 0) {
 
166
        gz_error(state, Z_BUF_ERROR, "requested length does not fit in int");
 
167
        return 0;
 
168
    }
 
169
 
 
170
    /* if len is zero, avoid unnecessary operations */
 
171
    if (len == 0)
 
172
        return 0;
 
173
 
 
174
    /* allocate memory if this is the first time through */
 
175
    if (state->size == 0 && gz_init(state) == -1)
 
176
        return 0;
 
177
 
 
178
    /* check for seek request */
 
179
    if (state->seek) {
 
180
        state->seek = 0;
 
181
        if (gz_zero(state, state->skip) == -1)
 
182
            return 0;
 
183
    }
 
184
 
 
185
    /* for small len, copy to input buffer, otherwise compress directly */
 
186
    if (len < state->size) {
 
187
        /* copy to input buffer, compress when full */
 
188
        do {
 
189
            if (strm->avail_in == 0)
 
190
                strm->next_in = state->in;
 
191
            n = state->size - strm->avail_in;
 
192
            if (n > len)
 
193
                n = len;
 
194
            memcpy(strm->next_in + strm->avail_in, buf, n);
 
195
            strm->avail_in += n;
 
196
            state->pos += n;
 
197
            buf = (char *)buf + n;
 
198
            len -= n;
 
199
            if (len && gz_comp(state, Z_NO_FLUSH) == -1)
 
200
                return 0;
 
201
        } while (len);
 
202
    }
 
203
    else {
 
204
        /* consume whatever's left in the input buffer */
 
205
        if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
 
206
            return 0;
 
207
 
 
208
        /* directly compress user buffer to file */
 
209
        strm->avail_in = len;
 
210
        strm->next_in = (voidp)buf;
 
211
        state->pos += len;
 
212
        if (gz_comp(state, Z_NO_FLUSH) == -1)
 
213
            return 0;
 
214
    }
 
215
 
 
216
    /* input was all buffered or compressed (put will fit in int) */
 
217
    return (int)put;
 
218
}
 
219
 
 
220
/* -- see zlib.h -- */
 
221
int ZEXPORT gzputc(file, c)
 
222
    gzFile file;
 
223
    int c;
 
224
{
 
225
    unsigned char buf[1];
 
226
    gz_statep state;
 
227
    z_streamp strm;
 
228
 
 
229
    /* get internal structure */
 
230
    if (file == NULL)
 
231
        return -1;
 
232
    state = (gz_statep)file;
 
233
    strm = &(state->strm);
 
234
 
 
235
    /* check that we're writing and that there's no error */
 
236
    if (state->mode != GZ_WRITE || state->err != Z_OK)
 
237
        return -1;
 
238
 
 
239
    /* check for seek request */
 
240
    if (state->seek) {
 
241
        state->seek = 0;
 
242
        if (gz_zero(state, state->skip) == -1)
 
243
            return -1;
 
244
    }
 
245
 
 
246
    /* try writing to input buffer for speed (state->size == 0 if buffer not
 
247
       initialized) */
 
248
    if (strm->avail_in < state->size) {
 
249
        if (strm->avail_in == 0)
 
250
            strm->next_in = state->in;
 
251
        strm->next_in[strm->avail_in++] = c;
 
252
        state->pos++;
 
253
        return c;
 
254
    }
 
255
 
 
256
    /* no room in buffer or not initialized, use gz_write() */
 
257
    buf[0] = c;
 
258
    if (gzwrite(file, buf, 1) != 1)
 
259
        return -1;
 
260
    return c;
 
261
}
 
262
 
 
263
/* -- see zlib.h -- */
 
264
int ZEXPORT gzputs(file, str)
 
265
    gzFile file;
 
266
    const char *str;
 
267
{
 
268
    int ret;
 
269
    unsigned len;
 
270
 
 
271
    /* write string */
 
272
    len = (unsigned)strlen(str);
 
273
    ret = gzwrite(file, str, len);
 
274
    return ret == 0 && len != 0 ? -1 : ret;
 
275
}
 
276
 
 
277
#ifdef STDC
 
278
#include <stdarg.h>
 
279
 
 
280
/* -- see zlib.h -- */
 
281
int ZEXPORTVA gzprintf (gzFile file, const char *format, ...)
 
282
{
 
283
    int size, len;
 
284
    gz_statep state;
 
285
    z_streamp strm;
 
286
    va_list va;
 
287
 
 
288
    /* get internal structure */
 
289
    if (file == NULL)
 
290
        return -1;
 
291
    state = (gz_statep)file;
 
292
    strm = &(state->strm);
 
293
 
 
294
    /* check that we're writing and that there's no error */
 
295
    if (state->mode != GZ_WRITE || state->err != Z_OK)
 
296
        return 0;
 
297
 
 
298
    /* make sure we have some buffer space */
 
299
    if (state->size == 0 && gz_init(state) == -1)
 
300
        return 0;
 
301
 
 
302
    /* check for seek request */
 
303
    if (state->seek) {
 
304
        state->seek = 0;
 
305
        if (gz_zero(state, state->skip) == -1)
 
306
            return 0;
 
307
    }
 
308
 
 
309
    /* consume whatever's left in the input buffer */
 
310
    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
 
311
        return 0;
 
312
 
 
313
    /* do the printf() into the input buffer, put length in len */
 
314
    size = (int)(state->size);
 
315
    state->in[size - 1] = 0;
 
316
    va_start(va, format);
 
317
#ifdef NO_vsnprintf
 
318
#  ifdef HAS_vsprintf_void
 
319
    (void)vsprintf(state->in, format, va);
 
320
    va_end(va);
 
321
    for (len = 0; len < size; len++)
 
322
        if (state->in[len] == 0) break;
 
323
#  else
 
324
    len = vsprintf(state->in, format, va);
 
325
    va_end(va);
 
326
#  endif
 
327
#else
 
328
#  ifdef HAS_vsnprintf_void
 
329
    (void)vsnprintf(state->in, size, format, va);
 
330
    va_end(va);
 
331
    len = strlen(state->in);
 
332
#  else
 
333
    len = vsnprintf((char *)(state->in), size, format, va);
 
334
    va_end(va);
 
335
#  endif
 
336
#endif
 
337
 
 
338
    /* check that printf() results fit in buffer */
 
339
    if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
 
340
        return 0;
 
341
 
 
342
    /* update buffer and position, defer compression until needed */
 
343
    strm->avail_in = (unsigned)len;
 
344
    strm->next_in = state->in;
 
345
    state->pos += len;
 
346
    return len;
 
347
}
 
348
 
 
349
#else /* !STDC */
 
350
 
 
351
/* -- see zlib.h -- */
 
352
int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
 
353
                       a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
 
354
    gzFile file;
 
355
    const char *format;
 
356
    int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
 
357
        a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
 
358
{
 
359
    int size, len;
 
360
    gz_statep state;
 
361
    z_streamp strm;
 
362
 
 
363
    /* get internal structure */
 
364
    if (file == NULL)
 
365
        return -1;
 
366
    state = (gz_statep)file;
 
367
    strm = &(state->strm);
 
368
 
 
369
    /* check that we're writing and that there's no error */
 
370
    if (state->mode != GZ_WRITE || state->err != Z_OK)
 
371
        return 0;
 
372
 
 
373
    /* make sure we have some buffer space */
 
374
    if (state->size == 0 && gz_init(state) == -1)
 
375
        return 0;
 
376
 
 
377
    /* check for seek request */
 
378
    if (state->seek) {
 
379
        state->seek = 0;
 
380
        if (gz_zero(state, state->skip) == -1)
 
381
            return 0;
 
382
    }
 
383
 
 
384
    /* consume whatever's left in the input buffer */
 
385
    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
 
386
        return 0;
 
387
 
 
388
    /* do the printf() into the input buffer, put length in len */
 
389
    size = (int)(state->size);
 
390
    state->in[size - 1] = 0;
 
391
#ifdef NO_snprintf
 
392
#  ifdef HAS_sprintf_void
 
393
    sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8,
 
394
            a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
 
395
    for (len = 0; len < size; len++)
 
396
        if (state->in[len] == 0) break;
 
397
#  else
 
398
    len = sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8,
 
399
                a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
 
400
#  endif
 
401
#else
 
402
#  ifdef HAS_snprintf_void
 
403
    snprintf(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8,
 
404
             a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
 
405
    len = strlen(state->in);
 
406
#  else
 
407
    len = snprintf(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8,
 
408
                 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
 
409
#  endif
 
410
#endif
 
411
 
 
412
    /* check that printf() results fit in buffer */
 
413
    if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
 
414
        return 0;
 
415
 
 
416
    /* update buffer and position, defer compression until needed */
 
417
    strm->avail_in = (unsigned)len;
 
418
    strm->next_in = state->in;
 
419
    state->pos += len;
 
420
    return len;
 
421
}
 
422
 
 
423
#endif
 
424
 
 
425
/* -- see zlib.h -- */
 
426
int ZEXPORT gzflush(file, flush)
 
427
    gzFile file;
 
428
    int flush;
 
429
{
 
430
    gz_statep state;
 
431
 
 
432
    /* get internal structure */
 
433
    if (file == NULL)
 
434
        return -1;
 
435
    state = (gz_statep)file;
 
436
 
 
437
    /* check that we're writing and that there's no error */
 
438
    if (state->mode != GZ_WRITE || state->err != Z_OK)
 
439
        return Z_STREAM_ERROR;
 
440
 
 
441
    /* check flush parameter */
 
442
    if (flush < 0 || flush > Z_FINISH)
 
443
        return Z_STREAM_ERROR;
 
444
 
 
445
    /* check for seek request */
 
446
    if (state->seek) {
 
447
        state->seek = 0;
 
448
        if (gz_zero(state, state->skip) == -1)
 
449
            return -1;
 
450
    }
 
451
 
 
452
    /* compress remaining data with requested flush */
 
453
    gz_comp(state, flush);
 
454
    return state->err;
 
455
}
 
456
 
 
457
/* -- see zlib.h -- */
 
458
int ZEXPORT gzsetparams(file, level, strategy)
 
459
    gzFile file;
 
460
    int level;
 
461
    int strategy;
 
462
{
 
463
    gz_statep state;
 
464
    z_streamp strm;
 
465
 
 
466
    /* get internal structure */
 
467
    if (file == NULL)
 
468
        return Z_STREAM_ERROR;
 
469
    state = (gz_statep)file;
 
470
    strm = &(state->strm);
 
471
 
 
472
    /* check that we're writing and that there's no error */
 
473
    if (state->mode != GZ_WRITE || state->err != Z_OK)
 
474
        return Z_STREAM_ERROR;
 
475
 
 
476
    /* if no change is requested, then do nothing */
 
477
    if (level == state->level && strategy == state->strategy)
 
478
        return Z_OK;
 
479
 
 
480
    /* check for seek request */
 
481
    if (state->seek) {
 
482
        state->seek = 0;
 
483
        if (gz_zero(state, state->skip) == -1)
 
484
            return -1;
 
485
    }
 
486
 
 
487
    /* change compression parameters for subsequent input */
 
488
    if (state->size) {
 
489
        /* flush previous input with previous parameters before changing */
 
490
        if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1)
 
491
            return state->err;
 
492
        deflateParams(strm, level, strategy);
 
493
    }
 
494
    state->level = level;
 
495
    state->strategy = strategy;
 
496
    return Z_OK;
 
497
}
 
498
 
 
499
/* -- see zlib.h -- */
 
500
int ZEXPORT gzclose_w(file)
 
501
    gzFile file;
 
502
{
 
503
    int ret = 0;
 
504
    gz_statep state;
 
505
 
 
506
    /* get internal structure */
 
507
    if (file == NULL)
 
508
        return Z_STREAM_ERROR;
 
509
    state = (gz_statep)file;
 
510
 
 
511
    /* check that we're writing */
 
512
    if (state->mode != GZ_WRITE)
 
513
        return Z_STREAM_ERROR;
 
514
 
 
515
    /* check for seek request */
 
516
    if (state->seek) {
 
517
        state->seek = 0;
 
518
        ret += gz_zero(state, state->skip);
 
519
    }
 
520
 
 
521
    /* flush, free memory, and close file */
 
522
    ret += gz_comp(state, Z_FINISH);
 
523
    (void)deflateEnd(&(state->strm));
 
524
    free(state->out);
 
525
    free(state->in);
 
526
    gz_error(state, Z_OK, NULL);
 
527
    free(state->path);
 
528
    ret += close(state->fd);
 
529
    free(state);
 
530
    return ret ? Z_ERRNO : Z_OK;
 
531
}