public virtual void Read(NetworkPacket packet, NetworkFormat format)
{
_lock.TryEnterReadLock(Timeout.Infinite);
{
if (format.Secured)
{
Encryption.Transform(packet);
switch (format.Command)
{
case 0x39:
case 0x3A:
TransFormDialog(packet);
Reader.Position = 6;
break;
default:
Reader.Position = 0;
break;
}
}
else
{
Reader.Position = -1;
}
Reader.Packet = packet;
format.Serialize(Reader);
}
_lock.ExitReadLock();
}
private void SendFormat(NetworkFormat format)
{
if (format == null)
{
return;
}
lock (Writer)
{
if (!GetPacket(format))
{
return;
}
var packet = Writer.ToPacket();
{
if (ServerContext.Config.LogSentPackets)
{
if (this is GameClient)
{
Console.WriteLine("{0}: {1}", (this as GameClient)?.Aisling?.Username, packet);
}
}
if (format.Secured)
{
Encryption.Transform(packet);
}
var buffer = packet.ToArray();
Socket.Send(buffer);
}
}
}
public void Send(NetworkFormat format)
{
if (Session.ConnectedSocket.Connected)
{
FlushAndSend(format);
}
}
public void Send(NetworkFormat format)
{
var queue = ServerContext.Config.QueuePackets;
catcher:
try
{
if (queue)
{
SendAsync(format);
}
else
{
SendFormat(format);
}
Errors = 0;
}
catch
{
if (Errors++ <= ServerContext.Config.ClientPacketSendErrorLimit)
{
Writer = new NetworkPacketWriter();
queue = !queue;
goto catcher;
}
}
}
public void Read(NetworkPacket packet, NetworkFormat format)
{
if (packet == null)
{
return;
}
lock (Reader)
{
if (format.Secured)
{
Encryption.Transform(packet);
if (format.Command == 0x39 || format.Command == 0x3A)
{
TransFormDialog(packet);
Reader.Position = 0x6;
}
else
{
Reader.Position = 0x0;
}
}
else
{
Reader.Position = -0x1;
}
Reader.Packet = packet;
format.Serialize(Reader);
Reader.Position = -0x1;
}
}
public virtual void Read(NetworkPacket packet, NetworkFormat format)
{
if (format.Secured)
{
Encryption.Transform(packet);
if (format.Command == 0x39 || format.Command == 0x3A)
{
TransFormDialog(packet);
Reader.Position = 6;
}
else
{
Reader.Position = 0;
}
}
else
{
Reader.Position = -1;
}
if (ServerContext.Config?.LogRecvPackets ?? false)
{
Console.WriteLine("r: {0}", packet);
}
Reader.Packet = packet;
format.Serialize(Reader);
}
public void FlushAndSend(NetworkFormat format)
{
lock (syncLock)
{
Writer.Position = 0;
Writer.Write(format.Command);
if (format.Secured)
{
Writer.Write(Ordinal++);
}
format.Serialize(Writer);
var packet = Writer.ToPacket();
if (packet == null)
{
return;
}
if (format.Secured)
{
Encryption.Transform(packet);
}
var array = packet.ToArray();
ServerSocket.Send(array, array.Length, SocketFlags.None);
}
}
public void Read(NetworkPacket packet, NetworkFormat format)
{
if (packet == null)
{
return;
}
if (format.Secured)
{
Encryption.Transform(packet);
switch (format.Command)
{
case 0x39:
case 0x3A:
TransFormDialog(packet);
Reader.Position = 6;
break;
default:
Reader.Position = 0;
break;
}
}
else
{
Reader.Position = -1;
}
Reader.Packet = packet;
format.Serialize(Reader);
Reader.Position = -1;
}
public void Send(NetworkFormat format)
{
if (format.Delay != 0)
{
Thread.Sleep(format.Delay);
}
SendAsync(format);
}
public override void Read(NetworkPacket packet, NetworkFormat format)
{
if (format.Secured)
{
Encryption.Transform(packet);
}
Reader.Packet = packet;
format.Serialize(Reader);
}
private void SendFormat(NetworkFormat format)
{
try
{
if (format == null)
{
return;
}
lock (Writer)
{
PreparePacketWriter(format);
var packet = Writer.ToPacket();
{
if (ServerContext.Config.LogSentPackets)
{
if (this is GameClient)
{
Console.WriteLine("{0}: {1}", (this as GameClient)?.Aisling?.Username, packet);
}
}
if (format.Secured)
{
Encryption.Transform(packet);
}
var buffer = packet.ToArray();
SocketError errorcode = SocketError.Success;
for (int i = 0; i < buffer.Length; i += 1024)
{
if (i + 1024 <= buffer.Length)
{
Socket.Send(buffer, i, 1024, SocketFlags.None, out errorcode);
}
else
{
Socket.Send(buffer, i, buffer.Length - i, SocketFlags.None, out errorcode);
}
}
if (errorcode != SocketError.Success)
{
Console.WriteLine(string.Format("[Network] Packet Error: {0} for Action {1}", errorcode, packet.Command));
}
}
}
}
catch (Exception)
{
//ignore
}
}
private void PreparePacketWriter(NetworkFormat format)
{
Writer.Position = 0;
Writer.Write(format.Command);
if (format.Secured)
{
Writer.Write(Ordinal++);
}
format.Serialize(Writer);
}
private bool GetPacket(NetworkFormat format)
{
Writer.Position = 0;
Writer.Write(format.Command);
if (format.Secured)
{
Writer.Write(Ordinal++);
}
format.Serialize(Writer);
return(true);
}
private void Enqueue(NetworkFormat format, NetworkPacket packet)
{
lock (packet)
{
if (format.Secured)
{
Encryption.Transform(packet);
}
var data = packet.ToArray();
CreateBuffers(data);
}
}
public void SendAsync(NetworkFormat format)
{
lock (_sendBuffers)
{
_sendBuffers.Enqueue(format);
if (_sending)
{
return;
}
_sending = true;
Task.Run(() => SendBuffers());
}
}
public void SendAsync(NetworkFormat format)
{
lock (_sendBuffers)
{
_sendBuffers.Enqueue(format);
if (_sending)
{
return;
}
_sending = true;
ThreadPool.QueueUserWorkItem(SendBuffers, this);
}
}
private NetworkPacket GetPacket(NetworkFormat format)
{
lock (Writer)
{
Writer.Position = 0;
Writer.Write(format.Command);
if (format.Secured)
{
Writer.Write(Ordinal++);
}
format.Serialize(Writer);
return(Writer.ToPacket());
}
}
private void SendFormat(NetworkFormat format)
{
if (!WorkSocket.Connected)
{
return;
}
if (format == null)
{
return;
}
var packet = GetPacket(format);
{
Enqueue(format, packet);
}
}
protected void HandleFormat(TClient client, NetworkFormat format)
{
//Sanity check on client.
if (client == null)
{
return;
}
if (_handlers[format.Command] != null)
{
_handlers[format.Command].Invoke(this, new object[]
{
client,
format
});
}
}
private void SendFormat(NetworkFormat format)
{
if (!WorkSocket.Connected)
{
return;
}
if (format == null)
{
return;
}
var packet = GetPacket(format);
{
ServerContext.Info.Info(packet.ToString());
Enqueue(format, packet);
}
}
public void FlushAndSend(NetworkFormat format)
{
if (Session.ConnectedSocket == null)
{
return;
}
if (!Session.ConnectedSocket.Connected)
{
return;
}
lock (Writer)
{
Writer.Position = 0;
Writer.Write(format.Command);
if (format.Secured)
{
Writer.Write(Ordinal++);
}
format.Serialize(Writer);
var packet = Writer.ToPacket();
if (packet == null)
{
return;
}
if (format.Secured)
{
Encryption.Transform(packet);
}
var array = packet.ToArray();
if (Session.ConnectedSocket.Connected)
{
Session.ConnectedSocket.Send(array, SocketFlags.None);
}
}
}
private void Enqueue(NetworkFormat format, NetworkPacket packet)
{
lock (packet)
{
if (format.Secured)
{
Encryption.Transform(packet);
}
var data = packet.ToArray();
if (format is ServerFormat3C)
{
// AddBuffer(data);
}
//else
{
CreateBuffers(data);
}
}
}
public NetworkClient <TClient> Send(NetworkFormat format)
{
if (this is LoginClient)
{
FlushAndSend(format);
return(this);
}
lock (syncLock)
{
Writer.Position = 0;
Writer.Write(format.Command);
if (format.Secured)
{
Writer.Write(Ordinal++);
}
format.Serialize(Writer);
var packet = Writer.ToPacket();
if (packet == null)
{
return(null);
}
if (format.Secured)
{
Encryption.Transform(packet);
}
var array = packet.ToArray();
SendBuffer.Enqueue(array);
//FlushBuffers();
}
return(this);
}
public void FlushAndSend(NetworkFormat format)
{
if (!Socket.Connected)
{
return;
}
lock (_sendLock)
{
Writer.Position = 0;
Writer.Write(format.Command);
if (format.Secured)
{
Writer.Write(Ordinal++);
}
format.Serialize(Writer);
var packet = Writer.ToPacket();
if (packet == null)
{
return;
}
if (format.Secured)
{
Encryption.Transform(packet);
}
var buffer = packet.ToArray();
if (buffer.Length <= 0)
{
return;
}
if (_sending)
{
return;
}
_sending = true;
try
{
Socket.BeginSend(
buffer,
0,
buffer.Length,
SocketFlags.None,
SendCompleted,
Socket
);
}
catch (SocketException)
{
//ignore
}
}
}
public void Send(NetworkFormat format)
{
FlushAndSend(format);
}
public static bool TryGetServerFormat(byte command, out NetworkFormat format)
{
return((format = GetServerFormat(command)) != null);
}
private void SendFormat(NetworkFormat format)
{
if (format == null)
{
return;
}
lock (Writer)
{
Writer.Position = 0;
Writer.Write(format.Command);
if (format.Secured)
{
Writer.Write(Ordinal++);
}
format.Serialize(Writer);
var packet = Writer.ToPacket();
if (_lastFormat == format.Command)
{
++_matches;
}
else
{
_lastFormat = format.Command;
_matches = 0;
}
var sendIt = _matches < (format is ServerFormat3C
? ServerContext.Config.PacketOverflowLimit
: ServerContext.Config.ServerOverflowTolerate);
if (ServerContext.Config.LogSentPackets)
{
if (this is GameClient)
{
Console.WriteLine("{0}: {1}", (this as GameClient)?.Aisling?.Username, packet);
}
}
if (format.Secured)
{
Encryption.Transform(packet);
}
if (!sendIt)
{
return;
}
var buffer = packet.ToArray();
if (ServerContext.Config.SendClientPacketsAsAsync)
{
Socket.BeginSend(buffer, 0, buffer.Length, 0, SendCallback, Socket);
return;
}
Socket.Send(buffer);
}
}
public void Send(NetworkFormat format)
{
SendFormat(format);
}
