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 ); }