#include "PyPacket.h"

Collaboration diagram for PyPacket:

Public Member Functions
	PyPacket ()

	~PyPacket ()

void	Dump (LogType type, PyVisitor &dumper)

bool	Decode (PyRep **packet)

PyRep *	Encode ()

PyPacket *	Clone () const

Public Attributes
std::string	type_string

MACHONETMSG_TYPE	type

PyAddress	source

PyAddress	dest

uint32	userid

PyTuple *	payload

PyDict *	named_payload

PyRep *	contextKey

Detailed Description

Definition at line 101 of file PyPacket.h.

Constructor & Destructor Documentation

PyPacket::PyPacket ( )

Definition at line 62 of file PyPacket.cpp.

Referenced by Clone().

 : type_string("none"),
 type(__Fake_Invalid_Type),
 userid(0),
 payload(nullptr),
 named_payload(nullptr),
 contextKey(nullptr)
 {
 
 }

Here is the caller graph for this function:

PyPacket::~PyPacket ( )

Definition at line 73 of file PyPacket.cpp.

References named_payload, payload, and PySafeDecRef.

 {
     PySafeDecRef(payload);
     PySafeDecRef(named_payload);
 }

Member Function Documentation

PyPacket * PyPacket::Clone ( ) const

Definition at line 79 of file PyPacket.cpp.

References PyRep::AsDict(), PyRep::AsTuple(), PyTuple::Clone(), PyDict::Clone(), dest, named_payload, payload, PyPacket(), source, type, type_string, and userid.

 {
     PyPacket *res = new PyPacket();
         res->type_string = type_string;
         res->type = type;
         res->source = source;
         res->dest = dest;
         res->userid = userid;
         res->payload = payload->Clone()->AsTuple();
     if (named_payload == nullptr)
         res->named_payload = nullptr;
     else
         res->named_payload = named_payload->Clone()->AsDict();
     return res;
 }

Here is the call graph for this function:

bool PyPacket::Decode ( PyRep ** packet )

Definition at line 115 of file PyPacket.cpp.

References PyObject::arguments(), PyRep::AsChecksumedStream(), PyRep::AsObject(), PyRep::AsSubStream(), PyRep::AsTuple(), AUTHENTICATION_REQ, AUTHENTICATION_RSP, CALL_REQ, CALL_RSP, codelog, PyString::content(), PyAddress::Decode(), PySubStream::decoded(), PySubStream::DecodeData(), dest, ERRORRESPONSE, IDENTIFICATION_REQ, IDENTIFICATION_RSP, PyRep::IntegerValue(), PyRep::IsChecksumedStream(), PyRep::IsObject(), PyRep::IsSubStream(), PyRep::IsTuple(), PyTuple::items, named_payload, NOTIFICATION, payload, PING_REQ, PING_RSP, PyDecRef, PySafeDecRef, RESOLVE_REQ, RESOLVE_RSP, SESSIONCHANGENOTIFICATION, SESSIONINITIALSTATENOTIFICATION, source, PyChecksumedStream::stream(), TRANSPORTCLOSED, type, PyObject::type(), type_string, PyRep::TypeString(), and userid.

