public GSPacketIn ReadPacket_()
{
byte[] buffer = ReadBytes();
GSPacketIn pkg = new GSPacketIn(buffer, buffer.Length);
pkg.ReadHeader();
return(pkg);
}
public GSPacketIn Clone()
{
GSPacketIn gSPacketIn = new GSPacketIn(this.m_buffer, this.m_length);
gSPacketIn.ReadHeader();
gSPacketIn.Offset = this.m_length;
return(gSPacketIn);
}
public GSPacketIn ReadPacket()
{
byte[] array = this.ReadBytes();
GSPacketIn gSPacketIn = new GSPacketIn(array, array.Length);
gSPacketIn.ReadHeader();
return(gSPacketIn);
}
public GSPacketIn Clone()
{
GSPacketIn pkg = new GSPacketIn(this.m_buffer, this.m_length);
pkg.ReadHeader();
pkg.Offset = this.m_length;
pkg.ClearChecksum();
return(pkg);
}
public GSPacketIn ReadPacket()
{
int maxLen = this.ReadShort();
byte[] buf = this.ReadBytes(maxLen);
buf[0] = 113;
buf[1] = 172;
GSPacketIn pkg = new GSPacketIn(buf, maxLen);
pkg.ReadHeader();
if (pkg.Length != maxLen)
{
throw new Exception(string.Format("Error packet in ReadPacket,data length didn't equal packet length, data:{0}, packet:{1}", maxLen, pkg.Length));
}
return(pkg);
}
public GSPacketIn ReadPacket()
{
int length = (int)this.ReadShort();
byte[] data = this.ReadBytes(length);
data[0] = 113;
data[1] = 171;
GSPacketIn content = new GSPacketIn(data, length);
content.ReadHeader();
if (content.Length != length)
{
throw new Exception(string.Format("Error packet in ReadPacket,data length didn't equal packet length, data:{0}, packet:{1}", length, content.Length));
}
return(content);
}
public GSPacketIn ReadPacket_()
{
byte[] buffer = ReadBytes();
GSPacketIn pkg = new GSPacketIn(buffer, buffer.Length);
pkg.ReadHeader();
return pkg;
}
public GSPacketIn ReadPacket()
{
int maxLen = this.ReadShort();
byte[] buf = this.ReadBytes(maxLen);
buf[0] = 113;
buf[1] = 172;
GSPacketIn pkg = new GSPacketIn(buf, maxLen);
pkg.ReadHeader();
if (pkg.Length != maxLen)
{
throw new Exception(string.Format("Error packet in ReadPacket,data length didn't equal packet length, data:{0}, packet:{1}", maxLen, pkg.Length));
}
return pkg;
}
public GSPacketIn Clone()
{
GSPacketIn pkg = new GSPacketIn(m_buffer, m_length);
pkg.ReadHeader();
pkg.Offset = m_length;
return pkg;
}
/// <summary>
/// Called when the client receives bytes
/// </summary>
/// <param name="numBytes">The number of bytes received</param>
public void ReceiveBytes(int numBytes)
{
lock (this)
{
byte[] buffer = m_client.PacketBuf;
//End Offset of buffer
int bufferSize = m_client.PacketBufSize + numBytes;
//log.Debug(Marshal.ToHexDump("Recieve:", buffer, 0, bufferSize));
//Size < minimum
if (bufferSize < GSPacketIn.HDR_SIZE)
{
m_client.PacketBufSize = bufferSize; // undo buffer read
return;
}
//Reset the offset
m_client.PacketBufSize = 0;
int curOffset = 0;
do
{
//read buffer length
int packetLength = 0;
int header = 0;
if (m_client.Encryted)
{
//int key = receive_fsm.getState();
int i = receive_fsm.count;
//key = (key & (0xff << 16)) >> 16;
byte[] tempKey = cloneArrary(m_client.RECEIVE_KEY);
while (curOffset + 4 < bufferSize)
{
byte[] tempBuffer = decryptBytes(buffer,curOffset, 8, tempKey);
header = ((byte)(tempBuffer[0] ) << 8) + (byte)(tempBuffer[1]);
if (header == GSPacketIn.HEADER)
{
packetLength = ((byte)(tempBuffer[2]) << 8) + (byte)(tempBuffer[3]);
break;
}
else
{
curOffset++;
}
}
//decryptBytes(buffer,
}
else
{
while(curOffset + 4 < bufferSize)
{
header = (buffer[curOffset] << 8) + buffer[curOffset + 1];
if (header == GSPacketIn.HEADER)
{
packetLength = (buffer[curOffset + 2] << 8) + buffer[curOffset + 3];
break;
}
else
{
curOffset++;
}
}
}
if ((packetLength != 0 && packetLength < GSPacketIn.HDR_SIZE) || packetLength > 2048)
{
log.Error("packetLength:" + packetLength + ",GSPacketIn.HDR_SIZE:" + GSPacketIn.HDR_SIZE + ",offset:" + curOffset + ",bufferSize:" + bufferSize + ",numBytes:" + numBytes);
log.ErrorFormat("Err pkg from {0}:", m_client.TcpEndpoint);
log.Error(Marshal.ToHexDump("===> error buffer", buffer));
m_client.PacketBufSize = 0;
if (m_client.Strict)
{
m_client.Disconnect();
}
return;
}
int dataLeft = bufferSize - curOffset;
if (dataLeft < packetLength || packetLength == 0)
{
Array.Copy(buffer, curOffset, buffer, 0, dataLeft);
m_client.PacketBufSize = dataLeft;
break;
}
GSPacketIn pkg = new GSPacketIn(new byte[2048],2048);
if (m_client.Encryted)
{
// pkg.CopyFrom(buffer, curOffset, 0, packetLength, receive_fsm.getState());
pkg.CopyFrom3(buffer, curOffset, 0, packetLength, m_client.RECEIVE_KEY);
//receive_fsm.UpdateState();
}
else
{
pkg.CopyFrom(buffer, curOffset, 0, packetLength);
}
pkg.ReadHeader();
log.Debug((Marshal.ToHexDump("Recieve Packet:", pkg.Buffer, 0, packetLength)));
try
{
m_client.OnRecvPacket(pkg);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
log.Error("HandlePacket(pak)", e);
}
curOffset += packetLength;
} while (bufferSize - 1 > curOffset);
if (bufferSize - 1 == curOffset)
{
buffer[0] = buffer[curOffset];
m_client.PacketBufSize = 1;
}
}
}
/// <summary>
/// Called when the client receives bytes
/// </summary>
/// <param name="numBytes">The number of bytes received</param>
public void ReceiveBytes(int numBytes)
{
lock (this)
{
byte[] buffer = m_client.PacketBuf;
//End Offset of buffer
int bufferSize = m_client.PacketBufSize + numBytes;
//log.Debug(Marshal.ToHexDump("Recieve:", buffer, 0, bufferSize));
//Size < minimum
if (bufferSize < GSPacketIn.HDR_SIZE)
{
m_client.PacketBufSize = bufferSize; // undo buffer read
return;
}
//Reset the offset
m_client.PacketBufSize = 0;
int curOffset = 0;
do
{
//read buffer length
int packetLength = 0;
int header = 0;
if (m_client.Encryted)
{
//int key = receive_fsm.getState();
int i = receive_fsm.count;
//key = (key & (0xff << 16)) >> 16;
byte[] tempKey = cloneArrary(m_client.RECEIVE_KEY);
while (curOffset + 4 < bufferSize)
{
byte[] tempBuffer = decryptBytes(buffer, curOffset, 8, tempKey);
header = ((byte)(tempBuffer[0]) << 8) + (byte)(tempBuffer[1]);
if (header == GSPacketIn.HEADER)
{
packetLength = ((byte)(tempBuffer[2]) << 8) + (byte)(tempBuffer[3]);
break;
}
else
{
curOffset++;
}
}
//decryptBytes(buffer,
}
else
{
while (curOffset + 4 < bufferSize)
{
header = (buffer[curOffset] << 8) + buffer[curOffset + 1];
if (header == GSPacketIn.HEADER)
{
packetLength = (buffer[curOffset + 2] << 8) + buffer[curOffset + 3];
break;
}
else
{
curOffset++;
}
}
}
if ((packetLength != 0 && packetLength < GSPacketIn.HDR_SIZE) || packetLength > 2048)
{
log.Error("packetLength:" + packetLength + ",GSPacketIn.HDR_SIZE:" + GSPacketIn.HDR_SIZE + ",offset:" + curOffset + ",bufferSize:" + bufferSize + ",numBytes:" + numBytes);
log.ErrorFormat("Err pkg from {0}:", m_client.TcpEndpoint);
log.Error(Marshal.ToHexDump("===> error buffer", buffer));
m_client.PacketBufSize = 0;
if (m_client.Strict)
{
m_client.Disconnect();
}
return;
}
int dataLeft = bufferSize - curOffset;
if (dataLeft < packetLength || packetLength == 0)
{
Array.Copy(buffer, curOffset, buffer, 0, dataLeft);
m_client.PacketBufSize = dataLeft;
break;
}
GSPacketIn pkg = new GSPacketIn(new byte[2048], 2048);
if (m_client.Encryted)
{
// pkg.CopyFrom(buffer, curOffset, 0, packetLength, receive_fsm.getState());
pkg.CopyFrom3(buffer, curOffset, 0, packetLength, m_client.RECEIVE_KEY);
//receive_fsm.UpdateState();
}
else
{
pkg.CopyFrom(buffer, curOffset, 0, packetLength);
}
pkg.ReadHeader();
log.Debug((Marshal.ToHexDump("Recieve Packet:", pkg.Buffer, 0, packetLength)));
try
{
m_client.OnRecvPacket(pkg);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.Error("HandlePacket(pak)", e);
}
}
curOffset += packetLength;
} while (bufferSize - 1 > curOffset);
if (bufferSize - 1 == curOffset)
{
buffer[0] = buffer[curOffset];
m_client.PacketBufSize = 1;
}
}
}
/// <summary>
/// Called when the client receives bytes
/// </summary>
/// <param name="numBytes">The number of bytes received</param>
public void ReceiveBytes(int numBytes)
{
// UnityEngine.Debug.Log("Nhan duoc pkg");
lock (this)
{
byte[] buffer = m_client.PacketBuf;
int bufferSize = m_client.PacketBufSize + numBytes;
if (bufferSize < 20)
{
// UnityEngine.Debug.Log("bufferSize < 20");
m_client.PacketBufSize = bufferSize;
}
else
{
// UnityEngine.Debug.Log("bufferSize >= 20");
m_client.PacketBufSize = 0;
int curOffset = 0;
do
{
int packetLength = 0;
int header3 = 0;
if (m_client.Encryted)
{
// UnityEngine.Debug.Log("m_client.Encryted");
int i = receive_fsm.count;
byte[] tempKey = cloneArray(m_client.RECEIVE_KEY);
for (; curOffset + 4 < bufferSize; curOffset++)
{
byte[] tempBuffer = decryptBytes(buffer, curOffset, 8, tempKey);
header3 = (tempBuffer[0] << 8) + tempBuffer[1];
if (header3 == 29099)
{
packetLength = (tempBuffer[2] << 8) + tempBuffer[3];
break;
}
}
}
else
{
// UnityEngine.Debug.Log("NOT m_client.Encryted");
for (; curOffset + 4 < bufferSize; curOffset++)
{
header3 = (buffer[curOffset] << 8) + buffer[curOffset + 1];
if (header3 == 29099)
{
packetLength = (buffer[curOffset + 2] << 8) + buffer[curOffset + 3];
break;
}
}
}
if ((packetLength != 0 && packetLength < 20) || packetLength > 8192)
{
// UnityEngine.Debug.Log("[Err] packetLength:" + packetLength + ",GSPacketIn.HDR_SIZE:" + (ushort)20 + ",offset:" + curOffset + ",bufferSize:" + bufferSize + ",numBytes:" + numBytes);
// UnityEngine.Debug.Log("[Err] pkg from "+ m_client.TcpEndpoint);
m_client.PacketBufSize = 0;
if (m_client.Strict)
{
m_client.Disconnect();
}
return;
}
int dataLeft = bufferSize - curOffset;
if (dataLeft < packetLength || packetLength == 0)
{
// UnityEngine.Debug.Log("dataLeft < packetLength || packetLength == 0");
Array.Copy(buffer, curOffset, buffer, 0, dataLeft);
m_client.PacketBufSize = dataLeft;
break;
}
GSPacketIn pkg = new GSPacketIn(new byte[8192], 8192);
if (m_client.Encryted)
{
pkg.CopyFrom3(buffer, curOffset, 0, packetLength, m_client.RECEIVE_KEY);
}
else
{
pkg.CopyFrom(buffer, curOffset, 0, packetLength);
}
pkg.ReadHeader();
// UnityEngine.Debug.Log(Marshal.ToHexDump("Recieve Packet:", pkg.Buffer, 0, packetLength));
try
{
m_client.OnRecvPacket(pkg);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
UnityEngine.Debug.Log("HandlePacket(pak)" + e);
}
}
curOffset += packetLength;
}while (bufferSize - 1 > curOffset);
if (bufferSize - 1 == curOffset)
{
buffer[0] = buffer[curOffset];
m_client.PacketBufSize = 1;
}
}
}
}
public void ReceiveBytes(int numBytes)
{
Monitor.Enter(this);
try
{
byte[] packetBuf = this.m_client.PacketBuf;
int num = this.m_client.PacketBufSize + numBytes;
if (num < 20)
{
this.m_client.PacketBufSize = num;
}
else
{
this.m_client.PacketBufSize = 0;
int num2 = 0;
int num3;
int num5;
while (true)
{
num3 = 0;
if (this.m_client.Encryted)
{
int count = this.receive_fsm.count;
byte[] param = StreamProcessor.cloneArrary(this.m_client.RECEIVE_KEY, 8);
while (num2 + 4 < num)
{
byte[] array = StreamProcessor.decryptBytes(packetBuf, num2, 8, param);
int num4 = ((int)array[0] << 8) + (int)array[1];
if (num4 == 29099)
{
num3 = ((int)array[2] << 8) + (int)array[3];
break;
}
num2++;
}
}
else
{
while (num2 + 4 < num)
{
int num4 = ((int)packetBuf[num2] << 8) + (int)packetBuf[num2 + 1];
if (num4 == 29099)
{
num3 = ((int)packetBuf[num2 + 2] << 8) + (int)packetBuf[num2 + 3];
break;
}
num2++;
}
}
if ((num3 != 0 && num3 < 20) || num3 > 16869)
{
break;
}
num5 = num - num2;
if (num5 < num3 || num3 == 0)
{
goto Block_11;
}
GSPacketIn gSPacketIn = new GSPacketIn(new byte[16869], 16869);
if (this.m_client.Encryted)
{
gSPacketIn.CopyFrom3(packetBuf, num2, 0, num3, this.m_client.RECEIVE_KEY);
}
else
{
gSPacketIn.CopyFrom(packetBuf, num2, 0, num3);
}
gSPacketIn.ReadHeader();
StreamProcessor.log.Debug(Marshal.ToHexDump("Recieve Packet:", gSPacketIn.Buffer, 0, num3));
try
{
this.m_client.OnRecvPacket(gSPacketIn);
}
catch (Exception exception)
{
if (StreamProcessor.log.IsErrorEnabled)
{
StreamProcessor.log.Error("HandlePacket(pak)", exception);
}
}
num2 += num3;
if (num - 1 <= num2)
{
goto IL_332;
}
}
StreamProcessor.log.Error(string.Concat(new object[]
{
"packetLength:",
num3,
",GSPacketIn.HDR_SIZE:",
20,
",offset:",
num2,
",bufferSize:",
num,
",numBytes:",
numBytes
}));
StreamProcessor.log.ErrorFormat("Err pkg from {0}:", this.m_client.TcpEndpoint);
StreamProcessor.log.Error(Marshal.ToHexDump("===> error buffer", packetBuf));
this.m_client.PacketBufSize = 0;
if (this.m_client.Strict)
{
this.m_client.Disconnect();
goto IL_228;
}
goto IL_228;
Block_11:
Array.Copy(packetBuf, num2, packetBuf, 0, num5);
this.m_client.PacketBufSize = num5;
IL_332:
if (num - 1 == num2)
{
packetBuf[0] = packetBuf[num2];
this.m_client.PacketBufSize = 1;
}
IL_228 :;
}
}
finally
{
Monitor.Exit(this);
}
}
public void ReceiveBytes(int numBytes)
{
Monitor.Enter(this);
try
{
int bufferSize = this.m_client.PacketBufSize + numBytes;
if (bufferSize < (int)GSPacketIn.HDR_SIZE)
{
this.m_client.PacketBufSize = bufferSize;
}
else
{
byte[] buffer = this.m_client.PacketBuf;
if (bufferSize > buffer.Length)
{
StreamProcessor.log.ErrorFormat("Error Buffersize: num {0} buffersize:{1} old buffer size:{2} buffer length:{3}", new object[]
{
numBytes,
bufferSize,
this.m_client.PacketBufSize,
buffer.Length
});
bufferSize = buffer.Length;
}
this.m_client.PacketBufSize = 0;
int curOffset = 0;
int dataleft = bufferSize;
while (dataleft >= (int)GSPacketIn.HDR_SIZE && curOffset >= 0)
{
int packetLength = 0;
if (this.m_client.Encryted)
{
int key = this.receive_fsm.getState();
int i = this.receive_fsm.count;
while (curOffset + 4 <= bufferSize)
{
int header = ((int)((byte)((int)buffer[curOffset] ^ (key++ & 16711680) >> 16)) << 8) + (int)((byte)((int)buffer[curOffset + 1] ^ (key++ & 16711680) >> 16));
if (header == (int)GSPacketIn.HEADER)
{
packetLength = ((int)((byte)((int)buffer[curOffset + 2] ^ (key++ & 16711680) >> 16)) << 8) + (int)((byte)((int)buffer[curOffset + 3] ^ (key++ & 16711680) >> 16));
break;
}
curOffset++;
}
}
else
{
while (curOffset + 4 <= bufferSize)
{
int header = ((int)buffer[curOffset] << 8) + (int)buffer[curOffset + 1];
if (header == (int)GSPacketIn.HEADER)
{
packetLength = ((int)buffer[curOffset + 2] << 8) + (int)buffer[curOffset + 3];
break;
}
curOffset++;
}
}
dataleft = bufferSize - curOffset;
if (packetLength < (int)GSPacketIn.HDR_SIZE || packetLength > buffer.Length)
{
StreamProcessor.log.Error(string.Concat(new object[]
{
"packetLength:",
packetLength,
",GSPacketIn.HDR_SIZE:",
GSPacketIn.HDR_SIZE,
",offset:",
curOffset,
",bufferSize:",
bufferSize,
",numBytes:",
numBytes
}));
StreamProcessor.log.ErrorFormat("Err pkg from {0}:", this.m_client.TcpEndpoint);
StreamProcessor.log.Error(Marshal.ToHexDump("===> error buffer", buffer, curOffset, (dataleft > 48) ? 48 : dataleft));
if (this.m_client.Strict && packetLength != 0)
{
StreamProcessor.log.Error("Disconnect the client in [Strict] mode.");
this.m_client.PacketBufSize = 0;
this.m_client.Disconnect();
return;
}
curOffset += 2;
dataleft = bufferSize - curOffset;
}
else
{
if (dataleft < packetLength)
{
break;
}
int size = (packetLength <= 1024) ? 1024 : packetLength;
GSPacketIn pkg = new GSPacketIn(new byte[size], size);
if (this.m_client.Encryted)
{
pkg.CopyFrom(buffer, curOffset, 0, packetLength, this.receive_fsm.getState());
this.receive_fsm.UpdateState();
}
else
{
pkg.CopyFrom(buffer, curOffset, 0, packetLength);
}
pkg.ReadHeader();
if (pkg.CheckSum == pkg.CalculateChecksum())
{
pkg.ClearChecksum();
//if (StreamProcessor.log.IsDebugEnabled)
//{
//StreamProcessor.log.Debug(Marshal.ToHexDump("Recieve Packet:", pkg.Buffer, 0, packetLength));
//}
try
{
//StreamProcessor.log.Debug("Receive Packet!");
this.m_client.OnRecvPacket(pkg);
}
catch (Exception e)
{
StreamProcessor.log.Error("HandlePacket(pak)", e);
}
curOffset += packetLength;
dataleft = bufferSize - curOffset;
}
else
{
curOffset += 2;
dataleft = bufferSize - curOffset;
}
}
}
if (dataleft > 0)
{
Array.Copy(buffer, curOffset, buffer, 0, dataleft);
this.m_client.PacketBufSize = dataleft;
}
}
}
finally
{
Monitor.Exit(this);
}
}
