static PyObject *
complex__format__(PyObject* self, PyObject* args)
{
PyObject *format_spec;
if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
return NULL;
if (PyBytes_Check(format_spec))
return _PyComplex_FormatAdvanced(self,
PyBytes_AS_STRING(format_spec),
PyBytes_GET_SIZE(format_spec));
if (PyUnicode_Check(format_spec)) {
/* Convert format_spec to a str */
PyObject *result;
PyObject *str_spec = PyObject_Str(format_spec);
if (str_spec == NULL)
return NULL;
result = _PyComplex_FormatAdvanced(self,
PyBytes_AS_STRING(str_spec),
PyBytes_GET_SIZE(str_spec));
Py_DECREF(str_spec);
return result;
}
PyErr_SetString(PyExc_TypeError, "__format__ requires str or unicode");
return NULL;
}
static uint32_t
p_memcpy(char *dst, struct p_place *p, uint32_t amount)
{
struct p_list *pl = p->list;
uint32_t offset = p->offset;
uint32_t amount_left = amount;
char *src;
Py_ssize_t chunk_size;
/* Nothing to read */
if (pl == NULL)
return(0);
src = (PyBytes_AS_STRING(pl->data) + offset);
chunk_size = PyBytes_GET_SIZE(pl->data) - offset;
while (amount_left > 0)
{
uint32_t this_read =
chunk_size < amount_left ? chunk_size : amount_left;
memcpy(dst, src, this_read);
dst = dst + this_read;
amount_left = amount_left - this_read;
pl = pl->next;
if (pl == NULL)
break;
src = PyBytes_AS_STRING(pl->data);
chunk_size = PyBytes_GET_SIZE(pl->data);
}
return(amount - amount_left);
}
//-----------------------------------------------------------------------------
// cxBuffer_FromObject()
// Populate the string buffer from a unicode object.
//-----------------------------------------------------------------------------
static int cxBuffer_FromObject(
udt_Buffer *buf, // buffer to fill
PyObject *obj, // object (string or Unicode object)
const char *encoding) // encoding to use, if applicable
{
if (!obj)
return cxBuffer_Init(buf);
if (encoding && PyUnicode_Check(obj)) {
buf->obj = PyUnicode_AsEncodedString(obj, encoding, NULL);
if (!buf->obj)
return -1;
buf->ptr = PyBytes_AS_STRING(buf->obj);
buf->size = PyBytes_GET_SIZE(buf->obj);
buf->numCharacters = PyUnicode_GET_SIZE(obj);
} else if (PyBytes_Check(obj)) {
Py_INCREF(obj);
buf->obj = obj;
buf->ptr = PyBytes_AS_STRING(buf->obj);
buf->size = buf->numCharacters = PyBytes_GET_SIZE(buf->obj);
#if PY_MAJOR_VERSION < 3
} else if (PyBuffer_Check(obj)) {
if (PyObject_AsReadBuffer(obj, &buf->ptr, &buf->size) < 0)
return -1;
Py_INCREF(obj);
buf->obj = obj;
buf->numCharacters = buf->size;
#endif
} else {
PyErr_SetString(PyExc_TypeError, CXORA_TYPE_ERROR);
return -1;
}
return 0;
}
/*
* p_at_least - whether the position has at least given number of bytes.
*/
static char
p_at_least(struct p_place *p, uint32_t amount)
{
int32_t current = 0;
struct p_list *pl;
pl = p->list;
if (pl)
current += PyBytes_GET_SIZE(pl->data) - p->offset;
if (current >= amount)
return((char) 1);
if (pl)
{
for (pl = pl->next; pl != NULL; pl = pl->next)
{
current += PyBytes_GET_SIZE(pl->data);
if (current >= amount)
return((char) 1);
}
}
return((char) 0);
}
static PyObject *
strxor_function(PyObject *self, PyObject *args)
{
PyObject *a, *b, *retval;
Py_ssize_t len_a, len_b;
if (!PyArg_ParseTuple(args, "SS", &a, &b))
return NULL;
len_a = PyBytes_GET_SIZE(a);
len_b = PyBytes_GET_SIZE(b);
assert(len_a >= 0);
assert(len_b >= 0);
if (len_a != len_b) {
PyErr_SetString(PyExc_ValueError, "length of both strings must be equal");
return NULL;
}
/* Create return string */
retval = PyBytes_FromStringAndSize(NULL, len_a);
if (!retval) {
return NULL;
}
/* retval := a ^ b */
xor_strings(PyBytes_AS_STRING(retval), PyBytes_AS_STRING(a), PyBytes_AS_STRING(b), len_a);
return retval;
}
static PyObject *
decompress(Decompressor *d, uint8_t *data, size_t len)
{
size_t data_size = 0;
PyObject *result;
result = PyBytes_FromStringAndSize(NULL, INITIAL_BUFFER_SIZE);
if (result == NULL)
return NULL;
d->lzs.next_in = data;
d->lzs.avail_in = len;
d->lzs.next_out = (uint8_t *)PyBytes_AS_STRING(result);
d->lzs.avail_out = PyBytes_GET_SIZE(result);
for (;;) {
lzma_ret lzret;
Py_BEGIN_ALLOW_THREADS
lzret = lzma_code(&d->lzs, LZMA_RUN);
data_size = (char *)d->lzs.next_out - PyBytes_AS_STRING(result);
Py_END_ALLOW_THREADS
if (catch_lzma_error(lzret))
goto error;
if (lzret == LZMA_GET_CHECK || lzret == LZMA_NO_CHECK)
d->check = lzma_get_check(&d->lzs);
if (lzret == LZMA_STREAM_END) {
d->eof = 1;
if (d->lzs.avail_in > 0) {
Py_CLEAR(d->unused_data);
d->unused_data = PyBytes_FromStringAndSize(
(char *)d->lzs.next_in, d->lzs.avail_in);
if (d->unused_data == NULL)
goto error;
}
break;
} else if (d->lzs.avail_in == 0) {
break;
} else if (d->lzs.avail_out == 0) {
if (grow_buffer(&result) == -1)
goto error;
d->lzs.next_out = (uint8_t *)PyBytes_AS_STRING(result) + data_size;
d->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;
}
static PyObject *
ghash_function(PyObject *self, PyObject *args)
{
PyObject *data, *y, *exp_h;
PyObject *retval = NULL;
Py_ssize_t len_data, len_y, len_exp_h;
if (!PyArg_ParseTuple(args, "SSS", &data, &y, &exp_h)) {
goto out;
}
len_data = PyBytes_GET_SIZE(data);
len_y = PyBytes_GET_SIZE(y);
len_exp_h = PyBytes_GET_SIZE(exp_h);
if (len_data%16!=0) {
PyErr_SetString(PyExc_ValueError, "Length of data must be a multiple of 16 bytes.");
goto out;
}
if (len_y!=16) {
PyErr_SetString(PyExc_ValueError, "Length of y must be 16 bytes.");
goto out;
}
if (len_exp_h!=sizeof(t_key_tables) && len_exp_h!=16) {
PyErr_SetString(PyExc_ValueError, "Length of expanded key is incorrect.");
goto out;
}
/* Create return string */
retval = PyBytes_FromStringAndSize(NULL, 16);
if (!retval) {
goto out;
}
Py_BEGIN_ALLOW_THREADS;
#define PyBytes_Buffer(a) (uint8_t*)PyBytes_AS_STRING(a)
ghash( PyBytes_Buffer(retval), PyBytes_Buffer(data), len_data,
PyBytes_Buffer(y),
PyBytes_Buffer(exp_h), len_exp_h );
#undef PyBytes_Buffer
Py_END_ALLOW_THREADS;
out:
return retval;
}
// from Python/bltinmodule.c
static const char *
source_as_string(PyObject *cmd, const char *funcname, const char *what, PyCompilerFlags *cf, PyObject **cmd_copy)
{
const char *str;
Py_ssize_t size;
Py_buffer view;
*cmd_copy = NULL;
if (PyUnicode_Check(cmd)) {
cf->cf_flags |= PyCF_IGNORE_COOKIE;
str = PyUnicode_AsUTF8AndSize(cmd, &size);
if (str == NULL)
return NULL;
}
else if (PyBytes_Check(cmd)) {
str = PyBytes_AS_STRING(cmd);
size = PyBytes_GET_SIZE(cmd);
}
else if (PyByteArray_Check(cmd)) {
str = PyByteArray_AS_STRING(cmd);
size = PyByteArray_GET_SIZE(cmd);
}
else if (PyObject_GetBuffer(cmd, &view, PyBUF_SIMPLE) == 0) {
/* Copy to NUL-terminated buffer. */
*cmd_copy = PyBytes_FromStringAndSize(
(const char *)view.buf, view.len);
PyBuffer_Release(&view);
if (*cmd_copy == NULL) {
return NULL;
}
str = PyBytes_AS_STRING(*cmd_copy);
size = PyBytes_GET_SIZE(*cmd_copy);
}
else {
PyErr_Format(PyExc_TypeError,
"%s() arg 1 must be a %s object",
funcname, what);
return NULL;
}
if (strlen(str) != (size_t)size) {
PyErr_SetString(PyExc_ValueError,
"source code string cannot contain null bytes");
Py_CLEAR(*cmd_copy);
return NULL;
}
return str;
}
NUITKA_MAY_BE_UNUSED static bool BYTES_ADD_INCREMENTAL(PyObject **operand1, PyObject *operand2) {
assert(PyBytes_CheckExact(*operand1));
assert(PyBytes_CheckExact(operand2));
// Buffer
Py_buffer wb;
wb.len = -1;
if (PyObject_GetBuffer(operand2, &wb, PyBUF_SIMPLE) != 0) {
PyErr_Format(PyExc_TypeError, "can't concat %s to %s", Py_TYPE(operand2)->tp_name, Py_TYPE(*operand1)->tp_name);
return false;
}
Py_ssize_t oldsize = PyBytes_GET_SIZE(*operand1);
if (oldsize > PY_SSIZE_T_MAX - wb.len) {
PyErr_NoMemory();
PyBuffer_Release(&wb);
return false;
}
if (_PyBytes_Resize(operand1, oldsize + wb.len) < 0) {
PyBuffer_Release(&wb);
return false;
}
memcpy(PyBytes_AS_STRING(*operand1) + oldsize, wb.buf, wb.len);
PyBuffer_Release(&wb);
return true;
}
int
PyUnicode_CopyPreferredEncoding(char *buffer, Py_ssize_t buffer_size)
{
PyObject *u = NULL;
PyObject *b = NULL;
Py_ssize_t len;
#if (PY_MAJOR_VERSION >= 3)
u = PyUnicode_GetPreferredEncoding();
if (u == NULL)
goto error;
b = PyUnicode_AsASCIIString(u);
#else
b = PyUnicode_GetPreferredEncoding();
#endif
if (b == NULL)
goto error;
len = PyBytes_GET_SIZE(b);
if (len >= buffer_size)
len = buffer_size - 1;
strncpy(buffer, PyBytes_AS_STRING(b), len);
buffer[len] = '\0';
Py_XDECREF(u);
Py_DECREF(b);
return 1;
error:
Py_XDECREF(u);
Py_XDECREF(b);
return 0;
}
static PyObject *
strxor_c_function(PyObject *self, PyObject *args)
{
PyObject *s, *retval;
int c;
Py_ssize_t length;
if (!PyArg_ParseTuple(args, "Si", &s, &c))
return NULL;
if ((c < 0) || (c > 255)) {
PyErr_SetString(PyExc_ValueError, "c must be in range(256)");
return NULL;
}
length = PyBytes_GET_SIZE(s);
assert(length >= 0);
/* Create return string */
retval = PyBytes_FromStringAndSize(NULL, length);
if (!retval) {
return NULL;
}
/* retval := a ^ chr(c)*length */
xor_string_with_char(PyBytes_AS_STRING(retval), PyBytes_AS_STRING(s), (char) c, length);
return retval;
}
static PyObject *
Signature_tp_iter(PyObject *self)
{
SignatureIter *iter = PyObject_New(SignatureIter, &SignatureIterType);
PyObject *self_as_bytes;
if (!iter) return NULL;
#ifdef PY3
self_as_bytes = PyUnicode_AsUTF8String(self);
if (!self_as_bytes) {
Py_CLEAR(iter);
return NULL;
}
#else
self_as_bytes = self;
Py_INCREF(self_as_bytes);
#endif
if (PyBytes_GET_SIZE(self_as_bytes) > 0) {
iter->bytes = self_as_bytes;
dbus_signature_iter_init(&(iter->iter),
PyBytes_AS_STRING(self_as_bytes));
}
else {
/* this is a null string, make a null iterator */
iter->bytes = NULL;
Py_CLEAR(self_as_bytes);
}
return (PyObject *)iter;
}
static int
_generate_regex(PyObject *s, void *vg)
{
int i, count;
gen_state_t *g = (gen_state_t *)vg;
regex_pt_t *p;
const char *pystr;
unsigned int pystrlen;
DBGN(D_GEN, "-> regex has %d parts, each generating: [", SYMOBJ(s)->data.regex.n_parts);
for (i = 0; i < SYMOBJ(s)->data.regex.n_parts; i++) {
p = SYMOBJ(s)->data.regex.parts + i;
if (gen_state_hit_limit(g) || gen_state_hit_depth(g))
count = p->min_count;
else
count = rnd(rnd(p->max_count - p->min_count + 1)) + p->min_count;
if (i)
PDBGN(D_GEN, ",");
PDBGN(D_GEN, "%d", count);
pystr = PyBytes_AS_STRING(p->charset);
pystrlen = PyBytes_GET_SIZE(p->charset);
for ( ;count > 0; count--) {
// TODO: unicode
if (gen_state_write(g, &pystr[rnd(pystrlen)], 1))
return -1;
}
}
PDBGN(D_GEN, "]\n");
return 0;
}
static int
dbm_contains(PyObject *self, PyObject *arg)
{
dbmobject *dp = (dbmobject *)self;
datum key, val;
Py_ssize_t size;
if ((dp)->di_dbm == NULL) {
PyErr_SetString(DbmError,
"DBM object has already been closed");
return -1;
}
if (PyUnicode_Check(arg)) {
key.dptr = PyUnicode_AsUTF8AndSize(arg, &size);
key.dsize = size;
if (key.dptr == NULL)
return -1;
}
else if (!PyBytes_Check(arg)) {
PyErr_Format(PyExc_TypeError,
"dbm key must be bytes or string, not %.100s",
arg->ob_type->tp_name);
return -1;
}
else {
key.dptr = PyBytes_AS_STRING(arg);
key.dsize = PyBytes_GET_SIZE(arg);
}
val = dbm_fetch(dp->di_dbm, key);
return val.dptr != NULL;
}
PyObjectHandle LuaToPythonConverter::convertToUnicode(lua_State* L, int index) {
fixIndex(L, index);
if (auto ref = getOpaqueRef(L, index)) {
// Must convert to a Python unicode object.
if (PyBytes_Check(ref->obj.get())) {
char* data = PyBytes_AS_STRING(ref->obj.get());
Py_ssize_t len = PyBytes_GET_SIZE(ref->obj.get());
PyObjectHandle obj(PyUnicode_DecodeUTF8(data, len, "strict"));
checkPythonError(obj, L, "convertToUnicode(bytes)");
return obj;
} else if (PyUnicode_Check(ref->obj.get())) {
return ref->obj;
} else {
luaL_error(L, "neither bytes nor unicode");
}
}
int type = lua_type(L, index);
if (type != LUA_TSTRING) {
luaL_error(L, "Invalid type for convertToUnicode: %d", type);
}
size_t len;
const char* str = lua_tolstring(L, index, &len);
PyObjectHandle obj(PyUnicode_DecodeUTF8(str, len, "strict"));
checkPythonError(obj, L, "convertToUnicdoe");
return obj;
}
/* Internal routine for changing the size of the buffer of BytesIO objects.
The caller should ensure that the 'size' argument is non-negative. Returns
0 on success, -1 otherwise. */
static int
resize_buffer(bytesio *self, size_t size)
{
/* Here, unsigned types are used to avoid dealing with signed integer
overflow, which is undefined in C. */
size_t alloc = PyBytes_GET_SIZE(self->buf);
assert(self->buf != NULL);
/* For simplicity, stay in the range of the signed type. Anyway, Python
doesn't allow strings to be longer than this. */
if (size > PY_SSIZE_T_MAX)
goto overflow;
if (size < alloc / 2) {
/* Major downsize; resize down to exact size. */
alloc = size + 1;
}
else if (size < alloc) {
/* Within allocated size; quick exit */
return 0;
}
else if (size <= alloc * 1.125) {
/* Moderate upsize; overallocate similar to list_resize() */
alloc = size + (size >> 3) + (size < 9 ? 3 : 6);
}
static int
append_signature_bits(struct ccn_charbuf *signature,
PyObject *py_obj_Signature)
{
PyObject *py_signatureBits = NULL;
const char *blob;
Py_ssize_t blobsize;
int r;
if (!PyObject_HasAttrString(py_obj_Signature, "signatureBits"))
return 0;
py_signatureBits = PyObject_GetAttrString(py_obj_Signature,
"signatureBits");
JUMP_IF_NULL(py_signatureBits, error);
if (py_signatureBits != Py_None) {
blob = PyBytes_AsString(py_signatureBits);
JUMP_IF_NULL(blob, error);
blobsize = PyBytes_GET_SIZE(py_signatureBits);
r = ccnb_append_tagged_blob(signature, CCN_DTAG_SignatureBits, blob,
blobsize);
JUMP_IF_NEG_MEM(r, error);
}
Py_DECREF(py_signatureBits);
return 0;
error:
Py_XDECREF(py_signatureBits);
return -1;
}
static PyObject *
_winapi_Overlapped_GetOverlappedResult_impl(OverlappedObject *self, int wait)
/*[clinic end generated code: output=bdd0c1ed6518cd03 input=194505ee8e0e3565]*/
{
BOOL res;
DWORD transferred = 0;
DWORD err;
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);
}
QDataStream &operator<<(QDataStream& out, const PyObjectWrapper& myObj)
{
if (Py_IsInitialized() == 0) {
qWarning() << "Stream operator for PyObject called without python interpreter.";
return out;
}
static PyObject *reduce_func = 0;
Shiboken::GilState gil;
if (!reduce_func) {
Shiboken::AutoDecRef pickleModule(PyImport_ImportModule("pickle"));
reduce_func = PyObject_GetAttrString(pickleModule, "dumps");
}
Shiboken::AutoDecRef repr(PyObject_CallFunctionObjArgs(reduce_func, (PyObject*)myObj, NULL));
if (repr.object()) {
const char* buff = 0;
Py_ssize_t size = 0;
if (PyBytes_Check(repr.object())) {
buff = PyBytes_AS_STRING(repr.object());
size = PyBytes_GET_SIZE(repr.object());
} else if (Shiboken::String::check(repr.object())) {
buff = Shiboken::String::toCString(repr.object());
size = Shiboken::String::len(repr.object());
}
QByteArray data(buff, size);
out << data;
}
return out;
}
static long __Pyx__PyObject_Ord(PyObject* c) {
Py_ssize_t size;
if (PyBytes_Check(c)) {
size = PyBytes_GET_SIZE(c);
if (likely(size == 1)) {
return (unsigned char) PyBytes_AS_STRING(c)[0];
}
#if PY_MAJOR_VERSION < 3
} else if (PyUnicode_Check(c)) {
return (long)__Pyx_PyUnicode_AsPy_UCS4(c);
#endif
#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
} else if (PyByteArray_Check(c)) {
size = PyByteArray_GET_SIZE(c);
if (likely(size == 1)) {
return (unsigned char) PyByteArray_AS_STRING(c)[0];
}
#endif
} else {
// FIXME: support character buffers - but CPython doesn't support them either
PyErr_Format(PyExc_TypeError,
"ord() expected string of length 1, but %.200s found", c->ob_type->tp_name);
return (long)(Py_UCS4)-1;
}
PyErr_Format(PyExc_TypeError,
"ord() expected a character, but string of length %zd found", size);
return (long)(Py_UCS4)-1;
}
static int
header_value_cb(http_parser *p, const char *buf, size_t len)
{
request *req = get_current_request(p);
PyObject *obj;
/* DEBUG("field value:%.*s", (int)len, buf); */
if(likely(req->value== NULL)){
obj = PyBytes_FromStringAndSize(buf, len);
}else{
obj = concat_string(req->value, buf, len);
}
if(unlikely(obj == NULL)){
req->bad_request_code = 500;
return -1;
}
if(unlikely(PyBytes_GET_SIZE(obj) > LIMIT_REQUEST_FIELD_SIZE)){
req->bad_request_code = 400;
return -1;
}
req->value = obj;
req->last_header_element = VALUE;
return 0;
}
static int
arrayflags_setitem(PyArrayFlagsObject *self, PyObject *ind, PyObject *item)
{
char *key;
char buf[16];
int n;
if (PyUnicode_Check(ind)) {
PyObject *tmp_str;
tmp_str = PyUnicode_AsASCIIString(ind);
key = PyBytes_AS_STRING(tmp_str);
n = PyBytes_GET_SIZE(tmp_str);
if (n > 16) n = 16;
memcpy(buf, key, n);
Py_DECREF(tmp_str);
key = buf;
}
else if (PyBytes_Check(ind)) {
key = PyBytes_AS_STRING(ind);
n = PyBytes_GET_SIZE(ind);
}
else {
goto fail;
}
if (((n==9) && (strncmp(key, "WRITEABLE", n) == 0)) ||
((n==1) && (strncmp(key, "W", n) == 0))) {
return arrayflags_writeable_set(self, item);
}
else if (((n==7) && (strncmp(key, "ALIGNED", n) == 0)) ||
((n==1) && (strncmp(key, "A", n) == 0))) {
return arrayflags_aligned_set(self, item);
}
else if (((n==12) && (strncmp(key, "UPDATEIFCOPY", n) == 0)) ||
((n==1) && (strncmp(key, "U", n) == 0))) {
return arrayflags_updateifcopy_set(self, item);
}
else if ((n==6) && (strncmp(key, "MASKNA", n) == 0)) {
return arrayflags_maskna_set(self, item);
}
else if ((n==9) && (strncmp(key, "OWNMASKNA", n) == 0)) {
return arrayflags_ownmaskna_set(self, item);
}
fail:
PyErr_SetString(PyExc_KeyError, "Unknown flag");
return -1;
}
static int
_generate_text(PyObject *s, void *g)
{
PyObject *t = SYMOBJ(s)->data.obj;
if (gen_state_write((gen_state_t *)g, PyBytes_AS_STRING(t), PyBytes_GET_SIZE(t)))
return -1;
return 0;
}
static IDProperty *idp_from_PyBytes(const char *name, PyObject *ob)
{
IDPropertyTemplate val = {0};
val.string.str = PyBytes_AS_STRING(ob);
val.string.len = PyBytes_GET_SIZE(ob);
val.string.subtype = IDP_STRING_SUB_BYTE;
return IDP_New(IDP_STRING, &val, name);
}
static int
header_field_cb(http_parser *p, const char *buf, size_t len)
{
request *req = get_current_request(p);
PyObject *env = NULL, *obj = NULL;
#ifdef PY3
char *c1, *c2;
PyObject *f, *v;
#endif
/* DEBUG("field key:%.*s", (int)len, buf); */
if(req->last_header_element != FIELD){
env = req->environ;
if(LIMIT_REQUEST_FIELDS <= req->num_headers){
req->bad_request_code = 400;
return -1;
}
#ifdef PY3
//TODO CHECK ERROR
c1 = PyBytes_AS_STRING(req->field);
f = PyUnicode_DecodeLatin1(c1, strlen(c1), NULL);
c2 = PyBytes_AS_STRING(req->value);
v = PyUnicode_DecodeLatin1(c2, strlen(c2), NULL);
PyDict_SetItem(env, f, v);
Py_DECREF(f);
Py_DECREF(v);
#else
PyDict_SetItem(env, req->field, req->value);
#endif
Py_DECREF(req->field);
Py_DECREF(req->value);
req->field = NULL;
req->value = NULL;
req->num_headers++;
}
if(likely(req->field == NULL)){
obj = get_http_header_key(buf, len);
}else{
char temp[len];
key_upper(temp, buf, len);
obj = concat_string(req->field, temp, len);
}
if(unlikely(obj == NULL)){
req->bad_request_code = 500;
return -1;
}
if(unlikely(PyBytes_GET_SIZE(obj) > LIMIT_REQUEST_FIELD_SIZE)){
req->bad_request_code = 400;
return -1;
}
req->field = obj;
req->last_header_element = FIELD;
return 0;
}
static PyObject *ffi_getctype(FFIObject *self, PyObject *args, PyObject *kwds)
{
PyObject *c_decl, *res;
char *p, *replace_with = "";
int add_paren, add_space;
CTypeDescrObject *ct;
size_t replace_with_len;
static char *keywords[] = {"cdecl", "replace_with", NULL};
#if PY_MAJOR_VERSION >= 3
PyObject *u;
#endif
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|s:getctype", keywords,
&c_decl, &replace_with))
return NULL;
ct = _ffi_type(self, c_decl, ACCEPT_STRING|ACCEPT_CTYPE);
if (ct == NULL)
return NULL;
while (replace_with[0] != 0 && isspace(replace_with[0]))
replace_with++;
replace_with_len = strlen(replace_with);
while (replace_with_len > 0 && isspace(replace_with[replace_with_len - 1]))
replace_with_len--;
add_paren = (replace_with[0] == '*' &&
((ct->ct_flags & CT_ARRAY) != 0));
add_space = (!add_paren && replace_with_len > 0 &&
replace_with[0] != '[' && replace_with[0] != '(');
res = _combine_type_name_l(ct, replace_with_len + add_space + 2*add_paren);
if (res == NULL)
return NULL;
p = PyBytes_AS_STRING(res) + ct->ct_name_position;
if (add_paren)
*p++ = '(';
if (add_space)
*p++ = ' ';
memcpy(p, replace_with, replace_with_len);
if (add_paren)
p[replace_with_len] = ')';
#if PY_MAJOR_VERSION >= 3
/* bytes -> unicode string */
u = PyUnicode_DecodeLatin1(PyBytes_AS_STRING(res),
PyBytes_GET_SIZE(res),
NULL);
Py_DECREF(res);
res = u;
#endif
return res;
}
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;
}
Py_ssize_t len(PyObject* str)
{
if (str == Py_None)
return 0;
if (PyUnicode_Check(str))
return PyUnicode_GET_SIZE(str);
if (PyBytes_Check(str))
return PyBytes_GET_SIZE(str);
return 0;
}
static PyObject *
zipimporter_get_source(PyObject *obj, PyObject *args)
{
ZipImporter *self = (ZipImporter *)obj;
PyObject *toc_entry;
PyObject *fullname, *subname, *path, *fullpath;
enum zi_module_info mi;
if (!PyArg_ParseTuple(args, "U:zipimporter.get_source", &fullname))
return NULL;
mi = get_module_info(self, fullname);
if (mi == MI_ERROR)
return NULL;
if (mi == MI_NOT_FOUND) {
PyErr_Format(ZipImportError, "can't find module %R", fullname);
return NULL;
}
subname = get_subname(fullname);
if (subname == NULL)
return NULL;
path = make_filename(self->prefix, subname);
Py_DECREF(subname);
if (path == NULL)
return NULL;
if (mi == MI_PACKAGE)
fullpath = PyUnicode_FromFormat("%U%c__init__.py", path, SEP);
else
fullpath = PyUnicode_FromFormat("%U.py", path);
Py_DECREF(path);
if (fullpath == NULL)
return NULL;
toc_entry = PyDict_GetItem(self->files, fullpath);
Py_DECREF(fullpath);
if (toc_entry != NULL) {
PyObject *res, *bytes;
bytes = get_data(self->archive, toc_entry);
if (bytes == NULL)
return NULL;
res = PyUnicode_FromStringAndSize(PyBytes_AS_STRING(bytes),
PyBytes_GET_SIZE(bytes));
Py_DECREF(bytes);
return res;
}
/* we have the module, but no source */
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
_io__RawIOBase_readall_impl(PyObject *self)
/*[clinic end generated code: output=1987b9ce929425a0 input=688874141213622a]*/
{
int r;
PyObject *chunks = PyList_New(0);
PyObject *result;
if (chunks == NULL)
return NULL;
while (1) {
PyObject *data = _PyObject_CallMethodId(self, &PyId_read,
"i", DEFAULT_BUFFER_SIZE);
if (!data) {
/* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals()
when EINTR occurs so we needn't do it ourselves. */
if (_PyIO_trap_eintr()) {
continue;
}
Py_DECREF(chunks);
return NULL;
}
if (data == Py_None) {
if (PyList_GET_SIZE(chunks) == 0) {
Py_DECREF(chunks);
return data;
}
Py_DECREF(data);
break;
}
if (!PyBytes_Check(data)) {
Py_DECREF(chunks);
Py_DECREF(data);
PyErr_SetString(PyExc_TypeError, "read() should return bytes");
return NULL;
}
if (PyBytes_GET_SIZE(data) == 0) {
/* EOF */
Py_DECREF(data);
break;
}
r = PyList_Append(chunks, data);
Py_DECREF(data);
if (r < 0) {
Py_DECREF(chunks);
return NULL;
}
}
result = _PyBytes_Join(_PyIO_empty_bytes, chunks);
Py_DECREF(chunks);
return result;
}
