private void CalcHeaderCrc(ref GamePackHeader header, byte[] dst)
{
int headerCrcSize = Marshal.SizeOf(header.headerCrc32);
int sz = Marshal.SizeOf(header) - headerCrcSize;
mCrc.Crc(dst, headerCrcSize, sz);
header.headerCrc32 = (uint)mCrc.Value;
byte[] crc = BitConverter.GetBytes(header.headerCrc32);
Buffer.BlockCopy(crc, 0, dst, 0, crc.Length);
}
// 子线程调用
private void OnThreadBufferProcess(TcpClient tcp)
{
if (tcp == null)
{
return;
}
int recvsize = mTcpClient.GetReadDataNoLock(mRecvBuffer, mRecvSize);
if (recvsize > 0)
{
mRecvSize += recvsize;
int recvBufSz = mRecvSize;
int i = 0;
GamePackHeader header = new GamePackHeader();
int headerSize = Marshal.SizeOf(header);
IntPtr headerBuffer = Marshal.AllocHGlobal(headerSize);
try {
while (recvBufSz - i >= headerSize)
{
Marshal.Copy(mRecvBuffer, i, headerBuffer, headerSize);
header = (GamePackHeader)Marshal.PtrToStructure(headerBuffer, typeof(GamePackHeader));
#if USE_NETORDER
// used Net
header.headerCrc32 = (uint)IPAddress.NetworkToHostOrder(header.headerCrc32);
header.dataCrc32 = (uint)IPAddress.NetworkToHostOrder(header.dataCrc32);
header.header = IPAddress.NetworkToHostOrder(header.header);
header.dataSize = IPAddress.NetworkToHostOrder(header.dataSize);
#endif
if ((recvBufSz - i) < (header.dataSize + headerSize))
{
break;
}
GamePacket packet = new GamePacket();
packet.header = header;
if (packet.header.dataSize <= 0)
{
packet.header.dataSize = 0;
packet.data = null;
}
else
{
packet.data = new byte[packet.header.dataSize];
Buffer.BlockCopy(mRecvBuffer, i + headerSize, packet.data, 0, packet.header.dataSize);
}
LinkedListNode <GamePacket> node = new LinkedListNode <GamePacket>(packet);
lock (this)
{
mPacketList.AddLast(node);
}
i += headerSize + header.dataSize;
}
} finally {
Marshal.FreeHGlobal(headerBuffer);
}
recvBufSz -= i;
mRecvSize = recvBufSz;
if (recvBufSz > 0)
{
Buffer.BlockCopy(mRecvBuffer, i, mRecvBuffer, 0, recvBufSz);
}
}
}
// 支持发送buf为null
public void Send(byte[] buf, int packetHandle)
{
if (mConnecting || (mTcpClient == null))
{
return;
}
if (mTcpClient.GetState() != eClientState.eClient_STATE_CONNECTED)
{
return;
}
bool hasBufData = (buf != null) && (buf.Length > 0);
GamePackHeader header = new GamePackHeader();
if (hasBufData)
{
header.dataSize = buf.Length;
}
else
{
header.dataSize = 0;
}
header.header = packetHandle;
if (hasBufData)
{
mCrc.Crc(buf);
header.dataCrc32 = (uint)mCrc.Value;
}
else
{
header.dataCrc32 = 0;
}
int headerSize = Marshal.SizeOf(header);
int dstSize = headerSize;
if (hasBufData)
{
dstSize += buf.Length;
}
byte[] dstBuffer = new byte[dstSize];
IntPtr pStruct = Marshal.AllocHGlobal(headerSize);
try {
Marshal.StructureToPtr(header, pStruct, false);
Marshal.Copy(pStruct, dstBuffer, 0, headerSize);
#if USE_NETORDER
// Calc header Crc
CalcHeaderCrc(ref header, dstBuffer);
// used net
header.headerCrc32 = (uint)IPAddress.HostToNetworkOrder(header.headerCrc32);
header.dataCrc32 = (uint)IPAddress.HostToNetworkOrder(header.dataCrc32);
header.header = IPAddress.HostToNetworkOrder(header.header);
header.dataSize = IPAddress.HostToNetworkOrder(header.dataSize);
Marshal.StructureToPtr(header, pStruct, false);
Marshal.Copy(pStruct, dstBuffer, 0, headerSize);
#endif
} finally {
Marshal.FreeHGlobal(pStruct);
}
#if USE_NETORDER
#else
// Calc header Crc
CalcHeaderCrc(ref header, dstBuffer);
#endif
if (hasBufData)
{
Buffer.BlockCopy(buf, 0, dstBuffer, headerSize, buf.Length);
}
mTcpClient.Send(dstBuffer);
}
public bool Execute()
{
// string threadId = Thread.CurrentThread.ManagedThreadId.ToString ();
// Console.WriteLine (threadId);
if (mTcpClient == null)
{
Stop();
return(false);
}
if (mConnecting)
{
eClientState state = mTcpClient.GetState();
if ((state == eClientState.eClient_STATE_CONNECTING) ||
(state == eClientState.eCLIENT_STATE_NONE))
{
return(true);
}
if ((state == eClientState.eClient_STATE_CONNECT_FAIL) ||
(state == eClientState.eClient_STATE_ABORT))
{
mConnecting = false;
mAbort = false;
mTcpClient.Release();
mTcpClient = null;
// Call Event Error
if (mStateEvents != null)
{
mStateEvents(state);
}
return(false);
}
else if (state == eClientState.eClient_STATE_CONNECTED)
{
mConnecting = false;
mAbort = false;
// Call Event Success
if (mStateEvents != null)
{
mStateEvents(state);
}
return(true);
}
mConnecting = false;
}
if (mTcpClient.HasReadData())
{
int recvsize = mTcpClient.GetReadData(mRecvBuffer, mRecvSize);
if (recvsize > 0)
{
mRecvSize += recvsize;
int recvBufSz = mRecvSize;
int i = 0;
GamePackHeader header = new GamePackHeader();
int headerSize = Marshal.SizeOf(header);
IntPtr headerBuffer = Marshal.AllocHGlobal(headerSize);
try {
while (recvBufSz - i >= headerSize)
{
Marshal.Copy(mRecvBuffer, i, headerBuffer, headerSize);
header = (GamePackHeader)Marshal.PtrToStructure(headerBuffer, typeof(GamePackHeader));
#if USE_NETORDER
// used Net
header.headerCrc32 = (uint)IPAddress.NetworkToHostOrder(header.headerCrc32);
header.dataCrc32 = (uint)IPAddress.NetworkToHostOrder(header.dataCrc32);
header.header = IPAddress.NetworkToHostOrder(header.header);
header.dataSize = IPAddress.NetworkToHostOrder(header.dataSize);
#endif
if ((recvBufSz - i) < (header.dataSize + headerSize))
{
break;
}
GamePacket packet = new GamePacket();
packet.header = header;
if (packet.header.dataSize <= 0)
{
packet.header.dataSize = 0;
packet.data = null;
}
else
{
packet.data = new byte[packet.header.dataSize];
Buffer.BlockCopy(mRecvBuffer, i + headerSize, packet.data, 0, packet.header.dataSize);
}
LinkedListNode <GamePacket> node = new LinkedListNode <GamePacket>(packet);
mPacketList.AddLast(node);
i += headerSize + header.dataSize;
}
} finally {
Marshal.FreeHGlobal(headerBuffer);
}
recvBufSz -= i;
mRecvSize = recvBufSz;
if (recvBufSz > 0)
{
Buffer.BlockCopy(mRecvBuffer, i, mRecvBuffer, 0, recvBufSz);
}
ProcessPackets();
return(true);
}
}
else
{
if (!mAbort)
{
eClientState state = mTcpClient.GetState();
if (state == eClientState.eClient_STATE_ABORT)
{
mAbort = true;
// Call Event Abort
if (mStateEvents != null)
{
mStateEvents(state);
}
return(false);
}
}
}
return(true);
}
