blob: 4c1ce23e21c33de66771c5e5fab4d3398f427854 [file] [log] [blame]
Guido van Rossumfb221561997-04-29 15:38:09 +00001/* zlibmodule.c -- gzip-compatible data compression */
Martin v. Löwis1dbce442001-10-09 10:54:31 +00002/* See http://www.gzip.org/zlib/ */
Mark Hammondae8c2682001-01-31 10:28:03 +00003
Tim Petersee826f82001-01-31 19:39:44 +00004/* Windows users: read Python's PCbuild\readme.txt */
Mark Hammondae8c2682001-01-31 10:28:03 +00005
Guido van Rossumfb221561997-04-29 15:38:09 +00006
Guido van Rossum97b54571997-06-03 22:21:47 +00007#include "Python.h"
8#include "zlib.h"
Guido van Rossumfb221561997-04-29 15:38:09 +00009
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +000010#ifdef WITH_THREAD
11#include "pythread.h"
12
13/* #defs ripped off from _tkinter.c, even though the situation here is much
14 simpler, because we don't have to worry about waiting for Tcl
15 events! And, since zlib itself is threadsafe, we don't need to worry
16 about re-entering zlib functions.
17
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +000018 N.B.
19
20 Since ENTER_ZLIB and LEAVE_ZLIB only need to be called on functions
21 that modify the components of preexisting de/compress objects, it
22 could prove to be a performance gain on multiprocessor machines if
23 there was an de/compress object-specific lock. However, for the
24 moment the ENTER_ZLIB and LEAVE_ZLIB calls are global for ALL
25 de/compress objects.
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +000026 */
27
28static PyThread_type_lock zlib_lock = NULL; /* initialized on module load */
29
30#define ENTER_ZLIB \
Tim Peters6605c642001-10-17 03:43:54 +000031 Py_BEGIN_ALLOW_THREADS \
32 PyThread_acquire_lock(zlib_lock, 1); \
33 Py_END_ALLOW_THREADS
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +000034
35#define LEAVE_ZLIB \
Tim Peters6605c642001-10-17 03:43:54 +000036 PyThread_release_lock(zlib_lock);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +000037
38#else
39
40#define ENTER_ZLIB
41#define LEAVE_ZLIB
42
43#endif
44
Guido van Rossumfb221561997-04-29 15:38:09 +000045/* The following parameters are copied from zutil.h, version 0.95 */
46#define DEFLATED 8
47#if MAX_MEM_LEVEL >= 8
48# define DEF_MEM_LEVEL 8
49#else
50# define DEF_MEM_LEVEL MAX_MEM_LEVEL
51#endif
52#define DEF_WBITS MAX_WBITS
53
Guido van Rossumb729a1d1999-04-07 20:23:17 +000054/* The output buffer will be increased in chunks of DEFAULTALLOC bytes. */
55#define DEFAULTALLOC (16*1024)
Guido van Rossumfb221561997-04-29 15:38:09 +000056#define PyInit_zlib initzlib
57
Jeremy Hylton938ace62002-07-17 16:30:39 +000058static PyTypeObject Comptype;
59static PyTypeObject Decomptype;
Guido van Rossumfb221561997-04-29 15:38:09 +000060
61static PyObject *ZlibError;
62
Tim Peters977e5402001-10-17 03:57:20 +000063typedef struct
Guido van Rossumfb221561997-04-29 15:38:09 +000064{
Jeremy Hylton9714f992001-10-16 21:19:45 +000065 PyObject_HEAD
66 z_stream zst;
67 PyObject *unused_data;
68 PyObject *unconsumed_tail;
69 int is_initialised;
Guido van Rossumfb221561997-04-29 15:38:09 +000070} compobject;
71
Jeremy Hylton0965e082001-10-16 21:56:09 +000072static void
73zlib_error(z_stream zst, int err, char *msg)
74{
75 if (zst.msg == Z_NULL)
76 PyErr_Format(ZlibError, "Error %d %s", err, msg);
77 else
78 PyErr_Format(ZlibError, "Error %d %s: %.200s", err, msg, zst.msg);
79}
80
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000081PyDoc_STRVAR(compressobj__doc__,
Tim Petersadbd35b2001-10-17 04:16:15 +000082"compressobj([level]) -- Return a compressor object.\n"
83"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000084"Optional arg level is the compression level, in 1-9.");
Guido van Rossum3c540301997-06-03 22:21:03 +000085
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000086PyDoc_STRVAR(decompressobj__doc__,
Tim Petersadbd35b2001-10-17 04:16:15 +000087"decompressobj([wbits]) -- Return a decompressor object.\n"
88"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000089"Optional arg wbits is the window buffer size.");
Guido van Rossum3c540301997-06-03 22:21:03 +000090
Guido van Rossumfb221561997-04-29 15:38:09 +000091static compobject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +000092newcompobject(PyTypeObject *type)
Guido van Rossumfb221561997-04-29 15:38:09 +000093{
Tim Peters977e5402001-10-17 03:57:20 +000094 compobject *self;
Jeremy Hylton9714f992001-10-16 21:19:45 +000095 self = PyObject_New(compobject, type);
96 if (self == NULL)
97 return NULL;
98 self->is_initialised = 0;
99 self->unused_data = PyString_FromString("");
100 if (self->unused_data == NULL) {
101 Py_DECREF(self);
102 return NULL;
103 }
104 self->unconsumed_tail = PyString_FromString("");
105 if (self->unconsumed_tail == NULL) {
106 Py_DECREF(self);
107 return NULL;
108 }
109 return self;
Guido van Rossumfb221561997-04-29 15:38:09 +0000110}
111
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000112PyDoc_STRVAR(compress__doc__,
Tim Petersadbd35b2001-10-17 04:16:15 +0000113"compress(string[, level]) -- Returned compressed string.\n"
114"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000115"Optional arg level is the compression level, in 1-9.");
Guido van Rossum3c540301997-06-03 22:21:03 +0000116
Guido van Rossumfb221561997-04-29 15:38:09 +0000117static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000118PyZlib_compress(PyObject *self, PyObject *args)
Guido van Rossumfb221561997-04-29 15:38:09 +0000119{
Jeremy Hylton9714f992001-10-16 21:19:45 +0000120 PyObject *ReturnVal = NULL;
121 Byte *input, *output;
122 int length, level=Z_DEFAULT_COMPRESSION, err;
123 z_stream zst;
Tim Peters977e5402001-10-17 03:57:20 +0000124
Jeremy Hylton9714f992001-10-16 21:19:45 +0000125 /* require Python string object, optional 'level' arg */
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000126 if (!PyArg_ParseTuple(args, "s#|i:compress", &input, &length, &level))
Jeremy Hylton9714f992001-10-16 21:19:45 +0000127 return NULL;
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000128
Jeremy Hylton9714f992001-10-16 21:19:45 +0000129 zst.avail_out = length + length/1000 + 12 + 1;
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000130
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000131 output = (Byte*)malloc(zst.avail_out);
132 if (output == NULL) {
Jeremy Hylton9714f992001-10-16 21:19:45 +0000133 PyErr_SetString(PyExc_MemoryError,
134 "Can't allocate memory to compress data");
Jeremy Hylton9714f992001-10-16 21:19:45 +0000135 return NULL;
Guido van Rossumfb221561997-04-29 15:38:09 +0000136 }
Jeremy Hyltona37e2441998-12-18 22:13:11 +0000137
Jeremy Hylton9714f992001-10-16 21:19:45 +0000138 /* Past the point of no return. From here on out, we need to make sure
139 we clean up mallocs & INCREFs. */
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000140
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000141 zst.zalloc = (alloc_func)NULL;
142 zst.zfree = (free_func)Z_NULL;
143 zst.next_out = (Byte *)output;
144 zst.next_in = (Byte *)input;
145 zst.avail_in = length;
146 err = deflateInit(&zst, level);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000147
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000148 switch(err) {
Guido van Rossumfb221561997-04-29 15:38:09 +0000149 case(Z_OK):
Jeremy Hylton9714f992001-10-16 21:19:45 +0000150 break;
Guido van Rossumfb221561997-04-29 15:38:09 +0000151 case(Z_MEM_ERROR):
Jeremy Hylton9714f992001-10-16 21:19:45 +0000152 PyErr_SetString(PyExc_MemoryError,
153 "Out of memory while compressing data");
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000154 goto error;
Guido van Rossumfb221561997-04-29 15:38:09 +0000155 case(Z_STREAM_ERROR):
Jeremy Hylton9714f992001-10-16 21:19:45 +0000156 PyErr_SetString(ZlibError,
157 "Bad compression level");
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000158 goto error;
Jeremy Hylton0965e082001-10-16 21:56:09 +0000159 default:
Guido van Rossumfb221561997-04-29 15:38:09 +0000160 deflateEnd(&zst);
Jeremy Hylton0965e082001-10-16 21:56:09 +0000161 zlib_error(zst, err, "while compressing data");
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000162 goto error;
Guido van Rossumfb221561997-04-29 15:38:09 +0000163 }
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000164
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000165 Py_BEGIN_ALLOW_THREADS;
166 err = deflate(&zst, Z_FINISH);
167 Py_END_ALLOW_THREADS;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000168
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000169 if (err != Z_STREAM_END) {
170 zlib_error(zst, err, "while compressing data");
171 deflateEnd(&zst);
172 goto error;
173 }
Tim Peters977e5402001-10-17 03:57:20 +0000174
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000175 err=deflateEnd(&zst);
176 if (err == Z_OK)
Tim Peters977e5402001-10-17 03:57:20 +0000177 ReturnVal = PyString_FromStringAndSize((char *)output,
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000178 zst.total_out);
Tim Peters977e5402001-10-17 03:57:20 +0000179 else
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000180 zlib_error(zst, err, "while finishing compression");
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000181
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000182 error:
Jeremy Hylton9714f992001-10-16 21:19:45 +0000183 free(output);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000184
Jeremy Hylton9714f992001-10-16 21:19:45 +0000185 return ReturnVal;
Guido van Rossumfb221561997-04-29 15:38:09 +0000186}
187
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000188PyDoc_STRVAR(decompress__doc__,
Tim Petersadbd35b2001-10-17 04:16:15 +0000189"decompress(string[, wbits[, bufsize]]) -- Return decompressed string.\n"
190"\n"
191"Optional arg wbits is the window buffer size. Optional arg bufsize is\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000192"the initial output buffer size.");
Guido van Rossum3c540301997-06-03 22:21:03 +0000193
Guido van Rossumfb221561997-04-29 15:38:09 +0000194static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000195PyZlib_decompress(PyObject *self, PyObject *args)
Guido van Rossumfb221561997-04-29 15:38:09 +0000196{
Jeremy Hylton9714f992001-10-16 21:19:45 +0000197 PyObject *result_str;
198 Byte *input;
199 int length, err;
200 int wsize=DEF_WBITS, r_strlen=DEFAULTALLOC;
201 z_stream zst;
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000202
Tim Peters977e5402001-10-17 03:57:20 +0000203 if (!PyArg_ParseTuple(args, "s#|ii:decompress",
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000204 &input, &length, &wsize, &r_strlen))
Jeremy Hylton9714f992001-10-16 21:19:45 +0000205 return NULL;
Jeremy Hyltoncb914041997-09-04 23:39:23 +0000206
Jeremy Hylton9714f992001-10-16 21:19:45 +0000207 if (r_strlen <= 0)
208 r_strlen = 1;
Jeremy Hyltona37e2441998-12-18 22:13:11 +0000209
Jeremy Hylton9714f992001-10-16 21:19:45 +0000210 zst.avail_in = length;
211 zst.avail_out = r_strlen;
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000212
Jeremy Hylton9bc9d662001-10-16 21:23:58 +0000213 if (!(result_str = PyString_FromStringAndSize(NULL, r_strlen)))
Jeremy Hylton9714f992001-10-16 21:19:45 +0000214 return NULL;
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000215
Jeremy Hylton9714f992001-10-16 21:19:45 +0000216 zst.zalloc = (alloc_func)NULL;
217 zst.zfree = (free_func)Z_NULL;
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000218 zst.next_out = (Byte *)PyString_AS_STRING(result_str);
Jeremy Hylton9714f992001-10-16 21:19:45 +0000219 zst.next_in = (Byte *)input;
220 err = inflateInit2(&zst, wsize);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000221
Jeremy Hylton9714f992001-10-16 21:19:45 +0000222 switch(err) {
Guido van Rossumfb221561997-04-29 15:38:09 +0000223 case(Z_OK):
Jeremy Hylton9714f992001-10-16 21:19:45 +0000224 break;
Tim Peters977e5402001-10-17 03:57:20 +0000225 case(Z_MEM_ERROR):
Jeremy Hylton9714f992001-10-16 21:19:45 +0000226 PyErr_SetString(PyExc_MemoryError,
227 "Out of memory while decompressing data");
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000228 goto error;
Jeremy Hylton0965e082001-10-16 21:56:09 +0000229 default:
Guido van Rossumfb221561997-04-29 15:38:09 +0000230 inflateEnd(&zst);
Jeremy Hylton0965e082001-10-16 21:56:09 +0000231 zlib_error(zst, err, "while preparing to decompress data");
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000232 goto error;
Guido van Rossumfb221561997-04-29 15:38:09 +0000233 }
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000234
Jeremy Hylton9714f992001-10-16 21:19:45 +0000235 do {
Jeremy Hylton9714f992001-10-16 21:19:45 +0000236 Py_BEGIN_ALLOW_THREADS
237 err=inflate(&zst, Z_FINISH);
238 Py_END_ALLOW_THREADS
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000239
Jeremy Hylton9714f992001-10-16 21:19:45 +0000240 switch(err) {
241 case(Z_STREAM_END):
Jeremy Hylton41b9f001997-08-13 23:19:55 +0000242 break;
Guido van Rossum115f5171998-04-23 20:22:11 +0000243 case(Z_BUF_ERROR):
Andrew M. Kuchlingd9238312000-10-09 14:18:10 +0000244 /*
245 * If there is at least 1 byte of room according to zst.avail_out
246 * and we get this error, assume that it means zlib cannot
247 * process the inflate call() due to an error in the data.
248 */
Jeremy Hylton0965e082001-10-16 21:56:09 +0000249 if (zst.avail_out > 0) {
Jeremy Hylton9714f992001-10-16 21:19:45 +0000250 PyErr_Format(ZlibError, "Error %i while decompressing data",
251 err);
252 inflateEnd(&zst);
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000253 goto error;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000254 }
Andrew M. Kuchlingd9238312000-10-09 14:18:10 +0000255 /* fall through */
256 case(Z_OK):
Jeremy Hylton41b9f001997-08-13 23:19:55 +0000257 /* need more memory */
Tim Peters5de98422002-04-27 18:44:32 +0000258 if (_PyString_Resize(&result_str, r_strlen << 1) < 0) {
Jeremy Hylton9714f992001-10-16 21:19:45 +0000259 inflateEnd(&zst);
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000260 goto error;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000261 }
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000262 zst.next_out = (unsigned char *)PyString_AS_STRING(result_str) \
Jeremy Hylton9714f992001-10-16 21:19:45 +0000263 + r_strlen;
264 zst.avail_out = r_strlen;
Jeremy Hylton41b9f001997-08-13 23:19:55 +0000265 r_strlen = r_strlen << 1;
266 break;
Jeremy Hylton0965e082001-10-16 21:56:09 +0000267 default:
Jeremy Hylton9714f992001-10-16 21:19:45 +0000268 inflateEnd(&zst);
Jeremy Hylton0965e082001-10-16 21:56:09 +0000269 zlib_error(zst, err, "while decompressing data");
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000270 goto error;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000271 }
272 } while (err != Z_STREAM_END);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000273
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000274 err = inflateEnd(&zst);
275 if (err != Z_OK) {
276 zlib_error(zst, err, "while finishing data decompression");
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000277 goto error;
Guido van Rossumfb221561997-04-29 15:38:09 +0000278 }
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000279
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000280 _PyString_Resize(&result_str, zst.total_out);
Jeremy Hylton9714f992001-10-16 21:19:45 +0000281 return result_str;
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000282
283 error:
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000284 Py_XDECREF(result_str);
285 return NULL;
Guido van Rossumfb221561997-04-29 15:38:09 +0000286}
287
288static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000289PyZlib_compressobj(PyObject *selfptr, PyObject *args)
Guido van Rossumfb221561997-04-29 15:38:09 +0000290{
Jeremy Hylton499000002001-10-16 21:59:35 +0000291 compobject *self;
292 int level=Z_DEFAULT_COMPRESSION, method=DEFLATED;
293 int wbits=MAX_WBITS, memLevel=DEF_MEM_LEVEL, strategy=0, err;
Jeremy Hylton41b9f001997-08-13 23:19:55 +0000294
Jeremy Hylton499000002001-10-16 21:59:35 +0000295 if (!PyArg_ParseTuple(args, "|iiiii:compressobj", &level, &method, &wbits,
296 &memLevel, &strategy))
297 return NULL;
Jeremy Hylton41b9f001997-08-13 23:19:55 +0000298
Jeremy Hylton499000002001-10-16 21:59:35 +0000299 self = newcompobject(&Comptype);
Tim Peters977e5402001-10-17 03:57:20 +0000300 if (self==NULL)
Jeremy Hylton499000002001-10-16 21:59:35 +0000301 return(NULL);
302 self->zst.zalloc = (alloc_func)NULL;
303 self->zst.zfree = (free_func)Z_NULL;
304 err = deflateInit2(&self->zst, level, method, wbits, memLevel, strategy);
305 switch(err) {
Guido van Rossumfb221561997-04-29 15:38:09 +0000306 case (Z_OK):
Jeremy Hylton499000002001-10-16 21:59:35 +0000307 self->is_initialised = 1;
308 return (PyObject*)self;
Guido van Rossumfb221561997-04-29 15:38:09 +0000309 case (Z_MEM_ERROR):
Jeremy Hylton499000002001-10-16 21:59:35 +0000310 Py_DECREF(self);
311 PyErr_SetString(PyExc_MemoryError,
312 "Can't allocate memory for compression object");
313 return NULL;
Guido van Rossumfb221561997-04-29 15:38:09 +0000314 case(Z_STREAM_ERROR):
Jeremy Hylton499000002001-10-16 21:59:35 +0000315 Py_DECREF(self);
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000316 PyErr_SetString(PyExc_ValueError, "Invalid initialization option");
Jeremy Hylton499000002001-10-16 21:59:35 +0000317 return NULL;
Guido van Rossumfb221561997-04-29 15:38:09 +0000318 default:
Jeremy Hylton0965e082001-10-16 21:56:09 +0000319 zlib_error(self->zst, err, "while creating compression object");
Andrew M. Kuchling1c7aaa21999-01-29 21:49:34 +0000320 Py_DECREF(self);
Guido van Rossumfb221561997-04-29 15:38:09 +0000321 return NULL;
Guido van Rossumfb221561997-04-29 15:38:09 +0000322 }
323}
324
325static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000326PyZlib_decompressobj(PyObject *selfptr, PyObject *args)
Guido van Rossumfb221561997-04-29 15:38:09 +0000327{
Jeremy Hylton499000002001-10-16 21:59:35 +0000328 int wbits=DEF_WBITS, err;
329 compobject *self;
330 if (!PyArg_ParseTuple(args, "|i:decompressobj", &wbits))
331 return NULL;
332
333 self = newcompobject(&Decomptype);
Tim Peters977e5402001-10-17 03:57:20 +0000334 if (self == NULL)
Jeremy Hylton499000002001-10-16 21:59:35 +0000335 return(NULL);
336 self->zst.zalloc = (alloc_func)NULL;
337 self->zst.zfree = (free_func)Z_NULL;
338 err = inflateInit2(&self->zst, wbits);
339 switch(err) {
Guido van Rossumfb221561997-04-29 15:38:09 +0000340 case (Z_OK):
Jeremy Hylton499000002001-10-16 21:59:35 +0000341 self->is_initialised = 1;
342 return (PyObject*)self;
Jeremy Hyltoncb914041997-09-04 23:39:23 +0000343 case(Z_STREAM_ERROR):
Jeremy Hylton499000002001-10-16 21:59:35 +0000344 Py_DECREF(self);
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000345 PyErr_SetString(PyExc_ValueError, "Invalid initialization option");
Jeremy Hylton499000002001-10-16 21:59:35 +0000346 return NULL;
Guido van Rossumfb221561997-04-29 15:38:09 +0000347 case (Z_MEM_ERROR):
Jeremy Hylton499000002001-10-16 21:59:35 +0000348 Py_DECREF(self);
349 PyErr_SetString(PyExc_MemoryError,
350 "Can't allocate memory for decompression object");
351 return NULL;
Guido van Rossumfb221561997-04-29 15:38:09 +0000352 default:
Jeremy Hylton0965e082001-10-16 21:56:09 +0000353 zlib_error(self->zst, err, "while creating decompression object");
Andrew M. Kuchling1c7aaa21999-01-29 21:49:34 +0000354 Py_DECREF(self);
Guido van Rossumfb221561997-04-29 15:38:09 +0000355 return NULL;
Jeremy Hylton499000002001-10-16 21:59:35 +0000356 }
Guido van Rossumfb221561997-04-29 15:38:09 +0000357}
358
359static void
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000360Comp_dealloc(compobject *self)
Guido van Rossumfb221561997-04-29 15:38:09 +0000361{
Andrew M. Kuchling1c7aaa21999-01-29 21:49:34 +0000362 if (self->is_initialised)
Jeremy Hylton499000002001-10-16 21:59:35 +0000363 deflateEnd(&self->zst);
Andrew M. Kuchlingb95227d1999-03-25 21:21:08 +0000364 Py_XDECREF(self->unused_data);
Jeremy Hylton511e2ca2001-10-16 20:39:49 +0000365 Py_XDECREF(self->unconsumed_tail);
Guido van Rossumb18618d2000-05-03 23:44:39 +0000366 PyObject_Del(self);
Guido van Rossumfb221561997-04-29 15:38:09 +0000367}
368
369static void
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000370Decomp_dealloc(compobject *self)
Guido van Rossumfb221561997-04-29 15:38:09 +0000371{
Andrew M. Kuchling9aff4a22001-02-21 02:15:56 +0000372 if (self->is_initialised)
Jeremy Hylton499000002001-10-16 21:59:35 +0000373 inflateEnd(&self->zst);
Andrew M. Kuchlingb95227d1999-03-25 21:21:08 +0000374 Py_XDECREF(self->unused_data);
Jeremy Hylton511e2ca2001-10-16 20:39:49 +0000375 Py_XDECREF(self->unconsumed_tail);
Guido van Rossumb18618d2000-05-03 23:44:39 +0000376 PyObject_Del(self);
Guido van Rossumfb221561997-04-29 15:38:09 +0000377}
378
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000379PyDoc_STRVAR(comp_compress__doc__,
Tim Petersadbd35b2001-10-17 04:16:15 +0000380"compress(data) -- Return a string containing data compressed.\n"
381"\n"
Guido van Rossum3c540301997-06-03 22:21:03 +0000382"After calling this function, some of the input data may still\n"
383"be stored in internal buffers for later processing.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000384"Call the flush() method to clear these buffers.");
Guido van Rossum3c540301997-06-03 22:21:03 +0000385
386
Guido van Rossumfb221561997-04-29 15:38:09 +0000387static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000388PyZlib_objcompress(compobject *self, PyObject *args)
Guido van Rossumfb221561997-04-29 15:38:09 +0000389{
Jeremy Hylton9714f992001-10-16 21:19:45 +0000390 int err, inplen, length = DEFAULTALLOC;
391 PyObject *RetVal;
392 Byte *input;
393 unsigned long start_total_out;
Tim Peters977e5402001-10-17 03:57:20 +0000394
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000395 if (!PyArg_ParseTuple(args, "s#:compress", &input, &inplen))
Jeremy Hylton9714f992001-10-16 21:19:45 +0000396 return NULL;
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000397
Jeremy Hylton9bc9d662001-10-16 21:23:58 +0000398 if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
Jeremy Hylton9714f992001-10-16 21:19:45 +0000399 return NULL;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000400
401 ENTER_ZLIB
402
Jeremy Hylton9714f992001-10-16 21:19:45 +0000403 start_total_out = self->zst.total_out;
404 self->zst.avail_in = inplen;
405 self->zst.next_in = input;
Andrew M. Kuchling9aff4a22001-02-21 02:15:56 +0000406 self->zst.avail_out = length;
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000407 self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
Jeremy Hylton9714f992001-10-16 21:19:45 +0000408
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000409 Py_BEGIN_ALLOW_THREADS
Andrew M. Kuchling9aff4a22001-02-21 02:15:56 +0000410 err = deflate(&(self->zst), Z_NO_FLUSH);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000411 Py_END_ALLOW_THREADS
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000412
Jeremy Hylton9714f992001-10-16 21:19:45 +0000413 /* while Z_OK and the output buffer is full, there might be more output,
414 so extend the output buffer and try again */
415 while (err == Z_OK && self->zst.avail_out == 0) {
Tim Peters5de98422002-04-27 18:44:32 +0000416 if (_PyString_Resize(&RetVal, length << 1) < 0)
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000417 goto error;
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000418 self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
Jeremy Hylton9714f992001-10-16 21:19:45 +0000419 + length;
420 self->zst.avail_out = length;
421 length = length << 1;
Tim Peters977e5402001-10-17 03:57:20 +0000422
Jeremy Hylton9714f992001-10-16 21:19:45 +0000423 Py_BEGIN_ALLOW_THREADS
424 err = deflate(&(self->zst), Z_NO_FLUSH);
425 Py_END_ALLOW_THREADS
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000426 }
Tim Peters977e5402001-10-17 03:57:20 +0000427 /* We will only get Z_BUF_ERROR if the output buffer was full but
Jeremy Hylton9714f992001-10-16 21:19:45 +0000428 there wasn't more output when we tried again, so it is not an error
Tim Peters977e5402001-10-17 03:57:20 +0000429 condition.
430 */
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000431
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000432 if (err != Z_OK && err != Z_BUF_ERROR) {
433 zlib_error(self->zst, err, "while compressing");
434 Py_DECREF(RetVal);
435 RetVal = NULL;
436 goto error;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000437 }
Tim Peters5de98422002-04-27 18:44:32 +0000438 _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000439
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000440 error:
Jeremy Hylton9714f992001-10-16 21:19:45 +0000441 LEAVE_ZLIB
Jeremy Hylton9714f992001-10-16 21:19:45 +0000442 return RetVal;
Guido van Rossumfb221561997-04-29 15:38:09 +0000443}
444
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000445PyDoc_STRVAR(decomp_decompress__doc__,
Tim Petersadbd35b2001-10-17 04:16:15 +0000446"decompress(data, max_length) -- Return a string containing the decompressed\n"
447"version of the data.\n"
448"\n"
449"After calling this function, some of the input data may still be stored in\n"
450"internal buffers for later processing.\n"
Jeremy Hylton511e2ca2001-10-16 20:39:49 +0000451"Call the flush() method to clear these buffers.\n"
452"If the max_length parameter is specified then the return value will be\n"
453"no longer than max_length. Unconsumed input data will be stored in\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000454"the unconsumed_tail attribute.");
Guido van Rossum3c540301997-06-03 22:21:03 +0000455
Guido van Rossumfb221561997-04-29 15:38:09 +0000456static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000457PyZlib_objdecompress(compobject *self, PyObject *args)
Guido van Rossumfb221561997-04-29 15:38:09 +0000458{
Jeremy Hylton9714f992001-10-16 21:19:45 +0000459 int err, inplen, old_length, length = DEFAULTALLOC;
460 int max_length = 0;
461 PyObject *RetVal;
462 Byte *input;
463 unsigned long start_total_out;
Jeremy Hyltoncb914041997-09-04 23:39:23 +0000464
Tim Peters977e5402001-10-17 03:57:20 +0000465 if (!PyArg_ParseTuple(args, "s#|i:decompress", &input,
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000466 &inplen, &max_length))
Jeremy Hylton9714f992001-10-16 21:19:45 +0000467 return NULL;
468 if (max_length < 0) {
469 PyErr_SetString(PyExc_ValueError,
470 "max_length must be greater than zero");
471 return NULL;
Andrew M. Kuchling9aff4a22001-02-21 02:15:56 +0000472 }
Jeremy Hylton9714f992001-10-16 21:19:45 +0000473
Jeremy Hylton9714f992001-10-16 21:19:45 +0000474 /* limit amount of data allocated to max_length */
Tim Peters977e5402001-10-17 03:57:20 +0000475 if (max_length && length > max_length)
Jeremy Hylton9714f992001-10-16 21:19:45 +0000476 length = max_length;
Jeremy Hylton9bc9d662001-10-16 21:23:58 +0000477 if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
Jeremy Hylton9714f992001-10-16 21:19:45 +0000478 return NULL;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000479
480 ENTER_ZLIB
Jeremy Hylton9714f992001-10-16 21:19:45 +0000481
Jeremy Hylton9714f992001-10-16 21:19:45 +0000482 start_total_out = self->zst.total_out;
483 self->zst.avail_in = inplen;
484 self->zst.next_in = input;
485 self->zst.avail_out = length;
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000486 self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
Jeremy Hylton511e2ca2001-10-16 20:39:49 +0000487
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000488 Py_BEGIN_ALLOW_THREADS
Andrew M. Kuchling9aff4a22001-02-21 02:15:56 +0000489 err = inflate(&(self->zst), Z_SYNC_FLUSH);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000490 Py_END_ALLOW_THREADS
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000491
Jeremy Hylton9714f992001-10-16 21:19:45 +0000492 /* While Z_OK and the output buffer is full, there might be more output.
493 So extend the output buffer and try again.
494 */
Tim Peters977e5402001-10-17 03:57:20 +0000495 while (err == Z_OK && self->zst.avail_out == 0) {
Jeremy Hylton9714f992001-10-16 21:19:45 +0000496 /* If max_length set, don't continue decompressing if we've already
497 reached the limit.
498 */
499 if (max_length && length >= max_length)
500 break;
Jeremy Hylton511e2ca2001-10-16 20:39:49 +0000501
Jeremy Hylton9714f992001-10-16 21:19:45 +0000502 /* otherwise, ... */
503 old_length = length;
504 length = length << 1;
Tim Peters977e5402001-10-17 03:57:20 +0000505 if (max_length && length > max_length)
Jeremy Hylton9714f992001-10-16 21:19:45 +0000506 length = max_length;
507
Tim Peters5de98422002-04-27 18:44:32 +0000508 if (_PyString_Resize(&RetVal, length) < 0)
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000509 goto error;
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000510 self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
Jeremy Hylton9714f992001-10-16 21:19:45 +0000511 + old_length;
512 self->zst.avail_out = length - old_length;
513
514 Py_BEGIN_ALLOW_THREADS
515 err = inflate(&(self->zst), Z_SYNC_FLUSH);
516 Py_END_ALLOW_THREADS
Guido van Rossumfb221561997-04-29 15:38:09 +0000517 }
Jeremy Hylton9714f992001-10-16 21:19:45 +0000518
519 /* Not all of the compressed data could be accomodated in the output buffer
520 of specified size. Return the unconsumed tail in an attribute.*/
521 if(max_length) {
522 Py_DECREF(self->unconsumed_tail);
Jack Jansen72af01a2001-10-23 22:29:06 +0000523 self->unconsumed_tail = PyString_FromStringAndSize((char *)self->zst.next_in,
Jeremy Hylton9714f992001-10-16 21:19:45 +0000524 self->zst.avail_in);
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000525 if(!self->unconsumed_tail) {
526 Py_DECREF(RetVal);
527 RetVal = NULL;
528 goto error;
529 }
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000530 }
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000531
Tim Peters977e5402001-10-17 03:57:20 +0000532 /* The end of the compressed data has been reached, so set the
533 unused_data attribute to a string containing the remainder of the
534 data in the string. Note that this is also a logical place to call
Jeremy Hylton9714f992001-10-16 21:19:45 +0000535 inflateEnd, but the old behaviour of only calling it on flush() is
536 preserved.
537 */
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000538 if (err == Z_STREAM_END) {
539 Py_XDECREF(self->unused_data); /* Free original empty string */
540 self->unused_data = PyString_FromStringAndSize(
541 (char *)self->zst.next_in, self->zst.avail_in);
542 if (self->unused_data == NULL) {
Jeremy Hylton9714f992001-10-16 21:19:45 +0000543 Py_DECREF(RetVal);
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000544 goto error;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000545 }
Tim Peters977e5402001-10-17 03:57:20 +0000546 /* We will only get Z_BUF_ERROR if the output buffer was full
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000547 but there wasn't more output when we tried again, so it is
548 not an error condition.
549 */
550 } else if (err != Z_OK && err != Z_BUF_ERROR) {
551 zlib_error(self->zst, err, "while decompressing");
552 Py_DECREF(RetVal);
553 RetVal = NULL;
554 goto error;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000555 }
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000556
Tim Peters5de98422002-04-27 18:44:32 +0000557 _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000558
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000559 error:
Jeremy Hylton9714f992001-10-16 21:19:45 +0000560 LEAVE_ZLIB
561
562 return RetVal;
Guido van Rossumfb221561997-04-29 15:38:09 +0000563}
564
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000565PyDoc_STRVAR(comp_flush__doc__,
Jeremy Hyltona37e2441998-12-18 22:13:11 +0000566"flush( [mode] ) -- Return a string containing any remaining compressed data.\n"
Tim Petersadbd35b2001-10-17 04:16:15 +0000567"\n"
568"mode can be one of the constants Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH; the\n"
Jeremy Hyltona37e2441998-12-18 22:13:11 +0000569"default value used when mode is not specified is Z_FINISH.\n"
570"If mode == Z_FINISH, the compressor object can no longer be used after\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000571"calling the flush() method. Otherwise, more data can still be compressed.");
Guido van Rossum3c540301997-06-03 22:21:03 +0000572
Guido van Rossumfb221561997-04-29 15:38:09 +0000573static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000574PyZlib_flush(compobject *self, PyObject *args)
Guido van Rossumfb221561997-04-29 15:38:09 +0000575{
Jeremy Hylton9714f992001-10-16 21:19:45 +0000576 int err, length = DEFAULTALLOC;
577 PyObject *RetVal;
578 int flushmode = Z_FINISH;
579 unsigned long start_total_out;
Jeremy Hyltona37e2441998-12-18 22:13:11 +0000580
Jeremy Hylton9714f992001-10-16 21:19:45 +0000581 if (!PyArg_ParseTuple(args, "|i:flush", &flushmode))
582 return NULL;
Jeremy Hyltona37e2441998-12-18 22:13:11 +0000583
Jeremy Hylton9714f992001-10-16 21:19:45 +0000584 /* Flushing with Z_NO_FLUSH is a no-op, so there's no point in
585 doing any work at all; just return an empty string. */
586 if (flushmode == Z_NO_FLUSH) {
587 return PyString_FromStringAndSize(NULL, 0);
Andrew M. Kuchling9aff4a22001-02-21 02:15:56 +0000588 }
Jeremy Hylton9714f992001-10-16 21:19:45 +0000589
Jeremy Hylton9bc9d662001-10-16 21:23:58 +0000590 if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
Jeremy Hylton9714f992001-10-16 21:19:45 +0000591 return NULL;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000592
593 ENTER_ZLIB
Tim Peters977e5402001-10-17 03:57:20 +0000594
Jeremy Hylton9714f992001-10-16 21:19:45 +0000595 start_total_out = self->zst.total_out;
596 self->zst.avail_in = 0;
Andrew M. Kuchling9aff4a22001-02-21 02:15:56 +0000597 self->zst.avail_out = length;
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000598 self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000599
600 Py_BEGIN_ALLOW_THREADS
Andrew M. Kuchling9aff4a22001-02-21 02:15:56 +0000601 err = deflate(&(self->zst), flushmode);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000602 Py_END_ALLOW_THREADS
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000603
Jeremy Hylton9714f992001-10-16 21:19:45 +0000604 /* while Z_OK and the output buffer is full, there might be more output,
605 so extend the output buffer and try again */
606 while (err == Z_OK && self->zst.avail_out == 0) {
Tim Peters5de98422002-04-27 18:44:32 +0000607 if (_PyString_Resize(&RetVal, length << 1) < 0)
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000608 goto error;
Jeremy Hyltonba3dd992001-10-16 23:26:08 +0000609 self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
Jeremy Hylton9714f992001-10-16 21:19:45 +0000610 + length;
611 self->zst.avail_out = length;
612 length = length << 1;
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000613
Jeremy Hylton9714f992001-10-16 21:19:45 +0000614 Py_BEGIN_ALLOW_THREADS
615 err = deflate(&(self->zst), flushmode);
616 Py_END_ALLOW_THREADS
Jeremy Hyltona37e2441998-12-18 22:13:11 +0000617 }
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000618
Jeremy Hylton9714f992001-10-16 21:19:45 +0000619 /* If flushmode is Z_FINISH, we also have to call deflateEnd() to free
Tim Peters977e5402001-10-17 03:57:20 +0000620 various data structures. Note we should only get Z_STREAM_END when
Jeremy Hylton9714f992001-10-16 21:19:45 +0000621 flushmode is Z_FINISH, but checking both for safety*/
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000622 if (err == Z_STREAM_END && flushmode == Z_FINISH) {
623 err = deflateEnd(&(self->zst));
624 if (err != Z_OK) {
625 zlib_error(self->zst, err, "from deflateEnd()");
Jeremy Hylton9714f992001-10-16 21:19:45 +0000626 Py_DECREF(RetVal);
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000627 RetVal = NULL;
628 goto error;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000629 }
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000630 else
631 self->is_initialised = 0;
Tim Peters977e5402001-10-17 03:57:20 +0000632
633 /* We will only get Z_BUF_ERROR if the output buffer was full
634 but there wasn't more output when we tried again, so it is
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000635 not an error condition.
636 */
637 } else if (err!=Z_OK && err!=Z_BUF_ERROR) {
638 zlib_error(self->zst, err, "while flushing");
639 Py_DECREF(RetVal);
640 RetVal = NULL;
Jeremy Hyltonc72737e2002-04-19 14:37:07 +0000641 goto error;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000642 }
Tim Peters977e5402001-10-17 03:57:20 +0000643
Tim Peters5de98422002-04-27 18:44:32 +0000644 _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000645
Tim Peters977e5402001-10-17 03:57:20 +0000646 error:
Tim Petersb1a37c02001-10-17 03:56:45 +0000647 LEAVE_ZLIB
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000648
649 return RetVal;
Guido van Rossumfb221561997-04-29 15:38:09 +0000650}
651
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000652PyDoc_STRVAR(decomp_flush__doc__,
Tim Petersadbd35b2001-10-17 04:16:15 +0000653"flush() -- Return a string containing any remaining decompressed data.\n"
654"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000655"The decompressor object can no longer be used after this call.");
Guido van Rossum3c540301997-06-03 22:21:03 +0000656
Guido van Rossumfb221561997-04-29 15:38:09 +0000657static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000658PyZlib_unflush(compobject *self, PyObject *args)
Tim Peters977e5402001-10-17 03:57:20 +0000659/*decompressor flush is a no-op because all pending data would have been
Andrew M. Kuchling9aff4a22001-02-21 02:15:56 +0000660 flushed by the decompress method. However, this routine previously called
Tim Peters977e5402001-10-17 03:57:20 +0000661 inflateEnd, causing any further decompress or flush calls to raise
Andrew M. Kuchling9aff4a22001-02-21 02:15:56 +0000662 exceptions. This behaviour has been preserved.*/
Guido van Rossumfb221561997-04-29 15:38:09 +0000663{
Jeremy Hylton9714f992001-10-16 21:19:45 +0000664 int err;
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000665 PyObject * retval = NULL;
Tim Peters977e5402001-10-17 03:57:20 +0000666
Jeremy Hylton9714f992001-10-16 21:19:45 +0000667 if (!PyArg_ParseTuple(args, ""))
668 return NULL;
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000669
Jeremy Hylton9714f992001-10-16 21:19:45 +0000670 ENTER_ZLIB
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000671
Jeremy Hylton9714f992001-10-16 21:19:45 +0000672 err = inflateEnd(&(self->zst));
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000673 if (err != Z_OK)
Jeremy Hylton0965e082001-10-16 21:56:09 +0000674 zlib_error(self->zst, err, "from inflateEnd()");
Jeremy Hylton9d620d02001-10-16 23:02:32 +0000675 else {
Jeremy Hylton9714f992001-10-16 21:19:45 +0000676 self->is_initialised = 0;
677 retval = PyString_FromStringAndSize(NULL, 0);
678 }
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000679
Jeremy Hylton9714f992001-10-16 21:19:45 +0000680 LEAVE_ZLIB
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000681
Jeremy Hylton9714f992001-10-16 21:19:45 +0000682 return retval;
Guido van Rossumfb221561997-04-29 15:38:09 +0000683}
684
685static PyMethodDef comp_methods[] =
686{
Tim Peters977e5402001-10-17 03:57:20 +0000687 {"compress", (binaryfunc)PyZlib_objcompress, METH_VARARGS,
Jeremy Hylton9714f992001-10-16 21:19:45 +0000688 comp_compress__doc__},
Tim Peters977e5402001-10-17 03:57:20 +0000689 {"flush", (binaryfunc)PyZlib_flush, METH_VARARGS,
Jeremy Hylton9714f992001-10-16 21:19:45 +0000690 comp_flush__doc__},
691 {NULL, NULL}
Guido van Rossumfb221561997-04-29 15:38:09 +0000692};
693
694static PyMethodDef Decomp_methods[] =
695{
Tim Peters977e5402001-10-17 03:57:20 +0000696 {"decompress", (binaryfunc)PyZlib_objdecompress, METH_VARARGS,
Jeremy Hylton9714f992001-10-16 21:19:45 +0000697 decomp_decompress__doc__},
Tim Peters977e5402001-10-17 03:57:20 +0000698 {"flush", (binaryfunc)PyZlib_unflush, METH_VARARGS,
Jeremy Hylton9714f992001-10-16 21:19:45 +0000699 decomp_flush__doc__},
700 {NULL, NULL}
Guido van Rossumfb221561997-04-29 15:38:09 +0000701};
702
703static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000704Comp_getattr(compobject *self, char *name)
Guido van Rossumfb221561997-04-29 15:38:09 +0000705{
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000706 /* No ENTER/LEAVE_ZLIB is necessary because this fn doesn't touch
707 internal data. */
708
709 return Py_FindMethod(comp_methods, (PyObject *)self, name);
Guido van Rossumfb221561997-04-29 15:38:09 +0000710}
711
712static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000713Decomp_getattr(compobject *self, char *name)
Guido van Rossumfb221561997-04-29 15:38:09 +0000714{
Jeremy Hylton9714f992001-10-16 21:19:45 +0000715 PyObject * retval;
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000716
Jeremy Hylton9714f992001-10-16 21:19:45 +0000717 ENTER_ZLIB
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000718
Tim Peters977e5402001-10-17 03:57:20 +0000719 if (strcmp(name, "unused_data") == 0) {
Jeremy Hylton9714f992001-10-16 21:19:45 +0000720 Py_INCREF(self->unused_data);
721 retval = self->unused_data;
Tim Peters977e5402001-10-17 03:57:20 +0000722 } else if (strcmp(name, "unconsumed_tail") == 0) {
Jeremy Hylton9714f992001-10-16 21:19:45 +0000723 Py_INCREF(self->unconsumed_tail);
724 retval = self->unconsumed_tail;
Tim Peters977e5402001-10-17 03:57:20 +0000725 } else
Jeremy Hylton9714f992001-10-16 21:19:45 +0000726 retval = Py_FindMethod(Decomp_methods, (PyObject *)self, name);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000727
Jeremy Hylton9714f992001-10-16 21:19:45 +0000728 LEAVE_ZLIB
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000729
Jeremy Hylton9714f992001-10-16 21:19:45 +0000730 return retval;
Guido van Rossumfb221561997-04-29 15:38:09 +0000731}
732
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000733PyDoc_STRVAR(adler32__doc__,
Tim Petersadbd35b2001-10-17 04:16:15 +0000734"adler32(string[, start]) -- Compute an Adler-32 checksum of string.\n"
735"\n"
736"An optional starting value can be specified. The returned checksum is\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000737"an integer.");
Guido van Rossum3c540301997-06-03 22:21:03 +0000738
Guido van Rossumfb221561997-04-29 15:38:09 +0000739static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000740PyZlib_adler32(PyObject *self, PyObject *args)
Guido van Rossumfb221561997-04-29 15:38:09 +0000741{
Jeremy Hylton9714f992001-10-16 21:19:45 +0000742 uLong adler32val = adler32(0L, Z_NULL, 0);
Jeremy Hyltoncb914041997-09-04 23:39:23 +0000743 Byte *buf;
744 int len;
Tim Peters977e5402001-10-17 03:57:20 +0000745
Guido van Rossum43713e52000-02-29 13:59:29 +0000746 if (!PyArg_ParseTuple(args, "s#|l:adler32", &buf, &len, &adler32val))
Jeremy Hyltoncb914041997-09-04 23:39:23 +0000747 return NULL;
Jeremy Hyltoncb914041997-09-04 23:39:23 +0000748 adler32val = adler32(adler32val, buf, len);
749 return PyInt_FromLong(adler32val);
Guido van Rossumfb221561997-04-29 15:38:09 +0000750}
Tim Peters977e5402001-10-17 03:57:20 +0000751
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000752PyDoc_STRVAR(crc32__doc__,
Tim Petersadbd35b2001-10-17 04:16:15 +0000753"crc32(string[, start]) -- Compute a CRC-32 checksum of string.\n"
754"\n"
755"An optional starting value can be specified. The returned checksum is\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000756"an integer.");
Guido van Rossumfb221561997-04-29 15:38:09 +0000757
758static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000759PyZlib_crc32(PyObject *self, PyObject *args)
Guido van Rossumfb221561997-04-29 15:38:09 +0000760{
Jeremy Hylton9714f992001-10-16 21:19:45 +0000761 uLong crc32val = crc32(0L, Z_NULL, 0);
Jeremy Hyltoncb914041997-09-04 23:39:23 +0000762 Byte *buf;
763 int len;
Guido van Rossum43713e52000-02-29 13:59:29 +0000764 if (!PyArg_ParseTuple(args, "s#|l:crc32", &buf, &len, &crc32val))
Jeremy Hyltoncb914041997-09-04 23:39:23 +0000765 return NULL;
Jeremy Hyltoncb914041997-09-04 23:39:23 +0000766 crc32val = crc32(crc32val, buf, len);
767 return PyInt_FromLong(crc32val);
Guido van Rossumfb221561997-04-29 15:38:09 +0000768}
Tim Peters977e5402001-10-17 03:57:20 +0000769
Guido van Rossumfb221561997-04-29 15:38:09 +0000770
771static PyMethodDef zlib_methods[] =
772{
Tim Peters977e5402001-10-17 03:57:20 +0000773 {"adler32", (PyCFunction)PyZlib_adler32, METH_VARARGS,
Jeremy Hylton9714f992001-10-16 21:19:45 +0000774 adler32__doc__},
Tim Peters977e5402001-10-17 03:57:20 +0000775 {"compress", (PyCFunction)PyZlib_compress, METH_VARARGS,
Jeremy Hylton9714f992001-10-16 21:19:45 +0000776 compress__doc__},
Tim Peters977e5402001-10-17 03:57:20 +0000777 {"compressobj", (PyCFunction)PyZlib_compressobj, METH_VARARGS,
Jeremy Hylton9714f992001-10-16 21:19:45 +0000778 compressobj__doc__},
Tim Peters977e5402001-10-17 03:57:20 +0000779 {"crc32", (PyCFunction)PyZlib_crc32, METH_VARARGS,
780 crc32__doc__},
781 {"decompress", (PyCFunction)PyZlib_decompress, METH_VARARGS,
Jeremy Hylton9714f992001-10-16 21:19:45 +0000782 decompress__doc__},
Tim Peters977e5402001-10-17 03:57:20 +0000783 {"decompressobj", (PyCFunction)PyZlib_decompressobj, METH_VARARGS,
Jeremy Hylton9714f992001-10-16 21:19:45 +0000784 decompressobj__doc__},
785 {NULL, NULL}
Guido van Rossumfb221561997-04-29 15:38:09 +0000786};
787
Tim Peters0c322792002-07-17 16:49:03 +0000788static PyTypeObject Comptype = {
Jeremy Hylton9714f992001-10-16 21:19:45 +0000789 PyObject_HEAD_INIT(0)
790 0,
Guido van Rossum14648392001-12-08 18:02:58 +0000791 "zlib.Compress",
Jeremy Hylton9714f992001-10-16 21:19:45 +0000792 sizeof(compobject),
793 0,
794 (destructor)Comp_dealloc, /*tp_dealloc*/
795 0, /*tp_print*/
796 (getattrfunc)Comp_getattr, /*tp_getattr*/
797 0, /*tp_setattr*/
798 0, /*tp_compare*/
799 0, /*tp_repr*/
800 0, /*tp_as_number*/
801 0, /*tp_as_sequence*/
802 0, /*tp_as_mapping*/
Guido van Rossumfb221561997-04-29 15:38:09 +0000803};
804
Tim Peters0c322792002-07-17 16:49:03 +0000805static PyTypeObject Decomptype = {
Jeremy Hylton9714f992001-10-16 21:19:45 +0000806 PyObject_HEAD_INIT(0)
807 0,
Guido van Rossum14648392001-12-08 18:02:58 +0000808 "zlib.Decompress",
Jeremy Hylton9714f992001-10-16 21:19:45 +0000809 sizeof(compobject),
810 0,
811 (destructor)Decomp_dealloc, /*tp_dealloc*/
812 0, /*tp_print*/
813 (getattrfunc)Decomp_getattr, /*tp_getattr*/
814 0, /*tp_setattr*/
815 0, /*tp_compare*/
816 0, /*tp_repr*/
817 0, /*tp_as_number*/
818 0, /*tp_as_sequence*/
819 0, /*tp_as_mapping*/
Guido van Rossumfb221561997-04-29 15:38:09 +0000820};
821
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000822PyDoc_STRVAR(zlib_module_documentation,
Tim Petersadbd35b2001-10-17 04:16:15 +0000823"The functions in this module allow compression and decompression using the\n"
824"zlib library, which is based on GNU zip.\n"
825"\n"
826"adler32(string[, start]) -- Compute an Adler-32 checksum.\n"
827"compress(string[, level]) -- Compress string, with compression level in 1-9.\n"
Guido van Rossum3c540301997-06-03 22:21:03 +0000828"compressobj([level]) -- Return a compressor object.\n"
Tim Petersadbd35b2001-10-17 04:16:15 +0000829"crc32(string[, start]) -- Compute a CRC-32 checksum.\n"
Andrew M. Kuchling313a3e31999-12-20 22:13:38 +0000830"decompress(string,[wbits],[bufsize]) -- Decompresses a compressed string.\n"
Tim Petersadbd35b2001-10-17 04:16:15 +0000831"decompressobj([wbits]) -- Return a decompressor object.\n"
832"\n"
833"'wbits' is window buffer size.\n"
834"Compressor objects support compress() and flush() methods; decompressor\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000835"objects support decompress() and flush().");
Guido van Rossum3c540301997-06-03 22:21:03 +0000836
Mark Hammond62b1ab12002-07-23 06:31:15 +0000837PyMODINIT_FUNC
Thomas Woutersf3f33dc2000-07-21 06:00:07 +0000838PyInit_zlib(void)
Guido van Rossumfb221561997-04-29 15:38:09 +0000839{
Fred Drake4baedc12002-04-01 14:53:37 +0000840 PyObject *m, *ver;
Jeremy Hylton9714f992001-10-16 21:19:45 +0000841 Comptype.ob_type = &PyType_Type;
842 Decomptype.ob_type = &PyType_Type;
843 m = Py_InitModule4("zlib", zlib_methods,
844 zlib_module_documentation,
845 (PyObject*)NULL,PYTHON_API_VERSION);
Jeremy Hyltoncb914041997-09-04 23:39:23 +0000846
Fred Drake4baedc12002-04-01 14:53:37 +0000847 ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
848 if (ZlibError != NULL) {
849 Py_INCREF(ZlibError);
850 PyModule_AddObject(m, "error", ZlibError);
851 }
Jeremy Hylton9714f992001-10-16 21:19:45 +0000852 PyModule_AddIntConstant(m, "MAX_WBITS", MAX_WBITS);
853 PyModule_AddIntConstant(m, "DEFLATED", DEFLATED);
854 PyModule_AddIntConstant(m, "DEF_MEM_LEVEL", DEF_MEM_LEVEL);
855 PyModule_AddIntConstant(m, "Z_BEST_SPEED", Z_BEST_SPEED);
856 PyModule_AddIntConstant(m, "Z_BEST_COMPRESSION", Z_BEST_COMPRESSION);
857 PyModule_AddIntConstant(m, "Z_DEFAULT_COMPRESSION", Z_DEFAULT_COMPRESSION);
858 PyModule_AddIntConstant(m, "Z_FILTERED", Z_FILTERED);
859 PyModule_AddIntConstant(m, "Z_HUFFMAN_ONLY", Z_HUFFMAN_ONLY);
860 PyModule_AddIntConstant(m, "Z_DEFAULT_STRATEGY", Z_DEFAULT_STRATEGY);
Tim Peters977e5402001-10-17 03:57:20 +0000861
Jeremy Hylton9714f992001-10-16 21:19:45 +0000862 PyModule_AddIntConstant(m, "Z_FINISH", Z_FINISH);
863 PyModule_AddIntConstant(m, "Z_NO_FLUSH", Z_NO_FLUSH);
864 PyModule_AddIntConstant(m, "Z_SYNC_FLUSH", Z_SYNC_FLUSH);
865 PyModule_AddIntConstant(m, "Z_FULL_FLUSH", Z_FULL_FLUSH);
Tim Peters977e5402001-10-17 03:57:20 +0000866
Jeremy Hylton9714f992001-10-16 21:19:45 +0000867 ver = PyString_FromString(ZLIB_VERSION);
Fred Drake4baedc12002-04-01 14:53:37 +0000868 if (ver != NULL)
869 PyModule_AddObject(m, "ZLIB_VERSION", ver);
Martin v. Löwis3bd8c1e2001-09-07 16:27:31 +0000870
871#ifdef WITH_THREAD
Jeremy Hylton9714f992001-10-16 21:19:45 +0000872 zlib_lock = PyThread_allocate_lock();
Sjoerd Mullender556a9382002-03-11 09:20:47 +0000873#endif /* WITH_THREAD */
Guido van Rossumfb221561997-04-29 15:38:09 +0000874}