| Geant4 Cross Reference |
1 /* gzwrite.c -- zlib functions for writing gzi 1 /* gzwrite.c -- zlib functions for writing gzip files
2 * Copyright (C) 2004-2019 Mark Adler 2 * Copyright (C) 2004-2019 Mark Adler
3 * For conditions of distribution and use, see 3 * For conditions of distribution and use, see copyright notice in zlib.h
4 */ 4 */
5 5
6 #include "gzguts.h" 6 #include "gzguts.h"
7 7
8 /* Local functions */ 8 /* Local functions */
9 local int gz_init OF((gz_statep)); 9 local int gz_init OF((gz_statep));
10 local int gz_comp OF((gz_statep, int)); 10 local int gz_comp OF((gz_statep, int));
11 local int gz_zero OF((gz_statep, z_off64_t)); 11 local int gz_zero OF((gz_statep, z_off64_t));
12 local z_size_t gz_write OF((gz_statep, voidpc, 12 local z_size_t gz_write OF((gz_statep, voidpc, z_size_t));
13 13
14 /* Initialize state for writing a gzip file. 14 /* Initialize state for writing a gzip file. Mark initialization by setting
15 state->size to non-zero. Return -1 on a me 15 state->size to non-zero. Return -1 on a memory allocation failure, or 0 on
16 success. */ 16 success. */
17 local int gz_init(state) 17 local int gz_init(state)
18 gz_statep state; 18 gz_statep state;
19 { 19 {
20 int ret; 20 int ret;
21 z_streamp strm = &(state->strm); 21 z_streamp strm = &(state->strm);
22 22
23 /* allocate input buffer (double size for 23 /* allocate input buffer (double size for gzprintf) */
24 state->in = (unsigned char *)malloc(state- 24 state->in = (unsigned char *)malloc(state->want << 1);
25 if (state->in == NULL) { 25 if (state->in == NULL) {
26 gz_error(state, Z_MEM_ERROR, "out of m 26 gz_error(state, Z_MEM_ERROR, "out of memory");
27 return -1; 27 return -1;
28 } 28 }
29 29
30 /* only need output buffer and deflate sta 30 /* only need output buffer and deflate state if compressing */
31 if (!state->direct) { 31 if (!state->direct) {
32 /* allocate output buffer */ 32 /* allocate output buffer */
33 state->out = (unsigned char *)malloc(s 33 state->out = (unsigned char *)malloc(state->want);
34 if (state->out == NULL) { 34 if (state->out == NULL) {
35 free(state->in); 35 free(state->in);
36 gz_error(state, Z_MEM_ERROR, "out 36 gz_error(state, Z_MEM_ERROR, "out of memory");
37 return -1; 37 return -1;
38 } 38 }
39 39
40 /* allocate deflate memory, set up for 40 /* allocate deflate memory, set up for gzip compression */
41 strm->zalloc = Z_NULL; 41 strm->zalloc = Z_NULL;
42 strm->zfree = Z_NULL; 42 strm->zfree = Z_NULL;
43 strm->opaque = Z_NULL; 43 strm->opaque = Z_NULL;
44 ret = deflateInit2(strm, state->level, 44 ret = deflateInit2(strm, state->level, Z_DEFLATED,
45 MAX_WBITS + 16, DEF 45 MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
46 if (ret != Z_OK) { 46 if (ret != Z_OK) {
47 free(state->out); 47 free(state->out);
48 free(state->in); 48 free(state->in);
49 gz_error(state, Z_MEM_ERROR, "out 49 gz_error(state, Z_MEM_ERROR, "out of memory");
50 return -1; 50 return -1;
51 } 51 }
52 strm->next_in = NULL; 52 strm->next_in = NULL;
53 } 53 }
54 54
55 /* mark state as initialized */ 55 /* mark state as initialized */
56 state->size = state->want; 56 state->size = state->want;
57 57
58 /* initialize write buffer if compressing 58 /* initialize write buffer if compressing */
59 if (!state->direct) { 59 if (!state->direct) {
60 strm->avail_out = state->size; 60 strm->avail_out = state->size;
61 strm->next_out = state->out; 61 strm->next_out = state->out;
62 state->x.next = strm->next_out; 62 state->x.next = strm->next_out;
63 } 63 }
64 return 0; 64 return 0;
65 } 65 }
66 66
67 /* Compress whatever is at avail_in and next_i 67 /* Compress whatever is at avail_in and next_in and write to the output file.
68 Return -1 if there is an error writing to t 68 Return -1 if there is an error writing to the output file or if gz_init()
69 fails to allocate memory, otherwise 0. flu 69 fails to allocate memory, otherwise 0. flush is assumed to be a valid
70 deflate() flush value. If flush is Z_FINIS 70 deflate() flush value. If flush is Z_FINISH, then the deflate() state is
71 reset to start a new gzip stream. If gz->d 71 reset to start a new gzip stream. If gz->direct is true, then simply write
72 to the output file without compressing, and 72 to the output file without compressing, and ignore flush. */
73 local int gz_comp(state, flush) 73 local int gz_comp(state, flush)
74 gz_statep state; 74 gz_statep state;
75 int flush; 75 int flush;
76 { 76 {
77 int ret, writ; 77 int ret, writ;
78 unsigned have, put, max = ((unsigned)-1 >> 78 unsigned have, put, max = ((unsigned)-1 >> 2) + 1;
79 z_streamp strm = &(state->strm); 79 z_streamp strm = &(state->strm);
80 80
81 /* allocate memory if this is the first ti 81 /* allocate memory if this is the first time through */
82 if (state->size == 0 && gz_init(state) == 82 if (state->size == 0 && gz_init(state) == -1)
83 return -1; 83 return -1;
84 84
85 /* write directly if requested */ 85 /* write directly if requested */
86 if (state->direct) { 86 if (state->direct) {
87 while (strm->avail_in) { 87 while (strm->avail_in) {
88 put = strm->avail_in > max ? max : 88 put = strm->avail_in > max ? max : strm->avail_in;
89 writ = write(state->fd, strm->next 89 writ = write(state->fd, strm->next_in, put);
90 if (writ < 0) { 90 if (writ < 0) {
91 gz_error(state, Z_ERRNO, zstre 91 gz_error(state, Z_ERRNO, zstrerror());
92 return -1; 92 return -1;
93 } 93 }
94 strm->avail_in -= (unsigned)writ; 94 strm->avail_in -= (unsigned)writ;
95 strm->next_in += writ; 95 strm->next_in += writ;
96 } 96 }
97 return 0; 97 return 0;
98 } 98 }
99 99
100 /* check for a pending reset */ 100 /* check for a pending reset */
101 if (state->reset) { 101 if (state->reset) {
102 /* don't start a new gzip member unles 102 /* don't start a new gzip member unless there is data to write */
103 if (strm->avail_in == 0) 103 if (strm->avail_in == 0)
104 return 0; 104 return 0;
105 deflateReset(strm); 105 deflateReset(strm);
106 state->reset = 0; 106 state->reset = 0;
107 } 107 }
108 108
109 /* run deflate() on provided input until i 109 /* run deflate() on provided input until it produces no more output */
110 ret = Z_OK; 110 ret = Z_OK;
111 do { 111 do {
112 /* write out current buffer contents i 112 /* write out current buffer contents if full, or if flushing, but if
113 doing Z_FINISH then don't write unt 113 doing Z_FINISH then don't write until we get to Z_STREAM_END */
114 if (strm->avail_out == 0 || (flush != 114 if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
115 (flush != Z_FINISH || ret == Z_STR 115 (flush != Z_FINISH || ret == Z_STREAM_END))) {
116 while (strm->next_out > state->x.n 116 while (strm->next_out > state->x.next) {
117 put = strm->next_out - state-> 117 put = strm->next_out - state->x.next > (int)max ? max :
118 (unsigned)(strm->next_ou 118 (unsigned)(strm->next_out - state->x.next);
119 writ = write(state->fd, state- 119 writ = write(state->fd, state->x.next, put);
120 if (writ < 0) { 120 if (writ < 0) {
121 gz_error(state, Z_ERRNO, z 121 gz_error(state, Z_ERRNO, zstrerror());
122 return -1; 122 return -1;
123 } 123 }
124 state->x.next += writ; 124 state->x.next += writ;
125 } 125 }
126 if (strm->avail_out == 0) { 126 if (strm->avail_out == 0) {
127 strm->avail_out = state->size; 127 strm->avail_out = state->size;
128 strm->next_out = state->out; 128 strm->next_out = state->out;
129 state->x.next = state->out; 129 state->x.next = state->out;
130 } 130 }
131 } 131 }
132 132
133 /* compress */ 133 /* compress */
134 have = strm->avail_out; 134 have = strm->avail_out;
135 ret = deflate(strm, flush); 135 ret = deflate(strm, flush);
136 if (ret == Z_STREAM_ERROR) { 136 if (ret == Z_STREAM_ERROR) {
137 gz_error(state, Z_STREAM_ERROR, 137 gz_error(state, Z_STREAM_ERROR,
138 "internal error: deflate 138 "internal error: deflate stream corrupt");
139 return -1; 139 return -1;
140 } 140 }
141 have -= strm->avail_out; 141 have -= strm->avail_out;
142 } while (have); 142 } while (have);
143 143
144 /* if that completed a deflate stream, all 144 /* if that completed a deflate stream, allow another to start */
145 if (flush == Z_FINISH) 145 if (flush == Z_FINISH)
146 state->reset = 1; 146 state->reset = 1;
147 147
148 /* all done, no errors */ 148 /* all done, no errors */
149 return 0; 149 return 0;
150 } 150 }
151 151
152 /* Compress len zeros to output. Return -1 on 152 /* Compress len zeros to output. Return -1 on a write error or memory
153 allocation failure by gz_comp(), or 0 on su 153 allocation failure by gz_comp(), or 0 on success. */
154 local int gz_zero(state, len) 154 local int gz_zero(state, len)
155 gz_statep state; 155 gz_statep state;
156 z_off64_t len; 156 z_off64_t len;
157 { 157 {
158 int first; 158 int first;
159 unsigned n; 159 unsigned n;
160 z_streamp strm = &(state->strm); 160 z_streamp strm = &(state->strm);
161 161
162 /* consume whatever's left in the input bu 162 /* consume whatever's left in the input buffer */
163 if (strm->avail_in && gz_comp(state, Z_NO_ 163 if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
164 return -1; 164 return -1;
165 165
166 /* compress len zeros (len guaranteed > 0) 166 /* compress len zeros (len guaranteed > 0) */
167 first = 1; 167 first = 1;
168 while (len) { 168 while (len) {
169 n = GT_OFF(state->size) || (z_off64_t) 169 n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
170 (unsigned)len : state->size; 170 (unsigned)len : state->size;
171 if (first) { 171 if (first) {
172 memset(state->in, 0, n); 172 memset(state->in, 0, n);
173 first = 0; 173 first = 0;
174 } 174 }
175 strm->avail_in = n; 175 strm->avail_in = n;
176 strm->next_in = state->in; 176 strm->next_in = state->in;
177 state->x.pos += n; 177 state->x.pos += n;
178 if (gz_comp(state, Z_NO_FLUSH) == -1) 178 if (gz_comp(state, Z_NO_FLUSH) == -1)
179 return -1; 179 return -1;
180 len -= n; 180 len -= n;
181 } 181 }
182 return 0; 182 return 0;
183 } 183 }
184 184
185 /* Write len bytes from buf to file. Return t 185 /* Write len bytes from buf to file. Return the number of bytes written. If
186 the returned value is less than len, then t 186 the returned value is less than len, then there was an error. */
187 local z_size_t gz_write(state, buf, len) 187 local z_size_t gz_write(state, buf, len)
188 gz_statep state; 188 gz_statep state;
189 voidpc buf; 189 voidpc buf;
190 z_size_t len; 190 z_size_t len;
191 { 191 {
192 z_size_t put = len; 192 z_size_t put = len;
193 193
194 /* if len is zero, avoid unnecessary opera 194 /* if len is zero, avoid unnecessary operations */
195 if (len == 0) 195 if (len == 0)
196 return 0; 196 return 0;
197 197
198 /* allocate memory if this is the first ti 198 /* allocate memory if this is the first time through */
199 if (state->size == 0 && gz_init(state) == 199 if (state->size == 0 && gz_init(state) == -1)
200 return 0; 200 return 0;
201 201
202 /* check for seek request */ 202 /* check for seek request */
203 if (state->seek) { 203 if (state->seek) {
204 state->seek = 0; 204 state->seek = 0;
205 if (gz_zero(state, state->skip) == -1) 205 if (gz_zero(state, state->skip) == -1)
206 return 0; 206 return 0;
207 } 207 }
208 208
209 /* for small len, copy to input buffer, ot 209 /* for small len, copy to input buffer, otherwise compress directly */
210 if (len < state->size) { 210 if (len < state->size) {
211 /* copy to input buffer, compress when 211 /* copy to input buffer, compress when full */
212 do { 212 do {
213 unsigned have, copy; 213 unsigned have, copy;
214 214
215 if (state->strm.avail_in == 0) 215 if (state->strm.avail_in == 0)
216 state->strm.next_in = state->i 216 state->strm.next_in = state->in;
217 have = (unsigned)((state->strm.nex 217 have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
218 state->in); 218 state->in);
219 copy = state->size - have; 219 copy = state->size - have;
220 if (copy > len) 220 if (copy > len)
221 copy = (unsigned)len; 221 copy = (unsigned)len;
222 memcpy(state->in + have, buf, copy 222 memcpy(state->in + have, buf, copy);
223 state->strm.avail_in += copy; 223 state->strm.avail_in += copy;
224 state->x.pos += copy; 224 state->x.pos += copy;
225 buf = (const char *)buf + copy; 225 buf = (const char *)buf + copy;
226 len -= copy; 226 len -= copy;
227 if (len && gz_comp(state, Z_NO_FLU 227 if (len && gz_comp(state, Z_NO_FLUSH) == -1)
228 return 0; 228 return 0;
229 } while (len); 229 } while (len);
230 } 230 }
231 else { 231 else {
232 /* consume whatever's left in the inpu 232 /* consume whatever's left in the input buffer */
233 if (state->strm.avail_in && gz_comp(st 233 if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
234 return 0; 234 return 0;
235 235
236 /* directly compress user buffer to fi 236 /* directly compress user buffer to file */
237 state->strm.next_in = (z_const Bytef * 237 state->strm.next_in = (z_const Bytef *)buf;
238 do { 238 do {
239 unsigned n = (unsigned)-1; 239 unsigned n = (unsigned)-1;
240 if (n > len) 240 if (n > len)
241 n = (unsigned)len; 241 n = (unsigned)len;
242 state->strm.avail_in = n; 242 state->strm.avail_in = n;
243 state->x.pos += n; 243 state->x.pos += n;
244 if (gz_comp(state, Z_NO_FLUSH) == 244 if (gz_comp(state, Z_NO_FLUSH) == -1)
245 return 0; 245 return 0;
246 len -= n; 246 len -= n;
247 } while (len); 247 } while (len);
248 } 248 }
249 249
250 /* input was all buffered or compressed */ 250 /* input was all buffered or compressed */
251 return put; 251 return put;
252 } 252 }
253 253
254 /* -- see zlib.h -- */ 254 /* -- see zlib.h -- */
255 int ZEXPORT gzwrite(file, buf, len) 255 int ZEXPORT gzwrite(file, buf, len)
256 gzFile file; 256 gzFile file;
257 voidpc buf; 257 voidpc buf;
258 unsigned len; 258 unsigned len;
259 { 259 {
260 gz_statep state; 260 gz_statep state;
261 261
262 /* get internal structure */ 262 /* get internal structure */
263 if (file == NULL) 263 if (file == NULL)
264 return 0; 264 return 0;
265 state = (gz_statep)file; 265 state = (gz_statep)file;
266 266
267 /* check that we're writing and that there 267 /* check that we're writing and that there's no error */
268 if (state->mode != GZ_WRITE || state->err 268 if (state->mode != GZ_WRITE || state->err != Z_OK)
269 return 0; 269 return 0;
270 270
271 /* since an int is returned, make sure len 271 /* since an int is returned, make sure len fits in one, otherwise return
272 with an error (this avoids a flaw in th 272 with an error (this avoids a flaw in the interface) */
273 if ((int)len < 0) { 273 if ((int)len < 0) {
274 gz_error(state, Z_DATA_ERROR, "request 274 gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
275 return 0; 275 return 0;
276 } 276 }
277 277
278 /* write len bytes from buf (the return va 278 /* write len bytes from buf (the return value will fit in an int) */
279 return (int)gz_write(state, buf, len); 279 return (int)gz_write(state, buf, len);
280 } 280 }
281 281
282 /* -- see zlib.h -- */ 282 /* -- see zlib.h -- */
283 z_size_t ZEXPORT gzfwrite(buf, size, nitems, f 283 z_size_t ZEXPORT gzfwrite(buf, size, nitems, file)
284 voidpc buf; 284 voidpc buf;
285 z_size_t size; 285 z_size_t size;
286 z_size_t nitems; 286 z_size_t nitems;
287 gzFile file; 287 gzFile file;
288 { 288 {
289 z_size_t len; 289 z_size_t len;
290 gz_statep state; 290 gz_statep state;
291 291
292 /* get internal structure */ 292 /* get internal structure */
293 if (file == NULL) 293 if (file == NULL)
294 return 0; 294 return 0;
295 state = (gz_statep)file; 295 state = (gz_statep)file;
296 296
297 /* check that we're writing and that there 297 /* check that we're writing and that there's no error */
298 if (state->mode != GZ_WRITE || state->err 298 if (state->mode != GZ_WRITE || state->err != Z_OK)
299 return 0; 299 return 0;
300 300
301 /* compute bytes to read -- error on overf 301 /* compute bytes to read -- error on overflow */
302 len = nitems * size; 302 len = nitems * size;
303 if (size && len / size != nitems) { 303 if (size && len / size != nitems) {
304 gz_error(state, Z_STREAM_ERROR, "reque 304 gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
305 return 0; 305 return 0;
306 } 306 }
307 307
308 /* write len bytes to buf, return the numb 308 /* write len bytes to buf, return the number of full items written */
309 return len ? gz_write(state, buf, len) / s 309 return len ? gz_write(state, buf, len) / size : 0;
310 } 310 }
311 311
312 /* -- see zlib.h -- */ 312 /* -- see zlib.h -- */
313 int ZEXPORT gzputc(file, c) 313 int ZEXPORT gzputc(file, c)
314 gzFile file; 314 gzFile file;
315 int c; 315 int c;
316 { 316 {
317 unsigned have; 317 unsigned have;
318 unsigned char buf[1]; 318 unsigned char buf[1];
319 gz_statep state; 319 gz_statep state;
320 z_streamp strm; 320 z_streamp strm;
321 321
322 /* get internal structure */ 322 /* get internal structure */
323 if (file == NULL) 323 if (file == NULL)
324 return -1; 324 return -1;
325 state = (gz_statep)file; 325 state = (gz_statep)file;
326 strm = &(state->strm); 326 strm = &(state->strm);
327 327
328 /* check that we're writing and that there 328 /* check that we're writing and that there's no error */
329 if (state->mode != GZ_WRITE || state->err 329 if (state->mode != GZ_WRITE || state->err != Z_OK)
330 return -1; 330 return -1;
331 331
332 /* check for seek request */ 332 /* check for seek request */
333 if (state->seek) { 333 if (state->seek) {
334 state->seek = 0; 334 state->seek = 0;
335 if (gz_zero(state, state->skip) == -1) 335 if (gz_zero(state, state->skip) == -1)
336 return -1; 336 return -1;
337 } 337 }
338 338
339 /* try writing to input buffer for speed ( 339 /* try writing to input buffer for speed (state->size == 0 if buffer not
340 initialized) */ 340 initialized) */
341 if (state->size) { 341 if (state->size) {
342 if (strm->avail_in == 0) 342 if (strm->avail_in == 0)
343 strm->next_in = state->in; 343 strm->next_in = state->in;
344 have = (unsigned)((strm->next_in + str 344 have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
345 if (have < state->size) { 345 if (have < state->size) {
346 state->in[have] = (unsigned char)c 346 state->in[have] = (unsigned char)c;
347 strm->avail_in++; 347 strm->avail_in++;
348 state->x.pos++; 348 state->x.pos++;
349 return c & 0xff; 349 return c & 0xff;
350 } 350 }
351 } 351 }
352 352
353 /* no room in buffer or not initialized, u 353 /* no room in buffer or not initialized, use gz_write() */
354 buf[0] = (unsigned char)c; 354 buf[0] = (unsigned char)c;
355 if (gz_write(state, buf, 1) != 1) 355 if (gz_write(state, buf, 1) != 1)
356 return -1; 356 return -1;
357 return c & 0xff; 357 return c & 0xff;
358 } 358 }
359 359
360 /* -- see zlib.h -- */ 360 /* -- see zlib.h -- */
361 int ZEXPORT gzputs(file, s) 361 int ZEXPORT gzputs(file, s)
362 gzFile file; 362 gzFile file;
363 const char *s; 363 const char *s;
364 { 364 {
365 z_size_t len, put; 365 z_size_t len, put;
366 gz_statep state; 366 gz_statep state;
367 367
368 /* get internal structure */ 368 /* get internal structure */
369 if (file == NULL) 369 if (file == NULL)
370 return -1; 370 return -1;
371 state = (gz_statep)file; 371 state = (gz_statep)file;
372 372
373 /* check that we're writing and that there 373 /* check that we're writing and that there's no error */
374 if (state->mode != GZ_WRITE || state->err 374 if (state->mode != GZ_WRITE || state->err != Z_OK)
375 return -1; 375 return -1;
376 376
377 /* write string */ 377 /* write string */
378 len = strlen(s); 378 len = strlen(s);
379 if ((int)len < 0 || (unsigned)len != len) 379 if ((int)len < 0 || (unsigned)len != len) {
380 gz_error(state, Z_STREAM_ERROR, "strin 380 gz_error(state, Z_STREAM_ERROR, "string length does not fit in int");
381 return -1; 381 return -1;
382 } 382 }
383 put = gz_write(state, s, len); 383 put = gz_write(state, s, len);
384 return put < len ? -1 : (int)len; 384 return put < len ? -1 : (int)len;
385 } 385 }
386 386
387 #if defined(STDC) || defined(Z_HAVE_STDARG_H) 387 #if defined(STDC) || defined(Z_HAVE_STDARG_H)
388 #include <stdarg.h> 388 #include <stdarg.h>
389 389
390 /* -- see zlib.h -- */ 390 /* -- see zlib.h -- */
391 int ZEXPORTVA gzvprintf(gzFile file, const cha 391 int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va)
392 { 392 {
393 int len; 393 int len;
394 unsigned left; 394 unsigned left;
395 char *next; 395 char *next;
396 gz_statep state; 396 gz_statep state;
397 z_streamp strm; 397 z_streamp strm;
398 398
399 /* get internal structure */ 399 /* get internal structure */
400 if (file == NULL) 400 if (file == NULL)
401 return Z_STREAM_ERROR; 401 return Z_STREAM_ERROR;
402 state = (gz_statep)file; 402 state = (gz_statep)file;
403 strm = &(state->strm); 403 strm = &(state->strm);
404 404
405 /* check that we're writing and that there 405 /* check that we're writing and that there's no error */
406 if (state->mode != GZ_WRITE || state->err 406 if (state->mode != GZ_WRITE || state->err != Z_OK)
407 return Z_STREAM_ERROR; 407 return Z_STREAM_ERROR;
408 408
409 /* make sure we have some buffer space */ 409 /* make sure we have some buffer space */
410 if (state->size == 0 && gz_init(state) == 410 if (state->size == 0 && gz_init(state) == -1)
411 return state->err; 411 return state->err;
412 412
413 /* check for seek request */ 413 /* check for seek request */
414 if (state->seek) { 414 if (state->seek) {
415 state->seek = 0; 415 state->seek = 0;
416 if (gz_zero(state, state->skip) == -1) 416 if (gz_zero(state, state->skip) == -1)
417 return state->err; 417 return state->err;
418 } 418 }
419 419
420 /* do the printf() into the input buffer, 420 /* do the printf() into the input buffer, put length in len -- the input
421 buffer is double-sized just for this fu 421 buffer is double-sized just for this function, so there is guaranteed to
422 be state->size bytes available after th 422 be state->size bytes available after the current contents */
423 if (strm->avail_in == 0) 423 if (strm->avail_in == 0)
424 strm->next_in = state->in; 424 strm->next_in = state->in;
425 next = (char *)(state->in + (strm->next_in 425 next = (char *)(state->in + (strm->next_in - state->in) + strm->avail_in);
426 next[state->size - 1] = 0; 426 next[state->size - 1] = 0;
427 #ifdef NO_vsnprintf 427 #ifdef NO_vsnprintf
428 # ifdef HAS_vsprintf_void 428 # ifdef HAS_vsprintf_void
429 (void)vsprintf(next, format, va); 429 (void)vsprintf(next, format, va);
430 for (len = 0; len < state->size; len++) 430 for (len = 0; len < state->size; len++)
431 if (next[len] == 0) break; 431 if (next[len] == 0) break;
432 # else 432 # else
433 len = vsprintf(next, format, va); 433 len = vsprintf(next, format, va);
434 # endif 434 # endif
435 #else 435 #else
436 # ifdef HAS_vsnprintf_void 436 # ifdef HAS_vsnprintf_void
437 (void)vsnprintf(next, state->size, format, 437 (void)vsnprintf(next, state->size, format, va);
438 len = strlen(next); 438 len = strlen(next);
439 # else 439 # else
440 len = vsnprintf(next, state->size, format, 440 len = vsnprintf(next, state->size, format, va);
441 # endif 441 # endif
442 #endif 442 #endif
443 443
444 /* check that printf() results fit in buff 444 /* check that printf() results fit in buffer */
445 if (len == 0 || (unsigned)len >= state->si 445 if (len == 0 || (unsigned)len >= state->size || next[state->size - 1] != 0)
446 return 0; 446 return 0;
447 447
448 /* update buffer and position, compress fi 448 /* update buffer and position, compress first half if past that */
449 strm->avail_in += (unsigned)len; 449 strm->avail_in += (unsigned)len;
450 state->x.pos += len; 450 state->x.pos += len;
451 if (strm->avail_in >= state->size) { 451 if (strm->avail_in >= state->size) {
452 left = strm->avail_in - state->size; 452 left = strm->avail_in - state->size;
453 strm->avail_in = state->size; 453 strm->avail_in = state->size;
454 if (gz_comp(state, Z_NO_FLUSH) == -1) 454 if (gz_comp(state, Z_NO_FLUSH) == -1)
455 return state->err; 455 return state->err;
456 memmove(state->in, state->in + state-> 456 memmove(state->in, state->in + state->size, left);
457 strm->next_in = state->in; 457 strm->next_in = state->in;
458 strm->avail_in = left; 458 strm->avail_in = left;
459 } 459 }
460 return len; 460 return len;
461 } 461 }
462 462
463 int ZEXPORTVA gzprintf(gzFile file, const char 463 int ZEXPORTVA gzprintf(gzFile file, const char *format, ...)
464 { 464 {
465 va_list va; 465 va_list va;
466 int ret; 466 int ret;
467 467
468 va_start(va, format); 468 va_start(va, format);
469 ret = gzvprintf(file, format, va); 469 ret = gzvprintf(file, format, va);
470 va_end(va); 470 va_end(va);
471 return ret; 471 return ret;
472 } 472 }
473 473
474 #else /* !STDC && !Z_HAVE_STDARG_H */ 474 #else /* !STDC && !Z_HAVE_STDARG_H */
475 475
476 /* -- see zlib.h -- */ 476 /* -- see zlib.h -- */
477 int ZEXPORTVA gzprintf(file, format, a1, a2, a 477 int ZEXPORTVA gzprintf(file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
478 a11, a12, a13, a14, a15 478 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
479 gzFile file; 479 gzFile file;
480 const char *format; 480 const char *format;
481 int a1, a2, a3, a4, a5, a6, a7, a8, a9, a1 481 int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
482 a11, a12, a13, a14, a15, a16, a17, a18 482 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
483 { 483 {
484 unsigned len, left; 484 unsigned len, left;
485 char *next; 485 char *next;
486 gz_statep state; 486 gz_statep state;
487 z_streamp strm; 487 z_streamp strm;
488 488
489 /* get internal structure */ 489 /* get internal structure */
490 if (file == NULL) 490 if (file == NULL)
491 return Z_STREAM_ERROR; 491 return Z_STREAM_ERROR;
492 state = (gz_statep)file; 492 state = (gz_statep)file;
493 strm = &(state->strm); 493 strm = &(state->strm);
494 494
495 /* check that can really pass pointer in i 495 /* check that can really pass pointer in ints */
496 if (sizeof(int) != sizeof(void *)) 496 if (sizeof(int) != sizeof(void *))
497 return Z_STREAM_ERROR; 497 return Z_STREAM_ERROR;
498 498
499 /* check that we're writing and that there 499 /* check that we're writing and that there's no error */
500 if (state->mode != GZ_WRITE || state->err 500 if (state->mode != GZ_WRITE || state->err != Z_OK)
501 return Z_STREAM_ERROR; 501 return Z_STREAM_ERROR;
502 502
503 /* make sure we have some buffer space */ 503 /* make sure we have some buffer space */
504 if (state->size == 0 && gz_init(state) == 504 if (state->size == 0 && gz_init(state) == -1)
505 return state->error; 505 return state->error;
506 506
507 /* check for seek request */ 507 /* check for seek request */
508 if (state->seek) { 508 if (state->seek) {
509 state->seek = 0; 509 state->seek = 0;
510 if (gz_zero(state, state->skip) == -1) 510 if (gz_zero(state, state->skip) == -1)
511 return state->error; 511 return state->error;
512 } 512 }
513 513
514 /* do the printf() into the input buffer, 514 /* do the printf() into the input buffer, put length in len -- the input
515 buffer is double-sized just for this fu 515 buffer is double-sized just for this function, so there is guaranteed to
516 be state->size bytes available after th 516 be state->size bytes available after the current contents */
517 if (strm->avail_in == 0) 517 if (strm->avail_in == 0)
518 strm->next_in = state->in; 518 strm->next_in = state->in;
519 next = (char *)(strm->next_in + strm->avai 519 next = (char *)(strm->next_in + strm->avail_in);
520 next[state->size - 1] = 0; 520 next[state->size - 1] = 0;
521 #ifdef NO_snprintf 521 #ifdef NO_snprintf
522 # ifdef HAS_sprintf_void 522 # ifdef HAS_sprintf_void
523 sprintf(next, format, a1, a2, a3, a4, a5, 523 sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
524 a13, a14, a15, a16, a17, a18, a19, 524 a13, a14, a15, a16, a17, a18, a19, a20);
525 for (len = 0; len < size; len++) 525 for (len = 0; len < size; len++)
526 if (next[len] == 0) 526 if (next[len] == 0)
527 break; 527 break;
528 # else 528 # else
529 len = sprintf(next, format, a1, a2, a3, a4 529 len = sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
530 a12, a13, a14, a15, a16, a17 530 a12, a13, a14, a15, a16, a17, a18, a19, a20);
531 # endif 531 # endif
532 #else 532 #else
533 # ifdef HAS_snprintf_void 533 # ifdef HAS_snprintf_void
534 snprintf(next, state->size, format, a1, a2 534 snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
535 a10, a11, a12, a13, a14, a15, a16 535 a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
536 len = strlen(next); 536 len = strlen(next);
537 # else 537 # else
538 len = snprintf(next, state->size, format, 538 len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
539 a9, a10, a11, a12, a13, a14 539 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
540 # endif 540 # endif
541 #endif 541 #endif
542 542
543 /* check that printf() results fit in buff 543 /* check that printf() results fit in buffer */
544 if (len == 0 || len >= state->size || next 544 if (len == 0 || len >= state->size || next[state->size - 1] != 0)
545 return 0; 545 return 0;
546 546
547 /* update buffer and position, compress fi 547 /* update buffer and position, compress first half if past that */
548 strm->avail_in += len; 548 strm->avail_in += len;
549 state->x.pos += len; 549 state->x.pos += len;
550 if (strm->avail_in >= state->size) { 550 if (strm->avail_in >= state->size) {
551 left = strm->avail_in - state->size; 551 left = strm->avail_in - state->size;
552 strm->avail_in = state->size; 552 strm->avail_in = state->size;
553 if (gz_comp(state, Z_NO_FLUSH) == -1) 553 if (gz_comp(state, Z_NO_FLUSH) == -1)
554 return state->err; 554 return state->err;
555 memmove(state->in, state->in + state-> 555 memmove(state->in, state->in + state->size, left);
556 strm->next_in = state->in; 556 strm->next_in = state->in;
557 strm->avail_in = left; 557 strm->avail_in = left;
558 } 558 }
559 return (int)len; 559 return (int)len;
560 } 560 }
561 561
562 #endif 562 #endif
563 563
564 /* -- see zlib.h -- */ 564 /* -- see zlib.h -- */
565 int ZEXPORT gzflush(file, flush) 565 int ZEXPORT gzflush(file, flush)
566 gzFile file; 566 gzFile file;
567 int flush; 567 int flush;
568 { 568 {
569 gz_statep state; 569 gz_statep state;
570 570
571 /* get internal structure */ 571 /* get internal structure */
572 if (file == NULL) 572 if (file == NULL)
573 return Z_STREAM_ERROR; 573 return Z_STREAM_ERROR;
574 state = (gz_statep)file; 574 state = (gz_statep)file;
575 575
576 /* check that we're writing and that there 576 /* check that we're writing and that there's no error */
577 if (state->mode != GZ_WRITE || state->err 577 if (state->mode != GZ_WRITE || state->err != Z_OK)
578 return Z_STREAM_ERROR; 578 return Z_STREAM_ERROR;
579 579
580 /* check flush parameter */ 580 /* check flush parameter */
581 if (flush < 0 || flush > Z_FINISH) 581 if (flush < 0 || flush > Z_FINISH)
582 return Z_STREAM_ERROR; 582 return Z_STREAM_ERROR;
583 583
584 /* check for seek request */ 584 /* check for seek request */
585 if (state->seek) { 585 if (state->seek) {
586 state->seek = 0; 586 state->seek = 0;
587 if (gz_zero(state, state->skip) == -1) 587 if (gz_zero(state, state->skip) == -1)
588 return state->err; 588 return state->err;
589 } 589 }
590 590
591 /* compress remaining data with requested 591 /* compress remaining data with requested flush */
592 (void)gz_comp(state, flush); 592 (void)gz_comp(state, flush);
593 return state->err; 593 return state->err;
594 } 594 }
595 595
596 /* -- see zlib.h -- */ 596 /* -- see zlib.h -- */
597 int ZEXPORT gzsetparams(file, level, strategy) 597 int ZEXPORT gzsetparams(file, level, strategy)
598 gzFile file; 598 gzFile file;
599 int level; 599 int level;
600 int strategy; 600 int strategy;
601 { 601 {
602 gz_statep state; 602 gz_statep state;
603 z_streamp strm; 603 z_streamp strm;
604 604
605 /* get internal structure */ 605 /* get internal structure */
606 if (file == NULL) 606 if (file == NULL)
607 return Z_STREAM_ERROR; 607 return Z_STREAM_ERROR;
608 state = (gz_statep)file; 608 state = (gz_statep)file;
609 strm = &(state->strm); 609 strm = &(state->strm);
610 610
611 /* check that we're writing and that there 611 /* check that we're writing and that there's no error */
612 if (state->mode != GZ_WRITE || state->err 612 if (state->mode != GZ_WRITE || state->err != Z_OK)
613 return Z_STREAM_ERROR; 613 return Z_STREAM_ERROR;
614 614
615 /* if no change is requested, then do noth 615 /* if no change is requested, then do nothing */
616 if (level == state->level && strategy == s 616 if (level == state->level && strategy == state->strategy)
617 return Z_OK; 617 return Z_OK;
618 618
619 /* check for seek request */ 619 /* check for seek request */
620 if (state->seek) { 620 if (state->seek) {
621 state->seek = 0; 621 state->seek = 0;
622 if (gz_zero(state, state->skip) == -1) 622 if (gz_zero(state, state->skip) == -1)
623 return state->err; 623 return state->err;
624 } 624 }
625 625
626 /* change compression parameters for subse 626 /* change compression parameters for subsequent input */
627 if (state->size) { 627 if (state->size) {
628 /* flush previous input with previous 628 /* flush previous input with previous parameters before changing */
629 if (strm->avail_in && gz_comp(state, Z 629 if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
630 return state->err; 630 return state->err;
631 deflateParams(strm, level, strategy); 631 deflateParams(strm, level, strategy);
632 } 632 }
633 state->level = level; 633 state->level = level;
634 state->strategy = strategy; 634 state->strategy = strategy;
635 return Z_OK; 635 return Z_OK;
636 } 636 }
637 637
638 /* -- see zlib.h -- */ 638 /* -- see zlib.h -- */
639 int ZEXPORT gzclose_w(file) 639 int ZEXPORT gzclose_w(file)
640 gzFile file; 640 gzFile file;
641 { 641 {
642 int ret = Z_OK; 642 int ret = Z_OK;
643 gz_statep state; 643 gz_statep state;
644 644
645 /* get internal structure */ 645 /* get internal structure */
646 if (file == NULL) 646 if (file == NULL)
647 return Z_STREAM_ERROR; 647 return Z_STREAM_ERROR;
648 state = (gz_statep)file; 648 state = (gz_statep)file;
649 649
650 /* check that we're writing */ 650 /* check that we're writing */
651 if (state->mode != GZ_WRITE) 651 if (state->mode != GZ_WRITE)
652 return Z_STREAM_ERROR; 652 return Z_STREAM_ERROR;
653 653
654 /* check for seek request */ 654 /* check for seek request */
655 if (state->seek) { 655 if (state->seek) {
656 state->seek = 0; 656 state->seek = 0;
657 if (gz_zero(state, state->skip) == -1) 657 if (gz_zero(state, state->skip) == -1)
658 ret = state->err; 658 ret = state->err;
659 } 659 }
660 660
661 /* flush, free memory, and close file */ 661 /* flush, free memory, and close file */
662 if (gz_comp(state, Z_FINISH) == -1) 662 if (gz_comp(state, Z_FINISH) == -1)
663 ret = state->err; 663 ret = state->err;
664 if (state->size) { 664 if (state->size) {
665 if (!state->direct) { 665 if (!state->direct) {
666 (void)deflateEnd(&(state->strm)); 666 (void)deflateEnd(&(state->strm));
667 free(state->out); 667 free(state->out);
668 } 668 }
669 free(state->in); 669 free(state->in);
670 } 670 }
671 gz_error(state, Z_OK, NULL); 671 gz_error(state, Z_OK, NULL);
672 free(state->path); 672 free(state->path);
673 if (close(state->fd) == -1) 673 if (close(state->fd) == -1)
674 ret = Z_ERRNO; 674 ret = Z_ERRNO;
675 free(state); 675 free(state);
676 return ret; 676 return ret;
677 } 677 }
678 678