Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/zlib/gzwrite.c @ 2:b50eed0cc0ef upstream

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