Referenced by EVEClientSession::_HandlePacket(), and tcp_callback().

 {
     PyRep *packet = *in_packet; //assign
     *in_packet = nullptr;       //consume
 
     PySafeDecRef(payload);
     PySafeDecRef(named_payload);
     payload = nullptr;
     named_payload = nullptr;
 
     if (packet == nullptr) {
         codelog(NET__PACKET_ERROR, "PyPacket::Decode() - packet is null.");
         return false;
     }
 
     if (packet->IsChecksumedStream()) {
         //TODO: check cs->checksum
         packet = packet->AsChecksumedStream()->stream();
     }
     //Dragon nuance... it gets wrapped again
     if (packet->IsSubStream()) {
         PySubStream* ss = packet->AsSubStream();
         ss->DecodeData();
         if (ss->decoded() == nullptr) {
             codelog(NET__PACKET_ERROR, "PyPacket::Decode() - unable to decode initial packet substream.");
             PyDecRef(packet);
             return false;
         }
 
         packet = ss->decoded();
     }
 
     if (!packet->IsObject()) {
         codelog(NET__PACKET_ERROR, "PyPacket::Decode() - packet body is not PyObject: %s", packet->TypeString());
         PyDecRef(packet);
         return false;
     }
 
     type_string = packet->AsObject()->type()->content();
     if (!packet->AsObject()->arguments()->IsTuple()) {
         codelog(NET__PACKET_ERROR, "PyPacket::Decode() - packet body does not contain a tuple");
         return false;
     }
 
     PyTuple *tuple = packet->AsObject()->arguments()->AsTuple();
     if (tuple == nullptr) {
         codelog(NET__PACKET_ERROR, "PyPacket::Decode() - tuple is null.");
         return false;
     }
 
     if (tuple->items.size() != 7) {
         codelog(NET__PACKET_ERROR, "PyPacket::Decode() - packet body does not contain a tuple of length 7 (is %u)", tuple->items.size());
         PyDecRef(packet);
         return false;
     }
 
     if (!tuple->items[0]->IsInt()) {
         codelog(NET__PACKET_ERROR, "PyPacket::Decode() - First main tuple element is not an integer");
         PyDecRef(packet);
         return false;
     }
 
     switch(PyRep::IntegerValue(tuple->items[0])) {
         case AUTHENTICATION_REQ:
         case AUTHENTICATION_RSP:
         case IDENTIFICATION_REQ:
         case IDENTIFICATION_RSP:
         case CALL_REQ:
         case CALL_RSP:
         case TRANSPORTCLOSED:
         case RESOLVE_REQ:
         case RESOLVE_RSP:
         case NOTIFICATION:
         case ERRORRESPONSE:
         case SESSIONCHANGENOTIFICATION:
         case SESSIONINITIALSTATENOTIFICATION:
         case PING_REQ:
         case PING_RSP: {
             type = (MACHONETMSG_TYPE) PyRep::IntegerValue(tuple->items[0]);
         } break;
         default: {
             codelog(NET__PACKET_ERROR, "PyPacket::Decode() - Unknown message type %i", PyRep::IntegerValue(tuple->items[0]));
             PyDecRef(packet);
             return false;
         } break;
     }
 
     //source address
     if (!source.Decode(tuple->items[1]))  {
         //error printed in decoder
         PyDecRef(packet);
         return false;
     }
     //dest address
     if (!dest.Decode(tuple->items[2])) {
         //error printed in decoder
         PyDecRef(packet);
         return false;
     }
 
     userid = PyRep::IntegerValue(tuple->items[3]);
 
     //payload
     if (!tuple->items[4]->IsTuple()) {
         codelog(NET__PACKET_ERROR, "PyPacket::Decode() - Fifth main tuple element is not a tuple");
         PyDecRef(packet);
         return false;
     }
     payload = tuple->items[4]->AsTuple();
 
     //options dict
     if (tuple->items[5]->IsNone()) {
         named_payload = nullptr;
     } else if (tuple->items[5]->IsDict()) {
         named_payload = tuple->items[5]->AsDict();
     } else {
         codelog(NET__PACKET_ERROR, "PyPacket::Decode() - Sixth main tuple element is neither dict or none.");
         PyDecRef(packet);
         return false;
     }
 
     PyDecRef(packet);
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PyPacket::Dump	(	LogType	type,
		PyVisitor &	dumper
	)

Definition at line 95 of file PyPacket.cpp.

References _log, dest, PyAddress::Dump(), MACHONETMSG_TYPE_NAMES, named_payload, payload, source, type, type_string, userid, PyTuple::visit(), and PyDict::visit().

Referenced by Client::_SendCallReturn(), EVECollectDispatcher::Handle_Other(), Client::SendInitialSessionStatus(), Client::SendNotification(), Client::SendSessionChange(), and tcp_callback().

 {
     _log(ltype, "Packet:");
     _log(ltype, "  Type: %s", type_string.c_str());
     _log(ltype, "  Command: %s (%d)", MACHONETMSG_TYPE_NAMES[type], type);
     _log(ltype, "  Source:");
     source.Dump(ltype, "    ");
     _log(ltype, "  Dest:");
     dest.Dump(ltype, "    ");
     _log(ltype, "  User ID: %u", userid);
     _log(ltype, "  Payload:");
     payload->visit( dumper );
     if (named_payload == nullptr) {
         _log(ltype, "  Named Payload: None (null)");
     } else {
         _log(ltype, "  Named Payload:");
         named_payload->visit( dumper );
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

PyRep * PyPacket::Encode ( )

Definition at line 240 of file PyPacket.cpp.

References contextKey, dest, PyAddress::Encode(), PyTuple::items, named_payload, payload, PyStatic, source, type, type_string, and userid.

Referenced by EVEClientSession::QueuePacket().

                         {
     PyTuple *arg_tuple = new PyTuple(7);
     //command
     arg_tuple->items[0] = new PyInt(type);
     //source
     arg_tuple->items[1] = source.Encode();
     //dest
     arg_tuple->items[2] = dest.Encode();
     //userid
     if (userid == 0)
         arg_tuple->items[3] = PyStatic.NewNone();
     else
         arg_tuple->items[3] = new PyInt(userid);
 
     //payload
     arg_tuple->items[4] = payload;     // dont clone here.  set actual rep in item, and it will be cleaned up by d'tor later
 
     //named arguments (OID+ or sn)
     if (named_payload == nullptr) {
         arg_tuple->items[5] = PyStatic.NewNone();
     } else {
         arg_tuple->items[5] = named_payload;    // dont clone here.  set actual rep in item, and it will be cleaned up by d'tor later
     }
 
     // contextKey, gives the client extra information on what exactly is going on
     // this is PyNone almost 100% of the time and seems to be used in the node<->proxy communication
     if (contextKey == nullptr) {
         arg_tuple->items[6] = PyStatic.NewNone();
     } else {
         arg_tuple->items[6] = contextKey;
     }
 
     return new PyObject( type_string.c_str(), arg_tuple );
 }