int libvirt_charPtrSizeUnwrap(PyObject *obj, char **str, Py_ssize_t *size)
{
int ret;
#if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION <= 4
int isize;
#endif
*str = NULL;
*size = 0;
if (!obj) {
PyErr_SetString(PyExc_TypeError, "unexpected type");
return -1;
}
#if PY_MAJOR_VERSION > 2
ret = PyBytes_AsStringAndSize(obj, str, size);
#else
# if PY_MINOR_VERSION <= 4
ret = PyString_AsStringAndSize(obj, str, &isize);
*size = isize;
# else
ret = PyString_AsStringAndSize(obj, str, size);
# endif
#endif
return ret;
}
static PyObject *
c_set_instance(PyObject *self, PyObject *args, PyObject *kwargs)
{
struct pack *p;
int ret;
PyObject *key, *value;
char *str;
size_t strlen;
int pos = 0;
proc_check_shutdown();
p = pack_new(512);
if (!p) return NULL;
while(PyDict_Next(kwargs, &pos, &key, &value)) {
PyString_AsStringAndSize(key, &str, &strlen);
pack_put(p, str, strlen);
PyString_AsStringAndSize(value, &str, &strlen);
pack_put(p, str, strlen);
}
ret = db_put_profile(bk_node, bk_app, p);
if (ret != 0) return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static std::string
KyotoDB_dump(PyObject *obj, bool use_pickle, bool *ok)
{
*ok = false;
if (use_pickle) {
APR pydata(PyObject_CallFunctionObjArgs(pickle_dumps, obj, NULL));
if (PyErr_Occurred() != NULL)
return "";
char *buffer;
Py_ssize_t size;
if (PyString_AsStringAndSize(pydata, &buffer, &size) < 0) {
return "";
}
*ok = true;
return std::string(buffer, size);
} else {
char *buffer;
Py_ssize_t size;
if (PyString_AsStringAndSize(obj, &buffer, &size) < 0) {
return "";
}
*ok = true;
return std::string(buffer, size);
}
}
PyObject * bitz_get_response( PyObject * self, PyObject * args ) {
PyObject * pyresponse;
PyObject * pypayload;
icap::Response * response = NULL;
unsigned int resp_status;
icap::payload_t payload;
// vars to ferry across strings from python dictionary to c++
char * pybuffer;
Py_ssize_t pybuflen;
// logger
bitz::Logger &logger = bitz::Logger::instance();
logger.debug( "[modpy.interface] get_response()" );
// parse args
if ( PyArg_ParseTuple( args, "IO!", &resp_status, &PyDict_Type, &pypayload ) ) {
// copy strings from python dictionary
PyString_AsStringAndSize( PyDict_GetItemString( pypayload, "req_header" ), &pybuffer, &pybuflen );
payload.req_header.assign( pybuffer, pybuflen );
PyString_AsStringAndSize( PyDict_GetItemString( pypayload, "req_body" ), &pybuffer, &pybuflen );
payload.req_body.assign( pybuffer, pybuflen );
PyString_AsStringAndSize( PyDict_GetItemString( pypayload, "res_header" ), &pybuffer, &pybuflen );
payload.res_header.assign( pybuffer, pybuflen );
PyString_AsStringAndSize( PyDict_GetItemString( pypayload, "res_body" ), &pybuffer, &pybuflen );
payload.res_body.assign( pybuffer, pybuflen );
// copy other data types from python dictionary
payload.ieof = PyBool_Check( PyDict_GetItemString( pypayload, "ieof" ) );
// construct the response object
response = new icap::Response( (icap::ResponseHeader::status_t) resp_status );
response->payload( payload );
} else {
logger.warn( "[modpy.interface] failed to parse arguments" );
}
// sanity check
if ( response == NULL ) {
response = new icap::Response( icap::ResponseHeader::SERVER_ERROR );
}
// convert the response into a capsule
pyresponse = PyCapsule_New( (void *) response, "response", NULL );
return pyresponse;
}
static PyObject*
th_brk_(PyObject *self, PyObject *args)
{
PyObject *result = NULL;
Py_UNICODE *s1;
int s1_len;
if (!PyArg_ParseTuple(args, "u#", &s1, &s1_len)) {
PyErr_SetString(PyExc_TypeError, "parameter must be unicode");
return NULL;
}
if(s1_len == 0) {
PyErr_SetString(PyExc_ValueError, "parameter must not be empty string");
return NULL;
}
PyObject *txt_cp874 = PyUnicode_Encode(s1, s1_len, "CP874", NULL);
if(txt_cp874 == NULL) {
return NULL;
}
Py_ssize_t len = PyString_Size(txt_cp874);
char *c_txt_cp874 = PyString_AsString(txt_cp874);
int *pos = (int *)malloc(sizeof(int) * (s1_len + 1));
int n = th_brk((unsigned char *)c_txt_cp874, pos, len);
int i, s = 0;
char *buffer;
result = PyList_New(0);
for(i = 0; i < n; i++) {
PyObject *tok;
PyObject *tok_cp874 = PySequence_GetSlice(txt_cp874, s, pos[i]);
Py_ssize_t tok_len;
PyString_AsStringAndSize(tok_cp874, &buffer, &tok_len);
tok = PyUnicode_Decode(buffer, tok_len, "CP874", NULL);
s = pos[i];
PyList_Append(result, tok);
Py_XDECREF(tok_cp874);
Py_XDECREF(tok);
}
if(s < len) {
PyObject *tok_cp874 = PySequence_GetSlice(txt_cp874, s, len);
Py_ssize_t tok_len;
PyObject *tok;
PyString_AsStringAndSize(tok_cp874, &buffer, &tok_len);
tok = PyUnicode_Decode(buffer, tok_len, "CP874", NULL);
PyList_Append(result, tok);
Py_XDECREF(tok_cp874);
Py_XDECREF(tok);
}
Py_XDECREF(txt_cp874);
free(pos);
return result;
}
static bool acpi_object_from_python(PyObject *pyobj, ACPI_OBJECT *obj)
{
PyObject *value;
if (pyobj == Py_None) {
obj->Type = ACPI_TYPE_ANY;
return true;
}
if (!PyArg_ParseTuple(pyobj, "IO:acpi_object_from_python", &obj->Type, &value))
return false;
switch (obj->Type) {
case ACPI_TYPE_INTEGER:
obj->Integer.Value = PyInt_AsUnsignedLongLongMask(value);
return true;
case ACPI_TYPE_STRING:
{
Py_ssize_t length;
if (PyString_AsStringAndSize(value, &obj->String.Pointer, &length) < 0)
return false;
if (length > GRUB_UINT_MAX) {
PyErr_Format(PyExc_RuntimeError, "Python object provided as ACPI string had > 4G of data");
return false;
}
obj->String.Length = length;
return true;
}
case ACPI_TYPE_BUFFER:
{
Py_ssize_t length;
if (PyString_AsStringAndSize(value, (char **)&obj->Buffer.Pointer, &length) < 0)
return false;
if (length > GRUB_UINT_MAX) {
PyErr_Format(PyExc_RuntimeError, "Python object provided as ACPI buffer had > 4G of data");
return false;
}
obj->Buffer.Length = length;
return true;
}
case ACPI_TYPE_PACKAGE:
return acpi_objects_from_python(value, &obj->Package.Elements, &obj->Package.Count);
case ACPI_TYPE_POWER:
return PyArg_ParseTuple(value, "II", &obj->PowerResource.SystemLevel, &obj->PowerResource.ResourceOrder);
case ACPI_TYPE_PROCESSOR:
return PyArg_ParseTuple(value, "IkI", &obj->Processor.ProcId, &obj->Processor.PblkAddress, &obj->Processor.PblkLength);
default:
PyErr_Format(PyExc_RuntimeError,
"Python object provided as ACPI method parameter used unhandled ACPI_OBJECT_TYPE %u.",
obj->Type);
return false;
}
}
static PyObject *
CdbMake_addmany(cdbmakeobject *self, PyObject *args) {
PyObject *list;
if (!PyArg_ParseTuple(args,"O!:addmany",&PyList_Type, &list))
return NULL;
if (self->finished) {
CDBMAKEfinished;
return NULL;
}
Py_ssize_t size = PyList_Size(list);
Py_ssize_t i;
for (i=0; i<size; i++)
{
PyObject *tuple = PyList_GetItem(list, i);
PyObject *key_item;
PyObject *data_item;
if (!PyTuple_Check(tuple)) {
PyErr_SetString(PyExc_TypeError, "list of tuples expected");
return NULL;
}
if (!(key_item = PyTuple_GetItem(tuple,0)))
return NULL;
if (!(data_item = PyTuple_GetItem(tuple,1)))
return NULL;
char *key, *dat;
Py_ssize_t klen, dlen;
if (PyString_AsStringAndSize(key_item, &key, &klen) < 0)
return NULL;
if (PyString_AsStringAndSize(data_item, &dat, &dlen) < 0)
return NULL;
if (cdb_make_add(&self->cm, key, klen, dat, dlen) == -1)
return CDBMAKEerr;
}
return Py_BuildValue("");
}
// This is called to fill the buffer when it gets too low:
static int PyPCAP_fill_buffer(PyPCAP *self, PyObject *fd) {
PyObject *data = PyObject_CallMethod(fd, "read", "l", FILL_SIZE);
char *buff;
Py_ssize_t len;
int current_readptr = self->buffer->readptr;
if(!data) return -1;
if(0 > PyString_AsStringAndSize(data, &buff, &len)) return -1;
if(!buff) return -1;
// Append the data to the end:
CALL(self->buffer, skip, self->buffer->readptr);
CALL(self->buffer, seek, 0, SEEK_END);
// Copy the data into our buffer:
CALL(self->buffer, write, buff, len);
CALL(self->buffer, seek, 0, SEEK_SET);
// self->buffer->readptr = current_readptr;
// Finished with the data
Py_DECREF(data);
return len;
};
PyObject * ppm_laplacian(PyObject *self, PyObject * args)
{
int width, height;
char *buffer;
unsigned char *data;
unsigned char *srcPR, *destPR;
Py_ssize_t datasize;
PyObject *py_data, *result;
dprint("Starting");
if (!PyArg_ParseTuple(args, "(ii)S", &width, &height, &py_data))
return NULL;
dprint("Parsing data");
PyString_AsStringAndSize(py_data, &buffer, &datasize);
data = (unsigned char *)(buffer);
dprint("width=%d", width);
dprint("height=%d", height);
dprint("datasize=%d", datasize);
if (width*height*3 != datasize) {
PyErr_SetString(PyExc_ValueError, "data size does not match 24bit");
return NULL;
}
destPR = malloc(datasize);
srcPR = malloc(datasize);
memcpy(srcPR, data, datasize);
laplace(width, height, srcPR, destPR);
result = Py_BuildValue("s#", destPR, datasize);
return result;
}
static void _read_png_data(PyObject* py_file_obj, png_bytep data, png_size_t length)
{
PyObject* read_method = PyObject_GetAttrString(py_file_obj, "read");
PyObject* result = NULL;
char *buffer;
Py_ssize_t bufflen;
if (read_method)
{
result = PyObject_CallFunction(read_method, (char *)"i", length);
}
#if PY_MAJOR_VERSION >= 3
PyObject* utf8_result = PyUnicode_AsUTF8String(result);
if (PyBytes_AsStringAndSize(utf8_result, &buffer, &bufflen) == 0)
#else
if (PyString_AsStringAndSize(result, &buffer, &bufflen) == 0)
#endif
{
if (bufflen == (Py_ssize_t)length)
{
memcpy(data, buffer, length);
}
}
Py_XDECREF(read_method);
Py_XDECREF(result);
}
static void idaapi s_py_get_user_defined_prefix(
ea_t ea,
int lnnum,
int indent,
const char *line,
char *buf,
size_t bufsize)
{
PYW_GIL_GET;
newref_t py_ret(
PyObject_CallFunction(
py_get_user_defined_prefix,
PY_FMT64 "iis" PY_FMT64,
ea, lnnum, indent, line, bufsize));
// Error? Display it
// No error? Copy the buffer
if ( !PyW_ShowCbErr("py_get_user_defined_prefix") )
{
Py_ssize_t py_len;
char *py_str;
if ( PyString_AsStringAndSize(py_ret.o, &py_str, &py_len) != -1 )
{
memcpy(buf, py_str, qmin(bufsize, py_len));
if ( py_len < bufsize )
buf[py_len] = '\0';
}
}
}
/* Caller is responsible for free-ing memory with PyMem_Free */
static bool
encoded_string_converter(PyObject *o, void *address) {
char **target = (char **)address;
char *buffer;
Py_ssize_t length;
if (o == NULL || o == Py_None) {
return 1;
}
if (PyUnicode_Check(o))
o = PyUnicode_AsEncodedString(o, ENCODING, "strict");
else
Py_INCREF(o);
if (PyString_AsStringAndSize(o, &buffer, &length) == -1) {
Py_DECREF(o);
return 0;
}
*target = PyMem_Malloc(length + 1);
if (target == NULL) {
PyErr_NoMemory();
Py_DECREF(o);
return 0;
}
strcpy(*target, buffer);
Py_DECREF(o);
return 1;
}
static PyObject *
_K_subscript(_K *self, PyObject *key)
{
int i;
K kobj = self->kobj;
char *skey;
int key_length;
int value_index = 1;
if (kobj->t != 5) {
PyErr_Format(PyExc_TypeError,
"k object of type %d is not a dictionary", kobj->t);
return NULL;
}
if (-1 == PyString_AsStringAndSize(key, &skey, &key_length)) {
return NULL;
}
if (skey[key_length-1] == '.') {
--key_length;
++value_index;
}
for (i=0; i < kobj->n; ++i) {
K e = KK(kobj)[i];
if (0 == strncmp(skey,Ks(KK(e)[0]),key_length)) {
PyTypeObject* type = self->ob_type;
_K* k = (_K*)type->tp_alloc(type, 0);
k->kobj = ci(KK(e)[value_index]);
return (PyObject*)k;
}
}
PyErr_SetObject(PyExc_KeyError, key);
return NULL;
}
/*
#<pydoc>
def dbg_read_memory(ea, sz):
"""
Reads from the debugee's memory at the specified ea
@return:
- The read buffer (as a string)
- Or None on failure
"""
pass
#</pydoc>
*/
static PyObject *dbg_read_memory(PyObject *py_ea, PyObject *py_sz)
{
PYW_GIL_CHECK_LOCKED_SCOPE();
uint64 ea, sz;
if ( !dbg_can_query() || !PyW_GetNumber(py_ea, &ea) || !PyW_GetNumber(py_sz, &sz) )
Py_RETURN_NONE;
// Create a Python string
PyObject *ret = PyString_FromStringAndSize(NULL, Py_ssize_t(sz));
if ( ret == NULL )
Py_RETURN_NONE;
// Get the internal buffer
Py_ssize_t len;
char *buf;
PyString_AsStringAndSize(ret, &buf, &len);
if ( (size_t)read_dbg_memory(ea_t(ea), buf, size_t(sz)) != sz )
{
// Release the string on failure
Py_DECREF(ret);
// Return None on failure
Py_RETURN_NONE;
}
return ret;
}
static PyObject *
do_strip(PyObject *args, int striptype)
{
char *s;
Py_ssize_t len, i, j;
if (PyString_AsStringAndSize(args, &s, &len))
return NULL;
i = 0;
if (striptype != RIGHTSTRIP) {
while (i < len && isspace(Py_CHARMASK(s[i]))) {
i++;
}
}
j = len;
if (striptype != LEFTSTRIP) {
do {
j--;
} while (j >= i && isspace(Py_CHARMASK(s[j])));
j++;
}
if (i == 0 && j == len) {
Py_INCREF(args);
return args;
}
else
return PyString_FromStringAndSize(s+i, j-i);
}
int _write_value_to_handle(const void *value, void *handle)
{
PyObject *py_value = (PyObject *)value,
*py_marshalled = NULL;
char *marshalled;
Py_ssize_t length;
int success = 0;
#ifdef Py_MARSHAL_VERSION
if(!(py_marshalled =
PyMarshal_WriteObjectToString(py_value, Py_MARSHAL_VERSION)))
goto _write_value_to_handle_cleanup;
#else
if(!(py_marshalled = PyMarshal_WriteObjectToString(py_value)))
goto _write_value_to_handle_cleanup;
#endif
if(PyString_AsStringAndSize(py_marshalled, &marshalled, &length) == -1)
goto _write_value_to_handle_cleanup;
if(!_write_to_handle(&length, sizeof(length), handle))
goto _write_value_to_handle_cleanup;
if (length != (int)length)
goto _write_value_to_handle_cleanup;
if(!_write_to_handle(marshalled, (int)length, handle))
goto _write_value_to_handle_cleanup;
success = 1;
_write_value_to_handle_cleanup:
if(py_marshalled) {
Py_DECREF(py_marshalled);
}
return success;
}
static PyObject *py_socket_setsockopt(pytalloc_Object *self, PyObject *args)
{
int level, optname;
int *sock;
PyObject *pyval;
int optval;
Py_ssize_t optlen;
char *buffer;
int status;
if (!PyArg_ParseTuple(args, "iiO:getsockopt", &level, &optname, &pyval)) {
return NULL;
}
if (PyInt_Check(pyval)) {
optval = PyInt_AsLong(pyval);
buffer = (char *)&optval;
optlen = sizeof(int);
} else {
PyString_AsStringAndSize(pyval, &buffer, &optlen);
}
sock = pytalloc_get_ptr(self);
status = swrap_setsockopt(*sock, level, optname, (void *)buffer, optlen);
if (status < 0) {
return PyErr_SetFromErrno(py_socket_error);
}
Py_RETURN_NONE;
}
PyObject* encode_wrapper(WebPEncodeFunc encode_func, PyObject* self, PyObject* args)
{
PyStringObject *data_string;
int width;
int height;
int stride;
float quality_factor;
if (!PyArg_ParseTuple(args, "Siiif", &data_string, &width, &height, &stride, &quality_factor)) {
Py_INCREF(Py_None);
return Py_None;
}
uint8_t *data;
Py_ssize_t size;
PyString_AsStringAndSize((struct PyObject *) data_string, &data, &size);
if (stride * height > size) {
Py_INCREF(Py_None);
return Py_None;
}
uint8_t *output;
size_t ret_size = encode_func(data, width, height, stride, quality_factor, &output);
if (ret_size > 0) {
PyObject *ret = PyString_FromStringAndSize(output, ret_size);
free(output);
return ret;
}
Py_INCREF(Py_None);
return Py_None;
}
static ssize_t CReader_PySocketBuffer_read(CReader_Buffer *buffer, size_t nr)
{
PyObject *read;
char *readbuf;
int readlen;
CReader_Buffer_lockInterpreter(buffer);
if (!(read = PyObject_CallMethod(buffer->file, "recv", "i", max(nr, buffer->maxsize))))
{
CReader_Buffer_releaseInterpreter(buffer);
return -1;
}
if (PyString_AsStringAndSize(read, &readbuf, &readlen) == -1)
{
Py_DECREF(read);
CReader_Buffer_releaseInterpreter(buffer);
return -1;
}
memcpy(buffer->buf + buffer->pos + buffer->len, readbuf, readlen);
Py_DECREF(read);
CReader_Buffer_releaseInterpreter(buffer);
return readlen;
}
static PyObject *
strop_upper(PyObject *self, PyObject *args)
{
char *s, *s_new;
Py_ssize_t i, n;
PyObject *newstr;
int changed;
WARN;
if (PyString_AsStringAndSize(args, &s, &n))
return NULL;
newstr = PyString_FromStringAndSize(NULL, n);
if (newstr == NULL)
return NULL;
s_new = PyString_AsString(newstr);
changed = 0;
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
if (islower(c)) {
changed = 1;
*s_new = toupper(c);
} else
*s_new = c;
s_new++;
}
if (!changed) {
Py_DECREF(newstr);
Py_INCREF(args);
return args;
}
return newstr;
}
static PyObject *
O_writelines(Oobject *self, PyObject *args) {
PyObject *it, *s;
it = PyObject_GetIter(args);
if (it == NULL)
return NULL;
while ((s = PyIter_Next(it)) != NULL) {
Py_ssize_t n;
char *c;
if (PyString_AsStringAndSize(s, &c, &n) == -1) {
Py_DECREF(it);
Py_DECREF(s);
return NULL;
}
if (O_cwrite((PyObject *)self, c, n) == -1) {
Py_DECREF(it);
Py_DECREF(s);
return NULL;
}
Py_DECREF(s);
}
Py_DECREF(it);
/* See if PyIter_Next failed */
if (PyErr_Occurred())
return NULL;
Py_RETURN_NONE;
}
flac_status
FlacDecoder_update_md5sum(decoders_FlacDecoder *self,
PyObject *framelist)
{
if (self->perform_validation) {
PyObject *string = PyObject_CallMethod(framelist,
"to_bytes","ii",
0,
1);
char *string_buffer;
Py_ssize_t length;
if (string != NULL) {
if (PyString_AsStringAndSize(string,
&string_buffer,
&length) == 0) {
audiotools__MD5Update(&(self->md5),
(unsigned char *)string_buffer,
length);
Py_DECREF(string);
return OK;
} else {
Py_DECREF(string);
return ERROR;
}
} else {
return ERROR;
}
} else {
return OK;
}
}
PyObject* vm_set_mem(JitCpu *self, PyObject* args)
{
PyObject *py_addr;
PyObject *py_buffer;
Py_ssize_t py_length;
char * buffer;
uint64_t size;
uint64_t addr;
int ret = 0x1337;
if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
return NULL;
PyGetInt(py_addr, addr);
if(!PyString_Check(py_buffer))
RAISE(PyExc_TypeError,"arg must be str");
size = PyString_Size(py_buffer);
PyString_AsStringAndSize(py_buffer, &buffer, &py_length);
ret = vm_write_mem(&(((VmMngr*)self->pyvm)->vm_mngr), addr, buffer, size);
if (ret < 0)
RAISE(PyExc_TypeError,"arg must be str");
check_automod(self, addr, size*8);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
UnicodeResultProcessor_process(UnicodeResultProcessor *self, PyObject *value)
{
const char *encoding, *errors;
char *str;
Py_ssize_t len;
if (value == Py_None)
Py_RETURN_NONE;
#if PY_MAJOR_VERSION >= 3
if (PyBytes_AsStringAndSize(value, &str, &len))
return NULL;
encoding = PyBytes_AS_STRING(self->encoding);
errors = PyBytes_AS_STRING(self->errors);
#else
if (PyString_AsStringAndSize(value, &str, &len))
return NULL;
encoding = PyString_AS_STRING(self->encoding);
errors = PyString_AS_STRING(self->errors);
#endif
return PyUnicode_Decode(str, len, encoding, errors);
}
static PyObject *set(BaseTDBResolver *self, PyObject *args, PyObject *kwds) {
static char *kwlist[] = {"urn", "attribute", "value", NULL};
TDB_DATA urn;
TDB_DATA attribute;
PyObject *value_obj, *value_str;
TDB_DATA value;
urn.dsize = 0;
attribute.dsize = 0;
if(!PyArg_ParseTupleAndKeywords(args, kwds, "s#s#O", kwlist,
&urn.dptr, &urn.dsize,
&attribute.dptr, &attribute.dsize,
&value_obj))
return NULL;
// Convert the object to a string
value_str = PyObject_Str(value_obj);
if(!value_str) return NULL;
PyString_AsStringAndSize(value_str, (char **)&value.dptr, (int *)&value.dsize);
/** If the value is already in the list, we just ignore this
request.
*/
if(is_value_present(self, urn, attribute, value, 1)) {
goto exit;
};
set_new_value(self, urn, attribute, value);
exit:
Py_DECREF(value_str);
Py_RETURN_NONE;
};
static int expy_header_line_setattr(expy_header_line_t *self, char *name, PyObject *value)
{
if (self->hline == NULL)
{
PyErr_Format(PyExc_AttributeError, "Header object no longer valid, held over from previously processed message?");
return -1;
}
if (!strcmp(name, "type"))
{
char *p;
#if PY_MINOR_VERSION < 5
int len;
#else
Py_ssize_t len;
#endif
if (PyString_AsStringAndSize(value, &p, &len) == -1)
return -1;
if (len != 1)
{
PyErr_SetString(PyExc_TypeError, "header.type can only be set to a single-character value");
return -1;
}
self->hline->type = (int)(p[0]);
return 0;
}
PyErr_Format(PyExc_AttributeError, "Attribute: %s is not settable", name);
return -1;
}
PyObject *encodedir(PyObject *self, PyObject *args)
{
Py_ssize_t len, newlen;
PyObject *pathobj, *newobj;
char *path;
if (!PyArg_ParseTuple(args, "O:encodedir", &pathobj))
return NULL;
if (PyString_AsStringAndSize(pathobj, &path, &len) == -1) {
PyErr_SetString(PyExc_TypeError, "expected a string");
return NULL;
}
newlen = len ? _encodedir(NULL, 0, path, len + 1) : 1;
if (newlen == len + 1) {
Py_INCREF(pathobj);
return pathobj;
}
newobj = PyString_FromStringAndSize(NULL, newlen);
if (newobj) {
PyString_GET_SIZE(newobj)--;
_encodedir(PyString_AS_STRING(newobj), newlen, path,
len + 1);
}
return newobj;
}
static void idaapi s_py_get_user_defined_prefix(
qstring *buf,
ea_t ea,
int lnnum,
int indent,
const char *line)
{
PYW_GIL_GET;
newref_t py_ret(
PyObject_CallFunction(
py_get_user_defined_prefix,
PY_BV_EA "iis" PY_BV_SZ,
bvea_t(ea), lnnum, indent, line));
// Error? Display it
// No error? Copy the buffer
if ( !PyW_ShowCbErr("py_get_user_defined_prefix") )
{
Py_ssize_t py_len;
char *py_str;
if ( PyString_AsStringAndSize(py_ret.o, &py_str, &py_len) != -1 )
{
buf->qclear();
buf->append(py_str, py_len);
}
}
}
static PyObject *
ctemplate_SetGlobalValue (PyObject* self, PyObject* args) {
const char* name;
size_t name_len;
PyObject* obj;
if (!PyArg_ParseTuple(args, "s#O", &name, &name_len, &obj))
return NULL;
char* value;
int value_len;
PyObject* value_obj = PyObject_Str(obj);
if (value_obj == NULL) {
Py_DECREF(obj);
return NULL;
}
if (PyString_AsStringAndSize(value_obj, &value, &value_len) == -1) {
Py_DECREF(obj);
Py_DECREF(value_obj);
return NULL;
}
ctemplate::TemplateDictionary::
SetGlobalValue(ctemplate::TemplateString(name, name_len),
ctemplate::TemplateString(value, value_len));
Py_DECREF(obj);
Py_DECREF(value_obj);
Py_RETURN_NONE;
}
bool readPythonProtobuf(PyObject* obj, T* t)
{
if (obj == Py_None) {
std::cerr << "None object given where protobuf expected" << std::endl;
return false;
}
PyObject* res = PyObject_CallMethod(obj,
(char*) "SerializeToString",
(char*) NULL);
if (res == NULL) {
std::cerr << "Failed to call Python object's SerializeToString "
<< "(perhaps it is not a protobuf?)" << std::endl;
PyErr_Print();
return false;
}
char* chars;
Py_ssize_t len;
if (PyString_AsStringAndSize(res, &chars, &len) < 0) {
std::cerr << "SerializeToString did not return a string" << std::endl;
PyErr_Print();
Py_DECREF(res);
return false;
}
google::protobuf::io::ArrayInputStream stream(chars, len);
bool success = t->ParseFromZeroCopyStream(&stream);
if (!success) {
std::cerr << "Could not deserialize protobuf as expected type" << std::endl;
}
Py_DECREF(res);
return success;
}
