static PyObject *
compress(Compressor *c, uint8_t *data, size_t len, lzma_action action)
{
size_t data_size = 0;
PyObject *result;
result = PyBytes_FromStringAndSize(NULL, INITIAL_BUFFER_SIZE);
if (result == NULL)
return NULL;
c->lzs.next_in = data;
c->lzs.avail_in = len;
c->lzs.next_out = (uint8_t *)PyBytes_AS_STRING(result);
c->lzs.avail_out = PyBytes_GET_SIZE(result);
for (;;) {
lzma_ret lzret;
Py_BEGIN_ALLOW_THREADS
lzret = lzma_code(&c->lzs, action);
data_size = (char *)c->lzs.next_out - PyBytes_AS_STRING(result);
Py_END_ALLOW_THREADS
if (catch_lzma_error(lzret))
goto error;
if ((action == LZMA_RUN && c->lzs.avail_in == 0) ||
(action == LZMA_FINISH && lzret == LZMA_STREAM_END)) {
break;
} else if (c->lzs.avail_out == 0) {
if (grow_buffer(&result) == -1)
goto error;
c->lzs.next_out = (uint8_t *)PyBytes_AS_STRING(result) + data_size;
c->lzs.avail_out = PyBytes_GET_SIZE(result) - data_size;
}
}
if (data_size != (size_t)PyBytes_GET_SIZE(result))
if (_PyBytes_Resize(&result, data_size) == -1)
goto error;
return result;
error:
Py_XDECREF(result);
return NULL;
}
PyObject *
pylzma_decompress(PyObject *self, PyObject *args, PyObject *kwargs)
{
unsigned char *data;
Byte *tmp;
int length, bufsize=BLOCK_SIZE, avail, totallength=-1;
PyObject *result=NULL;
CLzmaDec state;
ELzmaStatus status;
size_t srcLen, destLen;
int res;
CMemoryOutStream outStream;
// possible keywords for this function
static char *kwlist[] = {"data", "bufsize", "maxlength", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|ii", kwlist, &data, &length, &bufsize, &totallength))
return NULL;
if (totallength != -1) {
// We know the decompressed size, run simple case
result = PyBytes_FromStringAndSize(NULL, totallength);
if (result == NULL) {
return NULL;
}
tmp = (Byte *) PyBytes_AS_STRING(result);
srcLen = length - LZMA_PROPS_SIZE;
destLen = totallength;
Py_BEGIN_ALLOW_THREADS
res = LzmaDecode(tmp, &destLen, (Byte *) (data + LZMA_PROPS_SIZE), &srcLen, data, LZMA_PROPS_SIZE, LZMA_FINISH_ANY, &status, &allocator);
Py_END_ALLOW_THREADS
if (res != SZ_OK) {
Py_DECREF(result);
result = NULL;
PyErr_Format(PyExc_TypeError, "Error while decompressing: %d", res);
} else if (destLen < (size_t) totallength) {
_PyBytes_Resize(&result, destLen);
}
return result;
}
static PyObject *
overlapped_GetOverlappedResult(OverlappedObject *self, PyObject *waitobj)
{
int wait;
BOOL res;
DWORD transferred = 0;
DWORD err;
wait = PyObject_IsTrue(waitobj);
if (wait < 0)
return NULL;
Py_BEGIN_ALLOW_THREADS
res = GetOverlappedResult(self->handle, &self->overlapped, &transferred,
wait != 0);
Py_END_ALLOW_THREADS
err = res ? ERROR_SUCCESS : GetLastError();
switch (err) {
case ERROR_SUCCESS:
case ERROR_MORE_DATA:
case ERROR_OPERATION_ABORTED:
self->completed = 1;
self->pending = 0;
break;
case ERROR_IO_INCOMPLETE:
break;
default:
self->pending = 0;
return PyErr_SetExcFromWindowsErr(PyExc_IOError, err);
}
if (self->completed && self->read_buffer != NULL) {
assert(PyBytes_CheckExact(self->read_buffer));
if (transferred != PyBytes_GET_SIZE(self->read_buffer) &&
_PyBytes_Resize(&self->read_buffer, transferred))
return NULL;
}
return Py_BuildValue("II", (unsigned) transferred, (unsigned) err);
}
static PyObject *
compress_helper(void * input, size_t nbytes, size_t typesize,
int clevel, int shuffle, char *cname){
int cbytes;
PyObject *output = NULL;
/* Alloc memory for compression */
if (!(output = PyBytes_FromStringAndSize(NULL, nbytes+BLOSC_MAX_OVERHEAD)))
return NULL;
/* Select compressor */
if (blosc_set_compressor(cname) < 0) {
/* The compressor is not available (should never happen here) */
blosc_error(-1, "compressor not available");
return NULL;
}
/* Compress */
Py_BEGIN_ALLOW_THREADS;
cbytes = blosc_compress(clevel, shuffle, typesize, nbytes,
input, PyBytes_AS_STRING(output),
nbytes+BLOSC_MAX_OVERHEAD);
Py_END_ALLOW_THREADS;
if (cbytes < 0) {
blosc_error(cbytes, "while compressing data");
Py_XDECREF(output);
return NULL;
}
/* Attempt to resize, if it's much smaller, a copy is required. */
if (_PyBytes_Resize(&output, cbytes) < 0){
/* the memory exception will have been set, hopefully */
return NULL;
}
return output;
}
static PyObject *
PyZlib_flush(compobject *self, PyObject *args)
{
int err, length = DEFAULTALLOC;
PyObject *RetVal;
int flushmode = Z_FINISH;
unsigned long start_total_out;
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 PyBytes_FromStringAndSize(NULL, 0);
}
if (!(RetVal = PyBytes_FromStringAndSize(NULL, length)))
return NULL;
ENTER_ZLIB(self);
start_total_out = self->zst.total_out;
self->zst.avail_in = 0;
self->zst.avail_out = length;
self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal);
Py_BEGIN_ALLOW_THREADS
err = deflate(&(self->zst), flushmode);
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 (_PyBytes_Resize(&RetVal, length << 1) < 0) {
Py_DECREF(RetVal);
RetVal = NULL;
goto error;
}
self->zst.next_out =
(unsigned char *)PyBytes_AS_STRING(RetVal) + length;
self->zst.avail_out = length;
length = length << 1;
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 (err == Z_STREAM_END && flushmode == Z_FINISH) {
err = deflateEnd(&(self->zst));
if (err != Z_OK) {
zlib_error(self->zst, err, "while finishing compression");
Py_DECREF(RetVal);
RetVal = NULL;
goto error;
}
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) {
zlib_error(self->zst, err, "while flushing");
Py_DECREF(RetVal);
RetVal = NULL;
goto error;
}
if (_PyBytes_Resize(&RetVal, self->zst.total_out - start_total_out) < 0) {
Py_DECREF(RetVal);
RetVal = NULL;
}
error:
LEAVE_ZLIB(self);
return RetVal;
}
static PyObject *
PyZlib_unflush(compobject *self, PyObject *args)
{
int err, length = DEFAULTALLOC;
PyObject * retval = NULL;
unsigned long start_total_out;
if (!PyArg_ParseTuple(args, "|i:flush", &length))
return NULL;
if (length <= 0) {
PyErr_SetString(PyExc_ValueError, "length must be greater than zero");
return NULL;
}
if (!(retval = PyBytes_FromStringAndSize(NULL, length)))
return NULL;
ENTER_ZLIB(self);
start_total_out = self->zst.total_out;
self->zst.avail_out = length;
self->zst.next_out = (Byte *)PyBytes_AS_STRING(retval);
Py_BEGIN_ALLOW_THREADS
err = inflate(&(self->zst), Z_FINISH);
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 || err == Z_BUF_ERROR) && self->zst.avail_out == 0) {
if (_PyBytes_Resize(&retval, length << 1) < 0) {
Py_DECREF(retval);
retval = NULL;
goto error;
}
self->zst.next_out = (Byte *)PyBytes_AS_STRING(retval) + length;
self->zst.avail_out = length;
length = length << 1;
Py_BEGIN_ALLOW_THREADS
err = inflate(&(self->zst), Z_FINISH);
Py_END_ALLOW_THREADS
}
/* If at end of stream, clean up any memory allocated by zlib. */
if (err == Z_STREAM_END) {
self->eof = 1;
self->is_initialised = 0;
err = inflateEnd(&(self->zst));
if (err != Z_OK) {
zlib_error(self->zst, err, "while finishing decompression");
Py_DECREF(retval);
retval = NULL;
goto error;
}
}
if (_PyBytes_Resize(&retval, self->zst.total_out - start_total_out) < 0) {
Py_DECREF(retval);
retval = NULL;
}
error:
LEAVE_ZLIB(self);
return retval;
}
static PyObject *
PyZlib_objcompress(compobject *self, PyObject *args)
{
int err;
unsigned int inplen;
Py_ssize_t length = DEFAULTALLOC;
PyObject *RetVal = NULL;
Py_buffer pinput;
Byte *input;
unsigned long start_total_out;
if (!PyArg_ParseTuple(args, "y*:compress", &pinput))
return NULL;
if (pinput.len > UINT_MAX) {
PyErr_SetString(PyExc_OverflowError,
"Size does not fit in an unsigned int");
goto error_outer;
}
input = pinput.buf;
inplen = pinput.len;
if (!(RetVal = PyBytes_FromStringAndSize(NULL, length)))
goto error_outer;
ENTER_ZLIB(self);
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 *)PyBytes_AS_STRING(RetVal);
Py_BEGIN_ALLOW_THREADS
err = deflate(&(self->zst), Z_NO_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 (_PyBytes_Resize(&RetVal, length << 1) < 0) {
Py_DECREF(RetVal);
RetVal = NULL;
goto error;
}
self->zst.next_out =
(unsigned char *)PyBytes_AS_STRING(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 (err != Z_OK && err != Z_BUF_ERROR) {
zlib_error(self->zst, err, "while compressing data");
Py_DECREF(RetVal);
RetVal = NULL;
goto error;
}
if (_PyBytes_Resize(&RetVal, self->zst.total_out - start_total_out) < 0) {
Py_DECREF(RetVal);
RetVal = NULL;
}
error:
LEAVE_ZLIB(self);
error_outer:
PyBuffer_Release(&pinput);
return RetVal;
}
static PyObject *
PyZlib_objdecompress(compobject *self, PyObject *args)
{
int err, max_length = 0;
unsigned int inplen;
Py_ssize_t old_length, length = DEFAULTALLOC;
PyObject *RetVal = NULL;
Py_buffer pinput;
Byte *input;
unsigned long start_total_out;
if (!PyArg_ParseTuple(args, "y*|i:decompress", &pinput,
&max_length))
return NULL;
if (pinput.len > UINT_MAX) {
PyErr_SetString(PyExc_OverflowError,
"Size does not fit in an unsigned int");
goto error_outer;
}
input = pinput.buf;
inplen = pinput.len;
if (max_length < 0) {
PyErr_SetString(PyExc_ValueError,
"max_length must be greater than zero");
goto error_outer;
}
/* limit amount of data allocated to max_length */
if (max_length && length > max_length)
length = max_length;
if (!(RetVal = PyBytes_FromStringAndSize(NULL, length)))
goto error_outer;
ENTER_ZLIB(self);
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 *)PyBytes_AS_STRING(RetVal);
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.
*/
if (max_length && length >= max_length)
break;
/* otherwise, ... */
old_length = length;
length = length << 1;
if (max_length && length > max_length)
length = max_length;
if (_PyBytes_Resize(&RetVal, length) < 0) {
Py_DECREF(RetVal);
RetVal = NULL;
goto error;
}
self->zst.next_out =
(unsigned char *)PyBytes_AS_STRING(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(max_length) {
/* Not all of the compressed data could be accommodated in a buffer of
the specified size. Return the unconsumed tail in an attribute. */
Py_DECREF(self->unconsumed_tail);
self->unconsumed_tail = PyBytes_FromStringAndSize((char *)self->zst.next_in,
self->zst.avail_in);
}
else if (PyBytes_GET_SIZE(self->unconsumed_tail) > 0) {
/* All of the compressed data was consumed. Clear unconsumed_tail. */
Py_DECREF(self->unconsumed_tail);
self->unconsumed_tail = PyBytes_FromStringAndSize("", 0);
}
if (self->unconsumed_tail == NULL) {
Py_DECREF(RetVal);
RetVal = NULL;
goto error;
}
/* 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 (err == Z_STREAM_END) {
Py_XDECREF(self->unused_data); /* Free original empty string */
self->unused_data = PyBytes_FromStringAndSize(
(char *)self->zst.next_in, self->zst.avail_in);
if (self->unused_data == NULL) {
Py_DECREF(RetVal);
goto error;
}
self->eof = 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) {
zlib_error(self->zst, err, "while decompressing data");
Py_DECREF(RetVal);
RetVal = NULL;
goto error;
}
if (_PyBytes_Resize(&RetVal, self->zst.total_out - start_total_out) < 0) {
Py_DECREF(RetVal);
RetVal = NULL;
}
error:
LEAVE_ZLIB(self);
error_outer:
PyBuffer_Release(&pinput);
return RetVal;
}
static PyObject *
compress_helper(void * input, size_t nbytes, size_t typesize,
int clevel, int shuffle, char *cname){
int cbytes, blocksize, nthreads;
PyObject *output;
char *output_ptr;
PyThreadState *_save = NULL;
/* Alloc memory for compression */
if (!(output = PyBytes_FromStringAndSize(NULL, nbytes+BLOSC_MAX_OVERHEAD)))
return NULL;
/* Select compressor */
if (blosc_set_compressor(cname) < 0) {
/* The compressor is not available (should never happen here) */
blosc_error(-1, "compressor not available");
Py_DECREF(output);
return NULL;
}
/* Compress */
// This macro probably doesn't require the Python interpreter but let's leave it outside for safety
output_ptr = PyBytes_AS_STRING(output);
if( RELEASEGIL )
{
// Run with GIL released, tiny overhead penalty from this (although it
// may be significant for smaller chunks.)
_save = PyEval_SaveThread();
blocksize = blosc_get_blocksize();
// if blocksize==0, blosc_compress_ctx will try to auto-optimize it.
nthreads = blosc_get_nthreads();
cbytes = blosc_compress_ctx(clevel, shuffle, typesize, nbytes,
input, output_ptr, nbytes+BLOSC_MAX_OVERHEAD,
cname, blocksize, nthreads);
PyEval_RestoreThread(_save);
_save = NULL;
}
else
{ // Hold onto the Python GIL while compressing
cbytes = blosc_compress(clevel, shuffle, typesize, nbytes,
input, output_ptr,
nbytes+BLOSC_MAX_OVERHEAD);
}
if (cbytes < 0) {
blosc_error(cbytes, "while compressing data");
Py_DECREF(output);
return NULL;
}
/* Attempt to resize, if it's much smaller, a copy is required. */
if (_PyBytes_Resize(&output, cbytes) < 0){
/* the memory exception will have been set, hopefully */
Py_DECREF(output);
return NULL;
}
return output;
}
static PyObject *
PyZlib_decompress(PyObject *self, PyObject *args)
{
PyObject *result_str = NULL;
Py_buffer pinput;
Byte *input;
unsigned int length;
int err;
int wsize=DEF_WBITS;
Py_ssize_t r_strlen=DEFAULTALLOC;
z_stream zst;
if (!PyArg_ParseTuple(args, "y*|in:decompress",
&pinput, &wsize, &r_strlen))
return NULL;
if (pinput.len > UINT_MAX) {
PyErr_SetString(PyExc_OverflowError,
"Size does not fit in an unsigned int");
goto error;
}
input = pinput.buf;
length = pinput.len;
if (r_strlen <= 0)
r_strlen = 1;
zst.avail_in = length;
zst.avail_out = r_strlen;
if (!(result_str = PyBytes_FromStringAndSize(NULL, r_strlen)))
goto error;
zst.zalloc = (alloc_func)NULL;
zst.zfree = (free_func)Z_NULL;
zst.next_out = (Byte *)PyBytes_AS_STRING(result_str);
zst.next_in = (Byte *)input;
err = inflateInit2(&zst, wsize);
switch(err) {
case(Z_OK):
break;
case(Z_MEM_ERROR):
PyErr_SetString(PyExc_MemoryError,
"Out of memory while decompressing data");
goto error;
default:
inflateEnd(&zst);
zlib_error(zst, err, "while preparing to decompress data");
goto error;
}
do {
Py_BEGIN_ALLOW_THREADS
err=inflate(&zst, Z_FINISH);
Py_END_ALLOW_THREADS
switch(err) {
case(Z_STREAM_END):
break;
case(Z_BUF_ERROR):
/*
* If there is at least 1 byte of room according to zst.avail_out
* and we get this error, assume that it means zlib cannot
* process the inflate call() due to an error in the data.
*/
if (zst.avail_out > 0) {
zlib_error(zst, err, "while decompressing data");
inflateEnd(&zst);
goto error;
}
/* fall through */
case(Z_OK):
/* need more memory */
if (_PyBytes_Resize(&result_str, r_strlen << 1) < 0) {
inflateEnd(&zst);
goto error;
}
zst.next_out =
(unsigned char *)PyBytes_AS_STRING(result_str) + r_strlen;
zst.avail_out = r_strlen;
r_strlen = r_strlen << 1;
break;
default:
inflateEnd(&zst);
zlib_error(zst, err, "while decompressing data");
goto error;
}
} while (err != Z_STREAM_END);
err = inflateEnd(&zst);
if (err != Z_OK) {
zlib_error(zst, err, "while finishing decompression");
goto error;
}
if (_PyBytes_Resize(&result_str, zst.total_out) < 0)
goto error;
PyBuffer_Release(&pinput);
return result_str;
error:
PyBuffer_Release(&pinput);
Py_XDECREF(result_str);
return NULL;
}
bool AllocateMore(SQLLEN cbAdd)
{
// cbAdd
// The number of bytes (cb --> count of bytes) to add.
if (cbAdd == 0)
return true;
SQLLEN newSize = bufferSize + cbAdd;
if (usingStack)
{
// This is the first call and `buffer` points to stack memory. Allocate a new object and copy the stack
// data into it.
char* stackBuffer = buffer;
if (dataType == SQL_C_CHAR)
{
bufferOwner = PyBytes_FromStringAndSize(0, newSize);
buffer = bufferOwner ? PyBytes_AS_STRING(bufferOwner) : 0;
}
else if (dataType == SQL_C_BINARY)
{
#if PY_VERSION_HEX >= 0x02060000
bufferOwner = PyByteArray_FromStringAndSize(0, newSize);
buffer = bufferOwner ? PyByteArray_AS_STRING(bufferOwner) : 0;
#else
bufferOwner = PyBytes_FromStringAndSize(0, newSize);
buffer = bufferOwner ? PyBytes_AS_STRING(bufferOwner) : 0;
#endif
}
else if (sizeof(SQLWCHAR) == Py_UNICODE_SIZE)
{
// Allocate directly into a Unicode object.
bufferOwner = PyUnicode_FromUnicode(0, newSize / element_size);
buffer = bufferOwner ? (char*)PyUnicode_AsUnicode(bufferOwner) : 0;
}
else
{
// We're Unicode, but SQLWCHAR and Py_UNICODE don't match, so maintain our own SQLWCHAR buffer.
bufferOwner = 0;
buffer = (char*)pyodbc_malloc((size_t)newSize);
}
if (buffer == 0)
return false;
usingStack = false;
memcpy(buffer, stackBuffer, (size_t)bufferSize);
bufferSize = newSize;
return true;
}
if (bufferOwner && PyUnicode_CheckExact(bufferOwner))
{
if (PyUnicode_Resize(&bufferOwner, newSize / element_size) == -1)
return false;
buffer = (char*)PyUnicode_AsUnicode(bufferOwner);
}
#if PY_VERSION_HEX >= 0x02060000
else if (bufferOwner && PyByteArray_CheckExact(bufferOwner))
{
if (PyByteArray_Resize(bufferOwner, newSize) == -1)
return false;
buffer = PyByteArray_AS_STRING(bufferOwner);
}
#else
else if (bufferOwner && PyBytes_CheckExact(bufferOwner))
{
if (_PyBytes_Resize(&bufferOwner, newSize) == -1)
return false;
buffer = PyBytes_AS_STRING(bufferOwner);
}
#endif
else
{
char* tmp = (char*)realloc(buffer, (size_t)newSize);
if (tmp == 0)
return false;
buffer = tmp;
}
bufferSize = newSize;
return true;
}
static PyObject *
pylzma_decomp_flush(CDecompressionObject *self, PyObject *args)
{
PyObject *result=NULL;
int res;
SizeT avail_out, outsize;
unsigned char *tmp;
SizeT inProcessed, outProcessed;
ELzmaStatus status;
if (self->max_length != -1) {
avail_out = self->max_length - self->total_out;
} else {
avail_out = BLOCK_SIZE;
}
if (avail_out == 0) {
// no more remaining data
return PyBytes_FromString("");
}
result = PyBytes_FromStringAndSize(NULL, avail_out);
if (result == NULL) {
return NULL;
}
tmp = (unsigned char *) PyBytes_AS_STRING(result);
outsize = 0;
while (1) {
Py_BEGIN_ALLOW_THREADS
if (self->unconsumed_length == 0) {
// No remaining data
inProcessed = 0;
outProcessed = avail_out;
res = LzmaDec_DecodeToBuf(&self->state, tmp, &outProcessed,
(Byte *) "", &inProcessed, LZMA_FINISH_ANY, &status);
} else {
// Decompress remaining data
inProcessed = self->unconsumed_length;
outProcessed = avail_out;
res = LzmaDec_DecodeToBuf(&self->state, tmp, &outProcessed,
self->unconsumed_tail, &inProcessed, LZMA_FINISH_ANY, &status);
self->unconsumed_length -= inProcessed;
if (self->unconsumed_length > 0)
memmove(self->unconsumed_tail, self->unconsumed_tail + inProcessed, self->unconsumed_length);
else
FREE_AND_NULL(self->unconsumed_tail);
}
Py_END_ALLOW_THREADS
if (res != SZ_OK) {
PyErr_SetString(PyExc_ValueError, "data error during decompression");
DEC_AND_NULL(result);
goto exit;
}
if (!outProcessed && self->max_length != -1 && self->total_out < self->max_length) {
PyErr_SetString(PyExc_ValueError, "data error during decompression");
DEC_AND_NULL(result);
goto exit;
}
self->total_out += outProcessed;
outsize += outProcessed;
if (outProcessed < avail_out || (outProcessed == avail_out && self->max_length != -1)) {
break;
}
if (self->max_length != -1) {
PyErr_SetString(PyExc_ValueError, "not enough input data for decompression");
DEC_AND_NULL(result);
goto exit;
}
avail_out -= outProcessed;
// Output buffer is full, might be more data for decompression
if (_PyBytes_Resize(&result, outsize+BLOCK_SIZE) != 0) {
goto exit;
}
avail_out += BLOCK_SIZE;
tmp = (unsigned char *) PyBytes_AS_STRING(result) + outsize;
}
if (outsize != PyBytes_GET_SIZE(result)) {
_PyBytes_Resize(&result, outsize);
}
exit:
return result;
}
static PyObject *
PyZlib_unflush(compobject *self, PyObject *args)
{
int err, length = DEFAULTALLOC;
PyObject * retval = NULL;
unsigned long start_total_out;
if (!PyArg_ParseTuple(args, "|i:flush", &length))
return NULL;
if (length <= 0) {
PyErr_SetString(PyExc_ValueError, "length must be greater than zero");
return NULL;
}
if (!(retval = PyBytes_FromStringAndSize(NULL, length)))
return NULL;
ENTER_ZLIB(self);
start_total_out = self->zst.total_out;
self->zst.avail_out = length;
self->zst.next_out = (Byte *)PyBytes_AS_STRING(retval);
Py_BEGIN_ALLOW_THREADS
err = inflate(&(self->zst), Z_FINISH);
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 || err == Z_BUF_ERROR) && self->zst.avail_out == 0) {
if (_PyBytes_Resize(&retval, length << 1) < 0) {
Py_DECREF(retval);
retval = NULL;
goto error;
}
self->zst.next_out = (Byte *)PyBytes_AS_STRING(retval) + length;
self->zst.avail_out = length;
length = length << 1;
Py_BEGIN_ALLOW_THREADS
err = inflate(&(self->zst), Z_FINISH);
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 */
if (err == Z_STREAM_END) {
err = inflateEnd(&(self->zst));
self->is_initialised = 0;
if (err != Z_OK) {
zlib_error(self->zst, err, "from inflateEnd()");
Py_DECREF(retval);
retval = NULL;
goto error;
}
}
if (_PyBytes_Resize(&retval, self->zst.total_out - start_total_out) < 0) {
Py_DECREF(retval);
retval = NULL;
}
error:
LEAVE_ZLIB(self);
return retval;
}
static PyObject *parse_qsl(PyObject *self, PyObject *args)
{
PyObject *pairs;
int i, len;
PyObject *qso;
char unicode = 0;
char *qs = NULL;
int keep_blank_values = 0;
int strict_parsing = 0; /* XXX not implemented */
if (! PyArg_ParseTuple(args, "O|ii", &qso, &keep_blank_values,
&strict_parsing))
return NULL; /* error */
if (PyUnicode_Check(qso))
unicode = 1;
MP_ANYSTR_AS_STR(qs, qso, 1);
if (!qs) {
Py_DECREF(qso); /* MP_ANYSTR_AS_STR */
return NULL;
}
/* split query string by '&' and ';' into a list of pairs */
pairs = PyList_New(0);
if (pairs == NULL) {
Py_DECREF(qso); /* MP_ANYSTR_AS_STR */
return NULL;
}
i = 0;
len = strlen(qs);
while (i < len) {
PyObject *pair, *key, *val;
char *cpair, *ckey, *cval;
int plen, j, p, k, v;
pair = PyBytes_FromStringAndSize(NULL, len);
if (pair == NULL)
return NULL;
/* split by '&' or ';' */
cpair = PyBytes_AS_STRING(pair);
j = 0;
while ((qs[i] != '&') && (qs[i] != ';') && (i < len)) {
/* replace '+' with ' ' */
cpair[j] = (qs[i] == '+') ? ' ' : qs[i];
i++;
j++;
}
if (j == 0) {
Py_XDECREF(pair);
i++;
continue;
}
cpair[j] = '\0';
_PyBytes_Resize(&pair, j);
cpair = PyBytes_AS_STRING(pair);
/* split the "abc=def" pair */
plen = strlen(cpair);
key = PyBytes_FromStringAndSize(NULL, plen);
if (key == NULL) {
Py_DECREF(qso); /* MP_ANYSTR_AS_STR */
return NULL;
}
val = PyBytes_FromStringAndSize(NULL, plen);
if (val == NULL) {
Py_DECREF(qso); /* MP_ANYSTR_AS_STR */
return NULL;
}
ckey = PyBytes_AS_STRING(key);
cval = PyBytes_AS_STRING(val);
p = 0;
k = 0;
v = 0;
while (p < plen) {
if (cpair[p] != '=') {
ckey[k] = cpair[p];
k++;
p++;
}
else {
p++; /* skip '=' */
while (p < plen) {
cval[v] = cpair[p];
v++;
p++;
}
}
}
ckey[k] = '\0';
cval[v] = '\0';
if (keep_blank_values || (v > 0)) {
ap_unescape_url(ckey);
ap_unescape_url(cval);
_PyBytes_Resize(&key, strlen(ckey));
_PyBytes_Resize(&val, strlen(cval));
if (key && val) {
PyObject *listitem = NULL;
if (unicode) {
PyObject *ukey, *uval;
ukey = PyUnicode_DecodeLatin1(ckey, strlen(ckey), NULL);
uval = PyUnicode_DecodeLatin1(cval, strlen(cval), NULL);
listitem = Py_BuildValue("(O,O)", ukey, uval);
Py_DECREF(ukey);
Py_DECREF(uval);
} else
listitem = Py_BuildValue("(O,O)", key, val);
if(listitem) {
PyList_Append(pairs, listitem);
Py_DECREF(listitem);
}
}
}
Py_XDECREF(pair);
Py_XDECREF(key);
Py_XDECREF(val);
i++;
}
Py_DECREF(qso);
return pairs;
}
static PyObject *pylzma_decomp_decompress(CCompatDecompressionObject *self, PyObject *args)
{
PyObject *result=NULL;
char *data;
PARSE_LENGTH_TYPE length, old_length;
PY_LONG_LONG start_total_out;
int res;
PY_LONG_LONG max_length=BLOCK_SIZE;
if (!PyArg_ParseTuple(args, "s#|L", &data, &length, &max_length))
return NULL;
if (max_length < 0)
{
PyErr_SetString(PyExc_ValueError, "bufsize must be greater than zero");
return NULL;
}
start_total_out = self->stream.totalOut;
if (self->unconsumed_length > 0) {
self->unconsumed_tail = (char *)realloc(self->unconsumed_tail, self->unconsumed_length + length);
self->stream.next_in = (Byte *)self->unconsumed_tail;
memcpy(self->stream.next_in + self->unconsumed_length, data, length);
} else
self->stream.next_in = (Byte *)data;
self->stream.avail_in = self->unconsumed_length + length;
if (max_length && max_length < length)
length = max_length;
if (!(result = PyBytes_FromStringAndSize(NULL, length)))
return NULL;
self->stream.next_out = (unsigned char *) PyBytes_AS_STRING(result);
self->stream.avail_out = length;
Py_BEGIN_ALLOW_THREADS
res = lzmaCompatDecode(&self->stream);
Py_END_ALLOW_THREADS
while (res == LZMA_OK && self->stream.avail_out == 0)
{
if (max_length && length >= max_length)
break;
old_length = length;
length <<= 1;
if (max_length && length > max_length)
length = max_length;
if (_PyBytes_Resize(&result, length) < 0)
goto exit;
self->stream.avail_out = length - old_length;
self->stream.next_out = (Byte *) PyBytes_AS_STRING(result) + old_length;
Py_BEGIN_ALLOW_THREADS
res = lzmaCompatDecode(&self->stream);
Py_END_ALLOW_THREADS
}
if (res == LZMA_NOT_ENOUGH_MEM) {
// out of memory during decompression
PyErr_NoMemory();
DEC_AND_NULL(result);
goto exit;
} else if (res == LZMA_DATA_ERROR) {
PyErr_SetString(PyExc_ValueError, "data error during decompression");
DEC_AND_NULL(result);
goto exit;
} else if (res != LZMA_OK && res != LZMA_STREAM_END) {
PyErr_Format(PyExc_ValueError, "unknown return code from lzmaDecode: %d", res);
DEC_AND_NULL(result);
goto exit;
}
/* 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 != 0) {
if (self->stream.avail_in > 0)
{
if (self->stream.avail_in != self->unconsumed_length)
self->unconsumed_tail = (char *)realloc(self->unconsumed_tail, self->stream.avail_in);
if (!self->unconsumed_tail) {
PyErr_NoMemory();
DEC_AND_NULL(result);
goto exit;
}
memcpy(self->unconsumed_tail, self->stream.next_in, self->stream.avail_in);
} else
FREE_AND_NULL(self->unconsumed_tail);
self->unconsumed_length = self->stream.avail_in;
}
/* 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 (res == LZMA_STREAM_END) {
Py_XDECREF(self->unused_data); /* Free original empty string */
self->unused_data = PyBytes_FromStringAndSize((char *) self->stream.next_in, self->stream.avail_in);
if (self->unused_data == NULL) {
PyErr_NoMemory();
DEC_AND_NULL(result);
goto exit;
}
}
_PyBytes_Resize(&result, self->stream.totalOut - start_total_out);
exit:
return result;
}
static PyObject *parse_qs(PyObject *self, PyObject *args)
{
PyObject *pairs, *dict;
int i, n, len, lsize;
char *qs;
PyObject *qso;
char unicode = 0;
int keep_blank_values = 0;
int strict_parsing = 0; /* XXX not implemented */
if (! PyArg_ParseTuple(args, "O|ii", &qso, &keep_blank_values,
&strict_parsing))
return NULL; /* error */
if (PyUnicode_Check(qso))
unicode = 1;
MP_ANYSTR_AS_STR(qs, qso, 1);
if (!qs) {
Py_DECREF(qso); /* MP_ANYSTR_AS_STR */
return NULL;
}
/* split query string by '&' and ';' into a list of pairs */
pairs = PyList_New(0);
if (pairs == NULL) {
Py_DECREF(qso);
return NULL;
}
i = 0;
len = strlen(qs);
while (i < len) {
PyObject *pair;
char *cpair;
int j = 0;
pair = PyBytes_FromStringAndSize(NULL, len);
if (pair == NULL) {
Py_DECREF(qso);
return NULL;
}
/* split by '&' or ';' */
cpair = PyBytes_AS_STRING(pair);
while ((qs[i] != '&') && (qs[i] != ';') && (i < len)) {
/* replace '+' with ' ' */
cpair[j] = (qs[i] == '+') ? ' ' : qs[i];
i++;
j++;
}
if (j) {
_PyBytes_Resize(&pair, j);
if (pair)
PyList_Append(pairs, pair);
}
Py_XDECREF(pair);
i++;
}
Py_DECREF(qso); /* MP_ANYSTR_AS_STR */
/*
* now we have a list of "abc=def" string (pairs), let's split
* them all by '=' and put them in a dictionary.
*/
dict = PyDict_New();
if (dict == NULL)
return NULL;
lsize = PyList_Size(pairs);
n = 0;
while (n < lsize) {
PyObject *pair, *key, *val;
char *cpair, *ckey, *cval;
int k, v;
pair = PyList_GET_ITEM(pairs, n);
cpair = PyBytes_AS_STRING(pair);
len = strlen(cpair);
key = PyBytes_FromStringAndSize(NULL, len);
if (key == NULL)
return NULL;
val = PyBytes_FromStringAndSize(NULL, len);
if (val == NULL)
return NULL;
ckey = PyBytes_AS_STRING(key);
cval = PyBytes_AS_STRING(val);
i = 0;
k = 0;
v = 0;
while (i < len) {
if (cpair[i] != '=') {
ckey[k] = cpair[i];
k++;
i++;
}
else {
i++; /* skip '=' */
while (i < len) {
cval[v] = cpair[i];
v++;
i++;
}
}
}
ckey[k] = '\0';
cval[v] = '\0';
if (keep_blank_values || (v > 0)) {
ap_unescape_url(ckey);
ap_unescape_url(cval);
_PyBytes_Resize(&key, strlen(ckey));
_PyBytes_Resize(&val, strlen(cval));
if (key && val) {
ckey = PyBytes_AS_STRING(key);
cval = PyBytes_AS_STRING(val);
if (unicode) {
PyObject *list, *ukey, *uval;
ukey = PyUnicode_DecodeLatin1(ckey, strlen(ckey), NULL);
uval = PyUnicode_DecodeLatin1(ckey, strlen(cval), NULL);
list = PyDict_GetItem(dict, ukey);
if (list) {
PyList_Append(list, uval);
Py_DECREF(uval);
} else {
list = Py_BuildValue("[O]", uval);
PyDict_SetItem(dict, ukey, list);
Py_DECREF(ukey);
Py_DECREF(list);
}
} else {
PyObject *list;
list = PyDict_GetItem(dict, key);
if (list)
PyList_Append(list, val);
else {
list = Py_BuildValue("[O]", val);
PyDict_SetItem(dict, key, list);
Py_DECREF(list);
}
}
}
}
Py_XDECREF(key);
Py_XDECREF(val);
n++;
}
Py_DECREF(pairs);
return dict;
}
static PyObject *
pylzma_decomp_decompress(CDecompressionObject *self, PyObject *args)
{
PyObject *result=NULL;
unsigned char *data;
Byte *next_in, *next_out;
int length, res, bufsize=BLOCK_SIZE;
SizeT avail_in;
SizeT inProcessed, outProcessed;
ELzmaStatus status;
if (!PyArg_ParseTuple(args, "s#|i", &data, &length, &bufsize)){
return NULL;
}
if (bufsize <= 0) {
PyErr_SetString(PyExc_ValueError, "bufsize must be greater than zero");
return NULL;
}
if (self->unconsumed_length > 0) {
self->unconsumed_tail = (unsigned char *) realloc(self->unconsumed_tail, self->unconsumed_length + length);
next_in = (unsigned char *) self->unconsumed_tail;
memcpy(next_in + self->unconsumed_length, data, length);
} else {
next_in = data;
}
if (self->need_properties) {
if ((self->unconsumed_length + length) < LZMA_PROPS_SIZE) {
// we need enough bytes to read the properties
self->unconsumed_tail = (unsigned char *) realloc(self->unconsumed_tail, self->unconsumed_length + length);
if (self->unconsumed_tail == NULL) {
PyErr_NoMemory();
return NULL;
}
memcpy(self->unconsumed_tail + self->unconsumed_length, data, length);
self->unconsumed_length += length;
return PyBytes_FromString("");
}
self->unconsumed_length += length;
res = LzmaDec_Allocate(&self->state, next_in, LZMA_PROPS_SIZE, &allocator);
if (res != SZ_OK) {
PyErr_SetString(PyExc_TypeError, "Incorrect stream properties");
return NULL;
}
next_in += LZMA_PROPS_SIZE;
self->unconsumed_length -= LZMA_PROPS_SIZE;
if (self->unconsumed_length > 0) {
if (self->unconsumed_tail == NULL) {
// No remaining data yet
self->unconsumed_tail = (unsigned char *) malloc(self->unconsumed_length);
if (self->unconsumed_tail == NULL) {
PyErr_NoMemory();
return NULL;
}
memcpy(self->unconsumed_tail, next_in, self->unconsumed_length);
next_in = self->unconsumed_tail;
} else {
// Skip properties in remaining data
memmove(self->unconsumed_tail, self->unconsumed_tail+LZMA_PROPS_SIZE, self->unconsumed_length);
self->unconsumed_tail = next_in = (unsigned char *) realloc(self->unconsumed_tail, self->unconsumed_length);
if (self->unconsumed_tail == NULL) {
PyErr_NoMemory();
return NULL;
}
}
} else {
FREE_AND_NULL(self->unconsumed_tail);
}
self->need_properties = 0;
LzmaDec_Init(&self->state);
} else {
self->unconsumed_length += length;
}
avail_in = self->unconsumed_length;
if (avail_in == 0) {
// no more bytes to decompress
return PyBytes_FromString("");
}
result = PyBytes_FromStringAndSize(NULL, bufsize);
if (result == NULL) {
PyErr_NoMemory();
goto exit;
}
next_out = (unsigned char *) PyBytes_AS_STRING(result);
Py_BEGIN_ALLOW_THREADS
// Decompress until EOS marker is reached
inProcessed = avail_in;
outProcessed = bufsize;
res = LzmaDec_DecodeToBuf(&self->state, next_out, &outProcessed,
next_in, &inProcessed, LZMA_FINISH_ANY, &status);
Py_END_ALLOW_THREADS
self->total_out += outProcessed;
next_in += inProcessed;
avail_in -= inProcessed;
if (res != SZ_OK) {
DEC_AND_NULL(result);
PyErr_SetString(PyExc_ValueError, "data error during decompression");
goto exit;
}
// Not all of the compressed data could be accomodated in the output buffer
// of specified size. Return the unconsumed tail in an attribute.
if (avail_in > 0) {
if (self->unconsumed_tail == NULL) {
// data are in "data"
self->unconsumed_tail = (unsigned char *) malloc(avail_in);
if (self->unconsumed_tail == NULL) {
Py_DECREF(result);
PyErr_NoMemory();
goto exit;
}
memcpy(self->unconsumed_tail, next_in, avail_in);
} else {
memmove(self->unconsumed_tail, next_in, avail_in);
self->unconsumed_tail = (unsigned char *) realloc(self->unconsumed_tail, avail_in);
}
} else {
FREE_AND_NULL(self->unconsumed_tail);
}
self->unconsumed_length = avail_in;
_PyBytes_Resize(&result, outProcessed);
exit:
return result;
}
PyObject *
PyFile_GetLine(PyObject *f, int n)
{
PyObject *result;
if (f == NULL) {
PyErr_BadInternalCall();
return NULL;
}
{
PyObject *reader;
PyObject *args;
_Py_IDENTIFIER(readline);
reader = _PyObject_GetAttrId(f, &PyId_readline);
if (reader == NULL)
return NULL;
if (n <= 0)
args = PyTuple_New(0);
else
args = Py_BuildValue("(i)", n);
if (args == NULL) {
Py_DECREF(reader);
return NULL;
}
result = PyEval_CallObject(reader, args);
Py_DECREF(reader);
Py_DECREF(args);
if (result != NULL && !PyBytes_Check(result) &&
!PyUnicode_Check(result)) {
Py_DECREF(result);
result = NULL;
PyErr_SetString(PyExc_TypeError,
"object.readline() returned non-string");
}
}
if (n < 0 && result != NULL && PyBytes_Check(result)) {
char *s = PyBytes_AS_STRING(result);
Py_ssize_t len = PyBytes_GET_SIZE(result);
if (len == 0) {
Py_DECREF(result);
result = NULL;
PyErr_SetString(PyExc_EOFError,
"EOF when reading a line");
}
else if (s[len-1] == '\n') {
if (result->ob_refcnt == 1)
_PyBytes_Resize(&result, len-1);
else {
PyObject *v;
v = PyBytes_FromStringAndSize(s, len-1);
Py_DECREF(result);
result = v;
}
}
}
if (n < 0 && result != NULL && PyUnicode_Check(result)) {
Py_ssize_t len = PyUnicode_GET_LENGTH(result);
if (len == 0) {
Py_DECREF(result);
result = NULL;
PyErr_SetString(PyExc_EOFError,
"EOF when reading a line");
}
else if (PyUnicode_READ_CHAR(result, len-1) == '\n') {
PyObject *v;
v = PyUnicode_Substring(result, 0, len-1);
Py_DECREF(result);
result = v;
}
}
return result;
}
PyObject* DetachValue()
{
// At this point, Trim should have been called by PostRead.
if (bytesUsed == SQL_NULL_DATA || buffer == 0)
Py_RETURN_NONE;
if (usingStack)
{
if (dataType == SQL_C_CHAR)
return PyBytes_FromStringAndSize(buffer, bytesUsed);
if (dataType == SQL_C_BINARY)
{
#if PY_VERSION_HEX >= 0x02060000
return PyByteArray_FromStringAndSize(buffer, bytesUsed);
#else
return PyBytes_FromStringAndSize(buffer, bytesUsed);
#endif
}
if (sizeof(SQLWCHAR) == Py_UNICODE_SIZE)
return PyUnicode_FromUnicode((const Py_UNICODE*)buffer, bytesUsed / element_size);
return PyUnicode_FromSQLWCHAR((const SQLWCHAR*)buffer, bytesUsed / element_size);
}
if (bufferOwner && PyUnicode_CheckExact(bufferOwner))
{
if (PyUnicode_Resize(&bufferOwner, bytesUsed / element_size) == -1)
return 0;
PyObject* tmp = bufferOwner;
bufferOwner = 0;
buffer = 0;
return tmp;
}
if (bufferOwner && PyBytes_CheckExact(bufferOwner))
{
if (_PyBytes_Resize(&bufferOwner, bytesUsed) == -1)
return 0;
PyObject* tmp = bufferOwner;
bufferOwner = 0;
buffer = 0;
return tmp;
}
#if PY_VERSION_HEX >= 0x02060000
if (bufferOwner && PyByteArray_CheckExact(bufferOwner))
{
if (PyByteArray_Resize(bufferOwner, bytesUsed) == -1)
return 0;
PyObject* tmp = bufferOwner;
bufferOwner = 0;
buffer = 0;
return tmp;
}
#endif
// We have allocated our own SQLWCHAR buffer and must now copy it to a Unicode object.
I(bufferOwner == 0);
PyObject* result = PyUnicode_FromSQLWCHAR((const SQLWCHAR*)buffer, bytesUsed / element_size);
if (result == 0)
return false;
pyodbc_free(buffer);
buffer = 0;
return result;
}
static PyObject *Py_write_png(PyObject *self, PyObject *args, PyObject *kwds)
{
numpy::array_view<unsigned char, 3> buffer;
PyObject *filein;
double dpi = 0;
int compression = 6;
int filter = -1;
const char *names[] = { "buffer", "file", "dpi", "compression", "filter", NULL };
// We don't need strict contiguity, just for each row to be
// contiguous, and libpng has special handling for getting RGB out
// of RGBA, ARGB or BGR. But the simplest thing to do is to
// enforce contiguity using array_view::converter_contiguous.
if (!PyArg_ParseTupleAndKeywords(args,
kwds,
"O&O|dii:write_png",
(char **)names,
&buffer.converter_contiguous,
&buffer,
&filein,
&dpi,
&compression,
&filter)) {
return NULL;
}
png_uint_32 width = (png_uint_32)buffer.dim(1);
png_uint_32 height = (png_uint_32)buffer.dim(0);
int channels = buffer.dim(2);
std::vector<png_bytep> row_pointers(height);
for (png_uint_32 row = 0; row < (png_uint_32)height; ++row) {
row_pointers[row] = (png_bytep)buffer[row].data();
}
FILE *fp = NULL;
mpl_off_t offset = 0;
bool close_file = false;
bool close_dup_file = false;
PyObject *py_file = NULL;
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
struct png_color_8_struct sig_bit;
int png_color_type;
buffer_t buff;
buff.str = NULL;
switch (channels) {
case 1:
png_color_type = PNG_COLOR_TYPE_GRAY;
break;
case 3:
png_color_type = PNG_COLOR_TYPE_RGB;
break;
case 4:
png_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
break;
default:
PyErr_SetString(PyExc_ValueError,
"Buffer must be an NxMxD array with D in 1, 3, 4 "
"(grayscale, RGB, RGBA)");
goto exit;
}
if (compression < 0 || compression > 9) {
PyErr_Format(PyExc_ValueError,
"compression must be in range 0-9, got %d", compression);
goto exit;
}
if (PyBytes_Check(filein) || PyUnicode_Check(filein)) {
if ((py_file = mpl_PyFile_OpenFile(filein, (char *)"wb")) == NULL) {
goto exit;
}
close_file = true;
} else {
py_file = filein;
}
if (filein == Py_None) {
buff.size = width * height * 4 + 1024;
buff.str = PyBytes_FromStringAndSize(NULL, buff.size);
if (buff.str == NULL) {
goto exit;
}
buff.cursor = 0;
} else if ((fp = mpl_PyFile_Dup(py_file, (char *)"wb", &offset))) {
close_dup_file = true;
} else {
PyErr_Clear();
PyObject *write_method = PyObject_GetAttrString(py_file, "write");
if (!(write_method && PyCallable_Check(write_method))) {
Py_XDECREF(write_method);
PyErr_SetString(PyExc_TypeError,
"Object does not appear to be a 8-bit string path or "
"a Python file-like object");
goto exit;
}
Py_XDECREF(write_method);
}
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
PyErr_SetString(PyExc_RuntimeError, "Could not create write struct");
goto exit;
}
png_set_compression_level(png_ptr, compression);
if (filter >= 0) {
png_set_filter(png_ptr, 0, filter);
}
info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL) {
PyErr_SetString(PyExc_RuntimeError, "Could not create info struct");
goto exit;
}
if (setjmp(png_jmpbuf(png_ptr))) {
PyErr_SetString(PyExc_RuntimeError, "libpng signaled error");
goto exit;
}
if (buff.str) {
png_set_write_fn(png_ptr, (void *)&buff, &write_png_data_buffer, &flush_png_data_buffer);
} else if (fp) {
png_init_io(png_ptr, fp);
} else {
png_set_write_fn(png_ptr, (void *)py_file, &write_png_data, &flush_png_data);
}
png_set_IHDR(png_ptr,
info_ptr,
width,
height,
8,
png_color_type,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE,
PNG_FILTER_TYPE_BASE);
// Save the dpi of the image in the file
if (dpi > 0.0) {
png_uint_32 dots_per_meter = (png_uint_32)(dpi / (2.54 / 100.0));
png_set_pHYs(png_ptr, info_ptr, dots_per_meter, dots_per_meter, PNG_RESOLUTION_METER);
}
sig_bit.alpha = 0;
switch (png_color_type) {
case PNG_COLOR_TYPE_GRAY:
sig_bit.gray = 8;
sig_bit.red = 0;
sig_bit.green = 0;
sig_bit.blue = 0;
break;
case PNG_COLOR_TYPE_RGB_ALPHA:
sig_bit.alpha = 8;
// fall through
case PNG_COLOR_TYPE_RGB:
sig_bit.gray = 0;
sig_bit.red = 8;
sig_bit.green = 8;
sig_bit.blue = 8;
break;
default:
PyErr_SetString(PyExc_RuntimeError, "internal error, bad png_color_type");
goto exit;
}
png_set_sBIT(png_ptr, info_ptr, &sig_bit);
png_write_info(png_ptr, info_ptr);
png_write_image(png_ptr, &row_pointers[0]);
png_write_end(png_ptr, info_ptr);
exit:
if (png_ptr && info_ptr) {
png_destroy_write_struct(&png_ptr, &info_ptr);
}
if (close_dup_file) {
mpl_PyFile_DupClose(py_file, fp, offset);
}
if (close_file) {
mpl_PyFile_CloseFile(py_file);
Py_DECREF(py_file);
}
if (PyErr_Occurred()) {
Py_XDECREF(buff.str);
return NULL;
} else {
if (buff.str) {
_PyBytes_Resize(&buff.str, buff.cursor);
return buff.str;
}
Py_RETURN_NONE;
}
}
/* Reads a buffer of file entry data at a specific offset from EWF file(s)
* Returns a Python object holding the data if successful or NULL on error
*/
PyObject *pyewf_file_entry_read_buffer_at_offset(
pyewf_file_entry_t *pyewf_file_entry,
PyObject *arguments,
PyObject *keywords )
{
libcerror_error_t *error = NULL;
PyObject *string_object = NULL;
static char *function = "pyewf_file_entry_read_buffer_at_offset";
static char *keyword_list[] = { "size", "offset", NULL };
char *buffer = NULL;
off64_t read_offset = 0;
ssize_t read_count = 0;
int read_size = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf file_entry.",
function );
return( NULL );
}
if( pyewf_file_entry->file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf file_entry - missing libewf file_entry.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"i|L",
keyword_list,
&read_size,
&read_offset ) == 0 )
{
return( NULL );
}
if( read_size < 0 )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid argument read size value less than zero.",
function );
return( NULL );
}
/* Make sure the data fits into a memory buffer
*/
if( read_size > INT_MAX )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid argument read size value exceeds maximum.",
function );
return( NULL );
}
if( read_offset < 0 )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid argument read offset value less than zero.",
function );
return( NULL );
}
/* Make sure the data fits into a memory buffer
*/
#if PY_MAJOR_VERSION >= 3
string_object = PyBytes_FromStringAndSize(
NULL,
read_size );
buffer = PyBytes_AsString(
string_object );
#else
string_object = PyString_FromStringAndSize(
NULL,
read_size );
buffer = PyString_AsString(
string_object );
#endif
Py_BEGIN_ALLOW_THREADS
read_count = libewf_file_entry_read_buffer_at_offset(
pyewf_file_entry->file_entry,
(uint8_t *) buffer,
(size_t) read_size,
(off64_t) read_offset,
&error );
Py_END_ALLOW_THREADS
if( read_count <= -1 )
{
pyewf_error_raise(
error,
PyExc_IOError,
"%s: unable to read data.",
function );
libcerror_error_free(
&error );
Py_DecRef(
(PyObject *) string_object );
return( NULL );
}
/* Need to resize the string here in case read_size was not fully read.
*/
#if PY_MAJOR_VERSION >= 3
if( _PyBytes_Resize(
&string_object,
(Py_ssize_t) read_count ) != 0 )
#else
if( _PyString_Resize(
&string_object,
(Py_ssize_t) read_count ) != 0 )
#endif
{
Py_DecRef(
(PyObject *) string_object );
return( NULL );
}
return( string_object );
}
