bool PyCachedCall::Decode(PySubStream **in_ss)
{
PySubStream *ss = *in_ss; //consume
*in_ss = NULL;
PySafeDecRef( result );
ss->DecodeData();
if(ss->decoded() == NULL) {
SysLog::Error("PyCachedCall","Unable to decode initial stream for PyCachedCall");
PyDecRef( ss );
return false;
}
if(!ss->decoded()->IsDict()) {
SysLog::Error("PyCachedCall","Cached call substream does not contain a dict: %s", ss->decoded()->TypeString());
PyDecRef( ss );
return false;
}
PyDict *po = (PyDict *) ss->decoded();
PyDict::const_iterator cur, end;
cur = po->begin();
end = po->end();
for(; cur != end; cur++) {
if(!cur->first->IsString())
continue;
PyString *key = (PyString *) cur->first;
if( key->content() == "lret" )
result = cur->second->Clone();
}
PyDecRef( ss );
return(result != NULL);
}
bool PyAddress::_DecodeService(PyRep *rep) {
if(rep->IsString()) {
PyString *s = (PyString *) rep;
service = s->content();
} else if(rep->IsNone()) {
service = "";
} else {
codelog(NET__PACKET_ERROR, "Wrong type on service field");
rep->Dump(NET__PACKET_ERROR, " ");
return false;
}
return true;
}
uint32 DBRowDescriptor::FindColumn( const char* name ) const
{
uint32 cc = ColumnCount();
PyString* stringName = new PyString( name );
for( uint32 i = 0; i < cc; i++ )
{
if( stringName->hash() == GetColumnName( i )->hash() )
{
PyDecRef( stringName );
return i;
}
}
PyDecRef( stringName );
return cc;
}
bool PyXMLGenerator::VisitDict( const PyDict* rep )
{
enum
{
DictInline,
DictStringKey,
DictIntKey,
DictRaw
} ktype;
enum
{
ValueUnknown,
ValueString,
ValueInt,
ValueReal,
ValueMixed
} vtype;
ktype = DictInline;
vtype = ValueUnknown;
//this is kinda a hack, but we want to try and classify the contents of this dict:
PyDict::const_iterator cur, end;
cur = rep->begin();
end = rep->end();
for(; cur != end; ++cur)
{
if( cur->first->IsString() )
{
if( ktype == DictIntKey )
{
//we have varying key types, raw dict it is.
ktype = DictRaw;
break;
}
else if( ktype == DictInline )
ktype = DictStringKey;
}
else if( cur->first->IsInt() )
{
if( ktype == DictStringKey )
{
//we have varying key types, raw dict it is.
ktype = DictRaw;
break;
}
else if( ktype == DictInline )
ktype = DictIntKey;
}
else
{
//anything but those key types is more than we can think about, keep it raw.
ktype = DictRaw;
break;
}
if( cur->second->IsString() )
{
if( vtype == ValueInt || vtype == ValueReal )
vtype = ValueMixed;
else if( vtype == ValueUnknown )
vtype = ValueString;
}
else if(cur->second->IsInt())
{
if( vtype == ValueString || vtype == ValueReal )
vtype = ValueMixed;
else if( vtype == ValueUnknown )
vtype = ValueInt;
}
else if( cur->second->IsFloat() )
{
if( vtype == ValueString || vtype == ValueInt )
vtype = ValueMixed;
else if(vtype == ValueUnknown)
vtype = ValueReal;
}
else
vtype = ValueMixed;
}
if( ktype == DictRaw )
{
fprintf( mInto, "%s<dict name=\"dict%u\" />\n", _pfx(), mItem++ );
return true;
}
else if( ktype == DictIntKey )
{
//cant do an inline dict, but can try a vector
switch( vtype )
{
case ValueString:
fprintf( mInto, "%s<dictInt name=\"dict%u\" type=\"string\" />\n", _pfx(), mItem++ );
break;
case ValueInt:
fprintf( mInto, "%s<dictInt name=\"dict%u\" type=\"int\" />\n", _pfx(), mItem++ );
break;
case ValueReal:
fprintf( mInto, "%s<dictInt name=\"dict%u\" type=\"real\" />\n", _pfx(), mItem++ );
break;
case ValueUnknown:
case ValueMixed:
fprintf( mInto, "%s<dictRaw name=\"dict%u\" />\n", _pfx(), mItem++ );
break;
}
return true;
}
fprintf( mInto, "%s<dictInline>\n", _pfx() );
_pfxExtend( " " );
//! visit dict elements.
cur = rep->begin();
end = rep->end();
for(; cur != end; ++cur)
{
if( !cur->first->IsString() )
{
fprintf( mInto, "%s<!-- non-string dict key of type %s -->\n", _pfx(), cur->first->TypeString() );
return false;
}
PyString* str = cur->first->AsString();
fprintf( mInto, "%s<dictInlineEntry key=\"%s\">\n", _pfx(), str->content().c_str() );
_pfxExtend( " " );
cur->second->visit( *this );
_pfxWithdraw();
fprintf( mInto, "%s</dictInlineEntry>\n", _pfx() );
}
_pfxWithdraw();
fprintf( mInto, "%s</dictInline>\n", _pfx() );
return true;
}
bool PyCallStream::Decode(const std::string &type, PyTuple *&in_payload) {
PyTuple *payload = in_payload; //consume
in_payload = NULL;
PySafeDecRef(arg_tuple);
PySafeDecRef(arg_dict);
arg_tuple = NULL;
arg_dict = NULL;
if(type != "macho.CallReq") {
codelog(NET__PACKET_ERROR, "failed: packet payload has unknown string type '%s'", type.c_str());
PyDecRef(payload);
return false;
}
if (payload->items.size() != 1) {
codelog(NET__PACKET_ERROR, "invalid tuple length %lu", payload->items.size());
PyDecRef(payload);
return false;
}
if (!payload->items[0]->IsTuple()) {
codelog(NET__PACKET_ERROR, "non tuple payload[0]");
PyDecRef(payload);
return false;
}
PyTuple *payload2 = (PyTuple *) payload->items[0];
if(payload2->items.size() != 2) {
codelog(NET__PACKET_ERROR, "invalid tuple2 length %lu", payload2->items.size());
PyDecRef(payload);
return false;
}
//decode inner payload tuple
//ignore tuple 0, it should be an int, dont know what it is
if(!payload2->items[1]->IsSubStream()) {
codelog(NET__PACKET_ERROR, "non-substream type");
PyDecRef(payload);
return false;
}
PySubStream *ss = (PySubStream *) payload2->items[1];
ss->DecodeData();
if(ss->decoded() == NULL) {
codelog(NET__PACKET_ERROR, "Unable to decode call stream");
PyDecRef(payload);
return false;
}
if(!ss->decoded()->IsTuple()) {
codelog(NET__PACKET_ERROR, "packet body does not contain a tuple");
PyDecRef(payload);
return false;
}
PyTuple *maint = (PyTuple *) ss->decoded();
if(maint->items.size() != 4) {
codelog(NET__PACKET_ERROR, "packet body has %lu elements, expected %d", maint->items.size(), 4);
PyDecRef(payload);
return false;
}
//parse first tuple element, unknown
if(maint->items[0]->IsInt()) {
PyInt *tuple0 = (PyInt *) maint->items[0];
remoteObject = tuple0->value();
remoteObjectStr = "";
} else if(maint->items[0]->IsString()) {
PyString *tuple0 = (PyString *) maint->items[0];
remoteObject = 0;
remoteObjectStr = tuple0->content();
} else {
codelog(NET__PACKET_ERROR, "tuple[0] has invalid type %s", maint->items[0]->TypeString());
codelog(NET__PACKET_ERROR, " in:");
payload->Dump(NET__PACKET_ERROR, " ");
PyDecRef(payload);
return false;
}
//parse tuple[1]: method name
if(maint->items[1]->IsString()) {
PyString *i = (PyString *) maint->items[1];
method = i->content();
} else {
codelog(NET__PACKET_ERROR, "tuple[1] has non-string type");
maint->items[1]->Dump(NET__PACKET_ERROR, " --> ");
codelog(NET__PACKET_ERROR, " in:");
payload->Dump(NET__PACKET_ERROR, " ");
PyDecRef(payload);
return false;
}
//grab argument list.
if(!maint->items[2]->IsTuple()) {
codelog(NET__PACKET_ERROR, "argument list has non-tuple type");
maint->items[2]->Dump(NET__PACKET_ERROR, " --> ");
codelog(NET__PACKET_ERROR, "in:");
payload->Dump(NET__PACKET_ERROR, " ");
PyDecRef(payload);
return false;
}
arg_tuple = (PyTuple *) maint->items[2];
maint->items[2] = NULL; //we keep this one
//options dict
if(maint->items[3]->IsNone()) {
arg_dict = NULL;
} else if(maint->items[3]->IsDict()) {
arg_dict = (PyDict *) maint->items[3];
maint->items[3] = NULL; //we keep this too.
} else {
codelog(NET__PACKET_ERROR, "tuple[3] has non-dict type");
maint->items[3]->Dump(NET__PACKET_ERROR, " --> ");
codelog(NET__PACKET_ERROR, "in:");
payload->Dump(NET__PACKET_ERROR, " ");
PyDecRef(payload);
return false;
}
PyDecRef(payload);
return true;
}
bool PyAddress::Decode(PyRep *&in_object) {
PyRep *base = in_object;
in_object = NULL;
if(!base->IsObject()) {
codelog(NET__PACKET_ERROR, "Invalid element type, expected object");
PyDecRef(base);
return false;
}
PyObject *obj = (PyObject *) base;
//do we care about the object type? should be "macho.MachoAddress"
if(!obj->arguments()->IsTuple()) {
codelog(NET__PACKET_ERROR, "Invalid argument type, expected tuple");
PyDecRef(base);
return false;
}
PyTuple *args = (PyTuple *) obj->arguments();
if(args->items.size() < 3) {
codelog(NET__PACKET_ERROR, "Not enough elements in address tuple: %lu", args->items.size());
args->Dump(NET__PACKET_ERROR, " ");
PyDecRef(base);
return false;
}
//decode the address type.
if(!args->items[0]->IsInt()) {
codelog(NET__PACKET_ERROR, "Wrong type on address type element (0)");
args->items[0]->Dump(NET__PACKET_ERROR, " ");
PyDecRef(base);
return false;
}
PyInt *typei = (PyInt *) args->items[0];
switch(typei->value()) {
case Any: {
if(args->items.size() != 3) {
codelog(NET__PACKET_ERROR, "Invalid number of elements in Any address tuple: %lu", args->items.size());
PyDecRef(base);
return false;
}
type = Any;
if(!_DecodeService(args->items[1])
|| !_DecodeCallID(args->items[2])) {
PyDecRef(base);
return false;
}
break;
}
case Node: {
if(args->items.size() != 4) {
codelog(NET__PACKET_ERROR, "Invalid number of elements in Node address tuple: %lu", args->items.size());
PyDecRef(base);
return false;
}
type = Node;
if(!_DecodeTypeID(args->items[1])
|| !_DecodeService(args->items[2])
|| !_DecodeCallID(args->items[3])) {
PyDecRef(base);
return false;
}
break;
}
case Client: {
if(args->items.size() != 4) {
codelog(NET__PACKET_ERROR, "Invalid number of elements in Client address tuple: %lu", args->items.size());
PyDecRef(base);
return false;
}
type = Client;
if(!_DecodeTypeID(args->items[1])
|| !_DecodeCallID(args->items[2])
|| !_DecodeService(args->items[3])) {
PyDecRef(base);
return false;
}
break;
}
case Broadcast: {
if(args->items.size() != 4) {
codelog(NET__PACKET_ERROR, "Invalid number of elements in Broadcast address tuple: %lu", args->items.size());
PyDecRef(base);
return false;
}
type = Broadcast;
if(!args->items[1]->IsString()) {
codelog(NET__PACKET_ERROR, "Invalid type %s for brodcastID", args->items[1]->TypeString());
PyDecRef(base);
return false;
} else if(!args->items[3]->IsString()) {
codelog(NET__PACKET_ERROR, "Invalid type %s for idtype", args->items[3]->TypeString());
PyDecRef(base);
return false;
}
PyString *bid = (PyString *) args->items[1];
PyString *idt = (PyString *) args->items[3];
service = bid->content();
bcast_idtype = idt->content();
//items[2] is either a list or a tuple.
/*
//PyList *nclist = (PyList *) args->items[2];
if(!nclist->items.empty()) {
printf("Not decoding narrowcast list:");
nclist->Dump(NET__PACKET_ERROR, " ");
}*/
break;
}
default:
codelog(NET__PACKET_ERROR, "Unknown address type: %c", typei->value() );
PyDecRef(base);
return false;
}
PyDecRef(base);
return true;
}
