Variant f_thrift_protocol_read_binary(CObjRef transportobj,
CStrRef obj_typename,
bool strict_read) {
PHPInputTransport transport(transportobj);
int8_t messageType = 0;
int32_t sz = transport.readI32();
if (sz < 0) {
// Check for correct version number
int32_t version = sz & VERSION_MASK;
if (version != VERSION_1) {
throw_tprotocolexception("Bad version identifier", BAD_VERSION);
}
messageType = (sz & 0x000000ff);
int32_t namelen = transport.readI32();
// skip the name string and the sequence ID, we don't care about those
transport.skip(namelen + 4);
} else {
if (strict_read) {
throw_tprotocolexception("No version identifier... old protocol client in strict mode?", BAD_VERSION);
} else {
// Handle pre-versioned input
transport.skip(sz); // skip string body
messageType = transport.readI8();
transport.skip(4); // skip sequence number
}
}
if (messageType == T_EXCEPTION) {
Object ex = createObject("TApplicationException");
Variant spec = f_hphp_get_static_property("TApplicationException", s_TSPEC, false);
binary_deserialize_spec(ex, transport, spec.toArray());
throw ex;
}
Object ret_val = createObject(obj_typename);
Variant spec = f_hphp_get_static_property(obj_typename, s_TSPEC, false);
binary_deserialize_spec(ret_val, transport, spec.toArray());
return ret_val;
}
void f_thrift_protocol_write_binary(CObjRef transportobj, CStrRef method_name,
int64_t msgtype, CObjRef request_struct,
int seqid, bool strict_write) {
PHPOutputTransport transport(transportobj);
if (strict_write) {
int32_t version = VERSION_1 | msgtype;
transport.writeI32(version);
transport.writeString(method_name.data(), method_name.size());
transport.writeI32(seqid);
} else {
transport.writeString(method_name.data(), method_name.size());
transport.writeI8(msgtype);
transport.writeI32(seqid);
}
Variant spec = f_hphp_get_static_property(request_struct->o_getClassName(),
"_TSPEC");
binary_serialize_spec(request_struct, transport, spec.toArray());
transport.flush();
}
Variant binary_deserialize(int8_t thrift_typeID, PHPInputTransport& transport,
CArrRef fieldspec) {
Variant ret;
switch (thrift_typeID) {
case T_STOP:
case T_VOID:
return uninit_null();
case T_STRUCT: {
Variant val;
if ((val = fieldspec.rvalAt(PHPTransport::s_class)).isNull()) {
throw_tprotocolexception("no class type in spec", INVALID_DATA);
skip_element(T_STRUCT, transport);
return uninit_null();
}
String structType = val.toString();
ret = createObject(structType);
if (ret.isNull()) {
// unable to create class entry
skip_element(T_STRUCT, transport);
return uninit_null();
}
Variant spec = f_hphp_get_static_property(structType, s_TSPEC, false);
if (!spec.is(KindOfArray)) {
char errbuf[128];
snprintf(errbuf, 128, "spec for %s is wrong type: %d\n",
structType.data(), ret.getType());
throw_tprotocolexception(String(errbuf, CopyString), INVALID_DATA);
return uninit_null();
}
binary_deserialize_spec(ret.toObject(), transport, spec.toArray());
return ret;
} break;
case T_BOOL: {
uint8_t c;
transport.readBytes(&c, 1);
return c != 0;
}
//case T_I08: // same numeric value as T_BYTE
case T_BYTE: {
uint8_t c;
transport.readBytes(&c, 1);
return Variant((int8_t)c);
}
case T_I16: {
uint16_t c;
transport.readBytes(&c, 2);
return Variant((int16_t)ntohs(c));
}
case T_I32: {
uint32_t c;
transport.readBytes(&c, 4);
return Variant((int32_t)ntohl(c));
}
case T_U64:
case T_I64: {
uint64_t c;
transport.readBytes(&c, 8);
return Variant((int64_t)ntohll(c));
}
case T_DOUBLE: {
union {
uint64_t c;
double d;
} a;
transport.readBytes(&(a.c), 8);
a.c = ntohll(a.c);
return a.d;
}
case T_FLOAT: {
union {
uint32_t c;
float d;
} a;
transport.readBytes(&(a.c), 4);
a.c = ntohl(a.c);
return a.d;
}
//case T_UTF7: // aliases T_STRING
case T_UTF8:
case T_UTF16:
case T_STRING: {
uint32_t size = transport.readU32();
if (size && (size + 1)) {
String s = String(size, ReserveString);
char* strbuf = s.bufferSlice().ptr;
transport.readBytes(strbuf, size);
return s.setSize(size);
} else {
return "";
}
}
case T_MAP: { // array of key -> value
uint8_t types[2];
transport.readBytes(types, 2);
uint32_t size = transport.readU32();
Array keyspec = fieldspec.rvalAt(PHPTransport::s_key,
AccessFlags::Error_Key).toArray();
Array valspec = fieldspec.rvalAt(PHPTransport::s_val,
AccessFlags::Error_Key).toArray();
ret = Array::Create();
for (uint32_t s = 0; s < size; ++s) {
Variant key = binary_deserialize(types[0], transport, keyspec);
Variant value = binary_deserialize(types[1], transport, valspec);
ret.set(key, value);
}
return ret; // return_value already populated
}
case T_LIST: { // array with autogenerated numeric keys
int8_t type = transport.readI8();
uint32_t size = transport.readU32();
Variant elemvar = fieldspec.rvalAt(PHPTransport::s_elem,
AccessFlags::Error_Key);
Array elemspec = elemvar.toArray();
ret = Array::Create();
for (uint32_t s = 0; s < size; ++s) {
Variant value = binary_deserialize(type, transport, elemspec);
ret.append(value);
}
return ret;
}
case T_SET: { // array of key -> TRUE
uint8_t type;
uint32_t size;
transport.readBytes(&type, 1);
transport.readBytes(&size, 4);
size = ntohl(size);
Variant elemvar = fieldspec.rvalAt(PHPTransport::s_elem,
AccessFlags::Error_Key);
Array elemspec = elemvar.toArray();
ret = Array::Create();
for (uint32_t s = 0; s < size; ++s) {
Variant key = binary_deserialize(type, transport, elemspec);
if (key.isInteger()) {
ret.set(key, true);
} else {
ret.set(key.toString(), true);
}
}
return ret;
}
};
char errbuf[128];
sprintf(errbuf, "Unknown thrift typeID %d", thrift_typeID);
throw_tprotocolexception(String(errbuf, CopyString), INVALID_DATA);
return uninit_null();
}
void binary_serialize(int8_t thrift_typeID, PHPOutputTransport& transport,
CVarRef value, CArrRef fieldspec) {
// At this point the typeID (and field num, if applicable) should've already
// been written to the output so all we need to do is write the payload.
switch (thrift_typeID) {
case T_STOP:
case T_VOID:
return;
case T_STRUCT: {
if (!value.is(KindOfObject)) {
throw_tprotocolexception("Attempt to send non-object "
"type as a T_STRUCT", INVALID_DATA);
}
binary_serialize_spec(value.toObject(), transport,
f_hphp_get_static_property(value.toObject()->
o_getClassName(),
s_TSPEC,
false).toArray());
} return;
case T_BOOL:
transport.writeI8(value.toBoolean() ? 1 : 0);
return;
case T_BYTE:
transport.writeI8(value.toByte());
return;
case T_I16:
transport.writeI16(value.toInt16());
return;
case T_I32:
transport.writeI32(value.toInt32());
return;
case T_I64:
case T_U64:
transport.writeI64(value.toInt64());
return;
case T_DOUBLE: {
union {
int64_t c;
double d;
} a;
a.d = value.toDouble();
transport.writeI64(a.c);
} return;
case T_FLOAT: {
union {
int32_t c;
float d;
} a;
a.d = (float)value.toDouble();
transport.writeI32(a.c);
} return;
//case T_UTF7:
case T_UTF8:
case T_UTF16:
case T_STRING: {
String sv = value.toString();
transport.writeString(sv.data(), sv.size());
} return;
case T_MAP: {
Array ht = value.toArray();
uint8_t keytype = fieldspec.rvalAt(PHPTransport::s_ktype,
AccessFlags::Error_Key).toByte();
transport.writeI8(keytype);
uint8_t valtype = fieldspec.rvalAt(PHPTransport::s_vtype,
AccessFlags::Error_Key).toByte();
transport.writeI8(valtype);
Array valspec = fieldspec.rvalAt(PHPTransport::s_val,
AccessFlags::Error_Key).toArray();
transport.writeI32(ht.size());
for (ArrayIter key_ptr = ht.begin(); !key_ptr.end(); ++key_ptr) {
binary_serialize_hashtable_key(keytype, transport, key_ptr.first());
binary_serialize(valtype, transport, key_ptr.second(), valspec);
}
} return;
case T_LIST: {
Array ht = value.toArray();
Variant val;
uint8_t valtype = fieldspec.rvalAt(PHPTransport::s_etype,
AccessFlags::Error_Key).toInt64();
transport.writeI8(valtype);
Array valspec = fieldspec.rvalAt(PHPTransport::s_elem,
AccessFlags::Error_Key).toArray();
transport.writeI32(ht.size());
for (ArrayIter key_ptr = ht.begin(); !key_ptr.end(); ++key_ptr) {
binary_serialize(valtype, transport, key_ptr.second(), valspec);
}
} return;
case T_SET: {
Array ht = value.toArray();
uint8_t keytype = fieldspec.rvalAt(PHPTransport::s_etype,
AccessFlags::Error_Key).toByte();
transport.writeI8(keytype);
transport.writeI32(ht.size());
for (ArrayIter key_ptr = ht.begin(); !key_ptr.end(); ++key_ptr) {
binary_serialize_hashtable_key(keytype, transport, key_ptr.first());
}
} return;
};
char errbuf[128];
sprintf(errbuf, "Unknown thrift typeID %d", thrift_typeID);
throw_tprotocolexception(String(errbuf, CopyString), INVALID_DATA);
}
