static int
on_eom(uint64_t id, size_t sz)
{
PyObject *py_args;
PyObject *py_ret;
PyObject *py_id;
PyObject *py_sz;
py_args = PyTuple_New(2);
py_id = PyLong_FromUnsignedLongLong(id);
py_sz = PyLong_FromSize_t(sz);
PyTuple_SetItem(py_args, 0, py_id);
PyTuple_SetItem(py_args, 1, py_sz);
py_ret = PyObject_CallObject(py_on_eom, py_args);
Py_DECREF(py_args);
if (py_ret == NULL) {
PyErr_Print();
log_warnx("warn: filter-python: call to on_eom handler failed");
exit(1);
}
return (1);
}
PyObject *
option(PyObject *self, PyObject *args)
{
long option;
int error;
PyObject *py_option;
py_option = PyTuple_GetItem(args, 0);
if (!py_option)
return NULL;
if (!PyLong_Check(py_option))
goto on_non_integer;
option = PyLong_AsLong(py_option);
switch (option) {
case GIT_OPT_GET_SEARCH_PATH:
{
PyObject *py_level;
py_level = PyTuple_GetItem(args, 1);
if (!py_level)
return NULL;
if (!PyLong_Check(py_level))
goto on_non_integer;
return get_search_path(PyLong_AsLong(py_level));
break;
}
case GIT_OPT_SET_SEARCH_PATH:
{
PyObject *py_level, *py_path, *tpath;
const char *path;
int err;
py_level = PyTuple_GetItem(args, 1);
if (!py_level)
return NULL;
py_path = PyTuple_GetItem(args, 2);
if (!py_path)
return NULL;
if (!PyLong_Check(py_level))
goto on_non_integer;
path = py_str_borrow_c_str(&tpath, py_path, NULL);
if (!path)
return NULL;
err = git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, PyLong_AsLong(py_level), path);
Py_DECREF(tpath);
if (err < 0) {
Error_set(err);
return NULL;
}
Py_RETURN_NONE;
break;
}
case GIT_OPT_GET_MWINDOW_SIZE:
{
size_t size;
error = git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &size);
if (error < 0) {
Error_set(error);
return NULL;
}
return PyLong_FromSize_t(size);
break;
}
case GIT_OPT_SET_MWINDOW_SIZE:
{
size_t size;
PyObject *py_size;
py_size = PyTuple_GetItem(args, 1);
if (!py_size)
return NULL;
if (!PyLong_Check(py_size))
goto on_non_integer;
size = PyLong_AsSize_t(py_size);
error = git_libgit2_opts(GIT_OPT_SET_MWINDOW_SIZE, size);
if (error < 0) {
Error_set(error);
return NULL;
}
Py_RETURN_NONE;
break;
}
case GIT_OPT_GET_MWINDOW_MAPPED_LIMIT:
{
size_t limit;
error = git_libgit2_opts(GIT_OPT_GET_MWINDOW_MAPPED_LIMIT, &limit);
if (error < 0) {
Error_set(error);
return NULL;
}
return PyLong_FromSize_t(limit);
break;
}
case GIT_OPT_SET_MWINDOW_MAPPED_LIMIT:
{
size_t limit;
PyObject *py_limit;
py_limit = PyTuple_GetItem(args, 1);
if (!py_limit)
return NULL;
if (!PyLong_Check(py_limit))
goto on_non_integer;
limit = PyLong_AsSize_t(py_limit);
error = git_libgit2_opts(GIT_OPT_SET_MWINDOW_MAPPED_LIMIT, limit);
if (error < 0) {
Error_set(error);
return NULL;
}
Py_RETURN_NONE;
break;
}
case GIT_OPT_SET_CACHE_OBJECT_LIMIT:
{
size_t limit;
int object_type;
PyObject *py_object_type, *py_limit;
py_object_type = PyTuple_GetItem(args, 1);
if (!py_object_type)
return NULL;
py_limit = PyTuple_GetItem(args, 2);
if (!py_limit)
return NULL;
if (!PyLong_Check(py_limit))
goto on_non_integer;
object_type = PyLong_AsLong(py_object_type);
limit = PyLong_AsSize_t(py_limit);
error = git_libgit2_opts(GIT_OPT_SET_CACHE_OBJECT_LIMIT, object_type, limit);
if (error < 0) {
Error_set(error);
return NULL;
}
Py_RETURN_NONE;
break;
}
case GIT_OPT_SET_CACHE_MAX_SIZE:
{
size_t max_size;
PyObject *py_max_size;
py_max_size = PyTuple_GetItem(args, 1);
if (!py_max_size)
return NULL;
if (!PyLong_Check(py_max_size))
goto on_non_integer;
max_size = PyLong_AsSize_t(py_max_size);
error = git_libgit2_opts(GIT_OPT_SET_CACHE_MAX_SIZE, max_size);
if (error < 0) {
Error_set(error);
return NULL;
}
Py_RETURN_NONE;
break;
}
case GIT_OPT_ENABLE_CACHING:
{
int flag;
PyObject *py_flag;
py_flag = PyTuple_GetItem(args, 1);
if (!PyLong_Check(py_flag))
goto on_non_integer;
flag = PyLong_AsSize_t(py_flag);
error = git_libgit2_opts(GIT_OPT_ENABLE_CACHING, flag);
if (error < 0) {
Error_set(error);
return NULL;
}
Py_RETURN_NONE;
break;
}
case GIT_OPT_GET_CACHED_MEMORY:
{
size_t current;
size_t allowed;
PyObject* tup = PyTuple_New(2);
error = git_libgit2_opts(GIT_OPT_GET_CACHED_MEMORY, ¤t, &allowed);
if (error < 0) {
Error_set(error);
return NULL;
}
PyTuple_SetItem(tup, 0, PyLong_FromLong(current));
PyTuple_SetItem(tup, 1, PyLong_FromLong(allowed));
return tup;
break;
}
}
PyErr_SetString(PyExc_ValueError, "unknown/unsupported option value");
return NULL;
on_non_integer:
PyErr_SetString(PyExc_TypeError, "option is not an integer");
return NULL;
}
static PyObject* DCRenderTargetNumberOfColorTextures(DCRenderTarget* self, PyObject*)
{
DCOBJECT_VALIDATE(self->target, NULL);
return PyLong_FromSize_t(self->target->NumberOfColorTextures());
}
PyObject *
DiffStats_files_changed__get__(DiffStats *self)
{
return PyLong_FromSize_t(git_diff_stats_files_changed(self->stats));
}
PyObject *
DiffStats_deletions__get__(DiffStats *self)
{
return PyLong_FromSize_t(git_diff_stats_deletions(self->stats));
}
static PyObject* DataTransferRequest_get_missing_byte_count(DataTransferRequest *self) {
CHECK_DTR_UQ(self, NULL);
return PyLong_FromSize_t(self->l_rem);
}
static PyObject *
memsys_get_stats_mi_free(PyObject *self, PyObject *args) {
return PyLong_FromSize_t(NRT_MemSys_get_stats_mi_free());
}
static PyObject *aqbanking_Account_transactions(aqbanking_Account* self, PyObject *args, PyObject *kwds)
{
int rv;
double tmpDateTime = 0;
const char *bank_code;
const char *account_no;
#if PY_VERSION_HEX >= 0x03030000
bank_code = PyUnicode_AsUTF8(self->bank_code);
account_no = PyUnicode_AsUTF8(self->no);
#else
PyObject *s = _PyUnicode_AsDefaultEncodedString(self->bank_code, NULL);
bank_code = PyBytes_AS_STRING(s);
s = _PyUnicode_AsDefaultEncodedString(self->no, NULL);
account_no = PyBytes_AS_STRING(s);
#endif
GWEN_TIME *gwTime;
const char *dateFrom=NULL, *dateTo=NULL;
static char *kwlist[] = {"dateFrom", "dateTo", NULL};
if (! PyArg_ParseTupleAndKeywords(args, kwds, "|ss", kwlist, &dateFrom, &dateTo))
{
return NULL;
}
AB_ACCOUNT *a;
AB_JOB *job = 0;
AB_JOB_LIST2 *jl = 0;
AB_IMEXPORTER_CONTEXT *ctx = 0;
AB_IMEXPORTER_ACCOUNTINFO *ai;
/*aqbanking_Transaction *trans = NULL;*/
PyObject *transList = PyList_New(0);
// Valid data set?
if (self->no == NULL)
{
PyErr_SetString(PyExc_AttributeError, "no");
}
if (self->bank_code == NULL)
{
PyErr_SetString(PyExc_AttributeError, "bank_code");
}
// Initialize aqbanking.
rv = AB_create(self);
if (rv > 0)
{
Py_DECREF(transList);
return NULL;
}
// Let us find the account!
a = AB_Banking_GetAccountByCodeAndNumber(self->ab, bank_code, account_no);
if (!a)
{
PyErr_SetString(AccountNotFound, "Could not find the given account! ");
Py_DECREF(transList);
return NULL;
}
// Create job and execute it.
job = AB_JobGetTransactions_new(a);
if (dateFrom != NULL)
{
gwTime = GWEN_Time_fromString(dateFrom, "YYYYMMDD");
AB_JobGetTransactions_SetFromTime(job, gwTime);
}
if (dateTo != NULL)
{
gwTime = GWEN_Time_fromString(dateTo, "YYYYMMDD");
AB_JobGetTransactions_SetToTime(job, gwTime);
}
// Check for availability
rv = AB_Job_CheckAvailability(job);
if (rv) {
PyErr_SetString(ExecutionFailed, "Transaction retrieval is not supported!");
Py_DECREF(transList);
return NULL;
}
jl = AB_Job_List2_new();
AB_Job_List2_PushBack(jl, job);
ctx = AB_ImExporterContext_new();
rv = AB_Banking_ExecuteJobs(self->ab, jl, ctx);
if (rv)
{
PyErr_SetString(ExecutionFailed, "Could not retrieve transactions!");
Py_DECREF(transList);
return NULL;
}
// With success. No process the result.
ai = AB_ImExporterContext_GetFirstAccountInfo (ctx);
while(ai)
{
const AB_TRANSACTION *t;
t = AB_ImExporterAccountInfo_GetFirstTransaction(ai);
while(t) {
const AB_VALUE *v;
AB_TRANSACTION_STATUS state;
v=AB_Transaction_GetValue(t);
if (v) {
const GWEN_STRINGLIST *sl;
const GWEN_TIME *tdtime;
const char *purpose;
const char *remoteName;
aqbanking_Transaction *trans = (aqbanking_Transaction*) PyObject_CallObject((PyObject *) &aqbanking_TransactionType, NULL);
/* The purpose (memo field) might contain multiple lines.
* Therefore AqBanking stores the purpose in a string list
* of which the first entry is used in this tutorial */
sl = AB_Transaction_GetPurpose(t);
if (sl)
{
purpose = GWEN_StringList_FirstString(sl);
if (purpose == NULL) {
purpose = "";
}
}
else
{
purpose = "";
}
#ifdef DEBUGSTDERR
fprintf(stderr, "[%-10d]: [%-10s/%-10s][%-10s/%-10s] %-32s (%.2f %s)\n",
AB_Transaction_GetUniqueId(t),
AB_Transaction_GetRemoteIban(t),
AB_Transaction_GetRemoteBic(t),
AB_Transaction_GetRemoteAccountNumber(t),
AB_Transaction_GetRemoteBankCode(t),
purpose,
AB_Value_GetValueAsDouble(v),
AB_Value_GetCurrency(v)
);
#endif
tdtime = AB_Transaction_GetDate(t);
tmpDateTime = PyLong_AsDouble(PyLong_FromSize_t(GWEN_Time_Seconds(tdtime)));
trans->date = PyDate_FromTimestamp(Py_BuildValue("(O)", PyFloat_FromDouble(tmpDateTime)));
tdtime = AB_Transaction_GetValutaDate(t);
tmpDateTime = PyLong_AsDouble(PyLong_FromSize_t(GWEN_Time_Seconds(tdtime)));
trans->valutaDate = PyDate_FromTimestamp(Py_BuildValue("(O)", PyFloat_FromDouble(tmpDateTime)));
trans->purpose = PyUnicode_FromString(purpose);
// Local user
if (AB_Transaction_GetLocalAccountNumber(t) == NULL) {
trans->localAccount = Py_None;
Py_INCREF(Py_None);
} else {
trans->localAccount = PyUnicode_FromString(AB_Transaction_GetLocalAccountNumber(t));
}
if (AB_Transaction_GetLocalBankCode(t) == NULL) {
trans->localBank = Py_None;
Py_INCREF(Py_None);
} else {
trans->localBank = PyUnicode_FromString(AB_Transaction_GetLocalBankCode(t));
}
if (AB_Transaction_GetLocalIban(t) == NULL) {
trans->localIban = Py_None;
Py_INCREF(Py_None);
} else {
trans->localIban = PyUnicode_FromString(AB_Transaction_GetLocalIban(t));
}
if (AB_Transaction_GetLocalBic(t) == NULL) {
trans->localBic = Py_None;
Py_INCREF(Py_None);
} else {
trans->localBic = PyUnicode_FromString(AB_Transaction_GetLocalBic(t));
}
if (AB_Transaction_GetLocalName(t) == NULL) {
trans->localName = Py_None;
Py_INCREF(Py_None);
} else {
trans->localName = PyUnicode_FromString(AB_Transaction_GetLocalName(t));
}
// Remote user
if (AB_Transaction_GetRemoteAccountNumber(t) == NULL) {
trans->remoteAccount = Py_None;
Py_INCREF(Py_None);
} else {
trans->remoteAccount = PyUnicode_FromString(AB_Transaction_GetRemoteAccountNumber(t));
}
if (AB_Transaction_GetRemoteBankCode(t) == NULL) {
trans->remoteBank = Py_None;
Py_INCREF(Py_None);
} else {
trans->remoteBank = PyUnicode_FromString(AB_Transaction_GetRemoteBankCode(t));
}
if (AB_Transaction_GetRemoteIban(t) == NULL) {
trans->remoteIban = Py_None;
Py_INCREF(Py_None);
} else {
trans->remoteIban = PyUnicode_FromString(AB_Transaction_GetRemoteIban(t));
}
if (AB_Transaction_GetRemoteBic(t) == NULL) {
trans->remoteBic = Py_None;
Py_INCREF(Py_None);
} else {
trans->remoteBic = PyUnicode_FromString(AB_Transaction_GetRemoteBic(t));
}
if (AB_Transaction_GetRemoteName(t) == NULL) {
trans->remoteName = Py_None;
Py_INCREF(Py_None);
} else {
sl = AB_Transaction_GetRemoteName(t);
remoteName = GWEN_StringList_FirstString(sl);
if (remoteName == NULL) {
trans->remoteName = Py_None;
} else {
trans->remoteName = PyUnicode_FromString(remoteName);
}
}
trans->value = PyFloat_FromDouble(AB_Value_GetValueAsDouble(v));
trans->currency = PyUnicode_FromString("EUR");
trans->uniqueId = PyLong_FromLong(AB_Transaction_GetUniqueId(t));
if (AB_Transaction_GetTransactionText(t) == NULL) {
trans->transactionText = PyUnicode_FromString("");
} else {
trans->transactionText = PyUnicode_FromString(AB_Transaction_GetTransactionText(t));
}
trans->transactionCode = PyLong_FromLong(AB_Transaction_GetTransactionCode(t));
trans->textKey = PyLong_FromLong(AB_Transaction_GetTextKey(t));
trans->textKeyExt = PyLong_FromLong(AB_Transaction_GetTextKeyExt(t));
if (AB_Transaction_GetMandateId(t) == NULL) {
trans->sepaMandateId = Py_None;
} else {
trans->sepaMandateId = PyUnicode_FromString(AB_Transaction_GetMandateId(t));
}
if (AB_Transaction_GetCustomerReference(t) == NULL) {
trans->customerReference = PyUnicode_FromString("");
} else {
trans->customerReference = PyUnicode_FromString(AB_Transaction_GetCustomerReference(t));
}
if (AB_Transaction_GetBankReference(t) == NULL) {
trans->bankReference = PyUnicode_FromString("");
} else {
trans->bankReference = PyUnicode_FromString(AB_Transaction_GetBankReference(t));
}
if (AB_Transaction_GetEndToEndReference(t) == NULL) {
trans->endToEndReference = PyUnicode_FromString("");
} else {
trans->endToEndReference = PyUnicode_FromString(AB_Transaction_GetEndToEndReference(t));
}
trans->state = 0;
state = AB_Transaction_GetStatus(t);
switch(state)
{
case AB_Transaction_StatusUnknown:
trans->state = -1;
break;
case AB_Transaction_StatusNone:
trans->state = 0;
break;
case AB_Transaction_StatusAccepted:
trans->state = 1;
break;
case AB_Transaction_StatusRejected:
trans->state = 2;
break;
case AB_Transaction_StatusPending:
trans->state = 4;
break;
case AB_Transaction_StatusSending:
trans->state = 8;
break;
case AB_Transaction_StatusAutoReconciled:
trans->state = 16;
break;
case AB_Transaction_StatusManuallyReconciled:
trans->state = 32;
break;
case AB_Transaction_StatusRevoked:
trans->state = 64;
break;
case AB_Transaction_StatusAborted:
trans->state = 128;
break;
}
PyList_Append(transList, (PyObject *)trans);
Py_DECREF(trans);
}
t = AB_ImExporterAccountInfo_GetNextTransaction(ai);
}
ai = AB_ImExporterContext_GetNextAccountInfo(ctx);
}
// Free jobs.
AB_Job_free(job);
AB_Job_List2_free(jl);
AB_ImExporterContext_free(ctx);
// Exit aqbanking.
rv = AB_free(self);
if (rv > 0)
{
//Py_XDECREF(trans);
Py_DECREF(transList);
return NULL;
}
return transList;
}
static PyObject* DCTextureBytesPerPixel(DCTexture* self, void*)
{
DCOBJECT_VALIDATE(self->texture, NULL);
return PyLong_FromSize_t(self->texture->BytesPerPixel());
}
static PyObject* DCStaticTriangleMeshShapeNumberOfTriangles(DCStaticTriangleMeshShape* self, PyObject*)
{
DCOBJECT_VALIDATE(self->shape, NULL);
return PyLong_FromSize_t(self->shape->NumberOfTriangles());
}
static PyObject* DCTextureNumberOfComponents(DCTexture* self, void*)
{
DCOBJECT_VALIDATE(self->texture, NULL);
return PyLong_FromSize_t(self->texture->NumberOfComponents());
}
static PyObject* DCMultiSphereShapeNumberOfSpheres(DCMultiSphereShape* self, PyObject*)
{
DCOBJECT_VALIDATE(self->shape, NULL);
return PyLong_FromSize_t(self->shape->NumberOfSpheres());
}
PyObject *
option(PyObject *self, PyObject *args)
{
long option;
int error;
PyObject *py_option;
py_option = PyTuple_GetItem(args, 0);
if (!py_option)
return NULL;
if (!PyLong_Check(py_option))
goto on_non_integer;
option = PyLong_AsLong(py_option);
switch (option) {
case GIT_OPT_GET_SEARCH_PATH:
{
PyObject *py_level;
py_level = PyTuple_GetItem(args, 1);
if (!py_level)
return NULL;
if (!PyLong_Check(py_level))
goto on_non_integer;
return get_search_path(PyLong_AsLong(py_level));
break;
}
case GIT_OPT_SET_SEARCH_PATH:
{
PyObject *py_level, *py_path, *tpath;
const char *path;
int err;
py_level = PyTuple_GetItem(args, 1);
if (!py_level)
return NULL;
py_path = PyTuple_GetItem(args, 2);
if (!py_path)
return NULL;
if (!PyLong_Check(py_level))
goto on_non_integer;
path = py_str_borrow_c_str(&tpath, py_path, NULL);
if (!path)
return NULL;
err = git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, PyLong_AsLong(py_level), path);
Py_DECREF(tpath);
if (err < 0) {
Error_set(err);
return NULL;
}
Py_RETURN_NONE;
break;
}
case GIT_OPT_GET_MWINDOW_SIZE:
{
size_t size;
error = git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &size);
if (error < 0) {
Error_set(error);
return NULL;
}
return PyLong_FromSize_t(size);
break;
}
case GIT_OPT_SET_MWINDOW_SIZE:
{
size_t size;
PyObject *py_size;
py_size = PyTuple_GetItem(args, 1);
if (!py_size)
return NULL;
if (!PyLong_Check(py_size))
goto on_non_integer;
size = PyLong_AsSize_t(py_size);
error = git_libgit2_opts(GIT_OPT_SET_MWINDOW_SIZE, size);
if (error < 0) {
Error_set(error);
return NULL;
}
Py_RETURN_NONE;
break;
}
}
PyErr_SetString(PyExc_ValueError, "unknown/unsupported option value");
return NULL;
on_non_integer:
PyErr_SetString(PyExc_TypeError, "option is not an integer");
return NULL;
}
static PyObject* PyPointlessVector_sizeof(PyPointlessVector* self)
{
return PyLong_FromSize_t(sizeof(PyPointlessVector));
}
/* Reads a buffer from the file object
* Make sure to hold the GIL state before calling this function
* Returns the number of bytes read if successful, or -1 on error
*/
ssize_t pyewf_file_object_read_buffer(
PyObject *file_object,
uint8_t *buffer,
size_t size,
libcerror_error_t **error )
{
PyObject *argument_size = NULL;
PyObject *exception_string = NULL;
PyObject *exception_traceback = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyObject *method_name = NULL;
PyObject *method_result = NULL;
char *error_string = NULL;
char *safe_buffer = NULL;
static char *function = "pyewf_file_object_read_buffer";
Py_ssize_t safe_read_count = 0;
ssize_t read_count = 0;
int result = 0;
if( file_object == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file object.",
function );
return( -1 );
}
if( buffer == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid buffer.",
function );
return( -1 );
}
if( size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid size value exceeds maximum.",
function );
return( -1 );
}
if( size > 0 )
{
method_name = PyString_FromString(
"read" );
argument_size = PyLong_FromSize_t(
size );
PyErr_Clear();
method_result = PyObject_CallMethodObjArgs(
file_object,
method_name,
argument_size,
NULL );
if( PyErr_Occurred() )
{
PyErr_Fetch(
&exception_type,
&exception_value,
&exception_traceback );
exception_string = PyObject_Repr(
exception_value );
error_string = PyString_AsString(
exception_string );
if( error_string != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read from file object with error: %s.",
function,
error_string );
}
else
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read from file object.",
function );
}
Py_DecRef(
exception_string );
goto on_error;
}
result = PyString_AsStringAndSize(
method_result,
&safe_buffer,
&safe_read_count );
if( result == -1 )
{
PyErr_Fetch(
&exception_type,
&exception_value,
&exception_traceback );
exception_string = PyObject_Repr(
exception_value );
error_string = PyString_AsString(
exception_string );
if( error_string != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read from file object with error: %s.",
function,
error_string );
}
else
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read from file object.",
function );
}
Py_DecRef(
exception_string );
goto on_error;
}
if( safe_read_count > (Py_ssize_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid read count value exceeds maximum.",
function );
goto on_error;
}
read_count = (ssize_t) safe_read_count;
if( memory_copy(
buffer,
safe_buffer,
read_count ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to data to buffer.",
function );
goto on_error;
}
Py_DecRef(
method_result );
Py_DecRef(
argument_size );
Py_DecRef(
method_name );
}
return( read_count );
on_error:
if( method_result != NULL )
{
Py_DecRef(
method_result );
}
if( argument_size != NULL )
{
Py_DecRef(
argument_size );
}
if( method_name != NULL )
{
Py_DecRef(
method_name );
}
return( -1 );
}
/* Reads a buffer from the file object
* Make sure to hold the GIL state before calling this function
* Returns the number of bytes read if successful, or -1 on error
*/
ssize_t pymsiecf_file_object_read_buffer(
PyObject *file_object,
uint8_t *buffer,
size_t size,
libcerror_error_t **error )
{
PyObject *argument_size = NULL;
PyObject *method_name = NULL;
PyObject *method_result = NULL;
char *safe_buffer = NULL;
static char *function = "pymsiecf_file_object_read_buffer";
Py_ssize_t safe_read_count = 0;
ssize_t read_count = 0;
int result = 0;
if( file_object == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file object.",
function );
return( -1 );
}
if( buffer == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid buffer.",
function );
return( -1 );
}
if( size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid size value exceeds maximum.",
function );
return( -1 );
}
if( size > 0 )
{
#if PY_MAJOR_VERSION >= 3
method_name = PyUnicode_FromString(
"read" );
#else
method_name = PyString_FromString(
"read" );
#endif
argument_size = PyLong_FromSize_t(
size );
PyErr_Clear();
method_result = PyObject_CallMethodObjArgs(
file_object,
method_name,
argument_size,
NULL );
if( PyErr_Occurred() )
{
pymsiecf_error_fetch(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read from file object.",
function );
goto on_error;
}
if( method_result == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: missing method result.",
function );
goto on_error;
}
#if PY_MAJOR_VERSION >= 3
result = PyObject_IsInstance(
method_result,
(PyObject *) &PyBytes_Type );
#else
result = PyObject_IsInstance(
method_result,
(PyObject *) &PyString_Type );
#endif
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine if method result is a binary string object.",
function );
goto on_error;
}
else if( result == 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: invalid method result value is not a binary string object.",
function );
goto on_error;
}
#if PY_MAJOR_VERSION >= 3
result = PyBytes_AsStringAndSize(
method_result,
&safe_buffer,
&safe_read_count );
#else
result = PyString_AsStringAndSize(
method_result,
&safe_buffer,
&safe_read_count );
#endif
if( result == -1 )
{
pymsiecf_error_fetch(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read from file object.",
function );
goto on_error;
}
if( safe_read_count > (Py_ssize_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid read count value exceeds maximum.",
function );
goto on_error;
}
read_count = (ssize_t) safe_read_count;
if( memory_copy(
buffer,
safe_buffer,
read_count ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to data to buffer.",
function );
goto on_error;
}
Py_DecRef(
method_result );
Py_DecRef(
argument_size );
Py_DecRef(
method_name );
}
return( read_count );
on_error:
if( method_result != NULL )
{
Py_DecRef(
method_result );
}
if( argument_size != NULL )
{
Py_DecRef(
argument_size );
}
if( method_name != NULL )
{
Py_DecRef(
method_name );
}
return( -1 );
}
PyObject * PyContentEntry_getChecksum( PyContentEntry * contentEntry, PyObject * args )
{
return PyLong_FromSize_t( contentEntry->ptr->checksum );
}
static PyObject *
mmap_tell_method(mmap_object *self, PyObject *unused)
{
CHECK_VALID(NULL);
return PyLong_FromSize_t(self->pos);
}
static PyObject *pair_str(PyObject *self) {
PyObject *tmp = NULL;
PyObject *col = PyList_New(0);
PyObject *found = PyDict_New();
size_t index = 0;
PyObject *rest = self;
PyObject *rest_id;
PyList_Append(col, _str_open_paren);
for (rest = self; SibPair_CheckExact(rest); rest = SibPair_CDR(rest)) {
rest_id = PyLong_FromVoidPtr(rest);
if (PyDict_Contains(found, rest_id)) {
/* recursive pair detected */
PyList_Append(col, _str_elipsis);
PyList_Append(col, _str_close_paren);
if (rest != self) {
tmp = PyDict_GetItem(found, rest_id);
PyList_Insert(col, PyLong_AsSize_t(tmp) - 1, _str_open_paren);
PyList_Insert(col, PyLong_AsSize_t(tmp) - 1, _str_dot_space);
PyList_Append(col, _str_close_paren);
}
Py_DECREF(rest_id);
/* set rest to NULL so we don't try to close it like we would a
normal proper or improper list */
rest = NULL;
break;
} else {
index += 2;
tmp = PyLong_FromSize_t(index);
PyDict_SetItem(found, rest_id, tmp);
Py_DECREF(tmp);
Py_DECREF(rest_id);
tmp = SibPair_CAR(rest);
if (PyUnicode_CheckExact(tmp)) {
tmp = sib_quoted(tmp);
} else {
tmp = PyObject_Str(tmp);
}
PyList_Append(col, tmp);
Py_DECREF(tmp);
PyList_Append(col, _str_space);
}
}
if(SibNil_Check(rest)) {
/* end of a proper list */
Py_INCREF(_str_close_paren);
PyList_SetItem(col, index, _str_close_paren);
} else if (rest) {
/* end of an improper list */
tmp = rest;
if (PyUnicode_CheckExact(tmp)) {
tmp = sib_quoted(tmp);
} else {
tmp = PyObject_Str(tmp);
}
PyList_Append(col, _str_dot_space);
PyList_Append(col, tmp);
PyList_Append(col, _str_close_paren);
Py_DECREF(tmp);
}
tmp = PyUnicode_Join(_str_empty, col);
Py_DECREF(col);
Py_DECREF(found);
return tmp;
}
