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