| Bsoft 1.9 Bernard's software package

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

gzwrite.c
Go to the documentation of this file.
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 }
deflateParams
int ZEXPORT deflateParams(z_streamp strm, int level, int strategy)
Definition: deflate.c:412
deflateInit2
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy)
Definition: zlib.h:1550
write
int write(int fd, const char *buf, int nbytes)
Definition: tif_acorn.c:325
Z_NO_FLUSH
#define Z_NO_FLUSH
Definition: zlib.h:164
Z_PARTIAL_FLUSH
#define Z_PARTIAL_FLUSH
Definition: zlib.h:165
GT_OFF
#define GT_OFF(x)
Definition: gzguts.h:131
gzsetparams
int ZEXPORT gzsetparams(gzFile file, int level, int strategy)
Definition: gzwrite.c:458
Z_ERRNO
#define Z_ERRNO
Definition: zlib.h:176
z_off64_t
#define z_off64_t
Definition: zconf.h:400
deflateEnd
int ZEXPORT deflateEnd(z_streamp strm)
Definition: deflate.c:895
Z_STREAM_ERROR
#define Z_STREAM_ERROR
Definition: zlib.h:177
gzwrite
int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len)
Definition: gzwrite.c:143
gzFile
voidp gzFile
Definition: zlib.h:1165
gz_init
local int gz_init(gz_statep state)
Definition: gzwrite.c:15
gzputc
int ZEXPORT gzputc(gzFile file, int c)
Definition: gzwrite.c:221
Z_FINISH
#define Z_FINISH
Definition: zlib.h:168
gz_error
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.c:485
zstrerror
#define zstrerror()
Definition: gzguts.h:59
Z_DEFLATED
#define Z_DEFLATED
Definition: zlib.h:205
GZ_WRITE
#define GZ_WRITE
Definition: gzguts.h:77
close
int close(int fd)
Definition: tif_acorn.c:320
gz_zero
local int gz_zero(gz_statep state, z_off64_t len)
Definition: gzwrite.c:111
Z_STREAM_END
#define Z_STREAM_END
Definition: zlib.h:174
local
#define local
Definition: adler32.c:10
gzguts.h
gzclose_w
int ZEXPORT gzclose_w(gzFile file)
Definition: gzwrite.c:500
gzputs
int ZEXPORT gzputs(gzFile file, const char *str)
Definition: gzwrite.c:264
gz_comp
local int gz_comp(gz_statep state, int flush)
Definition: gzwrite.c:59
Z_MEM_ERROR
#define Z_MEM_ERROR
Definition: zlib.h:179
voidp
Byte * voidp
Definition: zconf.h:356
deflate
int ZEXPORT deflate(z_streamp strm, int flush)
Definition: deflate.c:582
gzprintf
int ZEXPORTVA gzprintf(gzFile file, const char *format, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, int a11, int a12, int a13, int a14, int a15, int a16, int a17, int a18, int a19, int a20)
Definition: gzwrite.c:352
OF
local int gz_init OF((gz_statep))
gzflush
int ZEXPORT gzflush(gzFile file, int flush)
Definition: gzwrite.c:426
Z_BUF_ERROR
#define Z_BUF_ERROR
Definition: zlib.h:180
Z_OK
#define Z_OK
Definition: zlib.h:173
gz_statep
gz_state FAR * gz_statep
Definition: gzguts.h:116
Z_NULL
#define Z_NULL
Definition: zlib.h:208
const
#define const
Definition: zconf.h:196
z_streamp
z_stream FAR * z_streamp
Definition: zlib.h:106
deflateReset
int ZEXPORT deflateReset(z_streamp strm)
Definition: deflate.c:353
voidpc
Byte const * voidpc
Definition: zconf.h:354
ZEXPORT
#define ZEXPORT
Definition: zconf.h:322
ZEXPORTVA
#define ZEXPORTVA
Definition: zconf.h:325
level
int level(0)