Branch data Line data Source code
1 : : /* zlibmodule.c -- gzip-compatible data compression */
2 : : /* See http://zlib.net/ */
3 : :
4 : : /* Windows users: read Python's PCbuild\readme.txt */
5 : :
6 : : #define PY_SSIZE_T_CLEAN
7 : :
8 : : #include "Python.h"
9 : : #include "structmember.h" // PyMemberDef
10 : : #include "zlib.h"
11 : :
12 : : // Blocks output buffer wrappers
13 : : #include "pycore_blocks_output_buffer.h"
14 : :
15 : : #if OUTPUT_BUFFER_MAX_BLOCK_SIZE > UINT32_MAX
16 : : #error "The maximum block size accepted by zlib is UINT32_MAX."
17 : : #endif
18 : :
19 : : /* On success, return value >= 0
20 : : On failure, return -1 */
21 : : static inline Py_ssize_t
22 : 68174 : OutputBuffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,
23 : : Bytef **next_out, uint32_t *avail_out)
24 : : {
25 : : Py_ssize_t allocated;
26 : :
27 : 68174 : allocated = _BlocksOutputBuffer_InitAndGrow(
28 : : buffer, max_length, (void**) next_out);
29 : 68174 : *avail_out = (uint32_t) allocated;
30 : 68174 : return allocated;
31 : : }
32 : :
33 : : /* On success, return value >= 0
34 : : On failure, return -1 */
35 : : static inline Py_ssize_t
36 : 775 : OutputBuffer_Grow(_BlocksOutputBuffer *buffer,
37 : : Bytef **next_out, uint32_t *avail_out)
38 : : {
39 : : Py_ssize_t allocated;
40 : :
41 : 775 : allocated = _BlocksOutputBuffer_Grow(
42 : 775 : buffer, (void**) next_out, (Py_ssize_t) *avail_out);
43 : 775 : *avail_out = (uint32_t) allocated;
44 : 775 : return allocated;
45 : : }
46 : :
47 : : static inline Py_ssize_t
48 : 24548 : OutputBuffer_GetDataSize(_BlocksOutputBuffer *buffer, uint32_t avail_out)
49 : : {
50 : 24548 : return _BlocksOutputBuffer_GetDataSize(buffer, (Py_ssize_t) avail_out);
51 : : }
52 : :
53 : : static inline PyObject *
54 : 68169 : OutputBuffer_Finish(_BlocksOutputBuffer *buffer, uint32_t avail_out)
55 : : {
56 : 68169 : return _BlocksOutputBuffer_Finish(buffer, (Py_ssize_t) avail_out);
57 : : }
58 : :
59 : : static inline void
60 : 5 : OutputBuffer_OnError(_BlocksOutputBuffer *buffer)
61 : : {
62 : 5 : _BlocksOutputBuffer_OnError(buffer);
63 : 5 : }
64 : :
65 : : /* The max buffer size accepted by zlib is UINT32_MAX, the initial buffer size
66 : : `init_size` may > it in 64-bit build. These wrapper functions maintain an
67 : : UINT32_MAX sliding window for the first block:
68 : : 1. OutputBuffer_WindowInitWithSize()
69 : : 2. OutputBuffer_WindowGrow()
70 : : 3. OutputBuffer_WindowFinish()
71 : : 4. OutputBuffer_WindowOnError()
72 : :
73 : : ==== is the sliding window:
74 : : 1. ====------
75 : : ^ next_posi, left_bytes is 6
76 : : 2. ----====--
77 : : ^ next_posi, left_bytes is 2
78 : : 3. --------==
79 : : ^ next_posi, left_bytes is 0 */
80 : : typedef struct {
81 : : Py_ssize_t left_bytes;
82 : : Bytef *next_posi;
83 : : } _Uint32Window;
84 : :
85 : : /* Initialize the buffer with an initial buffer size.
86 : :
87 : : On success, return value >= 0
88 : : On failure, return value < 0 */
89 : : static inline Py_ssize_t
90 : 6611 : OutputBuffer_WindowInitWithSize(_BlocksOutputBuffer *buffer, _Uint32Window *window,
91 : : Py_ssize_t init_size,
92 : : Bytef **next_out, uint32_t *avail_out)
93 : : {
94 : 6611 : Py_ssize_t allocated = _BlocksOutputBuffer_InitWithSize(
95 : : buffer, init_size, (void**) next_out);
96 : :
97 [ + - ]: 6611 : if (allocated >= 0) {
98 : : // the UINT32_MAX sliding window
99 : 6611 : Py_ssize_t window_size = Py_MIN((size_t)allocated, UINT32_MAX);
100 : 6611 : *avail_out = (uint32_t) window_size;
101 : :
102 : 6611 : window->left_bytes = allocated - window_size;
103 : 6611 : window->next_posi = *next_out + window_size;
104 : : }
105 : 6611 : return allocated;
106 : : }
107 : :
108 : : /* Grow the buffer.
109 : :
110 : : On success, return value >= 0
111 : : On failure, return value < 0 */
112 : : static inline Py_ssize_t
113 : 730 : OutputBuffer_WindowGrow(_BlocksOutputBuffer *buffer, _Uint32Window *window,
114 : : Bytef **next_out, uint32_t *avail_out)
115 : : {
116 : : Py_ssize_t allocated;
117 : :
118 : : /* ensure no gaps in the data.
119 : : if inlined, this check could be optimized away.*/
120 [ - + ]: 730 : if (*avail_out != 0) {
121 : 0 : PyErr_SetString(PyExc_SystemError,
122 : : "*avail_out != 0 in OutputBuffer_WindowGrow().");
123 : 0 : return -1;
124 : : }
125 : :
126 : : // slide the UINT32_MAX sliding window
127 [ - + ]: 730 : if (window->left_bytes > 0) {
128 : 0 : Py_ssize_t window_size = Py_MIN((size_t)window->left_bytes, UINT32_MAX);
129 : :
130 : 0 : *next_out = window->next_posi;
131 : 0 : *avail_out = (uint32_t) window_size;
132 : :
133 : 0 : window->left_bytes -= window_size;
134 : 0 : window->next_posi += window_size;
135 : :
136 : 0 : return window_size;
137 : : }
138 : : assert(window->left_bytes == 0);
139 : :
140 : : // only the first block may > UINT32_MAX
141 : 730 : allocated = _BlocksOutputBuffer_Grow(
142 : 730 : buffer, (void**) next_out, (Py_ssize_t) *avail_out);
143 : 730 : *avail_out = (uint32_t) allocated;
144 : 730 : return allocated;
145 : : }
146 : :
147 : : /* Finish the buffer.
148 : :
149 : : On success, return a bytes object
150 : : On failure, return NULL */
151 : : static inline PyObject *
152 : 6607 : OutputBuffer_WindowFinish(_BlocksOutputBuffer *buffer, _Uint32Window *window,
153 : : uint32_t avail_out)
154 : : {
155 : 6607 : Py_ssize_t real_avail_out = (Py_ssize_t) avail_out + window->left_bytes;
156 : 6607 : return _BlocksOutputBuffer_Finish(buffer, real_avail_out);
157 : : }
158 : :
159 : : static inline void
160 : 4 : OutputBuffer_WindowOnError(_BlocksOutputBuffer *buffer, _Uint32Window *window)
161 : : {
162 : 4 : _BlocksOutputBuffer_OnError(buffer);
163 : 4 : }
164 : :
165 : :
166 : : #define ENTER_ZLIB(obj) do { \
167 : : if (!PyThread_acquire_lock((obj)->lock, 0)) { \
168 : : Py_BEGIN_ALLOW_THREADS \
169 : : PyThread_acquire_lock((obj)->lock, 1); \
170 : : Py_END_ALLOW_THREADS \
171 : : } } while (0)
172 : : #define LEAVE_ZLIB(obj) PyThread_release_lock((obj)->lock);
173 : :
174 : : #if defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1221
175 : : # define AT_LEAST_ZLIB_1_2_2_1
176 : : #endif
177 : :
178 : : /* The following parameters are copied from zutil.h, version 0.95 */
179 : : #define DEFLATED 8
180 : : #if MAX_MEM_LEVEL >= 8
181 : : # define DEF_MEM_LEVEL 8
182 : : #else
183 : : # define DEF_MEM_LEVEL MAX_MEM_LEVEL
184 : : #endif
185 : :
186 : : /* Initial buffer size. */
187 : : #define DEF_BUF_SIZE (16*1024)
188 : :
189 : : static PyModuleDef zlibmodule;
190 : :
191 : : typedef struct {
192 : : PyTypeObject *Comptype;
193 : : PyTypeObject *Decomptype;
194 : : PyObject *ZlibError;
195 : : } zlibstate;
196 : :
197 : : static inline zlibstate*
198 : 83398 : get_zlib_state(PyObject *module)
199 : : {
200 : 83398 : void *state = PyModule_GetState(module);
201 : : assert(state != NULL);
202 : 83398 : return (zlibstate *)state;
203 : : }
204 : :
205 : : typedef struct
206 : : {
207 : : PyObject_HEAD
208 : : z_stream zst;
209 : : PyObject *unused_data;
210 : : PyObject *unconsumed_tail;
211 : : char eof;
212 : : int is_initialised;
213 : : PyObject *zdict;
214 : : PyThread_type_lock lock;
215 : : } compobject;
216 : :
217 : : static void
218 : 8 : zlib_error(zlibstate *state, z_stream zst, int err, const char *msg)
219 : : {
220 : 8 : const char *zmsg = Z_NULL;
221 : : /* In case of a version mismatch, zst.msg won't be initialized.
222 : : Check for this case first, before looking at zst.msg. */
223 [ - + ]: 8 : if (err == Z_VERSION_ERROR)
224 : 0 : zmsg = "library version mismatch";
225 [ + - ]: 8 : if (zmsg == Z_NULL)
226 : 8 : zmsg = zst.msg;
227 [ + + ]: 8 : if (zmsg == Z_NULL) {
228 [ + + - + ]: 5 : switch (err) {
229 : 2 : case Z_BUF_ERROR:
230 : 2 : zmsg = "incomplete or truncated stream";
231 : 2 : break;
232 : 2 : case Z_STREAM_ERROR:
233 : 2 : zmsg = "inconsistent stream state";
234 : 2 : break;
235 : 0 : case Z_DATA_ERROR:
236 : 0 : zmsg = "invalid input data";
237 : 0 : break;
238 : : }
239 : : }
240 [ + + ]: 8 : if (zmsg == Z_NULL)
241 : 1 : PyErr_Format(state->ZlibError, "Error %d %s", err, msg);
242 : : else
243 : 7 : PyErr_Format(state->ZlibError, "Error %d %s: %.200s", err, msg, zmsg);
244 : 8 : }
245 : :
246 : : /*[clinic input]
247 : : module zlib
248 : : class zlib.Compress "compobject *" "&Comptype"
249 : : class zlib.Decompress "compobject *" "&Decomptype"
250 : : [clinic start generated code]*/
251 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=093935115c3e3158]*/
252 : :
253 : : static compobject *
254 : 5418 : newcompobject(PyTypeObject *type)
255 : : {
256 : : compobject *self;
257 : 5418 : self = PyObject_New(compobject, type);
258 [ - + ]: 5418 : if (self == NULL)
259 : 0 : return NULL;
260 : 5418 : self->eof = 0;
261 : 5418 : self->is_initialised = 0;
262 : 5418 : self->zdict = NULL;
263 : 5418 : self->unused_data = PyBytes_FromStringAndSize("", 0);
264 [ - + ]: 5418 : if (self->unused_data == NULL) {
265 : 0 : Py_DECREF(self);
266 : 0 : return NULL;
267 : : }
268 : 5418 : self->unconsumed_tail = PyBytes_FromStringAndSize("", 0);
269 [ - + ]: 5418 : if (self->unconsumed_tail == NULL) {
270 : 0 : Py_DECREF(self);
271 : 0 : return NULL;
272 : : }
273 : 5418 : self->lock = PyThread_allocate_lock();
274 [ - + ]: 5418 : if (self->lock == NULL) {
275 : 0 : Py_DECREF(self);
276 : 0 : PyErr_SetString(PyExc_MemoryError, "Unable to allocate lock");
277 : 0 : return NULL;
278 : : }
279 : 5418 : return self;
280 : : }
281 : :
282 : : static void*
283 : 16791 : PyZlib_Malloc(voidpf ctx, uInt items, uInt size)
284 : : {
285 [ + - - + ]: 16791 : if (size != 0 && items > (size_t)PY_SSIZE_T_MAX / size)
286 : 0 : return NULL;
287 : : /* PyMem_Malloc() cannot be used: the GIL is not held when
288 : : inflate() and deflate() are called */
289 : 16791 : return PyMem_RawMalloc((size_t)items * (size_t)size);
290 : : }
291 : :
292 : : static void
293 : 16791 : PyZlib_Free(voidpf ctx, void *ptr)
294 : : {
295 : 16791 : PyMem_RawFree(ptr);
296 : 16791 : }
297 : :
298 : : static void
299 : 73883 : arrange_input_buffer(z_stream *zst, Py_ssize_t *remains)
300 : : {
301 [ + - ]: 73883 : zst->avail_in = (uInt)Py_MIN((size_t)*remains, UINT_MAX);
302 : 73883 : *remains -= zst->avail_in;
303 : 73883 : }
304 : :
305 : : /*[clinic input]
306 : : zlib.compress
307 : :
308 : : data: Py_buffer
309 : : Binary data to be compressed.
310 : : /
311 : : level: int(c_default="Z_DEFAULT_COMPRESSION") = Z_DEFAULT_COMPRESSION
312 : : Compression level, in 0-9 or -1.
313 : : wbits: int(c_default="MAX_WBITS") = MAX_WBITS
314 : : The window buffer size and container format.
315 : :
316 : : Returns a bytes object containing compressed data.
317 : : [clinic start generated code]*/
318 : :
319 : : static PyObject *
320 : 67 : zlib_compress_impl(PyObject *module, Py_buffer *data, int level, int wbits)
321 : : /*[clinic end generated code: output=46bd152fadd66df2 input=c4d06ee5782a7e3f]*/
322 : : {
323 : : PyObject *RetVal;
324 : : int flush;
325 : : z_stream zst;
326 : 67 : _BlocksOutputBuffer buffer = {.list = NULL};
327 : :
328 : 67 : zlibstate *state = get_zlib_state(module);
329 : :
330 : 67 : Byte *ibuf = data->buf;
331 : 67 : Py_ssize_t ibuflen = data->len;
332 : :
333 [ - + ]: 67 : if (OutputBuffer_InitAndGrow(&buffer, -1, &zst.next_out, &zst.avail_out) < 0) {
334 : 0 : goto error;
335 : : }
336 : :
337 : 67 : zst.opaque = NULL;
338 : 67 : zst.zalloc = PyZlib_Malloc;
339 : 67 : zst.zfree = PyZlib_Free;
340 : 67 : zst.next_in = ibuf;
341 : 67 : int err = deflateInit2(&zst, level, DEFLATED, wbits, DEF_MEM_LEVEL,
342 : : Z_DEFAULT_STRATEGY);
343 : :
344 [ + - + - ]: 67 : switch (err) {
345 : 66 : case Z_OK:
346 : 66 : break;
347 : 0 : case Z_MEM_ERROR:
348 : 0 : PyErr_SetString(PyExc_MemoryError,
349 : : "Out of memory while compressing data");
350 : 0 : goto error;
351 : 1 : case Z_STREAM_ERROR:
352 : 1 : PyErr_SetString(state->ZlibError, "Bad compression level");
353 : 1 : goto error;
354 : 0 : default:
355 : 0 : deflateEnd(&zst);
356 : 0 : zlib_error(state, zst, err, "while compressing data");
357 : 0 : goto error;
358 : : }
359 : :
360 : : do {
361 : 66 : arrange_input_buffer(&zst, &ibuflen);
362 [ + - ]: 66 : flush = ibuflen == 0 ? Z_FINISH : Z_NO_FLUSH;
363 : :
364 : : do {
365 [ + + ]: 71 : if (zst.avail_out == 0) {
366 [ - + ]: 5 : if (OutputBuffer_Grow(&buffer, &zst.next_out, &zst.avail_out) < 0) {
367 : 0 : deflateEnd(&zst);
368 : 0 : goto error;
369 : : }
370 : : }
371 : :
372 : 71 : Py_BEGIN_ALLOW_THREADS
373 : 71 : err = deflate(&zst, flush);
374 : 71 : Py_END_ALLOW_THREADS
375 : :
376 [ - + ]: 71 : if (err == Z_STREAM_ERROR) {
377 : 0 : deflateEnd(&zst);
378 : 0 : zlib_error(state, zst, err, "while compressing data");
379 : 0 : goto error;
380 : : }
381 : :
382 [ + + ]: 71 : } while (zst.avail_out == 0);
383 : : assert(zst.avail_in == 0);
384 : :
385 [ - + ]: 66 : } while (flush != Z_FINISH);
386 : : assert(err == Z_STREAM_END);
387 : :
388 : 66 : err = deflateEnd(&zst);
389 [ + - ]: 66 : if (err == Z_OK) {
390 : 66 : RetVal = OutputBuffer_Finish(&buffer, zst.avail_out);
391 [ - + ]: 66 : if (RetVal == NULL) {
392 : 0 : goto error;
393 : : }
394 : 66 : return RetVal;
395 : : }
396 : : else
397 : 0 : zlib_error(state, zst, err, "while finishing compression");
398 : 1 : error:
399 : 1 : OutputBuffer_OnError(&buffer);
400 : 1 : return NULL;
401 : : }
402 : :
403 : : /*[clinic input]
404 : : zlib.decompress
405 : :
406 : : data: Py_buffer
407 : : Compressed data.
408 : : /
409 : : wbits: int(c_default="MAX_WBITS") = MAX_WBITS
410 : : The window buffer size and container format.
411 : : bufsize: Py_ssize_t(c_default="DEF_BUF_SIZE") = DEF_BUF_SIZE
412 : : The initial output buffer size.
413 : :
414 : : Returns a bytes object containing the uncompressed data.
415 : : [clinic start generated code]*/
416 : :
417 : : static PyObject *
418 : 3305 : zlib_decompress_impl(PyObject *module, Py_buffer *data, int wbits,
419 : : Py_ssize_t bufsize)
420 : : /*[clinic end generated code: output=77c7e35111dc8c42 input=a9ac17beff1f893f]*/
421 : : {
422 : : PyObject *RetVal;
423 : : Byte *ibuf;
424 : : Py_ssize_t ibuflen;
425 : : int err, flush;
426 : : z_stream zst;
427 : 3305 : _BlocksOutputBuffer buffer = {.list = NULL};
428 : : _Uint32Window window; // output buffer's UINT32_MAX sliding window
429 : :
430 : 3305 : zlibstate *state = get_zlib_state(module);
431 : :
432 [ - + ]: 3305 : if (bufsize < 0) {
433 : 0 : PyErr_SetString(PyExc_ValueError, "bufsize must be non-negative");
434 : 0 : return NULL;
435 [ - + ]: 3305 : } else if (bufsize == 0) {
436 : 0 : bufsize = 1;
437 : : }
438 : :
439 [ - + ]: 3305 : if (OutputBuffer_WindowInitWithSize(&buffer, &window, bufsize,
440 : : &zst.next_out, &zst.avail_out) < 0) {
441 : 0 : goto error;
442 : : }
443 : :
444 : 3305 : ibuf = data->buf;
445 : 3305 : ibuflen = data->len;
446 : :
447 : 3305 : zst.opaque = NULL;
448 : 3305 : zst.zalloc = PyZlib_Malloc;
449 : 3305 : zst.zfree = PyZlib_Free;
450 : 3305 : zst.avail_in = 0;
451 : 3305 : zst.next_in = ibuf;
452 : 3305 : err = inflateInit2(&zst, wbits);
453 : :
454 [ + - - ]: 3305 : switch (err) {
455 : 3305 : case Z_OK:
456 : 3305 : break;
457 : 0 : case Z_MEM_ERROR:
458 : 0 : PyErr_SetString(PyExc_MemoryError,
459 : : "Out of memory while decompressing data");
460 : 0 : goto error;
461 : 0 : default:
462 : 0 : inflateEnd(&zst);
463 : 0 : zlib_error(state, zst, err, "while preparing to decompress data");
464 : 0 : goto error;
465 : : }
466 : :
467 : : do {
468 : 3305 : arrange_input_buffer(&zst, &ibuflen);
469 [ + - ]: 3305 : flush = ibuflen == 0 ? Z_FINISH : Z_NO_FLUSH;
470 : :
471 : : do {
472 [ + + ]: 4033 : if (zst.avail_out == 0) {
473 [ - + ]: 728 : if (OutputBuffer_WindowGrow(&buffer, &window,
474 : : &zst.next_out, &zst.avail_out) < 0) {
475 : 0 : inflateEnd(&zst);
476 : 0 : goto error;
477 : : }
478 : : }
479 : :
480 : 4033 : Py_BEGIN_ALLOW_THREADS
481 : 4033 : err = inflate(&zst, flush);
482 : 4033 : Py_END_ALLOW_THREADS
483 : :
484 [ + - + ]: 4033 : switch (err) {
485 : 4031 : case Z_OK: /* fall through */
486 : : case Z_BUF_ERROR: /* fall through */
487 : : case Z_STREAM_END:
488 : 4031 : break;
489 : 0 : case Z_MEM_ERROR:
490 : 0 : inflateEnd(&zst);
491 : 0 : PyErr_SetString(PyExc_MemoryError,
492 : : "Out of memory while decompressing data");
493 : 0 : goto error;
494 : 2 : default:
495 : 2 : inflateEnd(&zst);
496 : 2 : zlib_error(state, zst, err, "while decompressing data");
497 : 2 : goto error;
498 : : }
499 : :
500 [ + + ]: 4031 : } while (zst.avail_out == 0);
501 : :
502 [ + + - + ]: 3303 : } while (err != Z_STREAM_END && ibuflen != 0);
503 : :
504 : :
505 [ + + ]: 3303 : if (err != Z_STREAM_END) {
506 : 2 : inflateEnd(&zst);
507 : 2 : zlib_error(state, zst, err, "while decompressing data");
508 : 2 : goto error;
509 : : }
510 : :
511 : 3301 : err = inflateEnd(&zst);
512 [ - + ]: 3301 : if (err != Z_OK) {
513 : 0 : zlib_error(state, zst, err, "while finishing decompression");
514 : 0 : goto error;
515 : : }
516 : :
517 : 3301 : RetVal = OutputBuffer_WindowFinish(&buffer, &window, zst.avail_out);
518 [ + - ]: 3301 : if (RetVal != NULL) {
519 : 3301 : return RetVal;
520 : : }
521 : :
522 : 0 : error:
523 : 4 : OutputBuffer_WindowOnError(&buffer, &window);
524 : 4 : return NULL;
525 : : }
526 : :
527 : : /*[clinic input]
528 : : zlib.compressobj
529 : :
530 : : level: int(c_default="Z_DEFAULT_COMPRESSION") = Z_DEFAULT_COMPRESSION
531 : : The compression level (an integer in the range 0-9 or -1; default is
532 : : currently equivalent to 6). Higher compression levels are slower,
533 : : but produce smaller results.
534 : : method: int(c_default="DEFLATED") = DEFLATED
535 : : The compression algorithm. If given, this must be DEFLATED.
536 : : wbits: int(c_default="MAX_WBITS") = MAX_WBITS
537 : : +9 to +15: The base-two logarithm of the window size. Include a zlib
538 : : container.
539 : : -9 to -15: Generate a raw stream.
540 : : +25 to +31: Include a gzip container.
541 : : memLevel: int(c_default="DEF_MEM_LEVEL") = DEF_MEM_LEVEL
542 : : Controls the amount of memory used for internal compression state.
543 : : Valid values range from 1 to 9. Higher values result in higher memory
544 : : usage, faster compression, and smaller output.
545 : : strategy: int(c_default="Z_DEFAULT_STRATEGY") = Z_DEFAULT_STRATEGY
546 : : Used to tune the compression algorithm. Possible values are
547 : : Z_DEFAULT_STRATEGY, Z_FILTERED, and Z_HUFFMAN_ONLY.
548 : : zdict: Py_buffer = None
549 : : The predefined compression dictionary - a sequence of bytes
550 : : containing subsequences that are likely to occur in the input data.
551 : :
552 : : Return a compressor object.
553 : : [clinic start generated code]*/
554 : :
555 : : static PyObject *
556 : 847 : zlib_compressobj_impl(PyObject *module, int level, int method, int wbits,
557 : : int memLevel, int strategy, Py_buffer *zdict)
558 : : /*[clinic end generated code: output=8b5bed9c8fc3814d input=2fa3d026f90ab8d5]*/
559 : : {
560 : 847 : zlibstate *state = get_zlib_state(module);
561 [ + + - + ]: 847 : if (zdict->buf != NULL && (size_t)zdict->len > UINT_MAX) {
562 : 0 : PyErr_SetString(PyExc_OverflowError,
563 : : "zdict length does not fit in an unsigned int");
564 : 0 : return NULL;
565 : : }
566 : :
567 : 847 : compobject *self = newcompobject(state->Comptype);
568 [ - + ]: 847 : if (self == NULL)
569 : 0 : goto error;
570 : 847 : self->zst.opaque = NULL;
571 : 847 : self->zst.zalloc = PyZlib_Malloc;
572 : 847 : self->zst.zfree = PyZlib_Free;
573 : 847 : self->zst.next_in = NULL;
574 : 847 : self->zst.avail_in = 0;
575 : 847 : int err = deflateInit2(&self->zst, level, method, wbits, memLevel, strategy);
576 [ + - + - ]: 847 : switch (err) {
577 : 845 : case Z_OK:
578 : 845 : self->is_initialised = 1;
579 [ + + ]: 845 : if (zdict->buf == NULL) {
580 : 841 : goto success;
581 : : } else {
582 : 4 : err = deflateSetDictionary(&self->zst,
583 : 4 : zdict->buf, (unsigned int)zdict->len);
584 [ + - - ]: 4 : switch (err) {
585 : 4 : case Z_OK:
586 : 4 : goto success;
587 : 0 : case Z_STREAM_ERROR:
588 : 0 : PyErr_SetString(PyExc_ValueError, "Invalid dictionary");
589 : 0 : goto error;
590 : 0 : default:
591 : 0 : PyErr_SetString(PyExc_ValueError, "deflateSetDictionary()");
592 : 0 : goto error;
593 : : }
594 : : }
595 : 0 : case Z_MEM_ERROR:
596 : 0 : PyErr_SetString(PyExc_MemoryError,
597 : : "Can't allocate memory for compression object");
598 : 0 : goto error;
599 : 2 : case Z_STREAM_ERROR:
600 : 2 : PyErr_SetString(PyExc_ValueError, "Invalid initialization option");
601 : 2 : goto error;
602 : 0 : default:
603 : 0 : zlib_error(state, self->zst, err, "while creating compression object");
604 : 0 : goto error;
605 : : }
606 : :
607 : 2 : error:
608 [ - + ]: 2 : Py_CLEAR(self);
609 : 0 : success:
610 : 847 : return (PyObject *)self;
611 : : }
612 : :
613 : : static int
614 : 4 : set_inflate_zdict(zlibstate *state, compobject *self)
615 : : {
616 : : Py_buffer zdict_buf;
617 [ - + ]: 4 : if (PyObject_GetBuffer(self->zdict, &zdict_buf, PyBUF_SIMPLE) == -1) {
618 : 0 : return -1;
619 : : }
620 [ - + ]: 4 : if ((size_t)zdict_buf.len > UINT_MAX) {
621 : 0 : PyErr_SetString(PyExc_OverflowError,
622 : : "zdict length does not fit in an unsigned int");
623 : 0 : PyBuffer_Release(&zdict_buf);
624 : 0 : return -1;
625 : : }
626 : : int err;
627 : 4 : err = inflateSetDictionary(&self->zst,
628 : 4 : zdict_buf.buf, (unsigned int)zdict_buf.len);
629 : 4 : PyBuffer_Release(&zdict_buf);
630 [ - + ]: 4 : if (err != Z_OK) {
631 : 0 : zlib_error(state, self->zst, err, "while setting zdict");
632 : 0 : return -1;
633 : : }
634 : 4 : return 0;
635 : : }
636 : :
637 : : /*[clinic input]
638 : : zlib.decompressobj
639 : :
640 : : wbits: int(c_default="MAX_WBITS") = MAX_WBITS
641 : : The window buffer size and container format.
642 : : zdict: object(c_default="NULL") = b''
643 : : The predefined compression dictionary. This must be the same
644 : : dictionary as used by the compressor that produced the input data.
645 : :
646 : : Return a decompressor object.
647 : : [clinic start generated code]*/
648 : :
649 : : static PyObject *
650 : 4559 : zlib_decompressobj_impl(PyObject *module, int wbits, PyObject *zdict)
651 : : /*[clinic end generated code: output=3069b99994f36906 input=d3832b8511fc977b]*/
652 : : {
653 : 4559 : zlibstate *state = get_zlib_state(module);
654 : :
655 [ + + - + ]: 4559 : if (zdict != NULL && !PyObject_CheckBuffer(zdict)) {
656 : 0 : PyErr_SetString(PyExc_TypeError,
657 : : "zdict argument must support the buffer protocol");
658 : 0 : return NULL;
659 : : }
660 : :
661 : 4559 : compobject *self = newcompobject(state->Decomptype);
662 [ - + ]: 4559 : if (self == NULL)
663 : 0 : return NULL;
664 : 4559 : self->zst.opaque = NULL;
665 : 4559 : self->zst.zalloc = PyZlib_Malloc;
666 : 4559 : self->zst.zfree = PyZlib_Free;
667 : 4559 : self->zst.next_in = NULL;
668 : 4559 : self->zst.avail_in = 0;
669 [ + + ]: 4559 : if (zdict != NULL) {
670 : 4 : Py_INCREF(zdict);
671 : 4 : self->zdict = zdict;
672 : : }
673 : 4559 : int err = inflateInit2(&self->zst, wbits);
674 [ + + - - ]: 4559 : switch (err) {
675 : 4558 : case Z_OK:
676 : 4558 : self->is_initialised = 1;
677 [ + + + + ]: 4558 : if (self->zdict != NULL && wbits < 0) {
678 : : #ifdef AT_LEAST_ZLIB_1_2_2_1
679 [ - + ]: 2 : if (set_inflate_zdict(state, self) < 0) {
680 : 0 : Py_DECREF(self);
681 : 0 : return NULL;
682 : : }
683 : : #else
684 : : PyErr_Format(state->ZlibError,
685 : : "zlib version %s does not allow raw inflate with dictionary",
686 : : ZLIB_VERSION);
687 : : Py_DECREF(self);
688 : : return NULL;
689 : : #endif
690 : : }
691 : 4558 : return (PyObject *)self;
692 : 1 : case Z_STREAM_ERROR:
693 : 1 : Py_DECREF(self);
694 : 1 : PyErr_SetString(PyExc_ValueError, "Invalid initialization option");
695 : 1 : return NULL;
696 : 0 : case Z_MEM_ERROR:
697 : 0 : Py_DECREF(self);
698 : 0 : PyErr_SetString(PyExc_MemoryError,
699 : : "Can't allocate memory for decompression object");
700 : 0 : return NULL;
701 : 0 : default:
702 : 0 : zlib_error(state, self->zst, err, "while creating decompression object");
703 : 0 : Py_DECREF(self);
704 : 0 : return NULL;
705 : : }
706 : : }
707 : :
708 : : static void
709 : 5418 : Dealloc(compobject *self)
710 : : {
711 : 5418 : PyObject *type = (PyObject *)Py_TYPE(self);
712 : 5418 : PyThread_free_lock(self->lock);
713 : 5418 : Py_XDECREF(self->unused_data);
714 : 5418 : Py_XDECREF(self->unconsumed_tail);
715 : 5418 : Py_XDECREF(self->zdict);
716 : 5418 : PyObject_Free(self);
717 : 5418 : Py_DECREF(type);
718 : 5418 : }
719 : :
720 : : static void
721 : 853 : Comp_dealloc(compobject *self)
722 : : {
723 [ + + ]: 853 : if (self->is_initialised)
724 : 10 : deflateEnd(&self->zst);
725 : 853 : Dealloc(self);
726 : 853 : }
727 : :
728 : : static void
729 : 4565 : Decomp_dealloc(compobject *self)
730 : : {
731 [ + + ]: 4565 : if (self->is_initialised)
732 : 1258 : inflateEnd(&self->zst);
733 : 4565 : Dealloc(self);
734 : 4565 : }
735 : :
736 : : /*[clinic input]
737 : : zlib.Compress.compress
738 : :
739 : : cls: defining_class
740 : : data: Py_buffer
741 : : Binary data to be compressed.
742 : : /
743 : :
744 : : Returns a bytes object containing compressed data.
745 : :
746 : : After calling this function, some of the input data may still
747 : : be stored in internal buffers for later processing.
748 : : Call the flush() method to clear these buffers.
749 : : [clinic start generated code]*/
750 : :
751 : : static PyObject *
752 : 38943 : zlib_Compress_compress_impl(compobject *self, PyTypeObject *cls,
753 : : Py_buffer *data)
754 : : /*[clinic end generated code: output=6731b3f0ff357ca6 input=04d00f65ab01d260]*/
755 : : {
756 : : PyObject *RetVal;
757 : : int err;
758 : 38943 : _BlocksOutputBuffer buffer = {.list = NULL};
759 : 38943 : zlibstate *state = PyType_GetModuleState(cls);
760 : :
761 [ - + ]: 38943 : ENTER_ZLIB(self);
762 : :
763 : 38943 : self->zst.next_in = data->buf;
764 : 38943 : Py_ssize_t ibuflen = data->len;
765 : :
766 [ - + ]: 38943 : if (OutputBuffer_InitAndGrow(&buffer, -1, &self->zst.next_out, &self->zst.avail_out) < 0) {
767 : 0 : goto error;
768 : : }
769 : :
770 : : do {
771 : 38943 : arrange_input_buffer(&self->zst, &ibuflen);
772 : :
773 : : do {
774 [ + + ]: 38950 : if (self->zst.avail_out == 0) {
775 [ - + ]: 7 : if (OutputBuffer_Grow(&buffer, &self->zst.next_out, &self->zst.avail_out) < 0) {
776 : 0 : goto error;
777 : : }
778 : : }
779 : :
780 : 38950 : Py_BEGIN_ALLOW_THREADS
781 : 38950 : err = deflate(&self->zst, Z_NO_FLUSH);
782 : 38950 : Py_END_ALLOW_THREADS
783 : :
784 [ - + ]: 38950 : if (err == Z_STREAM_ERROR) {
785 : 0 : zlib_error(state, self->zst, err, "while compressing data");
786 : 0 : goto error;
787 : : }
788 : :
789 [ + + ]: 38950 : } while (self->zst.avail_out == 0);
790 : : assert(self->zst.avail_in == 0);
791 : :
792 [ - + ]: 38943 : } while (ibuflen != 0);
793 : :
794 : 38943 : RetVal = OutputBuffer_Finish(&buffer, self->zst.avail_out);
795 [ + - ]: 38943 : if (RetVal != NULL) {
796 : 38943 : goto success;
797 : : }
798 : :
799 : 0 : error:
800 : 0 : OutputBuffer_OnError(&buffer);
801 : 0 : RetVal = NULL;
802 : 38943 : success:
803 : 38943 : LEAVE_ZLIB(self);
804 : 38943 : return RetVal;
805 : : }
806 : :
807 : : /* Helper for objdecompress() and flush(). Saves any unconsumed input data in
808 : : self->unused_data or self->unconsumed_tail, as appropriate. */
809 : : static int
810 : 31569 : save_unconsumed_input(compobject *self, Py_buffer *data, int err)
811 : : {
812 [ + + ]: 31569 : if (err == Z_STREAM_END) {
813 : : /* The end of the compressed data has been reached. Store the leftover
814 : : input data in self->unused_data. */
815 [ + + ]: 6988 : if (self->zst.avail_in > 0) {
816 : 370 : Py_ssize_t old_size = PyBytes_GET_SIZE(self->unused_data);
817 : : Py_ssize_t new_size, left_size;
818 : : PyObject *new_data;
819 : 370 : left_size = (Byte *)data->buf + data->len - self->zst.next_in;
820 [ - + ]: 370 : if (left_size > (PY_SSIZE_T_MAX - old_size)) {
821 : : PyErr_NoMemory();
822 : 0 : return -1;
823 : : }
824 : 370 : new_size = old_size + left_size;
825 : 370 : new_data = PyBytes_FromStringAndSize(NULL, new_size);
826 [ - + ]: 370 : if (new_data == NULL)
827 : 0 : return -1;
828 : 370 : memcpy(PyBytes_AS_STRING(new_data),
829 : 370 : PyBytes_AS_STRING(self->unused_data), old_size);
830 : 740 : memcpy(PyBytes_AS_STRING(new_data) + old_size,
831 : 370 : self->zst.next_in, left_size);
832 : 370 : Py_SETREF(self->unused_data, new_data);
833 : 370 : self->zst.avail_in = 0;
834 : : }
835 : : }
836 : :
837 [ + + + + ]: 31569 : if (self->zst.avail_in > 0 || PyBytes_GET_SIZE(self->unconsumed_tail)) {
838 : : /* This code handles two distinct cases:
839 : : 1. Output limit was reached. Save leftover input in unconsumed_tail.
840 : : 2. All input data was consumed. Clear unconsumed_tail. */
841 : 24316 : Py_ssize_t left_size = (Byte *)data->buf + data->len - self->zst.next_in;
842 : 24316 : PyObject *new_data = PyBytes_FromStringAndSize(
843 : 24316 : (char *)self->zst.next_in, left_size);
844 [ - + ]: 24316 : if (new_data == NULL)
845 : 0 : return -1;
846 : 24316 : Py_SETREF(self->unconsumed_tail, new_data);
847 : : }
848 : :
849 : 31569 : return 0;
850 : : }
851 : :
852 : : /*[clinic input]
853 : : zlib.Decompress.decompress
854 : :
855 : : cls: defining_class
856 : : data: Py_buffer
857 : : The binary data to decompress.
858 : : /
859 : : max_length: Py_ssize_t = 0
860 : : The maximum allowable length of the decompressed data.
861 : : Unconsumed input data will be stored in
862 : : the unconsumed_tail attribute.
863 : :
864 : : Return a bytes object containing the decompressed version of the data.
865 : :
866 : : After calling this function, some of the input data may still be stored in
867 : : internal buffers for later processing.
868 : : Call the flush() method to clear these buffers.
869 : : [clinic start generated code]*/
870 : :
871 : : static PyObject *
872 : 28264 : zlib_Decompress_decompress_impl(compobject *self, PyTypeObject *cls,
873 : : Py_buffer *data, Py_ssize_t max_length)
874 : : /*[clinic end generated code: output=b024a93c2c922d57 input=bfb37b3864cfb606]*/
875 : : {
876 : 28264 : int err = Z_OK;
877 : : Py_ssize_t ibuflen;
878 : : PyObject *RetVal;
879 : 28264 : _BlocksOutputBuffer buffer = {.list = NULL};
880 : :
881 : 28264 : PyObject *module = PyType_GetModule(cls);
882 [ - + ]: 28264 : if (module == NULL)
883 : 0 : return NULL;
884 : :
885 : 28264 : zlibstate *state = get_zlib_state(module);
886 [ + + ]: 28264 : if (max_length < 0) {
887 : 1 : PyErr_SetString(PyExc_ValueError, "max_length must be non-negative");
888 : 1 : return NULL;
889 [ + + ]: 28263 : } else if (max_length == 0) {
890 : 224 : max_length = -1;
891 : : }
892 : :
893 [ - + ]: 28263 : ENTER_ZLIB(self);
894 : :
895 : 28263 : self->zst.next_in = data->buf;
896 : 28263 : ibuflen = data->len;
897 : :
898 [ - + ]: 28263 : if (OutputBuffer_InitAndGrow(&buffer, max_length, &self->zst.next_out, &self->zst.avail_out) < 0) {
899 : 0 : goto abort;
900 : : }
901 : :
902 : : do {
903 : 28263 : arrange_input_buffer(&self->zst, &ibuflen);
904 : :
905 : : do {
906 [ + + ]: 52813 : if (self->zst.avail_out == 0) {
907 [ + + ]: 24548 : if (OutputBuffer_GetDataSize(&buffer, self->zst.avail_out) == max_length) {
908 : 23785 : goto save;
909 : : }
910 [ - + ]: 763 : if (OutputBuffer_Grow(&buffer, &self->zst.next_out, &self->zst.avail_out) < 0) {
911 : 0 : goto abort;
912 : : }
913 : : }
914 : :
915 : 29028 : Py_BEGIN_ALLOW_THREADS
916 : 29028 : err = inflate(&self->zst, Z_SYNC_FLUSH);
917 : 29028 : Py_END_ALLOW_THREADS
918 : :
919 [ + + ]: 29028 : switch (err) {
920 : 29024 : case Z_OK: /* fall through */
921 : : case Z_BUF_ERROR: /* fall through */
922 : : case Z_STREAM_END:
923 : 29024 : break;
924 : 4 : default:
925 [ + + + + ]: 4 : if (err == Z_NEED_DICT && self->zdict != NULL) {
926 [ - + ]: 2 : if (set_inflate_zdict(state, self) < 0) {
927 : 0 : goto abort;
928 : : }
929 : : else
930 : 2 : break;
931 : : }
932 : 2 : goto save;
933 : : }
934 : :
935 [ + + + + ]: 29026 : } while (self->zst.avail_out == 0 || err == Z_NEED_DICT);
936 : :
937 [ + + + - ]: 4476 : } while (err != Z_STREAM_END && ibuflen != 0);
938 : :
939 : 4476 : save:
940 [ - + ]: 28263 : if (save_unconsumed_input(self, data, err) < 0)
941 : 0 : goto abort;
942 : :
943 [ + + ]: 28263 : if (err == Z_STREAM_END) {
944 : : /* This is the logical place to call inflateEnd, but the old behaviour
945 : : of only calling it on flush() is preserved. */
946 : 3685 : self->eof = 1;
947 [ + + + + ]: 24578 : } else if (err != Z_OK && err != Z_BUF_ERROR) {
948 : : /* We will only get Z_BUF_ERROR if the output buffer was full
949 : : but there wasn't more output when we tried again, so it is
950 : : not an error condition.
951 : : */
952 : 2 : zlib_error(state, self->zst, err, "while decompressing data");
953 : 2 : goto abort;
954 : : }
955 : :
956 : 28261 : RetVal = OutputBuffer_Finish(&buffer, self->zst.avail_out);
957 [ + - ]: 28261 : if (RetVal != NULL) {
958 : 28261 : goto success;
959 : : }
960 : :
961 : 0 : abort:
962 : 2 : OutputBuffer_OnError(&buffer);
963 : 2 : RetVal = NULL;
964 : 28263 : success:
965 : 28263 : LEAVE_ZLIB(self);
966 : 28263 : return RetVal;
967 : : }
968 : :
969 : : /*[clinic input]
970 : : zlib.Compress.flush
971 : :
972 : : cls: defining_class
973 : : mode: int(c_default="Z_FINISH") = zlib.Z_FINISH
974 : : One of the constants Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH.
975 : : If mode == Z_FINISH, the compressor object can no longer be
976 : : used after calling the flush() method. Otherwise, more data
977 : : can still be compressed.
978 : : /
979 : :
980 : : Return a bytes object containing any remaining compressed data.
981 : : [clinic start generated code]*/
982 : :
983 : : static PyObject *
984 : 911 : zlib_Compress_flush_impl(compobject *self, PyTypeObject *cls, int mode)
985 : : /*[clinic end generated code: output=c7efd13efd62add2 input=286146e29442eb6c]*/
986 : : {
987 : : int err;
988 : : PyObject *RetVal;
989 : 911 : _BlocksOutputBuffer buffer = {.list = NULL};
990 : :
991 : 911 : zlibstate *state = PyType_GetModuleState(cls);
992 : : /* Flushing with Z_NO_FLUSH is a no-op, so there's no point in
993 : : doing any work at all; just return an empty string. */
994 [ + + ]: 911 : if (mode == Z_NO_FLUSH) {
995 : 10 : return PyBytes_FromStringAndSize(NULL, 0);
996 : : }
997 : :
998 [ - + ]: 901 : ENTER_ZLIB(self);
999 : :
1000 : 901 : self->zst.avail_in = 0;
1001 : :
1002 [ - + ]: 901 : if (OutputBuffer_InitAndGrow(&buffer, -1, &self->zst.next_out, &self->zst.avail_out) < 0) {
1003 : 0 : goto error;
1004 : : }
1005 : :
1006 : : do {
1007 [ - + ]: 901 : if (self->zst.avail_out == 0) {
1008 [ # # ]: 0 : if (OutputBuffer_Grow(&buffer, &self->zst.next_out, &self->zst.avail_out) < 0) {
1009 : 0 : goto error;
1010 : : }
1011 : : }
1012 : :
1013 : 901 : Py_BEGIN_ALLOW_THREADS
1014 : 901 : err = deflate(&self->zst, mode);
1015 : 901 : Py_END_ALLOW_THREADS
1016 : :
1017 [ + + ]: 901 : if (err == Z_STREAM_ERROR) {
1018 : 2 : zlib_error(state, self->zst, err, "while flushing");
1019 : 2 : goto error;
1020 : : }
1021 [ - + ]: 899 : } while (self->zst.avail_out == 0);
1022 : : assert(self->zst.avail_in == 0);
1023 : :
1024 : : /* If mode is Z_FINISH, we also have to call deflateEnd() to free
1025 : : various data structures. Note we should only get Z_STREAM_END when
1026 : : mode is Z_FINISH, but checking both for safety*/
1027 [ + + + - ]: 899 : if (err == Z_STREAM_END && mode == Z_FINISH) {
1028 : 838 : err = deflateEnd(&self->zst);
1029 [ - + ]: 838 : if (err != Z_OK) {
1030 : 0 : zlib_error(state, self->zst, err, "while finishing compression");
1031 : 0 : goto error;
1032 : : }
1033 : : else
1034 : 838 : self->is_initialised = 0;
1035 : :
1036 : : /* We will only get Z_BUF_ERROR if the output buffer was full
1037 : : but there wasn't more output when we tried again, so it is
1038 : : not an error condition.
1039 : : */
1040 [ - + - - ]: 61 : } else if (err != Z_OK && err != Z_BUF_ERROR) {
1041 : 0 : zlib_error(state, self->zst, err, "while flushing");
1042 : 0 : goto error;
1043 : : }
1044 : :
1045 : 899 : RetVal = OutputBuffer_Finish(&buffer, self->zst.avail_out);
1046 [ + - ]: 899 : if (RetVal != NULL) {
1047 : 899 : goto success;
1048 : : }
1049 : :
1050 : 0 : error:
1051 : 2 : OutputBuffer_OnError(&buffer);
1052 : 2 : RetVal = NULL;
1053 : 901 : success:
1054 : 901 : LEAVE_ZLIB(self);
1055 : 901 : return RetVal;
1056 : : }
1057 : :
1058 : : #ifdef HAVE_ZLIB_COPY
1059 : :
1060 : : /*[clinic input]
1061 : : zlib.Compress.copy
1062 : :
1063 : : cls: defining_class
1064 : :
1065 : : Return a copy of the compression object.
1066 : : [clinic start generated code]*/
1067 : :
1068 : : static PyObject *
1069 : 6 : zlib_Compress_copy_impl(compobject *self, PyTypeObject *cls)
1070 : : /*[clinic end generated code: output=c4d2cfb4b0d7350b input=235497e482d40986]*/
1071 : : {
1072 : 6 : zlibstate *state = PyType_GetModuleState(cls);
1073 : :
1074 : 6 : compobject *retval = newcompobject(state->Comptype);
1075 [ - + ]: 6 : if (!retval) return NULL;
1076 : :
1077 : : /* Copy the zstream state
1078 : : * We use ENTER_ZLIB / LEAVE_ZLIB to make this thread-safe
1079 : : */
1080 [ - + ]: 6 : ENTER_ZLIB(self);
1081 : 6 : int err = deflateCopy(&retval->zst, &self->zst);
1082 [ + + - - ]: 6 : switch (err) {
1083 : 3 : case Z_OK:
1084 : 3 : break;
1085 : 3 : case Z_STREAM_ERROR:
1086 : 3 : PyErr_SetString(PyExc_ValueError, "Inconsistent stream state");
1087 : 3 : goto error;
1088 : 0 : case Z_MEM_ERROR:
1089 : 0 : PyErr_SetString(PyExc_MemoryError,
1090 : : "Can't allocate memory for compression object");
1091 : 0 : goto error;
1092 : 0 : default:
1093 : 0 : zlib_error(state, self->zst, err, "while copying compression object");
1094 : 0 : goto error;
1095 : : }
1096 : 3 : Py_INCREF(self->unused_data);
1097 : 3 : Py_XSETREF(retval->unused_data, self->unused_data);
1098 : 3 : Py_INCREF(self->unconsumed_tail);
1099 : 3 : Py_XSETREF(retval->unconsumed_tail, self->unconsumed_tail);
1100 : 3 : Py_XINCREF(self->zdict);
1101 : 3 : Py_XSETREF(retval->zdict, self->zdict);
1102 : 3 : retval->eof = self->eof;
1103 : :
1104 : : /* Mark it as being initialized */
1105 : 3 : retval->is_initialised = 1;
1106 : :
1107 : 3 : LEAVE_ZLIB(self);
1108 : 3 : return (PyObject *)retval;
1109 : :
1110 : 3 : error:
1111 : 3 : LEAVE_ZLIB(self);
1112 : 3 : Py_XDECREF(retval);
1113 : 3 : return NULL;
1114 : : }
1115 : :
1116 : : /*[clinic input]
1117 : : zlib.Compress.__copy__
1118 : :
1119 : : cls: defining_class
1120 : :
1121 : : [clinic start generated code]*/
1122 : :
1123 : : static PyObject *
1124 : 2 : zlib_Compress___copy___impl(compobject *self, PyTypeObject *cls)
1125 : : /*[clinic end generated code: output=074613db332cb668 input=5c0188367ab0fe64]*/
1126 : : {
1127 : 2 : return zlib_Compress_copy_impl(self, cls);
1128 : : }
1129 : :
1130 : : /*[clinic input]
1131 : : zlib.Compress.__deepcopy__
1132 : :
1133 : : cls: defining_class
1134 : : memo: object
1135 : : /
1136 : :
1137 : : [clinic start generated code]*/
1138 : :
1139 : : static PyObject *
1140 : 2 : zlib_Compress___deepcopy___impl(compobject *self, PyTypeObject *cls,
1141 : : PyObject *memo)
1142 : : /*[clinic end generated code: output=24b3aed785f54033 input=c90347319a514430]*/
1143 : : {
1144 : 2 : return zlib_Compress_copy_impl(self, cls);
1145 : : }
1146 : :
1147 : : /*[clinic input]
1148 : : zlib.Decompress.copy
1149 : :
1150 : : cls: defining_class
1151 : :
1152 : : Return a copy of the decompression object.
1153 : : [clinic start generated code]*/
1154 : :
1155 : : static PyObject *
1156 : 6 : zlib_Decompress_copy_impl(compobject *self, PyTypeObject *cls)
1157 : : /*[clinic end generated code: output=a7ddc016e1d0a781 input=20ef3aa208282ff2]*/
1158 : : {
1159 : 6 : zlibstate *state = PyType_GetModuleState(cls);
1160 : :
1161 : 6 : compobject *retval = newcompobject(state->Decomptype);
1162 [ - + ]: 6 : if (!retval) return NULL;
1163 : :
1164 : : /* Copy the zstream state
1165 : : * We use ENTER_ZLIB / LEAVE_ZLIB to make this thread-safe
1166 : : */
1167 [ - + ]: 6 : ENTER_ZLIB(self);
1168 : 6 : int err = inflateCopy(&retval->zst, &self->zst);
1169 [ + + - - ]: 6 : switch (err) {
1170 : 3 : case Z_OK:
1171 : 3 : break;
1172 : 3 : case Z_STREAM_ERROR:
1173 : 3 : PyErr_SetString(PyExc_ValueError, "Inconsistent stream state");
1174 : 3 : goto error;
1175 : 0 : case Z_MEM_ERROR:
1176 : 0 : PyErr_SetString(PyExc_MemoryError,
1177 : : "Can't allocate memory for decompression object");
1178 : 0 : goto error;
1179 : 0 : default:
1180 : 0 : zlib_error(state, self->zst, err, "while copying decompression object");
1181 : 0 : goto error;
1182 : : }
1183 : :
1184 : 3 : Py_INCREF(self->unused_data);
1185 : 3 : Py_XSETREF(retval->unused_data, self->unused_data);
1186 : 3 : Py_INCREF(self->unconsumed_tail);
1187 : 3 : Py_XSETREF(retval->unconsumed_tail, self->unconsumed_tail);
1188 : 3 : Py_XINCREF(self->zdict);
1189 : 3 : Py_XSETREF(retval->zdict, self->zdict);
1190 : 3 : retval->eof = self->eof;
1191 : :
1192 : : /* Mark it as being initialized */
1193 : 3 : retval->is_initialised = 1;
1194 : :
1195 : 3 : LEAVE_ZLIB(self);
1196 : 3 : return (PyObject *)retval;
1197 : :
1198 : 3 : error:
1199 : 3 : LEAVE_ZLIB(self);
1200 : 3 : Py_XDECREF(retval);
1201 : 3 : return NULL;
1202 : : }
1203 : :
1204 : : /*[clinic input]
1205 : : zlib.Decompress.__copy__
1206 : :
1207 : : cls: defining_class
1208 : :
1209 : : [clinic start generated code]*/
1210 : :
1211 : : static PyObject *
1212 : 2 : zlib_Decompress___copy___impl(compobject *self, PyTypeObject *cls)
1213 : : /*[clinic end generated code: output=cf1e6473744f53fa input=cc3143067b622bdf]*/
1214 : : {
1215 : 2 : return zlib_Decompress_copy_impl(self, cls);
1216 : : }
1217 : :
1218 : : /*[clinic input]
1219 : : zlib.Decompress.__deepcopy__
1220 : :
1221 : : cls: defining_class
1222 : : memo: object
1223 : : /
1224 : :
1225 : : [clinic start generated code]*/
1226 : :
1227 : : static PyObject *
1228 : 2 : zlib_Decompress___deepcopy___impl(compobject *self, PyTypeObject *cls,
1229 : : PyObject *memo)
1230 : : /*[clinic end generated code: output=34f7b719a0c0d51b input=fc13b9c58622544e]*/
1231 : : {
1232 : 2 : return zlib_Decompress_copy_impl(self, cls);
1233 : : }
1234 : :
1235 : : #endif
1236 : :
1237 : : /*[clinic input]
1238 : : zlib.Decompress.flush
1239 : :
1240 : : cls: defining_class
1241 : : length: Py_ssize_t(c_default="DEF_BUF_SIZE") = zlib.DEF_BUF_SIZE
1242 : : the initial size of the output buffer.
1243 : : /
1244 : :
1245 : : Return a bytes object containing any remaining decompressed data.
1246 : : [clinic start generated code]*/
1247 : :
1248 : : static PyObject *
1249 : 3308 : zlib_Decompress_flush_impl(compobject *self, PyTypeObject *cls,
1250 : : Py_ssize_t length)
1251 : : /*[clinic end generated code: output=4532fc280bd0f8f2 input=42f1f4b75230e2cd]*/
1252 : : {
1253 : : int err, flush;
1254 : : Py_buffer data;
1255 : : PyObject *RetVal;
1256 : : Py_ssize_t ibuflen;
1257 : 3308 : _BlocksOutputBuffer buffer = {.list = NULL};
1258 : : _Uint32Window window; // output buffer's UINT32_MAX sliding window
1259 : :
1260 : 3308 : PyObject *module = PyType_GetModule(cls);
1261 [ - + ]: 3308 : if (module == NULL) {
1262 : 0 : return NULL;
1263 : : }
1264 : :
1265 : 3308 : zlibstate *state = get_zlib_state(module);
1266 : :
1267 [ + + ]: 3308 : if (length <= 0) {
1268 : 2 : PyErr_SetString(PyExc_ValueError, "length must be greater than zero");
1269 : 2 : return NULL;
1270 : : }
1271 : :
1272 [ - + ]: 3306 : ENTER_ZLIB(self);
1273 : :
1274 [ - + ]: 3306 : if (PyObject_GetBuffer(self->unconsumed_tail, &data, PyBUF_SIMPLE) == -1) {
1275 : 0 : LEAVE_ZLIB(self);
1276 : 0 : return NULL;
1277 : : }
1278 : :
1279 : 3306 : self->zst.next_in = data.buf;
1280 : 3306 : ibuflen = data.len;
1281 : :
1282 [ - + ]: 3306 : if (OutputBuffer_WindowInitWithSize(&buffer, &window, length,
1283 : 3306 : &self->zst.next_out, &self->zst.avail_out) < 0) {
1284 : 0 : goto abort;
1285 : : }
1286 : :
1287 : : do {
1288 : 3306 : arrange_input_buffer(&self->zst, &ibuflen);
1289 [ + - ]: 3306 : flush = ibuflen == 0 ? Z_FINISH : Z_NO_FLUSH;
1290 : :
1291 : : do {
1292 [ + + ]: 3308 : if (self->zst.avail_out == 0) {
1293 [ - + ]: 2 : if (OutputBuffer_WindowGrow(&buffer, &window,
1294 : 2 : &self->zst.next_out, &self->zst.avail_out) < 0) {
1295 : 0 : goto abort;
1296 : : }
1297 : : }
1298 : :
1299 : 3308 : Py_BEGIN_ALLOW_THREADS
1300 : 3308 : err = inflate(&self->zst, flush);
1301 : 3308 : Py_END_ALLOW_THREADS
1302 : :
1303 [ + - ]: 3308 : switch (err) {
1304 : 3308 : case Z_OK: /* fall through */
1305 : : case Z_BUF_ERROR: /* fall through */
1306 : : case Z_STREAM_END:
1307 : 3308 : break;
1308 : 0 : default:
1309 [ # # # # ]: 0 : if (err == Z_NEED_DICT && self->zdict != NULL) {
1310 [ # # ]: 0 : if (set_inflate_zdict(state, self) < 0) {
1311 : 0 : goto abort;
1312 : : }
1313 : : else
1314 : 0 : break;
1315 : : }
1316 : 0 : goto save;
1317 : : }
1318 : :
1319 [ + + - + ]: 3308 : } while (self->zst.avail_out == 0 || err == Z_NEED_DICT);
1320 : :
1321 [ + + + - ]: 3306 : } while (err != Z_STREAM_END && ibuflen != 0);
1322 : :
1323 : 3306 : save:
1324 [ - + ]: 3306 : if (save_unconsumed_input(self, &data, err) < 0) {
1325 : 0 : goto abort;
1326 : : }
1327 : :
1328 : : /* If at end of stream, clean up any memory allocated by zlib. */
1329 [ + + ]: 3306 : if (err == Z_STREAM_END) {
1330 : 3303 : self->eof = 1;
1331 : 3303 : self->is_initialised = 0;
1332 : 3303 : err = inflateEnd(&self->zst);
1333 [ - + ]: 3303 : if (err != Z_OK) {
1334 : 0 : zlib_error(state, self->zst, err, "while finishing decompression");
1335 : 0 : goto abort;
1336 : : }
1337 : : }
1338 : :
1339 : 3306 : RetVal = OutputBuffer_WindowFinish(&buffer, &window, self->zst.avail_out);
1340 [ + - ]: 3306 : if (RetVal != NULL) {
1341 : 3306 : goto success;
1342 : : }
1343 : :
1344 : 0 : abort:
1345 : 0 : OutputBuffer_WindowOnError(&buffer, &window);
1346 : 0 : RetVal = NULL;
1347 : 3306 : success:
1348 : 3306 : PyBuffer_Release(&data);
1349 : 3306 : LEAVE_ZLIB(self);
1350 : 3306 : return RetVal;
1351 : : }
1352 : :
1353 : : #include "clinic/zlibmodule.c.h"
1354 : :
1355 : : static PyMethodDef comp_methods[] =
1356 : : {
1357 : : ZLIB_COMPRESS_COMPRESS_METHODDEF
1358 : : ZLIB_COMPRESS_FLUSH_METHODDEF
1359 : : ZLIB_COMPRESS_COPY_METHODDEF
1360 : : ZLIB_COMPRESS___COPY___METHODDEF
1361 : : ZLIB_COMPRESS___DEEPCOPY___METHODDEF
1362 : : {NULL, NULL}
1363 : : };
1364 : :
1365 : : static PyMethodDef Decomp_methods[] =
1366 : : {
1367 : : ZLIB_DECOMPRESS_DECOMPRESS_METHODDEF
1368 : : ZLIB_DECOMPRESS_FLUSH_METHODDEF
1369 : : ZLIB_DECOMPRESS_COPY_METHODDEF
1370 : : ZLIB_DECOMPRESS___COPY___METHODDEF
1371 : : ZLIB_DECOMPRESS___DEEPCOPY___METHODDEF
1372 : : {NULL, NULL}
1373 : : };
1374 : :
1375 : : #define COMP_OFF(x) offsetof(compobject, x)
1376 : : static PyMemberDef Decomp_members[] = {
1377 : : {"unused_data", T_OBJECT, COMP_OFF(unused_data), READONLY},
1378 : : {"unconsumed_tail", T_OBJECT, COMP_OFF(unconsumed_tail), READONLY},
1379 : : {"eof", T_BOOL, COMP_OFF(eof), READONLY},
1380 : : {NULL},
1381 : : };
1382 : :
1383 : : /*[clinic input]
1384 : : zlib.adler32
1385 : :
1386 : : data: Py_buffer
1387 : : value: unsigned_int(bitwise=True) = 1
1388 : : Starting value of the checksum.
1389 : : /
1390 : :
1391 : : Compute an Adler-32 checksum of data.
1392 : :
1393 : : The returned checksum is an integer.
1394 : : [clinic start generated code]*/
1395 : :
1396 : : static PyObject *
1397 : 12 : zlib_adler32_impl(PyObject *module, Py_buffer *data, unsigned int value)
1398 : : /*[clinic end generated code: output=422106f5ca8c92c0 input=6ff4557872160e88]*/
1399 : : {
1400 : : /* Releasing the GIL for very small buffers is inefficient
1401 : : and may lower performance */
1402 [ - + ]: 12 : if (data->len > 1024*5) {
1403 : 0 : unsigned char *buf = data->buf;
1404 : 0 : Py_ssize_t len = data->len;
1405 : :
1406 : 0 : Py_BEGIN_ALLOW_THREADS
1407 : : /* Avoid truncation of length for very large buffers. adler32() takes
1408 : : length as an unsigned int, which may be narrower than Py_ssize_t. */
1409 [ # # ]: 0 : while ((size_t)len > UINT_MAX) {
1410 : 0 : value = adler32(value, buf, UINT_MAX);
1411 : 0 : buf += (size_t) UINT_MAX;
1412 : 0 : len -= (size_t) UINT_MAX;
1413 : : }
1414 : 0 : value = adler32(value, buf, (unsigned int)len);
1415 : 0 : Py_END_ALLOW_THREADS
1416 : : } else {
1417 : 12 : value = adler32(value, data->buf, (unsigned int)data->len);
1418 : : }
1419 : 12 : return PyLong_FromUnsignedLong(value & 0xffffffffU);
1420 : : }
1421 : :
1422 : : /*[clinic input]
1423 : : zlib.crc32 -> unsigned_int
1424 : :
1425 : : data: Py_buffer
1426 : : value: unsigned_int(bitwise=True) = 0
1427 : : Starting value of the checksum.
1428 : : /
1429 : :
1430 : : Compute a CRC-32 checksum of data.
1431 : :
1432 : : The returned checksum is an integer.
1433 : : [clinic start generated code]*/
1434 : :
1435 : : static unsigned int
1436 : 165027 : zlib_crc32_impl(PyObject *module, Py_buffer *data, unsigned int value)
1437 : : /*[clinic end generated code: output=b217562e4fe6d6a6 input=1229cb2fb5ea948a]*/
1438 : : {
1439 : : /* Releasing the GIL for very small buffers is inefficient
1440 : : and may lower performance */
1441 [ + + ]: 165027 : if (data->len > 1024*5) {
1442 : 15453 : unsigned char *buf = data->buf;
1443 : 15453 : Py_ssize_t len = data->len;
1444 : :
1445 : 15453 : Py_BEGIN_ALLOW_THREADS
1446 : : /* Avoid truncation of length for very large buffers. crc32() takes
1447 : : length as an unsigned int, which may be narrower than Py_ssize_t. */
1448 [ - + ]: 15453 : while ((size_t)len > UINT_MAX) {
1449 : 0 : value = crc32(value, buf, UINT_MAX);
1450 : 0 : buf += (size_t) UINT_MAX;
1451 : 0 : len -= (size_t) UINT_MAX;
1452 : : }
1453 : 15453 : value = crc32(value, buf, (unsigned int)len);
1454 : 15453 : Py_END_ALLOW_THREADS
1455 : : } else {
1456 : 149574 : value = crc32(value, data->buf, (unsigned int)data->len);
1457 : : }
1458 : 165027 : return value;
1459 : : }
1460 : :
1461 : :
1462 : : static PyMethodDef zlib_methods[] =
1463 : : {
1464 : : ZLIB_ADLER32_METHODDEF
1465 : : ZLIB_COMPRESS_METHODDEF
1466 : : ZLIB_COMPRESSOBJ_METHODDEF
1467 : : ZLIB_CRC32_METHODDEF
1468 : : ZLIB_DECOMPRESS_METHODDEF
1469 : : ZLIB_DECOMPRESSOBJ_METHODDEF
1470 : : {NULL, NULL}
1471 : : };
1472 : :
1473 : : static PyType_Slot Comptype_slots[] = {
1474 : : {Py_tp_dealloc, Comp_dealloc},
1475 : : {Py_tp_methods, comp_methods},
1476 : : {0, 0},
1477 : : };
1478 : :
1479 : : static PyType_Spec Comptype_spec = {
1480 : : .name = "zlib.Compress",
1481 : : .basicsize = sizeof(compobject),
1482 : : .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION,
1483 : : .slots= Comptype_slots,
1484 : : };
1485 : :
1486 : : static PyType_Slot Decomptype_slots[] = {
1487 : : {Py_tp_dealloc, Decomp_dealloc},
1488 : : {Py_tp_methods, Decomp_methods},
1489 : : {Py_tp_members, Decomp_members},
1490 : : {0, 0},
1491 : : };
1492 : :
1493 : : static PyType_Spec Decomptype_spec = {
1494 : : .name = "zlib.Decompress",
1495 : : .basicsize = sizeof(compobject),
1496 : : .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION,
1497 : : .slots = Decomptype_slots,
1498 : : };
1499 : :
1500 : : PyDoc_STRVAR(zlib_module_documentation,
1501 : : "The functions in this module allow compression and decompression using the\n"
1502 : : "zlib library, which is based on GNU zip.\n"
1503 : : "\n"
1504 : : "adler32(string[, start]) -- Compute an Adler-32 checksum.\n"
1505 : : "compress(data[, level]) -- Compress data, with compression level 0-9 or -1.\n"
1506 : : "compressobj([level[, ...]]) -- Return a compressor object.\n"
1507 : : "crc32(string[, start]) -- Compute a CRC-32 checksum.\n"
1508 : : "decompress(string,[wbits],[bufsize]) -- Decompresses a compressed string.\n"
1509 : : "decompressobj([wbits[, zdict]]) -- Return a decompressor object.\n"
1510 : : "\n"
1511 : : "'wbits' is window buffer size and container format.\n"
1512 : : "Compressor objects support compress() and flush() methods; decompressor\n"
1513 : : "objects support decompress() and flush().");
1514 : :
1515 : : static int
1516 : 2866 : zlib_clear(PyObject *mod)
1517 : : {
1518 : 2866 : zlibstate *state = get_zlib_state(mod);
1519 [ + + ]: 2866 : Py_CLEAR(state->Comptype);
1520 [ + + ]: 2866 : Py_CLEAR(state->Decomptype);
1521 [ + + ]: 2866 : Py_CLEAR(state->ZlibError);
1522 : 2866 : return 0;
1523 : : }
1524 : :
1525 : : static int
1526 : 38749 : zlib_traverse(PyObject *mod, visitproc visit, void *arg)
1527 : : {
1528 : 38749 : zlibstate *state = get_zlib_state(mod);
1529 [ + + - + ]: 38749 : Py_VISIT(state->Comptype);
1530 [ + + - + ]: 38749 : Py_VISIT(state->Decomptype);
1531 [ + + - + ]: 38749 : Py_VISIT(state->ZlibError);
1532 : 38749 : return 0;
1533 : : }
1534 : :
1535 : : static void
1536 : 1433 : zlib_free(void *mod)
1537 : : {
1538 : 1433 : zlib_clear((PyObject *)mod);
1539 : 1433 : }
1540 : :
1541 : : static int
1542 : 1433 : zlib_exec(PyObject *mod)
1543 : : {
1544 : 1433 : zlibstate *state = get_zlib_state(mod);
1545 : :
1546 : 1433 : state->Comptype = (PyTypeObject *)PyType_FromModuleAndSpec(
1547 : : mod, &Comptype_spec, NULL);
1548 [ - + ]: 1433 : if (state->Comptype == NULL) {
1549 : 0 : return -1;
1550 : : }
1551 : :
1552 : 1433 : state->Decomptype = (PyTypeObject *)PyType_FromModuleAndSpec(
1553 : : mod, &Decomptype_spec, NULL);
1554 [ - + ]: 1433 : if (state->Decomptype == NULL) {
1555 : 0 : return -1;
1556 : : }
1557 : :
1558 : 1433 : state->ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
1559 [ - + ]: 1433 : if (state->ZlibError == NULL) {
1560 : 0 : return -1;
1561 : : }
1562 : :
1563 : 1433 : Py_INCREF(state->ZlibError);
1564 [ - + ]: 1433 : if (PyModule_AddObject(mod, "error", state->ZlibError) < 0) {
1565 : 0 : Py_DECREF(state->ZlibError);
1566 : 0 : return -1;
1567 : : }
1568 : :
1569 : : #define ZLIB_ADD_INT_MACRO(c) \
1570 : : do { \
1571 : : if ((PyModule_AddIntConstant(mod, #c, c)) < 0) { \
1572 : : return -1; \
1573 : : } \
1574 : : } while(0)
1575 : :
1576 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(MAX_WBITS);
1577 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(DEFLATED);
1578 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(DEF_MEM_LEVEL);
1579 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(DEF_BUF_SIZE);
1580 : : // compression levels
1581 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_NO_COMPRESSION);
1582 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_BEST_SPEED);
1583 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_BEST_COMPRESSION);
1584 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_DEFAULT_COMPRESSION);
1585 : : // compression strategies
1586 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_FILTERED);
1587 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_HUFFMAN_ONLY);
1588 : : #ifdef Z_RLE // 1.2.0.1
1589 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_RLE);
1590 : : #endif
1591 : : #ifdef Z_FIXED // 1.2.2.2
1592 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_FIXED);
1593 : : #endif
1594 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_DEFAULT_STRATEGY);
1595 : : // allowed flush values
1596 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_NO_FLUSH);
1597 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_PARTIAL_FLUSH);
1598 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_SYNC_FLUSH);
1599 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_FULL_FLUSH);
1600 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_FINISH);
1601 : : #ifdef Z_BLOCK // 1.2.0.5 for inflate, 1.2.3.4 for deflate
1602 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_BLOCK);
1603 : : #endif
1604 : : #ifdef Z_TREES // 1.2.3.4, only for inflate
1605 [ - + ]: 1433 : ZLIB_ADD_INT_MACRO(Z_TREES);
1606 : : #endif
1607 : 1433 : PyObject *ver = PyUnicode_FromString(ZLIB_VERSION);
1608 [ - + ]: 1433 : if (ver == NULL) {
1609 : 0 : return -1;
1610 : : }
1611 : :
1612 [ - + ]: 1433 : if (PyModule_AddObject(mod, "ZLIB_VERSION", ver) < 0) {
1613 : 0 : Py_DECREF(ver);
1614 : 0 : return -1;
1615 : : }
1616 : :
1617 : 1433 : ver = PyUnicode_FromString(zlibVersion());
1618 [ - + ]: 1433 : if (ver == NULL) {
1619 : 0 : return -1;
1620 : : }
1621 : :
1622 [ - + ]: 1433 : if (PyModule_AddObject(mod, "ZLIB_RUNTIME_VERSION", ver) < 0) {
1623 : 0 : Py_DECREF(ver);
1624 : 0 : return -1;
1625 : : }
1626 : :
1627 [ - + ]: 1433 : if (PyModule_AddStringConstant(mod, "__version__", "1.0") < 0) {
1628 : 0 : return -1;
1629 : : }
1630 : 1433 : return 0;
1631 : : }
1632 : :
1633 : : static PyModuleDef_Slot zlib_slots[] = {
1634 : : {Py_mod_exec, zlib_exec},
1635 : : {0, NULL}
1636 : : };
1637 : :
1638 : : static struct PyModuleDef zlibmodule = {
1639 : : PyModuleDef_HEAD_INIT,
1640 : : .m_name = "zlib",
1641 : : .m_doc = zlib_module_documentation,
1642 : : .m_size = sizeof(zlibstate),
1643 : : .m_methods = zlib_methods,
1644 : : .m_slots = zlib_slots,
1645 : : .m_traverse = zlib_traverse,
1646 : : .m_clear = zlib_clear,
1647 : : .m_free = zlib_free,
1648 : : };
1649 : :
1650 : : PyMODINIT_FUNC
1651 : 1433 : PyInit_zlib(void)
1652 : : {
1653 : 1433 : return PyModuleDef_Init(&zlibmodule);
1654 : : }
|
