public void ProcessFromClient(byte[] buffer)
{
int length = buffer.Length;
Array.Copy(buffer, clientRecvMsg.GetBuffer(), length);
clientRecvMsg.Length = length;
OnReceivedDataFromClient(clientRecvMsg.Data);
switch (protocol)
{
case Protocol.None:
case Protocol.Login:
ParseFirstClientMsg();
break;
case Protocol.World:
bool adlerOkay = clientRecvMsg.CheckAdler32();
bool decryptOkay = clientRecvMsg.XteaDecrypt(client.IO.XteaKey);
if (adlerOkay && decryptOkay)
{
clientRecvMsg.Position = 6;
int msgLength = (int)clientRecvMsg.GetUInt16() + 8;
int position = clientRecvMsg.Position;
if (!ParsePacketFromClient(client, clientRecvMsg, serverSendMsg))
{
//unknown packet
byte[] unknown = clientRecvMsg.GetBytes(clientRecvMsg.Length - clientRecvMsg.Position);
OnSplitPacketFromClient(unknown[0], unknown);
}
byte[] data = new byte[clientRecvMsg.Position - position];
Array.Copy(clientRecvMsg.GetBuffer(), position, data, 0, data.Length);
OnSplitPacketFromClient(data[0], data);
}
break;
}
}
private void ListenClientCallBack(IAsyncResult ar)
{
try
{
if (!accepting)
{
return;
}
accepting = false;
clientSocket = loginClientTcp.EndAcceptSocket(ar);
loginClientTcp.Stop();
worldClientTcp.Stop();
if (Version.CurrentVersion >= 854)
{
int type = (int)ar.AsyncState;
//we have to connect to the world server now.. and send w8 for response..
if (type == 1)
{
serverTcp = new TcpClient(BitConverter.GetBytes(charList[client.Login.SelectedChar].WorldIP).ToIPString(), charList[client.Login.SelectedChar].WorldPort);
serverStream = serverTcp.GetStream();
serverStream.BeginRead(serverRecvMsg.GetBuffer(), 0, 2, new AsyncCallback(ServerReadCallBack), null);
}
}
clientStream = new NetworkStream(clientSocket);
clientStream.BeginRead(clientRecvMsg.GetBuffer(), 0, 2, new AsyncCallback(ClientReadCallBack), null);
}
catch (ObjectDisposedException) { /*We don't have to log this exception. */ }
catch (Exception ex)
{
WriteDebug(ex.ToString());
Restart();
}
}
private void GameServerReceive(IAsyncResult ar)
{
try
{
readCount = gameSocket.EndReceive(ar);
if(readCount!=2)
{
//some error
}
else
{
packetTrueLength=BitConverter.ToUInt16(bufferServer,0);
NetworkMessage msg = new NetworkMessage(packetTrueLength+2);
Array.Copy(bufferServer, msg.GetBuffer(), 2);
while (readCount < packetTrueLength + 2)
{
readCount += gameSocket.Receive(msg.GetBuffer(), readCount, packetTrueLength + 2 - readCount, SocketFlags.None);
}
receiveQueue.Enqueue(msg);
ProcessReceiveQueue();
if(gameSocket.Connected)
gameSocket.BeginReceive(bufferServer, 0, 2, SocketFlags.None, (AsyncCallback)GameServerReceive, null);
}
}
catch (Exception)
{
}
}
public void ProcessFromServer(byte[] buffer)
{
int length = (int)BitConverter.ToUInt16(buffer, 0) + 2;
if (length > buffer.Length)
{
// Packet is split into multiple chunks
if (partialPacketSize == 0)
{
// This is the first chunk
fullPacketSize = length;
Array.Copy(buffer, serverRecvMsg.GetBuffer(), buffer.Length);
partialPacketSize = buffer.Length;
return;
}
else
{
// This is a subsequent chunk
Array.Copy(buffer, 0, serverRecvMsg.GetBuffer(), partialPacketSize, buffer.Length);
partialPacketSize += buffer.Length;
if (partialPacketSize < fullPacketSize)
{
// Packet is still incomplete
return;
}
else
{
// Packet is complete
serverRecvMsg.Length = fullPacketSize;
}
}
}
else
{
fullPacketSize = 0;
partialPacketSize = 0;
Array.Copy(buffer, serverRecvMsg.GetBuffer(), length);
serverRecvMsg.Length = length;
}
OnReceivedDataFromServer(serverRecvMsg.Data);
switch (protocol)
{
case Protocol.Login:
break;
case Protocol.World:
bool adlerOkay = serverRecvMsg.CheckAdler32();
bool decryptOkay = serverRecvMsg.XteaDecrypt(client.IO.XteaKey);
if (adlerOkay && decryptOkay)
{
serverRecvMsg.Position = 6;
int msgSize = (int)serverRecvMsg.GetUInt16() + 8;
clientSendMsg.Reset();
while (serverRecvMsg.Position < msgSize)
{
int position = serverRecvMsg.Position;
bool parsed = false;
try
{
parsed = ParsePacketFromServer(client, serverRecvMsg, clientSendMsg);
}
catch (Exception ex)
{
WriteDebug(ex.Message + "\nStackTrace: " + ex.StackTrace);
}
if (!parsed)
{
if (serverRecvMsg.Length - serverRecvMsg.Position > 0 &&
serverRecvMsg.Length < serverRecvMsg.GetBuffer().Length)
{
byte[] unknown = serverRecvMsg.GetBytes(serverRecvMsg.Length - serverRecvMsg.Position);
OnSplitPacketFromServer(unknown[0], unknown);
}
break;
}
if (serverRecvMsg.Position - position > 0)
{
byte[] data = new byte[serverRecvMsg.Position - position];
Array.Copy(serverRecvMsg.GetBuffer(), position, data, 0, data.Length);
OnSplitPacketFromServer(data[0], data);
}
}
}
break;
case Protocol.None:
break;
}
}
