1 /* _bz2 - Low-level Python interface to libbzip2. */
2
3 #define PY_SSIZE_T_CLEAN
4
5 #include "Python.h"
6 #include "structmember.h" // PyMemberDef
7
8 #include <bzlib.h>
9 #include <stdio.h>
10
11 // Blocks output buffer wrappers
12 #include "pycore_blocks_output_buffer.h"
13
14 #if OUTPUT_BUFFER_MAX_BLOCK_SIZE > UINT32_MAX
15 #error "The maximum block size accepted by libbzip2 is UINT32_MAX."
16 #endif
17
18 /* On success, return value >= 0
19 On failure, return -1 */
20 static inline Py_ssize_t
21 OutputBuffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,
22 char **next_out, uint32_t *avail_out)
23 {
24 Py_ssize_t allocated;
25
26 allocated = _BlocksOutputBuffer_InitAndGrow(
27 buffer, max_length, (void**) next_out);
28 *avail_out = (uint32_t) allocated;
29 return allocated;
30 }
31
32 /* On success, return value >= 0
33 On failure, return -1 */
34 static inline Py_ssize_t
35 OutputBuffer_Grow(_BlocksOutputBuffer *buffer,
36 char **next_out, uint32_t *avail_out)
37 {
38 Py_ssize_t allocated;
39
40 allocated = _BlocksOutputBuffer_Grow(
41 buffer, (void**) next_out, (Py_ssize_t) *avail_out);
42 *avail_out = (uint32_t) allocated;
43 return allocated;
44 }
45
46 static inline Py_ssize_t
47 OutputBuffer_GetDataSize(_BlocksOutputBuffer *buffer, uint32_t avail_out)
48 {
49 return _BlocksOutputBuffer_GetDataSize(buffer, (Py_ssize_t) avail_out);
50 }
51
52 static inline PyObject *
53 OutputBuffer_Finish(_BlocksOutputBuffer *buffer, uint32_t avail_out)
54 {
55 return _BlocksOutputBuffer_Finish(buffer, (Py_ssize_t) avail_out);
56 }
57
58 static inline void
59 OutputBuffer_OnError(_BlocksOutputBuffer *buffer)
60 {
61 _BlocksOutputBuffer_OnError(buffer);
62 }
63
64
65 #ifndef BZ_CONFIG_ERROR
66 #define BZ2_bzCompress bzCompress
67 #define BZ2_bzCompressInit bzCompressInit
68 #define BZ2_bzCompressEnd bzCompressEnd
69 #define BZ2_bzDecompress bzDecompress
70 #define BZ2_bzDecompressInit bzDecompressInit
71 #define BZ2_bzDecompressEnd bzDecompressEnd
72 #endif /* ! BZ_CONFIG_ERROR */
73
74
75 #define ACQUIRE_LOCK(obj) do { \
76 if (!PyThread_acquire_lock((obj)->lock, 0)) { \
77 Py_BEGIN_ALLOW_THREADS \
78 PyThread_acquire_lock((obj)->lock, 1); \
79 Py_END_ALLOW_THREADS \
80 } } while (0)
81 #define RELEASE_LOCK(obj) PyThread_release_lock((obj)->lock)
82
83
84 typedef struct {
85 PyTypeObject *bz2_compressor_type;
86 PyTypeObject *bz2_decompressor_type;
87 } _bz2_state;
88
89 static inline _bz2_state*
90 get_bz2_state(PyObject *module)
91 {
92 void *state = PyModule_GetState(module);
93 assert(state != NULL);
94 return (_bz2_state *)state;
95 }
96
97 typedef struct {
98 PyObject_HEAD
99 bz_stream bzs;
100 int flushed;
101 PyThread_type_lock lock;
102 } BZ2Compressor;
103
104 typedef struct {
105 PyObject_HEAD
106 bz_stream bzs;
107 char eof; /* T_BOOL expects a char */
108 PyObject *unused_data;
109 char needs_input;
110 char *input_buffer;
111 size_t input_buffer_size;
112
113 /* bzs->avail_in is only 32 bit, so we store the true length
114 separately. Conversion and looping is encapsulated in
115 decompress_buf() */
116 size_t bzs_avail_in_real;
117 PyThread_type_lock lock;
118 } BZ2Decompressor;
119
120 /* Helper functions. */
121
122 static int
123 catch_bz2_error(int bzerror)
124 {
125 switch(bzerror) {
126 case BZ_OK:
127 case BZ_RUN_OK:
128 case BZ_FLUSH_OK:
129 case BZ_FINISH_OK:
130 case BZ_STREAM_END:
131 return 0;
132
133 #ifdef BZ_CONFIG_ERROR
134 case BZ_CONFIG_ERROR:
135 PyErr_SetString(PyExc_SystemError,
136 "libbzip2 was not compiled correctly");
137 return 1;
138 #endif
139 case BZ_PARAM_ERROR:
140 PyErr_SetString(PyExc_ValueError,
141 "Internal error - "
142 "invalid parameters passed to libbzip2");
143 return 1;
144 case BZ_MEM_ERROR:
145 PyErr_NoMemory();
146 return 1;
147 case BZ_DATA_ERROR:
148 case BZ_DATA_ERROR_MAGIC:
149 PyErr_SetString(PyExc_OSError, "Invalid data stream");
150 return 1;
151 case BZ_IO_ERROR:
152 PyErr_SetString(PyExc_OSError, "Unknown I/O error");
153 return 1;
154 case BZ_UNEXPECTED_EOF:
155 PyErr_SetString(PyExc_EOFError,
156 "Compressed file ended before the logical "
157 "end-of-stream was detected");
158 return 1;
159 case BZ_SEQUENCE_ERROR:
160 PyErr_SetString(PyExc_RuntimeError,
161 "Internal error - "
162 "Invalid sequence of commands sent to libbzip2");
163 return 1;
164 default:
165 PyErr_Format(PyExc_OSError,
166 "Unrecognized error from libbzip2: %d", bzerror);
167 return 1;
168 }
169 }
170
171
172 /* BZ2Compressor class. */
173
174 static PyObject *
175 compress(BZ2Compressor *c, char *data, size_t len, int action)
176 {
177 PyObject *result;
178 _BlocksOutputBuffer buffer = {.list = NULL};
179
180 if (OutputBuffer_InitAndGrow(&buffer, -1, &c->bzs.next_out, &c->bzs.avail_out) < 0) {
181 goto error;
182 }
183 c->bzs.next_in = data;
184 c->bzs.avail_in = 0;
185
186 for (;;) {
187 int bzerror;
188
189 /* On a 64-bit system, len might not fit in avail_in (an unsigned int).
190 Do compression in chunks of no more than UINT_MAX bytes each. */
191 if (c->bzs.avail_in == 0 && len > 0) {
192 c->bzs.avail_in = (unsigned int)Py_MIN(len, UINT_MAX);
193 len -= c->bzs.avail_in;
194 }
195
196 /* In regular compression mode, stop when input data is exhausted. */
197 if (action == BZ_RUN && c->bzs.avail_in == 0)
198 break;
199
200 if (c->bzs.avail_out == 0) {
201 if (OutputBuffer_Grow(&buffer, &c->bzs.next_out, &c->bzs.avail_out) < 0) {
202 goto error;
203 }
204 }
205
206 Py_BEGIN_ALLOW_THREADS
207 bzerror = BZ2_bzCompress(&c->bzs, action);
208 Py_END_ALLOW_THREADS
209
210 if (catch_bz2_error(bzerror))
211 goto error;
212
213 /* In flushing mode, stop when all buffered data has been flushed. */
214 if (action == BZ_FINISH && bzerror == BZ_STREAM_END)
215 break;
216 }
217
218 result = OutputBuffer_Finish(&buffer, c->bzs.avail_out);
219 if (result != NULL) {
220 return result;
221 }
222
223 error:
224 OutputBuffer_OnError(&buffer);
225 return NULL;
226 }
227
228 /*[clinic input]
229 module _bz2
230 class _bz2.BZ2Compressor "BZ2Compressor *" "&BZ2Compressor_Type"
231 class _bz2.BZ2Decompressor "BZ2Decompressor *" "&BZ2Decompressor_Type"
232 [clinic start generated code]*/
233 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=dc7d7992a79f9cb7]*/
234
235 #include "clinic/_bz2module.c.h"
236
237 /*[clinic input]
238 _bz2.BZ2Compressor.compress
239
240 data: Py_buffer
241 /
242
243 Provide data to the compressor object.
244
245 Returns a chunk of compressed data if possible, or b'' otherwise.
246
247 When you have finished providing data to the compressor, call the
248 flush() method to finish the compression process.
249 [clinic start generated code]*/
250
251 static PyObject *
252 _bz2_BZ2Compressor_compress_impl(BZ2Compressor *self, Py_buffer *data)
253 /*[clinic end generated code: output=59365426e941fbcc input=85c963218070fc4c]*/
254 {
255 PyObject *result = NULL;
256
257 ACQUIRE_LOCK(self);
258 if (self->flushed)
259 PyErr_SetString(PyExc_ValueError, "Compressor has been flushed");
260 else
261 result = compress(self, data->buf, data->len, BZ_RUN);
262 RELEASE_LOCK(self);
263 return result;
264 }
265
266 /*[clinic input]
267 _bz2.BZ2Compressor.flush
268
269 Finish the compression process.
270
271 Returns the compressed data left in internal buffers.
272
273 The compressor object may not be used after this method is called.
274 [clinic start generated code]*/
275
276 static PyObject *
277 _bz2_BZ2Compressor_flush_impl(BZ2Compressor *self)
278 /*[clinic end generated code: output=3ef03fc1b092a701 input=d64405d3c6f76691]*/
279 {
280 PyObject *result = NULL;
281
282 ACQUIRE_LOCK(self);
283 if (self->flushed)
284 PyErr_SetString(PyExc_ValueError, "Repeated call to flush()");
285 else {
286 self->flushed = 1;
287 result = compress(self, NULL, 0, BZ_FINISH);
288 }
289 RELEASE_LOCK(self);
290 return result;
291 }
292
293 static void*
294 BZ2_Malloc(void* ctx, int items, int size)
295 {
296 if (items < 0 || size < 0)
297 return NULL;
298 if (size != 0 && (size_t)items > (size_t)PY_SSIZE_T_MAX / (size_t)size)
299 return NULL;
300 /* PyMem_Malloc() cannot be used: compress() and decompress()
301 release the GIL */
302 return PyMem_RawMalloc((size_t)items * (size_t)size);
303 }
304
305 static void
306 BZ2_Free(void* ctx, void *ptr)
307 {
308 PyMem_RawFree(ptr);
309 }
310
311
312 /* Argument Clinic is not used since the Argument Clinic always want to
313 check the type which would be wrong here */
314 static int
315 _bz2_BZ2Compressor___init___impl(BZ2Compressor *self, int compresslevel)
316 {
317 int bzerror;
318
319 if (!(1 <= compresslevel && compresslevel <= 9)) {
320 PyErr_SetString(PyExc_ValueError,
321 "compresslevel must be between 1 and 9");
322 return -1;
323 }
324
325 self->lock = PyThread_allocate_lock();
326 if (self->lock == NULL) {
327 PyErr_SetString(PyExc_MemoryError, "Unable to allocate lock");
328 return -1;
329 }
330
331 self->bzs.opaque = NULL;
332 self->bzs.bzalloc = BZ2_Malloc;
333 self->bzs.bzfree = BZ2_Free;
334 bzerror = BZ2_bzCompressInit(&self->bzs, compresslevel, 0, 0);
335 if (catch_bz2_error(bzerror))
336 goto error;
337
338 return 0;
339
340 error:
341 PyThread_free_lock(self->lock);
342 self->lock = NULL;
343 return -1;
344 }
345
346 PyDoc_STRVAR(_bz2_BZ2Compressor___init____doc__,
347 "BZ2Compressor(compresslevel=9, /)\n"
348 "--\n"
349 "\n"
350 "Create a compressor object for compressing data incrementally.\n"
351 "\n"
352 " compresslevel\n"
353 " Compression level, as a number between 1 and 9.\n"
354 "\n"
355 "For one-shot compression, use the compress() function instead.");
356
357 static int
358 _bz2_BZ2Compressor___init__(PyObject *self, PyObject *args, PyObject *kwargs)
359 {
360 int return_value = -1;
361 int compresslevel = 9;
362
363 if (!_PyArg_NoKeywords("BZ2Compressor", kwargs)) {
364 goto exit;
365 }
366 if (!_PyArg_CheckPositional("BZ2Compressor", PyTuple_GET_SIZE(args), 0, 1)) {
367 goto exit;
368 }
369 if (PyTuple_GET_SIZE(args) < 1) {
370 goto skip_optional;
371 }
372 compresslevel = _PyLong_AsInt(PyTuple_GET_ITEM(args, 0));
373 if (compresslevel == -1 && PyErr_Occurred()) {
374 goto exit;
375 }
376 skip_optional:
377 return_value = _bz2_BZ2Compressor___init___impl((BZ2Compressor *)self, compresslevel);
378
379 exit:
380 return return_value;
381 }
382
383 static void
384 BZ2Compressor_dealloc(BZ2Compressor *self)
385 {
386 BZ2_bzCompressEnd(&self->bzs);
387 if (self->lock != NULL) {
388 PyThread_free_lock(self->lock);
389 }
390 PyTypeObject *tp = Py_TYPE(self);
391 tp->tp_free((PyObject *)self);
392 Py_DECREF(tp);
393 }
394
395 static int
396 BZ2Compressor_traverse(BZ2Compressor *self, visitproc visit, void *arg)
397 {
398 Py_VISIT(Py_TYPE(self));
399 return 0;
400 }
401
402 static PyMethodDef BZ2Compressor_methods[] = {
403 _BZ2_BZ2COMPRESSOR_COMPRESS_METHODDEF
404 _BZ2_BZ2COMPRESSOR_FLUSH_METHODDEF
405 {NULL}
406 };
407
408 static PyType_Slot bz2_compressor_type_slots[] = {
409 {Py_tp_dealloc, BZ2Compressor_dealloc},
410 {Py_tp_methods, BZ2Compressor_methods},
411 {Py_tp_init, _bz2_BZ2Compressor___init__},
412 {Py_tp_new, PyType_GenericNew},
413 {Py_tp_doc, (char *)_bz2_BZ2Compressor___init____doc__},
414 {Py_tp_traverse, BZ2Compressor_traverse},
415 {0, 0}
416 };
417
418 static PyType_Spec bz2_compressor_type_spec = {
419 .name = "_bz2.BZ2Compressor",
420 .basicsize = sizeof(BZ2Compressor),
421 // Calling PyType_GetModuleState() on a subclass is not safe.
422 // bz2_compressor_type_spec does not have Py_TPFLAGS_BASETYPE flag
423 // which prevents to create a subclass.
424 // So calling PyType_GetModuleState() in this file is always safe.
425 .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE),
426 .slots = bz2_compressor_type_slots,
427 };
428
429 /* BZ2Decompressor class. */
430
431 /* Decompress data of length d->bzs_avail_in_real in d->bzs.next_in. The output
432 buffer is allocated dynamically and returned. At most max_length bytes are
433 returned, so some of the input may not be consumed. d->bzs.next_in and
434 d->bzs_avail_in_real are updated to reflect the consumed input. */
435 static PyObject*
436 decompress_buf(BZ2Decompressor *d, Py_ssize_t max_length)
437 {
438 /* data_size is strictly positive, but because we repeatedly have to
439 compare against max_length and PyBytes_GET_SIZE we declare it as
440 signed */
441 PyObject *result;
442 _BlocksOutputBuffer buffer = {.list = NULL};
443 bz_stream *bzs = &d->bzs;
444
445 if (OutputBuffer_InitAndGrow(&buffer, max_length, &bzs->next_out, &bzs->avail_out) < 0) {
446 goto error;
447 }
448
449 for (;;) {
450 int bzret;
451 /* On a 64-bit system, buffer length might not fit in avail_out, so we
452 do decompression in chunks of no more than UINT_MAX bytes
453 each. Note that the expression for `avail` is guaranteed to be
454 positive, so the cast is safe. */
455 bzs->avail_in = (unsigned int)Py_MIN(d->bzs_avail_in_real, UINT_MAX);
456 d->bzs_avail_in_real -= bzs->avail_in;
457
458 Py_BEGIN_ALLOW_THREADS
459 bzret = BZ2_bzDecompress(bzs);
460 Py_END_ALLOW_THREADS
461
462 d->bzs_avail_in_real += bzs->avail_in;
463
464 if (catch_bz2_error(bzret))
465 goto error;
466 if (bzret == BZ_STREAM_END) {
467 d->eof = 1;
468 break;
469 } else if (d->bzs_avail_in_real == 0) {
470 break;
471 } else if (bzs->avail_out == 0) {
472 if (OutputBuffer_GetDataSize(&buffer, bzs->avail_out) == max_length) {
473 break;
474 }
475 if (OutputBuffer_Grow(&buffer, &bzs->next_out, &bzs->avail_out) < 0) {
476 goto error;
477 }
478 }
479 }
480
481 result = OutputBuffer_Finish(&buffer, bzs->avail_out);
482 if (result != NULL) {
483 return result;
484 }
485
486 error:
487 OutputBuffer_OnError(&buffer);
488 return NULL;
489 }
490
491
492 static PyObject *
493 decompress(BZ2Decompressor *d, char *data, size_t len, Py_ssize_t max_length)
494 {
495 char input_buffer_in_use;
496 PyObject *result;
497 bz_stream *bzs = &d->bzs;
498
499 /* Prepend unconsumed input if necessary */
500 if (bzs->next_in != NULL) {
501 size_t avail_now, avail_total;
502
503 /* Number of bytes we can append to input buffer */
504 avail_now = (d->input_buffer + d->input_buffer_size)
505 - (bzs->next_in + d->bzs_avail_in_real);
506
507 /* Number of bytes we can append if we move existing
508 contents to beginning of buffer (overwriting
509 consumed input) */
510 avail_total = d->input_buffer_size - d->bzs_avail_in_real;
511
512 if (avail_total < len) {
513 size_t offset = bzs->next_in - d->input_buffer;
514 char *tmp;
515 size_t new_size = d->input_buffer_size + len - avail_now;
516
517 /* Assign to temporary variable first, so we don't
518 lose address of allocated buffer if realloc fails */
519 tmp = PyMem_Realloc(d->input_buffer, new_size);
520 if (tmp == NULL) {
521 PyErr_SetNone(PyExc_MemoryError);
522 return NULL;
523 }
524 d->input_buffer = tmp;
525 d->input_buffer_size = new_size;
526
527 bzs->next_in = d->input_buffer + offset;
528 }
529 else if (avail_now < len) {
530 memmove(d->input_buffer, bzs->next_in,
531 d->bzs_avail_in_real);
532 bzs->next_in = d->input_buffer;
533 }
534 memcpy((void*)(bzs->next_in + d->bzs_avail_in_real), data, len);
535 d->bzs_avail_in_real += len;
536 input_buffer_in_use = 1;
537 }
538 else {
539 bzs->next_in = data;
540 d->bzs_avail_in_real = len;
541 input_buffer_in_use = 0;
542 }
543
544 result = decompress_buf(d, max_length);
545 if(result == NULL) {
546 bzs->next_in = NULL;
547 return NULL;
548 }
549
550 if (d->eof) {
551 d->needs_input = 0;
552 if (d->bzs_avail_in_real > 0) {
553 Py_XSETREF(d->unused_data,
554 PyBytes_FromStringAndSize(bzs->next_in, d->bzs_avail_in_real));
555 if (d->unused_data == NULL)
556 goto error;
557 }
558 }
559 else if (d->bzs_avail_in_real == 0) {
560 bzs->next_in = NULL;
561 d->needs_input = 1;
562 }
563 else {
564 d->needs_input = 0;
565
566 /* If we did not use the input buffer, we now have
567 to copy the tail from the caller's buffer into the
568 input buffer */
569 if (!input_buffer_in_use) {
570
571 /* Discard buffer if it's too small
572 (resizing it may needlessly copy the current contents) */
573 if (d->input_buffer != NULL &&
574 d->input_buffer_size < d->bzs_avail_in_real) {
575 PyMem_Free(d->input_buffer);
576 d->input_buffer = NULL;
577 }
578
579 /* Allocate if necessary */
580 if (d->input_buffer == NULL) {
581 d->input_buffer = PyMem_Malloc(d->bzs_avail_in_real);
582 if (d->input_buffer == NULL) {
583 PyErr_SetNone(PyExc_MemoryError);
584 goto error;
585 }
586 d->input_buffer_size = d->bzs_avail_in_real;
587 }
588
589 /* Copy tail */
590 memcpy(d->input_buffer, bzs->next_in, d->bzs_avail_in_real);
591 bzs->next_in = d->input_buffer;
592 }
593 }
594
595 return result;
596
597 error:
598 Py_XDECREF(result);
599 return NULL;
600 }
601
602 /*[clinic input]
603 _bz2.BZ2Decompressor.decompress
604
605 data: Py_buffer
606 max_length: Py_ssize_t=-1
607
608 Decompress *data*, returning uncompressed data as bytes.
609
610 If *max_length* is nonnegative, returns at most *max_length* bytes of
611 decompressed data. If this limit is reached and further output can be
612 produced, *self.needs_input* will be set to ``False``. In this case, the next
613 call to *decompress()* may provide *data* as b'' to obtain more of the output.
614
615 If all of the input data was decompressed and returned (either because this
616 was less than *max_length* bytes, or because *max_length* was negative),
617 *self.needs_input* will be set to True.
618
619 Attempting to decompress data after the end of stream is reached raises an
620 EOFError. Any data found after the end of the stream is ignored and saved in
621 the unused_data attribute.
622 [clinic start generated code]*/
623
624 static PyObject *
625 _bz2_BZ2Decompressor_decompress_impl(BZ2Decompressor *self, Py_buffer *data,
626 Py_ssize_t max_length)
627 /*[clinic end generated code: output=23e41045deb240a3 input=52e1ffc66a8ea624]*/
628 {
629 PyObject *result = NULL;
630
631 ACQUIRE_LOCK(self);
632 if (self->eof)
633 PyErr_SetString(PyExc_EOFError, "End of stream already reached");
634 else
635 result = decompress(self, data->buf, data->len, max_length);
636 RELEASE_LOCK(self);
637 return result;
638 }
639
640 /* Argument Clinic is not used since the Argument Clinic always want to
641 check the type which would be wrong here */
642 static int
643 _bz2_BZ2Decompressor___init___impl(BZ2Decompressor *self)
644 {
645 int bzerror;
646
647 PyThread_type_lock lock = PyThread_allocate_lock();
648 if (lock == NULL) {
649 PyErr_SetString(PyExc_MemoryError, "Unable to allocate lock");
650 return -1;
651 }
652 if (self->lock != NULL) {
653 PyThread_free_lock(self->lock);
654 }
655 self->lock = lock;
656
657 self->needs_input = 1;
658 self->bzs_avail_in_real = 0;
659 self->input_buffer = NULL;
660 self->input_buffer_size = 0;
661 Py_XSETREF(self->unused_data, PyBytes_FromStringAndSize(NULL, 0));
662 if (self->unused_data == NULL)
663 goto error;
664
665 bzerror = BZ2_bzDecompressInit(&self->bzs, 0, 0);
666 if (catch_bz2_error(bzerror))
667 goto error;
668
669 return 0;
670
671 error:
672 Py_CLEAR(self->unused_data);
673 PyThread_free_lock(self->lock);
674 self->lock = NULL;
675 return -1;
676 }
677
678 static int
679 _bz2_BZ2Decompressor___init__(PyObject *self, PyObject *args, PyObject *kwargs)
680 {
681 int return_value = -1;
682
683 if (!_PyArg_NoPositional("BZ2Decompressor", args)) {
684 goto exit;
685 }
686 if (!_PyArg_NoKeywords("BZ2Decompressor", kwargs)) {
687 goto exit;
688 }
689 return_value = _bz2_BZ2Decompressor___init___impl((BZ2Decompressor *)self);
690
691 exit:
692 return return_value;
693 }
694
695 PyDoc_STRVAR(_bz2_BZ2Decompressor___init____doc__,
696 "BZ2Decompressor()\n"
697 "--\n"
698 "\n"
699 "Create a decompressor object for decompressing data incrementally.\n"
700 "\n"
701 "For one-shot decompression, use the decompress() function instead.");
702
703 static void
704 BZ2Decompressor_dealloc(BZ2Decompressor *self)
705 {
706 if(self->input_buffer != NULL) {
707 PyMem_Free(self->input_buffer);
708 }
709 BZ2_bzDecompressEnd(&self->bzs);
710 Py_CLEAR(self->unused_data);
711 if (self->lock != NULL) {
712 PyThread_free_lock(self->lock);
713 }
714
715 PyTypeObject *tp = Py_TYPE(self);
716 tp->tp_free((PyObject *)self);
717 Py_DECREF(tp);
718 }
719
720 static int
721 BZ2Decompressor_traverse(BZ2Decompressor *self, visitproc visit, void *arg)
722 {
723 Py_VISIT(Py_TYPE(self));
724 return 0;
725 }
726
727 static PyMethodDef BZ2Decompressor_methods[] = {
728 _BZ2_BZ2DECOMPRESSOR_DECOMPRESS_METHODDEF
729 {NULL}
730 };
731
732 PyDoc_STRVAR(BZ2Decompressor_eof__doc__,
733 "True if the end-of-stream marker has been reached.");
734
735 PyDoc_STRVAR(BZ2Decompressor_unused_data__doc__,
736 "Data found after the end of the compressed stream.");
737
738 PyDoc_STRVAR(BZ2Decompressor_needs_input_doc,
739 "True if more input is needed before more decompressed data can be produced.");
740
741 static PyMemberDef BZ2Decompressor_members[] = {
742 {"eof", T_BOOL, offsetof(BZ2Decompressor, eof),
743 READONLY, BZ2Decompressor_eof__doc__},
744 {"unused_data", T_OBJECT_EX, offsetof(BZ2Decompressor, unused_data),
745 READONLY, BZ2Decompressor_unused_data__doc__},
746 {"needs_input", T_BOOL, offsetof(BZ2Decompressor, needs_input), READONLY,
747 BZ2Decompressor_needs_input_doc},
748 {NULL}
749 };
750
751 static PyType_Slot bz2_decompressor_type_slots[] = {
752 {Py_tp_dealloc, BZ2Decompressor_dealloc},
753 {Py_tp_methods, BZ2Decompressor_methods},
754 {Py_tp_init, _bz2_BZ2Decompressor___init__},
755 {Py_tp_doc, (char *)_bz2_BZ2Decompressor___init____doc__},
756 {Py_tp_members, BZ2Decompressor_members},
757 {Py_tp_new, PyType_GenericNew},
758 {Py_tp_traverse, BZ2Decompressor_traverse},
759 {0, 0}
760 };
761
762 static PyType_Spec bz2_decompressor_type_spec = {
763 .name = "_bz2.BZ2Decompressor",
764 .basicsize = sizeof(BZ2Decompressor),
765 // Calling PyType_GetModuleState() on a subclass is not safe.
766 // bz2_decompressor_type_spec does not have Py_TPFLAGS_BASETYPE flag
767 // which prevents to create a subclass.
768 // So calling PyType_GetModuleState() in this file is always safe.
769 .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE),
770 .slots = bz2_decompressor_type_slots,
771 };
772
773 /* Module initialization. */
774
775 static int
776 _bz2_exec(PyObject *module)
777 {
778 _bz2_state *state = get_bz2_state(module);
779 state->bz2_compressor_type = (PyTypeObject *)PyType_FromModuleAndSpec(module,
780 &bz2_compressor_type_spec, NULL);
781 if (state->bz2_compressor_type == NULL) {
782 return -1;
783 }
784
785 if (PyModule_AddType(module, state->bz2_compressor_type) < 0) {
786 return -1;
787 }
788
789 state->bz2_decompressor_type = (PyTypeObject *)PyType_FromModuleAndSpec(module,
790 &bz2_decompressor_type_spec, NULL);
791 if (state->bz2_decompressor_type == NULL) {
792 return -1;
793 }
794
795 if (PyModule_AddType(module, state->bz2_decompressor_type) < 0) {
796 return -1;
797 }
798
799 return 0;
800 }
801
802 static int
803 _bz2_traverse(PyObject *module, visitproc visit, void *arg)
804 {
805 _bz2_state *state = get_bz2_state(module);
806 Py_VISIT(state->bz2_compressor_type);
807 Py_VISIT(state->bz2_decompressor_type);
808 return 0;
809 }
810
811 static int
812 _bz2_clear(PyObject *module)
813 {
814 _bz2_state *state = get_bz2_state(module);
815 Py_CLEAR(state->bz2_compressor_type);
816 Py_CLEAR(state->bz2_decompressor_type);
817 return 0;
818 }
819
820 static void
821 _bz2_free(void *module)
822 {
823 _bz2_clear((PyObject *)module);
824 }
825
826 static struct PyModuleDef_Slot _bz2_slots[] = {
827 {Py_mod_exec, _bz2_exec},
828 {0, NULL}
829 };
830
831 static struct PyModuleDef _bz2module = {
832 PyModuleDef_HEAD_INIT,
833 .m_name = "_bz2",
834 .m_size = sizeof(_bz2_state),
835 .m_slots = _bz2_slots,
836 .m_traverse = _bz2_traverse,
837 .m_clear = _bz2_clear,
838 .m_free = _bz2_free,
839 };
840
841 PyMODINIT_FUNC
842 PyInit__bz2(void)
843 {
844 return PyModuleDef_Init(&_bz2module);
845 }