private unsafe void _PostResponseImpl(long pctx, MessageBuff *messageBuff)
{
int header_len = TrinityProtocol.MsgHeader + sizeof(int) + sizeof(int) + sizeof(long);
int socket_header = header_len + (int)messageBuff->Length - TrinityProtocol.SocketMsgHeader;
byte * buf = stackalloc byte[header_len];
byte **bufs = stackalloc byte *[2];
int * sizes = stackalloc int[2];
sizes[0] = header_len;
sizes[1] = (int)messageBuff->Length;
bufs[0] = buf;
bufs[1] = messageBuff->Buffer;
PointerHelper sp = PointerHelper.New(buf);
*sp.ip = socket_header;
*(TrinityMessageType *)(sp.bp + TrinityProtocol.MsgTypeOffset) = TrinityMessageType.SYNC;
*(ushort *)(sp.bp + TrinityProtocol.MsgIdOffset) = (ushort)TSL.CommunicationModule.TrinityClientModule.SynReqMessageType.PostResponse;
sp.bp += TrinityProtocol.MsgHeader;
*sp.ip++ = m_id;
*sp.ip++ = m_cookie;
*sp.lp++ = pctx;
m_mod.SendMessage(m_client, bufs, sizes, 2);
}
private unsafe void _SetSendRecvBuff(TrinityErrorCode msgProcessResult, MessageBuff *sendRecvBuff, TrinityMessage response)
{
if (TrinityErrorCode.E_SUCCESS == msgProcessResult)
{
// Response buffer will be freed in Trinity.C after it is sent
sendRecvBuff->Buffer = response.Buffer;
sendRecvBuff->Length = (uint)response.Size;
}
else// TrinityErrorCode.E_RPC_EXCEPTION == msgProcessResult
{
// The client is expecting a reply payload, it will be notified because
// the payload length is E_RPC_EXCEPTION;
sendRecvBuff->Buffer = (byte *)Memory.malloc(sizeof(TrinityErrorCode));
sendRecvBuff->Length = sizeof(TrinityErrorCode);
*(TrinityErrorCode *)sendRecvBuff->Buffer = TrinityErrorCode.E_RPC_EXCEPTION;
}
}
internal static void WorkerThreadProc()
{
CNativeNetwork.EnterSocketServerThreadPool();
while (true)
{
void *pContext = null;
CNativeNetwork.AwaitRequest(out pContext);
// a null pContext means that the completion port is closing.
if (pContext == null)
{
break;
}
MessageBuff *sendRecvBuff = (MessageBuff *)pContext;
HandleMessage(sendRecvBuff);
CNativeNetwork.SendResponse(pContext); // Send response back to the client
}
CNativeNetwork.ExitSocketServerThreadPool();
}
private unsafe void _SetSendRecvBuff(TrinityErrorCode msgProcessResult, MessageBuff *sendRecvBuff)
{
if (TrinityErrorCode.E_SUCCESS == msgProcessResult)
{
// Response buffer will be freed in Trinity.C after it is sent
sendRecvBuff->Buffer = (byte *)Memory.malloc(sizeof(TrinityErrorCode));
sendRecvBuff->Length = sizeof(TrinityErrorCode);
*(TrinityErrorCode *)sendRecvBuff->Buffer = TrinityErrorCode.E_SUCCESS;
}
else// TrinityErrorCode.E_RPC_EXCEPTION == msgProcessResult
{
// The client is expecting an ACK package, it will be notified because
// the status code would be E_RPC_EXCEPTION or E_MSG_OVERFLOW;
sendRecvBuff->Buffer = (byte *)Memory.malloc(sizeof(TrinityErrorCode));
sendRecvBuff->Length = sizeof(TrinityErrorCode);
*(TrinityErrorCode *)sendRecvBuff->Buffer = msgProcessResult;
}
}
private unsafe void _MessageInitializationTrap(MessageBuff *sendRecvBuff)
{
m_module_init_signal.Wait();
MessageHandlers.DefaultParser.DispatchMessage(sendRecvBuff);
}
internal static void HandleMessage(MessageBuff *sendRecvBuff)
{
//Console.WriteLine("Received (managed world): {0}", sendRecvBuff->BytesReceived);
MessageHandlers.DefaultParser.DispatchMessage(sendRecvBuff);
}
internal void *DispatchMessage(MessageBuff *sendRecvBuff)
{
byte *ByteArray = sendRecvBuff->Buffer;
int Length = (int)sendRecvBuff->Length;
TrinityMessageType msgType = *(TrinityMessageType *)(sendRecvBuff->Buffer + TrinityProtocol.TrinityMsgTypeOffset);
ushort msgId = *(ushort *)(ByteArray + TrinityProtocol.TrinityMsgIdOffset);
TrinityErrorCode msgProcessResult;
try
{
switch (msgType)
{
case TrinityMessageType.SYNC_WITH_RSP:
SynReqRspArgs sync_rsp_args = new SynReqRspArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
sync_rsp_handlers[msgId]);
msgProcessResult = sync_rsp_args.MessageProcess();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff, sync_rsp_args.Response);
return(null);
case TrinityMessageType.PRESERVED_SYNC_WITH_RSP:
SynReqRspArgs preserved_sync_rsp_args = new SynReqRspArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
preserved_sync_rsp_handlers[msgId]);
msgProcessResult = preserved_sync_rsp_args.MessageProcess();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff, preserved_sync_rsp_args.Response);
return(null);
case TrinityMessageType.SYNC:
SynReqArgs sync_args = new SynReqArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
sync_handlers[msgId]);
msgProcessResult = sync_args.MessageProcess();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff);
return(null);
case TrinityMessageType.PRESERVED_SYNC:
SynReqArgs preserved_sync_args = new SynReqArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
preserved_sync_handlers[msgId]);
msgProcessResult = preserved_sync_args.MessageProcess();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff);
return(null);
case TrinityMessageType.ASYNC:
AsynReqArgs async_args = new AsynReqArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
async_handlers[msgId]);
msgProcessResult = async_args.AsyncProcessMessage();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff);
return(null);
case TrinityMessageType.PRESERVED_ASYNC:
AsynReqArgs preserved_async_args = new AsynReqArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
preserved_async_handlers[msgId]);
msgProcessResult = preserved_async_args.AsyncProcessMessage();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff);
return(null);
case TrinityMessageType.ASYNC_WITH_RSP:
AsynReqRspArgs async_rsp_args = new AsynReqRspArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
async_rsp_handlers[msgId]);
msgProcessResult = async_rsp_args.AsyncProcessMessage();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff);
return(null);
default:
throw new Exception("Not recognized message type.");
}
}
catch (MessageTooLongException ex)
{
Log.WriteLine("Message Type: " + msgType);
Log.WriteLine("Message SN: " + msgId);
Log.WriteLine(ex.Message);
Log.WriteLine(ex.StackTrace);
_SetSendRecvBuff(TrinityErrorCode.E_MSG_OVERFLOW, sendRecvBuff);
return(null);
}
catch (Exception ex)
{
Log.WriteLine("Message Type: " + msgType);
Log.WriteLine("Message SN: " + msgId);
Log.WriteLine(ex.Message);
Log.WriteLine(ex.StackTrace);
_SetSendRecvBuff(TrinityErrorCode.E_RPC_EXCEPTION, sendRecvBuff);
return(null);
}
}
private static extern void LocalSendMessage(MessageBuff *lpmsg);
