static bool
decode_struct(DecodeBuffer* input, PyObject* output, PyObject* spec_seq) {
int spec_seq_len = PyTuple_Size(spec_seq);
if (spec_seq_len == -1) {
return false;
}
while (true) {
TType type;
int16_t tag;
PyObject* item_spec;
PyObject* fieldval = NULL;
StructItemSpec parsedspec;
type = readByte(input);
if (type == -1) {
return false;
}
if (type == T_STOP) {
break;
}
tag = readI16(input);
if (INT_CONV_ERROR_OCCURRED(tag)) {
return false;
}
if (tag >= 0 && tag < spec_seq_len) {
item_spec = PyTuple_GET_ITEM(spec_seq, tag);
} else {
item_spec = Py_None;
}
if (item_spec == Py_None) {
if (!skip(input, type)) {
return false;
} else {
continue;
}
}
if (!parse_struct_item_spec(&parsedspec, item_spec)) {
return false;
}
if (parsedspec.type != type) {
PyErr_SetString(PyExc_TypeError, "struct field had wrong type while reading");
return false;
}
fieldval = decode_val(input, parsedspec.type, parsedspec.typeargs);
if (fieldval == NULL) {
return false;
}
if (PyObject_SetAttr(output, parsedspec.attrname, fieldval) == -1) {
Py_DECREF(fieldval);
return false;
}
Py_DECREF(fieldval);
}
return true;
}
bool BinaryProtocol::readFieldBegin(TType& type, int16_t& tag) {
uint8_t b = 0;
if (!readByte(b)) {
return false;
}
type = static_cast<TType>(b);
if (type == T_STOP) {
return true;
}
return readI16(tag);
}
uint32_t TBinaryProtocol::readFieldBegin(string& name,
TType& fieldType,
int16_t& fieldId) {
uint32_t result = 0;
int8_t type;
result += readByte(type);
fieldType = (TType)type;
if (fieldType == T_STOP) {
fieldId = 0;
return result;
}
result += readI16(fieldId);
return result;
}
// Returns a new reference.
static PyObject*
decode_val(DecodeBuffer* input, TType type, PyObject* typeargs, long string_limit, long container_limit) {
switch (type) {
case T_BOOL: {
int8_t v = readByte(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
switch (v) {
case 0:
Py_RETURN_FALSE;
case 1:
Py_RETURN_TRUE;
// Don't laugh. This is a potentially serious issue.
default:
PyErr_SetString(PyExc_TypeError, "boolean out of range");
return NULL;
}
break;
}
case T_I08: {
int8_t v = readByte(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
return PyInt_FromLong(v);
}
case T_I16: {
int16_t v = readI16(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
return PyInt_FromLong(v);
}
case T_I32: {
int32_t v = readI32(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
return PyInt_FromLong(v);
}
case T_I64: {
int64_t v = readI64(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
// TODO(dreiss): Find out if we can take this fastpath always when
// sizeof(long) == sizeof(long long).
if (CHECK_RANGE(v, LONG_MIN, LONG_MAX)) {
return PyInt_FromLong((long) v);
}
return PyLong_FromLongLong(v);
}
case T_DOUBLE: {
double v = readDouble(input);
if (v == -1.0 && PyErr_Occurred()) {
return false;
}
return PyFloat_FromDouble(v);
}
case T_STRING: {
Py_ssize_t len = readI32(input);
char* buf;
if (!readBytes(input, &buf, len)) {
return NULL;
}
if (!check_length_limit(len, string_limit)) {
return NULL;
}
if (is_utf8(typeargs))
return PyUnicode_DecodeUTF8(buf, len, 0);
else
return PyString_FromStringAndSize(buf, len);
}
case T_LIST:
case T_SET: {
SetListTypeArgs parsedargs;
int32_t len;
PyObject* ret = NULL;
int i;
bool use_tuple = false;
if (!parse_set_list_args(&parsedargs, typeargs)) {
return NULL;
}
if (!checkTypeByte(input, parsedargs.element_type)) {
return NULL;
}
len = readI32(input);
if (!check_length_limit(len, container_limit)) {
return NULL;
}
use_tuple = type == T_LIST && parsedargs.immutable;
ret = use_tuple ? PyTuple_New(len) : PyList_New(len);
if (!ret) {
return NULL;
}
for (i = 0; i < len; i++) {
PyObject* item = decode_val(input, parsedargs.element_type, parsedargs.typeargs, string_limit, container_limit);
if (!item) {
Py_DECREF(ret);
return NULL;
}
if (use_tuple) {
PyTuple_SET_ITEM(ret, i, item);
} else {
PyList_SET_ITEM(ret, i, item);
}
}
// TODO(dreiss): Consider biting the bullet and making two separate cases
// for list and set, avoiding this post facto conversion.
if (type == T_SET) {
PyObject* setret;
setret = parsedargs.immutable ? PyFrozenSet_New(ret) : PySet_New(ret);
Py_DECREF(ret);
return setret;
}
return ret;
}
case T_MAP: {
int32_t len;
int i;
MapTypeArgs parsedargs;
PyObject* ret = NULL;
if (!parse_map_args(&parsedargs, typeargs)) {
return NULL;
}
if (!checkTypeByte(input, parsedargs.ktag)) {
return NULL;
}
if (!checkTypeByte(input, parsedargs.vtag)) {
return NULL;
}
len = readI32(input);
if (!check_length_limit(len, container_limit)) {
return NULL;
}
ret = PyDict_New();
if (!ret) {
goto error;
}
for (i = 0; i < len; i++) {
PyObject* k = NULL;
PyObject* v = NULL;
k = decode_val(input, parsedargs.ktag, parsedargs.ktypeargs, string_limit, container_limit);
if (k == NULL) {
goto loop_error;
}
v = decode_val(input, parsedargs.vtag, parsedargs.vtypeargs, string_limit, container_limit);
if (v == NULL) {
goto loop_error;
}
if (PyDict_SetItem(ret, k, v) == -1) {
goto loop_error;
}
Py_DECREF(k);
Py_DECREF(v);
continue;
// Yuck! Destructors, anyone?
loop_error:
Py_XDECREF(k);
Py_XDECREF(v);
goto error;
}
if (parsedargs.immutable) {
PyObject* thrift = PyImport_ImportModule("thrift.Thrift");
PyObject* cls = NULL;
PyObject* arg = NULL;
if (!thrift) {
goto error;
}
cls = PyObject_GetAttrString(thrift, "TFrozenDict");
if (!cls) {
goto error;
}
arg = PyTuple_New(1);
PyTuple_SET_ITEM(arg, 0, ret);
return PyObject_CallObject(cls, arg);
}
return ret;
error:
Py_XDECREF(ret);
return NULL;
}
case T_STRUCT: {
StructTypeArgs parsedargs;
if (!parse_struct_args(&parsedargs, typeargs)) {
return NULL;
}
return decode_struct(input, Py_None, parsedargs.klass, parsedargs.spec, string_limit, container_limit);
}
case T_STOP:
case T_VOID:
case T_UTF16:
case T_UTF8:
case T_U64:
default:
PyErr_SetString(PyExc_TypeError, "Unexpected TType");
return NULL;
}
}
static PyObject*
decode_struct(DecodeBuffer* input, PyObject* output, PyObject* klass, PyObject* spec_seq, long string_limit, long container_limit) {
int spec_seq_len = PyTuple_Size(spec_seq);
bool immutable = output == Py_None;
PyObject* kwargs = NULL;
if (spec_seq_len == -1) {
return NULL;
}
if (immutable) {
kwargs = PyDict_New();
if (!kwargs) {
PyErr_SetString(PyExc_TypeError, "failed to prepare kwargument storage");
return NULL;
}
}
while (true) {
TType type;
int16_t tag;
PyObject* item_spec;
PyObject* fieldval = NULL;
StructItemSpec parsedspec;
type = readByte(input);
if (type == -1) {
goto error;
}
if (type == T_STOP) {
break;
}
tag = readI16(input);
if (INT_CONV_ERROR_OCCURRED(tag)) {
goto error;
}
if (tag >= 0 && tag < spec_seq_len) {
item_spec = PyTuple_GET_ITEM(spec_seq, tag);
} else {
item_spec = Py_None;
}
if (item_spec == Py_None) {
if (!skip(input, type)) {
goto error;
} else {
continue;
}
}
if (!parse_struct_item_spec(&parsedspec, item_spec)) {
goto error;
}
if (parsedspec.type != type) {
if (!skip(input, type)) {
PyErr_Format(PyExc_TypeError, "struct field had wrong type: expected %d but got %d", parsedspec.type, type);
goto error;
} else {
continue;
}
}
fieldval = decode_val(input, parsedspec.type, parsedspec.typeargs, string_limit, container_limit);
if (fieldval == NULL) {
goto error;
}
if ((immutable && PyDict_SetItem(kwargs, parsedspec.attrname, fieldval) == -1)
|| (!immutable && PyObject_SetAttr(output, parsedspec.attrname, fieldval) == -1)) {
Py_DECREF(fieldval);
goto error;
}
Py_DECREF(fieldval);
}
if (immutable) {
PyObject* args = PyTuple_New(0);
PyObject* ret = NULL;
if (!args) {
PyErr_SetString(PyExc_TypeError, "failed to prepare argument storage");
goto error;
}
ret = PyObject_Call(klass, args, kwargs);
Py_DECREF(kwargs);
Py_DECREF(args);
return ret;
}
Py_INCREF(output);
return output;
error:
Py_XDECREF(kwargs);
return NULL;
}
// Returns a new reference.
static PyObject*
decode_val(DecodeBuffer* input, TType type, PyObject* typeargs) {
switch (type) {
case T_BOOL: {
int8_t v = readByte(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
switch (v) {
case 0: Py_RETURN_FALSE;
case 1: Py_RETURN_TRUE;
// Don't laugh. This is a potentially serious issue.
default: PyErr_SetString(PyExc_TypeError, "boolean out of range"); return NULL;
}
break;
}
case T_I08: {
int8_t v = readByte(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
return PyInt_FromLong(v);
}
case T_I16: {
int16_t v = readI16(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
return PyInt_FromLong(v);
}
case T_I32: {
int32_t v = readI32(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
return PyInt_FromLong(v);
}
case T_I64: {
int64_t v = readI64(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
// TODO(dreiss): Find out if we can take this fastpath always when
// sizeof(long) == sizeof(long long).
if (CHECK_RANGE(v, LONG_MIN, LONG_MAX)) {
return PyInt_FromLong((long) v);
}
return PyLong_FromLongLong(v);
}
case T_DOUBLE: {
double v = readDouble(input);
if (v == -1.0 && PyErr_Occurred()) {
return false;
}
return PyFloat_FromDouble(v);
}
case T_STRING: {
Py_ssize_t len = readI32(input);
char* buf;
if (!readBytes(input, &buf, len)) {
return NULL;
}
return PyString_FromStringAndSize(buf, len);
}
case T_LIST:
case T_SET: {
SetListTypeArgs parsedargs;
int32_t len;
PyObject* ret = NULL;
int i;
if (!parse_set_list_args(&parsedargs, typeargs)) {
return NULL;
}
if (!checkTypeByte(input, parsedargs.element_type)) {
return NULL;
}
len = readI32(input);
if (!check_ssize_t_32(len)) {
return NULL;
}
ret = PyList_New(len);
if (!ret) {
return NULL;
}
for (i = 0; i < len; i++) {
PyObject* item = decode_val(input, parsedargs.element_type, parsedargs.typeargs);
if (!item) {
Py_DECREF(ret);
return NULL;
}
PyList_SET_ITEM(ret, i, item);
}
// TODO(dreiss): Consider biting the bullet and making two separate cases
// for list and set, avoiding this post facto conversion.
if (type == T_SET) {
PyObject* setret;
#if (PY_VERSION_HEX < 0x02050000)
// hack needed for older versions
setret = PyObject_CallFunctionObjArgs((PyObject*)&PySet_Type, ret, NULL);
#else
// official version
setret = PySet_New(ret);
#endif
Py_DECREF(ret);
return setret;
}
return ret;
}
case T_MAP: {
int32_t len;
int i;
MapTypeArgs parsedargs;
PyObject* ret = NULL;
if (!parse_map_args(&parsedargs, typeargs)) {
return NULL;
}
if (!checkTypeByte(input, parsedargs.ktag)) {
return NULL;
}
if (!checkTypeByte(input, parsedargs.vtag)) {
return NULL;
}
len = readI32(input);
if (!check_ssize_t_32(len)) {
return false;
}
ret = PyDict_New();
if (!ret) {
goto error;
}
for (i = 0; i < len; i++) {
PyObject* k = NULL;
PyObject* v = NULL;
k = decode_val(input, parsedargs.ktag, parsedargs.ktypeargs);
if (k == NULL) {
goto loop_error;
}
v = decode_val(input, parsedargs.vtag, parsedargs.vtypeargs);
if (v == NULL) {
goto loop_error;
}
if (PyDict_SetItem(ret, k, v) == -1) {
goto loop_error;
}
Py_DECREF(k);
Py_DECREF(v);
continue;
// Yuck! Destructors, anyone?
loop_error:
Py_XDECREF(k);
Py_XDECREF(v);
goto error;
}
return ret;
error:
Py_XDECREF(ret);
return NULL;
}
case T_STRUCT: {
StructTypeArgs parsedargs;
if (!parse_struct_args(&parsedargs, typeargs)) {
return NULL;
}
PyObject* ret = PyObject_CallObject(parsedargs.klass, NULL);
if (!ret) {
return NULL;
}
if (!decode_struct(input, ret, parsedargs.spec)) {
Py_DECREF(ret);
return NULL;
}
return ret;
}
case T_STOP:
case T_VOID:
case T_UTF16:
case T_UTF8:
case T_U64:
default:
PyErr_SetString(PyExc_TypeError, "Unexpected TType");
return NULL;
}
}
