diff options
| -rw-r--r-- | Modules/zlibmodule.c | 1162 |
1 files changed, 576 insertions, 586 deletions
diff --git a/Modules/zlibmodule.c b/Modules/zlibmodule.c index 2d9e777..7a9dcf0 100644 --- a/Modules/zlibmodule.c +++ b/Modules/zlibmodule.c @@ -75,11 +75,11 @@ static PyObject *ZlibError; typedef struct { - PyObject_HEAD - z_stream zst; - PyObject *unused_data; - PyObject *unconsumed_tail; - int is_initialised; + PyObject_HEAD + z_stream zst; + PyObject *unused_data; + PyObject *unconsumed_tail; + int is_initialised; } compobject; static char compressobj__doc__[] = @@ -95,22 +95,22 @@ static char decompressobj__doc__[] = static compobject * newcompobject(PyTypeObject *type) { - compobject *self; - self = PyObject_New(compobject, type); - if (self == NULL) - return NULL; - self->is_initialised = 0; - self->unused_data = PyString_FromString(""); - if (self->unused_data == NULL) { - Py_DECREF(self); - return NULL; - } - self->unconsumed_tail = PyString_FromString(""); - if (self->unconsumed_tail == NULL) { - Py_DECREF(self); - return NULL; - } - return self; + compobject *self; + self = PyObject_New(compobject, type); + if (self == NULL) + return NULL; + self->is_initialised = 0; + self->unused_data = PyString_FromString(""); + if (self->unused_data == NULL) { + Py_DECREF(self); + return NULL; + } + self->unconsumed_tail = PyString_FromString(""); + if (self->unconsumed_tail == NULL) { + Py_DECREF(self); + return NULL; + } + return self; } static char compress__doc__[] = @@ -123,62 +123,61 @@ static char compress__doc__[] = static PyObject * PyZlib_compress(PyObject *self, PyObject *args) { - PyObject *ReturnVal = NULL; - Byte *input, *output; - int length, level=Z_DEFAULT_COMPRESSION, err; - z_stream zst; - int return_error; - PyObject * inputString; + PyObject *ReturnVal = NULL; + Byte *input, *output; + int length, level=Z_DEFAULT_COMPRESSION, err; + z_stream zst; + int return_error; + PyObject * inputString; - /* require Python string object, optional 'level' arg */ - if (!PyArg_ParseTuple(args, "S|i:compress", &inputString, &level)) - return NULL; + /* require Python string object, optional 'level' arg */ + if (!PyArg_ParseTuple(args, "S|i:compress", &inputString, &level)) + return NULL; - /* now get a pointer to the internal string */ - if (PyString_AsStringAndSize(inputString, (char**)&input, &length) == -1) - return NULL; + /* now get a pointer to the internal string */ + if (PyString_AsStringAndSize(inputString, (char**)&input, &length) == -1) + return NULL; - zst.avail_out = length + length/1000 + 12 + 1; + zst.avail_out = length + length/1000 + 12 + 1; - output=(Byte*)malloc(zst.avail_out); - if (output==NULL) + output=(Byte*)malloc(zst.avail_out); + if (output==NULL) { - PyErr_SetString(PyExc_MemoryError, - "Can't allocate memory to compress data"); - free(output); + PyErr_SetString(PyExc_MemoryError, + "Can't allocate memory to compress data"); + free(output); - return NULL; + return NULL; } - /* Past the point of no return. From here on out, we need to make sure - we clean up mallocs & INCREFs. */ + /* Past the point of no return. From here on out, we need to make sure + we clean up mallocs & INCREFs. */ - Py_INCREF(inputString); /* increment so that we hold ref */ + Py_INCREF(inputString); /* increment so that we hold ref */ - zst.zalloc=(alloc_func)NULL; - zst.zfree=(free_func)Z_NULL; - zst.next_out=(Byte *)output; - zst.next_in =(Byte *)input; - zst.avail_in=length; - err=deflateInit(&zst, level); + zst.zalloc=(alloc_func)NULL; + zst.zfree=(free_func)Z_NULL; + zst.next_out=(Byte *)output; + zst.next_in =(Byte *)input; + zst.avail_in=length; + err=deflateInit(&zst, level); - return_error = 0; - switch(err) + return_error = 0; + switch(err) { case(Z_OK): - break; + break; case(Z_MEM_ERROR): - PyErr_SetString(PyExc_MemoryError, - "Out of memory while compressing data"); - return_error = 1; - break; + PyErr_SetString(PyExc_MemoryError, + "Out of memory while compressing data"); + return_error = 1; + break; case(Z_STREAM_ERROR): - PyErr_SetString(ZlibError, - "Bad compression level"); - return_error = 1; - break; - default: - { + PyErr_SetString(ZlibError, + "Bad compression level"); + return_error = 1; + break; + default: { if (zst.msg == Z_NULL) PyErr_Format(ZlibError, "Error %i while compressing data", err); @@ -187,57 +186,55 @@ PyZlib_compress(PyObject *self, PyObject *args) err, zst.msg); deflateEnd(&zst); return_error = 1; - } + } } - if (!return_error) { - Py_BEGIN_ALLOW_THREADS - err=deflate(&zst, Z_FINISH); - Py_END_ALLOW_THREADS + if (!return_error) { + Py_BEGIN_ALLOW_THREADS; + err=deflate(&zst, Z_FINISH); + Py_END_ALLOW_THREADS; - switch(err) - { - case(Z_STREAM_END): - break; - /* Are there other errors to be trapped here? */ - default: + switch(err) { - if (zst.msg == Z_NULL) - PyErr_Format(ZlibError, "Error %i while compressing data", - err); - else - PyErr_Format(ZlibError, "Error %i while compressing data: %.200s", - err, zst.msg); + case(Z_STREAM_END): + break; + /* Are there other errors to be trapped here? */ + default: { + if (zst.msg == Z_NULL) + PyErr_Format(ZlibError, "Error %i while compressing data", + err); + else + PyErr_Format(ZlibError, "Error %i while compressing data: %.200s", + err, zst.msg); - deflateEnd(&zst); + deflateEnd(&zst); - return_error = 1; + return_error = 1; + } } - } - if (!return_error) { - err=deflateEnd(&zst); - if (err == Z_OK) - ReturnVal = PyString_FromStringAndSize((char *)output, zst.total_out); - else { - { - if (zst.msg == Z_NULL) - PyErr_Format(ZlibError, "Error %i while finishing compression", - err); - else - PyErr_Format(ZlibError, - "Error %i while finishing compression: %.200s", - err, zst.msg); + if (!return_error) { + err=deflateEnd(&zst); + if (err == Z_OK) + ReturnVal = PyString_FromStringAndSize((char *)output, + zst.total_out); + else { + if (zst.msg == Z_NULL) + PyErr_Format(ZlibError, + "Error %i while finishing compression", + err); + else + PyErr_Format(ZlibError, + "Error %i while finishing compression: %.200s", + err, zst.msg); + } } - } - } - } - free(output); - Py_DECREF(inputString); + free(output); + Py_DECREF(inputString); - return ReturnVal; + return ReturnVal; } static char decompress__doc__[] = @@ -249,54 +246,52 @@ static char decompress__doc__[] = static PyObject * PyZlib_decompress(PyObject *self, PyObject *args) { - PyObject *result_str; - Byte *input; - int length, err; - int wsize=DEF_WBITS, r_strlen=DEFAULTALLOC; - z_stream zst; - int return_error; - PyObject * inputString; - - if (!PyArg_ParseTuple(args, "S|ii:decompress", &inputString, &wsize, &r_strlen)) - return NULL; - if (PyString_AsStringAndSize(inputString, (char**)&input, &length) == -1) - return NULL; - - if (r_strlen <= 0) - r_strlen = 1; - - zst.avail_in=length; - zst.avail_out=r_strlen; - - if (!(result_str = PyString_FromStringAndSize(NULL, r_strlen))) - { - PyErr_SetString(PyExc_MemoryError, - "Can't allocate memory to decompress data"); - return NULL; - } + PyObject *result_str; + Byte *input; + int length, err; + int wsize=DEF_WBITS, r_strlen=DEFAULTALLOC; + z_stream zst; + int return_error; + PyObject * inputString; + + if (!PyArg_ParseTuple(args, "S|ii:decompress", + &inputString, &wsize, &r_strlen)) + return NULL; + if (PyString_AsStringAndSize(inputString, (char**)&input, &length) == -1) + return NULL; - /* Past the point of no return. From here on out, we need to make sure - we clean up mallocs & INCREFs. */ + if (r_strlen <= 0) + r_strlen = 1; - Py_INCREF(inputString); /* increment so that we hold ref */ + zst.avail_in = length; + zst.avail_out = r_strlen; - zst.zalloc=(alloc_func)NULL; - zst.zfree=(free_func)Z_NULL; - zst.next_out=(Byte *)PyString_AsString(result_str); - zst.next_in =(Byte *)input; - err=inflateInit2(&zst, wsize); + if (!(result_str = PyString_FromStringAndSize(NULL, r_strlen))) { + PyErr_SetString(PyExc_MemoryError, + "Can't allocate memory to decompress data"); + return NULL; + } - return_error = 0; - switch(err) - { + /* Past the point of no return. From here on out, we need to make sure + we clean up mallocs & INCREFs. */ + + Py_INCREF(inputString); /* increment so that we hold ref */ + + zst.zalloc = (alloc_func)NULL; + zst.zfree = (free_func)Z_NULL; + zst.next_out = (Byte *)PyString_AsString(result_str); + zst.next_in = (Byte *)input; + err = inflateInit2(&zst, wsize); + + return_error = 0; + switch(err) { case(Z_OK): - break; + break; case(Z_MEM_ERROR): - PyErr_SetString(PyExc_MemoryError, - "Out of memory while decompressing data"); - return_error = 1; - default: - { + PyErr_SetString(PyExc_MemoryError, + "Out of memory while decompressing data"); + return_error = 1; + default: { if (zst.msg == Z_NULL) PyErr_Format(ZlibError, "Error %i preparing to decompress data", err); @@ -307,21 +302,19 @@ PyZlib_decompress(PyObject *self, PyObject *args) inflateEnd(&zst); return_error = 1; - } + } } - do - { - if (return_error) - break; + do { + if (return_error) + break; - Py_BEGIN_ALLOW_THREADS - err=inflate(&zst, Z_FINISH); - Py_END_ALLOW_THREADS + Py_BEGIN_ALLOW_THREADS + err=inflate(&zst, Z_FINISH); + Py_END_ALLOW_THREADS - switch(err) - { - case(Z_STREAM_END): + switch(err) { + case(Z_STREAM_END): break; case(Z_BUF_ERROR): /* @@ -330,69 +323,66 @@ PyZlib_decompress(PyObject *self, PyObject *args) * process the inflate call() due to an error in the data. */ if (zst.avail_out > 0) - { - PyErr_Format(ZlibError, "Error %i while decompressing data", - err); - inflateEnd(&zst); - return_error = 1; - break; - } + { + PyErr_Format(ZlibError, "Error %i while decompressing data", + err); + inflateEnd(&zst); + return_error = 1; + break; + } /* fall through */ case(Z_OK): /* need more memory */ - if (_PyString_Resize(&result_str, r_strlen << 1) == -1) - { - PyErr_SetString(PyExc_MemoryError, - "Out of memory while decompressing data"); - inflateEnd(&zst); - result_str = NULL; - return_error = 1; - } - zst.next_out = (unsigned char *)PyString_AsString(result_str) + r_strlen; - zst.avail_out=r_strlen; + if (_PyString_Resize(&result_str, r_strlen << 1) == -1) { + PyErr_SetString(PyExc_MemoryError, + "Out of memory while decompressing data"); + inflateEnd(&zst); + result_str = NULL; + return_error = 1; + } + zst.next_out = (unsigned char *)PyString_AsString(result_str) \ + + r_strlen; + zst.avail_out = r_strlen; r_strlen = r_strlen << 1; break; - default: - { - if (zst.msg == Z_NULL) - PyErr_Format(ZlibError, "Error %i while decompressing data", - err); - else - PyErr_Format(ZlibError, - "Error %i while decompressing data: %.200s", - err, zst.msg); - inflateEnd(&zst); + default: { + if (zst.msg == Z_NULL) + PyErr_Format(ZlibError, "Error %i while decompressing data", + err); + else + PyErr_Format(ZlibError, + "Error %i while decompressing data: %.200s", + err, zst.msg); + inflateEnd(&zst); return_error = 1; - } - } - } while(err!=Z_STREAM_END); + } + } + } while (err != Z_STREAM_END); - if (!return_error) { - err=inflateEnd(&zst); - if (err!=Z_OK) - { - if (zst.msg == Z_NULL) - PyErr_Format(ZlibError, - "Error %i while finishing data decompression", - err); - else - PyErr_Format(ZlibError, - "Error %i while finishing data decompression: %.200s", - err, zst.msg); + if (!return_error) { + err = inflateEnd(&zst); + if (err != Z_OK) { + if (zst.msg == Z_NULL) + PyErr_Format(ZlibError, + "Error %i while finishing data decompression", + err); + else + PyErr_Format(ZlibError, + "Error %i while finishing data decompression: %.200s", + err, zst.msg); - return_error = 1; - return NULL; + return_error = 1; + return NULL; + } } - } - if (!return_error) - _PyString_Resize(&result_str, zst.total_out); - else { - Py_XDECREF(result_str); /* sets result_str == NULL, if not already */ - } - Py_DECREF(inputString); + if (!return_error) + _PyString_Resize(&result_str, zst.total_out); + else + Py_XDECREF(result_str); /* sets result_str == NULL, if not already */ + Py_DECREF(inputString); - return result_str; + return result_str; } static PyObject * @@ -526,84 +516,87 @@ static char comp_compress__doc__[] = static PyObject * PyZlib_objcompress(compobject *self, PyObject *args) { - int err, inplen, length = DEFAULTALLOC; - PyObject *RetVal; - Byte *input; - unsigned long start_total_out; - int return_error; - PyObject * inputString; + int err, inplen, length = DEFAULTALLOC; + PyObject *RetVal; + Byte *input; + unsigned long start_total_out; + int return_error; + PyObject * inputString; - if (!PyArg_ParseTuple(args, "S:compress", &inputString)) - return NULL; - if (PyString_AsStringAndSize(inputString, (char**)&input, &inplen) == -1) - return NULL; - - if (!(RetVal = PyString_FromStringAndSize(NULL, length))) { - PyErr_SetString(PyExc_MemoryError, - "Can't allocate memory to compress data"); - return NULL; - } + if (!PyArg_ParseTuple(args, "S:compress", &inputString)) + return NULL; + if (PyString_AsStringAndSize(inputString, (char**)&input, &inplen) == -1) + return NULL; + + if (!(RetVal = PyString_FromStringAndSize(NULL, length))) { + PyErr_SetString(PyExc_MemoryError, + "Can't allocate memory to compress data"); + return NULL; + } - ENTER_ZLIB + ENTER_ZLIB - Py_INCREF(inputString); + Py_INCREF(inputString); - start_total_out = self->zst.total_out; - self->zst.avail_in = inplen; - self->zst.next_in = input; - self->zst.avail_out = length; - self->zst.next_out = (unsigned char *)PyString_AsString(RetVal); - - Py_BEGIN_ALLOW_THREADS - err = deflate(&(self->zst), Z_NO_FLUSH); - Py_END_ALLOW_THREADS - - return_error = 0; - - /* while Z_OK and the output buffer is full, there might be more output, - so extend the output buffer and try again */ - while (err == Z_OK && self->zst.avail_out == 0) { - if (_PyString_Resize(&RetVal, length << 1) == -1) { - PyErr_SetString(PyExc_MemoryError, - "Can't allocate memory to compress data"); - return_error = 1; - break; - } - self->zst.next_out = (unsigned char *)PyString_AsString(RetVal) + length; + start_total_out = self->zst.total_out; + self->zst.avail_in = inplen; + self->zst.next_in = input; self->zst.avail_out = length; - length = length << 1; - + self->zst.next_out = (unsigned char *)PyString_AsString(RetVal); + Py_BEGIN_ALLOW_THREADS err = deflate(&(self->zst), Z_NO_FLUSH); Py_END_ALLOW_THREADS - } - /* We will only get Z_BUF_ERROR if the output buffer was full but there - wasn't more output when we tried again, so it is not an error condition */ - - if (!return_error) { - if (err != Z_OK && err != Z_BUF_ERROR) { - if (self->zst.msg == Z_NULL) - PyErr_Format(ZlibError, "Error %i while compressing", - err); - else - PyErr_Format(ZlibError, "Error %i while compressing: %.200s", - err, self->zst.msg); - - return_error = 1; - Py_DECREF(RetVal); + + return_error = 0; + + /* while Z_OK and the output buffer is full, there might be more output, + so extend the output buffer and try again */ + while (err == Z_OK && self->zst.avail_out == 0) { + if (_PyString_Resize(&RetVal, length << 1) == -1) { + PyErr_SetString(PyExc_MemoryError, + "Can't allocate memory to compress data"); + return_error = 1; + break; + } + self->zst.next_out = (unsigned char *)PyString_AsString(RetVal) \ + + length; + self->zst.avail_out = length; + length = length << 1; + + Py_BEGIN_ALLOW_THREADS + err = deflate(&(self->zst), Z_NO_FLUSH); + Py_END_ALLOW_THREADS } - } + /* We will only get Z_BUF_ERROR if the output buffer was full but + there wasn't more output when we tried again, so it is not an error + condition. + */ - if (return_error) - RetVal = NULL; /* should have been handled by DECREF */ - else - _PyString_Resize(&RetVal, self->zst.total_out - start_total_out); + if (!return_error) { + if (err != Z_OK && err != Z_BUF_ERROR) { + if (self->zst.msg == Z_NULL) + PyErr_Format(ZlibError, "Error %i while compressing", + err); + else + PyErr_Format(ZlibError, "Error %i while compressing: %.200s", + err, self->zst.msg); + + return_error = 1; + Py_DECREF(RetVal); + } + } + + if (return_error) + RetVal = NULL; /* should have been handled by DECREF */ + else + _PyString_Resize(&RetVal, self->zst.total_out - start_total_out); - Py_DECREF(inputString); + Py_DECREF(inputString); - LEAVE_ZLIB + LEAVE_ZLIB - return RetVal; + return RetVal; } static char decomp_decompress__doc__[] = @@ -620,130 +613,134 @@ static char decomp_decompress__doc__[] = static PyObject * PyZlib_objdecompress(compobject *self, PyObject *args) { - int err, inplen, old_length, length = DEFAULTALLOC; - int max_length = 0; - PyObject *RetVal; - Byte *input; - unsigned long start_total_out; - int return_error; - PyObject * inputString; - - if (!PyArg_ParseTuple(args, "S|i:decompress", &inputString, &max_length)) - return NULL; - if (max_length < 0) { - PyErr_SetString(PyExc_ValueError, - "max_length must be greater than zero"); - return NULL; - } + int err, inplen, old_length, length = DEFAULTALLOC; + int max_length = 0; + PyObject *RetVal; + Byte *input; + unsigned long start_total_out; + int return_error; + PyObject * inputString; + + if (!PyArg_ParseTuple(args, "S|i:decompress", &inputString, &max_length)) + return NULL; + if (max_length < 0) { + PyErr_SetString(PyExc_ValueError, + "max_length must be greater than zero"); + return NULL; + } - if (PyString_AsStringAndSize(inputString, (char**)&input, &inplen) == -1) - return NULL; + if (PyString_AsStringAndSize(inputString, (char**)&input, &inplen) == -1) + return NULL; - /* limit amount of data allocated to max_length */ - if (max_length && length > max_length) - length = max_length; - if (!(RetVal = PyString_FromStringAndSize(NULL, length))) { - PyErr_SetString(PyExc_MemoryError, - "Can't allocate memory to compress data"); - return NULL; - } + /* limit amount of data allocated to max_length */ + if (max_length && length > max_length) + length = max_length; + if (!(RetVal = PyString_FromStringAndSize(NULL, length))) { + PyErr_SetString(PyExc_MemoryError, + "Can't allocate memory to compress data"); + return NULL; + } - ENTER_ZLIB - return_error = 0; + ENTER_ZLIB + return_error = 0; - Py_INCREF(inputString); + Py_INCREF(inputString); - start_total_out = self->zst.total_out; - self->zst.avail_in = inplen; - self->zst.next_in = input; - self->zst.avail_out = length; - self->zst.next_out = (unsigned char *)PyString_AsString(RetVal); + start_total_out = self->zst.total_out; + self->zst.avail_in = inplen; + self->zst.next_in = input; + self->zst.avail_out = length; + self->zst.next_out = (unsigned char *)PyString_AsString(RetVal); - Py_BEGIN_ALLOW_THREADS - err = inflate(&(self->zst), Z_SYNC_FLUSH); - Py_END_ALLOW_THREADS + Py_BEGIN_ALLOW_THREADS + err = inflate(&(self->zst), Z_SYNC_FLUSH); + Py_END_ALLOW_THREADS - /* While Z_OK and the output buffer is full, there might be more output. - So extend the output buffer and try again. - */ - while (err == Z_OK && self->zst.avail_out == 0) { - /* If max_length set, don't continue decompressing if we've already - reached the limit. + /* While Z_OK and the output buffer is full, there might be more output. + So extend the output buffer and try again. */ - if (max_length && length >= max_length) - break; + while (err == Z_OK && self->zst.avail_out == 0) { + /* If max_length set, don't continue decompressing if we've already + reached the limit. + */ + if (max_length && length >= max_length) + break; - /* otherwise, ... */ - old_length = length; - length = length << 1; - if (max_length && length > max_length) - length = max_length; + /* otherwise, ... */ + old_length = length; + length = length << 1; + if (max_length && length > max_length) + length = max_length; - if (_PyString_Resize(&RetVal, length) == -1) { - PyErr_SetString(PyExc_MemoryError, - "Can't allocate memory to compress data"); - return_error = 1; - break; - } - self->zst.next_out = (unsigned char *)PyString_AsString(RetVal)+old_length; - self->zst.avail_out = length - old_length; - - Py_BEGIN_ALLOW_THREADS - err = inflate(&(self->zst), Z_SYNC_FLUSH); - Py_END_ALLOW_THREADS - } + if (_PyString_Resize(&RetVal, length) == -1) { + PyErr_SetString(PyExc_MemoryError, + "Can't allocate memory to compress data"); + return_error = 1; + break; + } + self->zst.next_out = (unsigned char *)PyString_AsString(RetVal) \ + + old_length; + self->zst.avail_out = length - old_length; - /* Not all of the compressed data could be accomodated in the output buffer - of specified size. Return the unconsumed tail in an attribute.*/ - if(max_length) { - Py_DECREF(self->unconsumed_tail); - self->unconsumed_tail = PyString_FromStringAndSize(self->zst.next_in, - self->zst.avail_in); - if(!self->unconsumed_tail) - return_error = 1; - } + Py_BEGIN_ALLOW_THREADS + err = inflate(&(self->zst), Z_SYNC_FLUSH); + Py_END_ALLOW_THREADS + } - /* The end of the compressed data has been reached, so set the unused_data - attribute to a string containing the remainder of the data in the string. - Note that this is also a logical place to call inflateEnd, but the old - behaviour of only calling it on flush() is preserved.*/ - if (!return_error) { - if (err == Z_STREAM_END) { - Py_XDECREF(self->unused_data); /* Free the original, empty string */ - self->unused_data = PyString_FromStringAndSize((char *)self->zst.next_in, - self->zst.avail_in); - if (self->unused_data == NULL) { - PyErr_SetString(PyExc_MemoryError, - "Can't allocate memory to unused_data"); - Py_DECREF(RetVal); - return_error = 1; + /* Not all of the compressed data could be accomodated in the output buffer + of specified size. Return the unconsumed tail in an attribute.*/ + if(max_length) { + Py_DECREF(self->unconsumed_tail); + self->unconsumed_tail = PyString_FromStringAndSize(self->zst.next_in, + self->zst.avail_in); + if(!self->unconsumed_tail) + return_error = 1; } - /* We will only get Z_BUF_ERROR if the output buffer was full but there - wasn't more output when we tried again, so it is not an error - condition */ - } else if (err != Z_OK && err != Z_BUF_ERROR) { - if (self->zst.msg == Z_NULL) - PyErr_Format(ZlibError, "Error %i while decompressing", - err); - else - PyErr_Format(ZlibError, "Error %i while decompressing: %.200s", - err, self->zst.msg); - Py_DECREF(RetVal); - return_error = 1; + + /* The end of the compressed data has been reached, so set the + unused_data attribute to a string containing the remainder of the + data in the string. Note that this is also a logical place to call + inflateEnd, but the old behaviour of only calling it on flush() is + preserved. + */ + if (!return_error) { + if (err == Z_STREAM_END) { + Py_XDECREF(self->unused_data); /* Free original empty string */ + self->unused_data = PyString_FromStringAndSize( + (char *)self->zst.next_in, self->zst.avail_in); + if (self->unused_data == NULL) { + PyErr_SetString(PyExc_MemoryError, + "Can't allocate memory to unused_data"); + Py_DECREF(RetVal); + return_error = 1; + } + /* We will only get Z_BUF_ERROR if the output buffer was full + but there wasn't more output when we tried again, so it is + not an error condition. + */ + } else if (err != Z_OK && err != Z_BUF_ERROR) { + if (self->zst.msg == Z_NULL) + PyErr_Format(ZlibError, "Error %i while decompressing", + err); + else + PyErr_Format(ZlibError, "Error %i while decompressing: %.200s", + err, self->zst.msg); + Py_DECREF(RetVal); + return_error = 1; + } } - } - if (!return_error) { - _PyString_Resize(&RetVal, self->zst.total_out - start_total_out); - } - else - RetVal = NULL; /* should be handled by DECREF */ + if (!return_error) { + _PyString_Resize(&RetVal, self->zst.total_out - start_total_out); + } + else + RetVal = NULL; /* should be handled by DECREF */ - Py_DECREF(inputString); + Py_DECREF(inputString); - LEAVE_ZLIB + LEAVE_ZLIB - return RetVal; + return RetVal; } static char comp_flush__doc__[] = @@ -757,101 +754,103 @@ static char comp_flush__doc__[] = static PyObject * PyZlib_flush(compobject *self, PyObject *args) { - int err, length=DEFAULTALLOC; - PyObject *RetVal; - int flushmode = Z_FINISH; - unsigned long start_total_out; - int return_error; - - if (!PyArg_ParseTuple(args, "|i:flush", &flushmode)) - return NULL; - - /* Flushing with Z_NO_FLUSH is a no-op, so there's no point in - doing any work at all; just return an empty string. */ - if (flushmode == Z_NO_FLUSH) { - return PyString_FromStringAndSize(NULL, 0); - } - - if (!(RetVal = PyString_FromStringAndSize(NULL, length))) { - PyErr_SetString(PyExc_MemoryError, - "Can't allocate memory to compress data"); - return NULL; - } - - ENTER_ZLIB - - start_total_out = self->zst.total_out; - self->zst.avail_in = 0; - self->zst.avail_out = length; - self->zst.next_out = (unsigned char *)PyString_AsString(RetVal); + int err, length = DEFAULTALLOC; + PyObject *RetVal; + int flushmode = Z_FINISH; + unsigned long start_total_out; + int return_error; - Py_BEGIN_ALLOW_THREADS - err = deflate(&(self->zst), flushmode); - Py_END_ALLOW_THREADS + if (!PyArg_ParseTuple(args, "|i:flush", &flushmode)) + return NULL; - return_error = 0; + /* Flushing with Z_NO_FLUSH is a no-op, so there's no point in + doing any work at all; just return an empty string. */ + if (flushmode == Z_NO_FLUSH) { + return PyString_FromStringAndSize(NULL, 0); + } - /* while Z_OK and the output buffer is full, there might be more output, - so extend the output buffer and try again */ - while (err == Z_OK && self->zst.avail_out == 0) { - if (_PyString_Resize(&RetVal, length << 1) == -1) { - PyErr_SetString(PyExc_MemoryError, - "Can't allocate memory to compress data"); - return_error = 1; - break; + if (!(RetVal = PyString_FromStringAndSize(NULL, length))) { + PyErr_SetString(PyExc_MemoryError, + "Can't allocate memory to compress data"); + return NULL; } - self->zst.next_out = (unsigned char *)PyString_AsString(RetVal) + length; + + ENTER_ZLIB + + start_total_out = self->zst.total_out; + self->zst.avail_in = 0; self->zst.avail_out = length; - length = length << 1; + self->zst.next_out = (unsigned char *)PyString_AsString(RetVal); Py_BEGIN_ALLOW_THREADS err = deflate(&(self->zst), flushmode); Py_END_ALLOW_THREADS - } - /* If flushmode is Z_FINISH, we also have to call deflateEnd() to free - various data structures. Note we should only get Z_STREAM_END when - flushmode is Z_FINISH, but checking both for safety*/ - if (!return_error) { - if (err == Z_STREAM_END && flushmode == Z_FINISH) { - err=deflateEnd(&(self->zst)); - if (err!=Z_OK) { - if (self->zst.msg == Z_NULL) - PyErr_Format(ZlibError, "Error %i from deflateEnd()", - err); - else - PyErr_Format(ZlibError,"Error %i from deflateEnd(): %.200s", - err, self->zst.msg); + return_error = 0; - Py_DECREF(RetVal); - return_error = 1; - } - else - self->is_initialised = 0; + /* while Z_OK and the output buffer is full, there might be more output, + so extend the output buffer and try again */ + while (err == Z_OK && self->zst.avail_out == 0) { + if (_PyString_Resize(&RetVal, length << 1) == -1) { + PyErr_SetString(PyExc_MemoryError, + "Can't allocate memory to compress data"); + return_error = 1; + break; + } + self->zst.next_out = (unsigned char *)PyString_AsString(RetVal) \ + + length; + self->zst.avail_out = length; + length = length << 1; + + Py_BEGIN_ALLOW_THREADS + err = deflate(&(self->zst), flushmode); + Py_END_ALLOW_THREADS + } - /* We will only get Z_BUF_ERROR if the output buffer was full but there - wasn't more output when we tried again, so it is not an error - condition */ - } else if (err!=Z_OK && err!=Z_BUF_ERROR) { - if (self->zst.msg == Z_NULL) - PyErr_Format(ZlibError, "Error %i while flushing", - err); - else - PyErr_Format(ZlibError, "Error %i while flushing: %.200s", - err, self->zst.msg); - Py_DECREF(RetVal); - return_error = 1; + /* If flushmode is Z_FINISH, we also have to call deflateEnd() to free + various data structures. Note we should only get Z_STREAM_END when + flushmode is Z_FINISH, but checking both for safety*/ + if (!return_error) { + if (err == Z_STREAM_END && flushmode == Z_FINISH) { + err = deflateEnd(&(self->zst)); + if (err != Z_OK) { + if (self->zst.msg == Z_NULL) + PyErr_Format(ZlibError, "Error %i from deflateEnd()", + err); + else + PyErr_Format(ZlibError, + "Error %i from deflateEnd(): %.200s", + err, self->zst.msg); + + Py_DECREF(RetVal); + return_error = 1; + } else + self->is_initialised = 0; + + /* We will only get Z_BUF_ERROR if the output buffer was full + but there wasn't more output when we tried again, so it is + not an error condition. + */ + } else if (err!=Z_OK && err!=Z_BUF_ERROR) { + if (self->zst.msg == Z_NULL) + PyErr_Format(ZlibError, "Error %i while flushing", + err); + else + PyErr_Format(ZlibError, "Error %i while flushing: %.200s", + err, self->zst.msg); + Py_DECREF(RetVal); + return_error = 1; + } } - } - if (!return_error) - _PyString_Resize(&RetVal, self->zst.total_out - start_total_out); - else - RetVal = NULL; /* should have been handled by DECREF */ + if (!return_error) + _PyString_Resize(&RetVal, self->zst.total_out - start_total_out); + else + RetVal = NULL; /* should have been handled by DECREF */ - LEAVE_ZLIB + LEAVE_ZLIB - return RetVal; + return RetVal; } static char decomp_flush__doc__[] = @@ -866,51 +865,50 @@ PyZlib_unflush(compobject *self, PyObject *args) inflateEnd, causing any further decompress or flush calls to raise exceptions. This behaviour has been preserved.*/ { - int err; - PyObject * retval; + int err; + PyObject * retval; - if (!PyArg_ParseTuple(args, "")) - return NULL; - - ENTER_ZLIB + if (!PyArg_ParseTuple(args, "")) + return NULL; - err=inflateEnd(&(self->zst)); - if (err!=Z_OK) { - if (self->zst.msg == Z_NULL) - PyErr_Format(ZlibError, "Error %i from inflateEnd()", - err); - else - PyErr_Format(ZlibError, "Error %i from inflateEnd(): %.200s", - err, self->zst.msg); + ENTER_ZLIB - retval = NULL; + err = inflateEnd(&(self->zst)); + if (err != Z_OK) { + if (self->zst.msg == Z_NULL) + PyErr_Format(ZlibError, "Error %i from inflateEnd()", + err); + else + PyErr_Format(ZlibError, "Error %i from inflateEnd(): %.200s", + err, self->zst.msg); - } else { - self->is_initialised = 0; - retval = PyString_FromStringAndSize(NULL, 0); - } + retval = NULL; + } else { + self->is_initialised = 0; + retval = PyString_FromStringAndSize(NULL, 0); + } - LEAVE_ZLIB + LEAVE_ZLIB - return retval; + return retval; } static PyMethodDef comp_methods[] = { - {"compress", (binaryfunc)PyZlib_objcompress, - METH_VARARGS, comp_compress__doc__}, - {"flush", (binaryfunc)PyZlib_flush, - METH_VARARGS, comp_flush__doc__}, - {NULL, NULL} + {"compress", (binaryfunc)PyZlib_objcompress, METH_VARARGS, + comp_compress__doc__}, + {"flush", (binaryfunc)PyZlib_flush, METH_VARARGS, + comp_flush__doc__}, + {NULL, NULL} }; static PyMethodDef Decomp_methods[] = { - {"decompress", (binaryfunc)PyZlib_objdecompress, - METH_VARARGS, decomp_decompress__doc__}, - {"flush", (binaryfunc)PyZlib_unflush, - METH_VARARGS, decomp_flush__doc__}, - {NULL, NULL} + {"decompress", (binaryfunc)PyZlib_objdecompress, METH_VARARGS, + decomp_decompress__doc__}, + {"flush", (binaryfunc)PyZlib_unflush, METH_VARARGS, + decomp_flush__doc__}, + {NULL, NULL} }; static PyObject * @@ -925,26 +923,22 @@ Comp_getattr(compobject *self, char *name) static PyObject * Decomp_getattr(compobject *self, char *name) { - PyObject * retval; - - ENTER_ZLIB - - if (strcmp(name, "unused_data") == 0) - { - Py_INCREF(self->unused_data); - retval = self->unused_data; - } - else if (strcmp(name, "unconsumed_tail") == 0) - { - Py_INCREF(self->unconsumed_tail); - retval = self->unconsumed_tail; - } - else - retval = Py_FindMethod(Decomp_methods, (PyObject *)self, name); - - LEAVE_ZLIB - - return retval; + PyObject * retval; + + ENTER_ZLIB + + if (strcmp(name, "unused_data") == 0) { + Py_INCREF(self->unused_data); + retval = self->unused_data; + } else if (strcmp(name, "unconsumed_tail") == 0) { + Py_INCREF(self->unconsumed_tail); + retval = self->unconsumed_tail; + } else + retval = Py_FindMethod(Decomp_methods, (PyObject *)self, name); + + LEAVE_ZLIB + + return retval; } static char adler32__doc__[] = @@ -957,14 +951,12 @@ static char adler32__doc__[] = static PyObject * PyZlib_adler32(PyObject *self, PyObject *args) { - uLong adler32val=adler32(0L, Z_NULL, 0); + uLong adler32val = adler32(0L, Z_NULL, 0); Byte *buf; int len; if (!PyArg_ParseTuple(args, "s#|l:adler32", &buf, &len, &adler32val)) - { return NULL; - } adler32val = adler32(adler32val, buf, len); return PyInt_FromLong(adler32val); } @@ -979,13 +971,11 @@ static char crc32__doc__[] = static PyObject * PyZlib_crc32(PyObject *self, PyObject *args) { - uLong crc32val=crc32(0L, Z_NULL, 0); + uLong crc32val = crc32(0L, Z_NULL, 0); Byte *buf; int len; if (!PyArg_ParseTuple(args, "s#|l:crc32", &buf, &len, &crc32val)) - { return NULL; - } crc32val = crc32(crc32val, buf, len); return PyInt_FromLong(crc32val); } @@ -993,53 +983,53 @@ PyZlib_crc32(PyObject *self, PyObject *args) static PyMethodDef zlib_methods[] = { - {"adler32", (PyCFunction)PyZlib_adler32, - METH_VARARGS, adler32__doc__}, - {"compress", (PyCFunction)PyZlib_compress, - METH_VARARGS, compress__doc__}, - {"compressobj", (PyCFunction)PyZlib_compressobj, - METH_VARARGS, compressobj__doc__}, - {"crc32", (PyCFunction)PyZlib_crc32, - METH_VARARGS, crc32__doc__}, - {"decompress", (PyCFunction)PyZlib_decompress, - METH_VARARGS, decompress__doc__}, - {"decompressobj", (PyCFunction)PyZlib_decompressobj, - METH_VARARGS, decompressobj__doc__}, - {NULL, NULL} + {"adler32", (PyCFunction)PyZlib_adler32, METH_VARARGS, + adler32__doc__}, + {"compress", (PyCFunction)PyZlib_compress, METH_VARARGS, + compress__doc__}, + {"compressobj", (PyCFunction)PyZlib_compressobj, METH_VARARGS, + compressobj__doc__}, + {"crc32", (PyCFunction)PyZlib_crc32, METH_VARARGS, + crc32__doc__}, + {"decompress", (PyCFunction)PyZlib_decompress, METH_VARARGS, + decompress__doc__}, + {"decompressobj", (PyCFunction)PyZlib_decompressobj, METH_VARARGS, + decompressobj__doc__}, + {NULL, NULL} }; statichere PyTypeObject Comptype = { - PyObject_HEAD_INIT(0) - 0, - "Compress", - sizeof(compobject), - 0, - (destructor)Comp_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (getattrfunc)Comp_getattr, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ + PyObject_HEAD_INIT(0) + 0, + "Compress", + sizeof(compobject), + 0, + (destructor)Comp_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)Comp_getattr, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ }; statichere PyTypeObject Decomptype = { - PyObject_HEAD_INIT(0) - 0, - "Decompress", - sizeof(compobject), - 0, - (destructor)Decomp_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (getattrfunc)Decomp_getattr, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ + PyObject_HEAD_INIT(0) + 0, + "Decompress", + sizeof(compobject), + 0, + (destructor)Decomp_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)Decomp_getattr, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ }; /* The following insint() routine was blatantly ripped off from @@ -1080,39 +1070,39 @@ static char zlib_module_documentation[]= DL_EXPORT(void) PyInit_zlib(void) { - PyObject *m, *d, *ver; - Comptype.ob_type = &PyType_Type; - Decomptype.ob_type = &PyType_Type; - m = Py_InitModule4("zlib", zlib_methods, - zlib_module_documentation, - (PyObject*)NULL,PYTHON_API_VERSION); - d = PyModule_GetDict(m); - ZlibError = PyErr_NewException("zlib.error", NULL, NULL); - if (ZlibError != NULL) - PyDict_SetItemString(d, "error", ZlibError); - - insint(d, "MAX_WBITS", MAX_WBITS); - insint(d, "DEFLATED", DEFLATED); - insint(d, "DEF_MEM_LEVEL", DEF_MEM_LEVEL); - insint(d, "Z_BEST_SPEED", Z_BEST_SPEED); - insint(d, "Z_BEST_COMPRESSION", Z_BEST_COMPRESSION); - insint(d, "Z_DEFAULT_COMPRESSION", Z_DEFAULT_COMPRESSION); - insint(d, "Z_FILTERED", Z_FILTERED); - insint(d, "Z_HUFFMAN_ONLY", Z_HUFFMAN_ONLY); - insint(d, "Z_DEFAULT_STRATEGY", Z_DEFAULT_STRATEGY); - - insint(d, "Z_FINISH", Z_FINISH); - insint(d, "Z_NO_FLUSH", Z_NO_FLUSH); - insint(d, "Z_SYNC_FLUSH", Z_SYNC_FLUSH); - insint(d, "Z_FULL_FLUSH", Z_FULL_FLUSH); - - ver = PyString_FromString(ZLIB_VERSION); - if (ver != NULL) { - PyDict_SetItemString(d, "ZLIB_VERSION", ver); - Py_DECREF(ver); - } + PyObject *m, *d, *ver; + Comptype.ob_type = &PyType_Type; + Decomptype.ob_type = &PyType_Type; + m = Py_InitModule4("zlib", zlib_methods, + zlib_module_documentation, + (PyObject*)NULL,PYTHON_API_VERSION); + d = PyModule_GetDict(m); + ZlibError = PyErr_NewException("zlib.error", NULL, NULL); + if (ZlibError != NULL) + PyDict_SetItemString(d, "error", ZlibError); + + PyModule_AddIntConstant(m, "MAX_WBITS", MAX_WBITS); + PyModule_AddIntConstant(m, "DEFLATED", DEFLATED); + PyModule_AddIntConstant(m, "DEF_MEM_LEVEL", DEF_MEM_LEVEL); + PyModule_AddIntConstant(m, "Z_BEST_SPEED", Z_BEST_SPEED); + PyModule_AddIntConstant(m, "Z_BEST_COMPRESSION", Z_BEST_COMPRESSION); + PyModule_AddIntConstant(m, "Z_DEFAULT_COMPRESSION", Z_DEFAULT_COMPRESSION); + PyModule_AddIntConstant(m, "Z_FILTERED", Z_FILTERED); + PyModule_AddIntConstant(m, "Z_HUFFMAN_ONLY", Z_HUFFMAN_ONLY); + PyModule_AddIntConstant(m, "Z_DEFAULT_STRATEGY", Z_DEFAULT_STRATEGY); + + PyModule_AddIntConstant(m, "Z_FINISH", Z_FINISH); + PyModule_AddIntConstant(m, "Z_NO_FLUSH", Z_NO_FLUSH); + PyModule_AddIntConstant(m, "Z_SYNC_FLUSH", Z_SYNC_FLUSH); + PyModule_AddIntConstant(m, "Z_FULL_FLUSH", Z_FULL_FLUSH); + + ver = PyString_FromString(ZLIB_VERSION); + if (ver != NULL) { + PyDict_SetItemString(d, "ZLIB_VERSION", ver); + Py_DECREF(ver); + } #ifdef WITH_THREAD - zlib_lock = PyThread_allocate_lock(); + zlib_lock = PyThread_allocate_lock(); #endif // WITH_THREAD } |