public bool Send(SendMethod method)
{
if (msg == null)
{
msg = new NetworkMessage(Client, 4048);
}
switch (method)
{
case SendMethod.Proxy:
lock (msgLock)
{
msg.Reset();
ToNetworkMessage(msg);
if (msg.Length > 8)
{
msg.InsetLogicalPacketHeader();
msg.PrepareToSend();
if (Destination == PacketDestination.Client)
{
Client.IO.Proxy.SendToClient(msg.Data);
}
else if (Destination == PacketDestination.Server)
{
Client.IO.Proxy.SendToServer(msg.Data);
}
return(true);
}
}
break;
case SendMethod.HookProxy:
lock (msgLock)
{
msg.Reset();
ToNetworkMessage(msg);
if (msg.Length > 8)
{
msg.InsetLogicalPacketHeader();
msg.PrepareToSend();
Pipes.HookSendToServerPacket.Send(Client, msg.Data);
return(true);
}
}
break;
case SendMethod.Memory:
lock (msgLock)
{
msg.Reset();
ToNetworkMessage(msg);
if (Destination == PacketDestination.Server)
{
if (msg.Length > 8)
{
msg.InsetLogicalPacketHeader();
msg.PrepareToSend();
return(SendPacketToServerByMemory(Client, msg.Data));
}
}
else if (Destination == PacketDestination.Client)
{
byte[] data = new byte[msg.Data.Length - 8];
Array.Copy(msg.Data, 8, data, 0, data.Length);
SendPacketToClientByMemory(Client, data);
}
}
break;
}
return(false);
}
private void ServerReadCallBack(IAsyncResult ar)
{
byte[] serverData = null;
try
{
int read = serverStream.EndRead(ar);
if (read < 2)
{
Restart();
return;
}
lastInteraction = DateTime.Now;
int pSize = (int)BitConverter.ToUInt16(serverRecvMsg.GetBuffer(), 0) + 2;
while (read < pSize)
{
if (serverStream.CanRead)
{
read += serverStream.Read(serverRecvMsg.GetBuffer(), read, pSize - read);
}
else
{
throw new Exception("Connection broken.");
}
}
serverRecvMsg.Length = pSize;
switch (protocol)
{
case Protocol.Login:
ParseCharacterList();
break;
case Protocol.World:
OnReceivedDataFromServer(serverRecvMsg.Data);
serverData = serverRecvMsg.Data;
if (serverRecvMsg.CheckAdler32() && serverRecvMsg.XteaDecrypt(xteaKey))
{
serverRecvMsg.Position = serverRecvMsg.GetPacketHeaderSize();
int msgSize = (int)serverRecvMsg.GetUInt16() + serverRecvMsg.GetPacketHeaderSize() + 2;
clientSendMsg.Reset();
while (serverRecvMsg.Position < msgSize)
{
int position = serverRecvMsg.Position;
byte type = serverRecvMsg.PeekByte();
lastReceivedPacketTypes.Push(type);
if (!ParsePacketFromServer(client, serverRecvMsg, clientSendMsg))
{
byte[] unknown = serverRecvMsg.GetBytes(serverRecvMsg.Length - serverRecvMsg.Position);
OnSplitPacketFromServer(unknown[0], unknown);
WriteDebug("Unknown incoming packet, type: " + type.ToString("X") + ", data: " + unknown.ToHexString());
clientSendMsg.AddBytes(unknown);
break;
}
byte[] data = new byte[serverRecvMsg.Position - position];
Array.Copy(serverRecvMsg.GetBuffer(), position, data, 0, data.Length);
OnSplitPacketFromServer(data[0], data);
}
if (AllowIncomingModification &&
clientSendMsg.Length > clientSendMsg.GetPacketHeaderSize() + 2)
{
clientSendMsg.InsetLogicalPacketHeader();
clientSendMsg.PrepareToSend(xteaKey);
SendToClient(clientSendMsg.Data);
}
else
{
SendToClient(serverData);
}
}
else
{
SendToClient(serverData);
}
serverStream.BeginRead(serverRecvMsg.GetBuffer(), 0, 2, new AsyncCallback(ServerReadCallBack), null);
break;
case Protocol.None:
SendToClient(serverRecvMsg.Data);
break;
}
}
catch (System.IO.IOException) { }
catch (ObjectDisposedException) { }
catch (Exception ex)
{
WriteDebug(ex.ToString());
if (serverData != null)
{
SendToClient(serverData);
serverStream.BeginRead(serverRecvMsg.GetBuffer(), 0, 2, new AsyncCallback(ServerReadCallBack), null);
}
//Restart();
}
}
