public void RegisterPacketHandler(IPacketHandler handler)
{
if (PacketHandlers.All(p => p.GetType() != handler.GetType()))
{
_packetHandlers.Add(handler);
}
}
internal void OnNetworkStream(Network.ByteInStream stream)
{
#if !DEBUG
try
{
#endif
while (stream.Stream.CanRead)
{
byte handlerId = stream.ReadByte();
IPacketHandler handler = packetHandlers[handlerId];
if (handler == null)
{
log.Error("No packet handler for id #{0} found, can't process byte stream", handlerId);
return;
}
if (!handler.OnPacket(handlerId, this, stream))
{
log.Error("Handler '{0}' failed processing byte stream", handler.GetType().GetPrettyName());
return;
}
}
#if !DEBUG
}
catch (Exception exn)
{
log.Error(exn);
}
#endif
}
public void HandlePacketTimeout(object sender, ElapsedEventArgs e)
{
string source = ((m_client.Account != null) ? m_client.Account.Name : m_client.TcpEndpoint);
if (log.IsErrorEnabled)
log.Error("Thread " + m_handlerThreadID + " - Handler " + m_activePacketHandler.GetType() +
" takes too much time (>10000ms) <" + source + "> " + "!");
}
public void HandlePacketTimeout(object sender, ElapsedEventArgs e)
{
string source = (_client.Account != null) ? _client.Account.Name : _client.TcpEndpoint;
if (Log.IsErrorEnabled)
{
Log.Error($"Thread {_handlerThreadId} - Handler {_activePacketHandler.GetType()} takes too much time (>10000ms) <{source}> !");
}
}
public void HandlePacket(GSPacketIn packet)
{
int code = packet.Code;
Statistics.BytesIn += packet.Length;
Statistics.PacketsIn++;
IPacketHandler packetHandler = null;
if (code < m_packetHandlers.Length)
{
packetHandler = m_packetHandlers[code];
}
else if (log.IsErrorEnabled)
{
log.ErrorFormat("Received packet code is outside of m_packetHandlers array bounds! " + m_client.ToString());
log.Error(Marshal.ToHexDump(
String.Format("===> <{2}> Packet 0x{0:X2} (0x{1:X2}) length: {3} (ThreadId={4})", code, code ^ 168, m_client.TcpEndpoint, packet.Length, Thread.CurrentThread.ManagedThreadId),
packet.Buffer));
}
if (packetHandler != null)
{
long start = Environment.TickCount;
try
{
packetHandler.HandlePacket(m_client, packet);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
string client = m_client.TcpEndpoint;
log.Error("Error while processing packet (handler=" + packetHandler.GetType().FullName + " client: " + client + ")", e);
log.Error(Marshal.ToHexDump("Package Buffer:", packet.Buffer, 0, packet.Length));
}
}
long timeUsed = Environment.TickCount - start;
m_activePacketHandler = null;
if (log.IsDebugEnabled)
{
log.Debug("Package process Time:" + timeUsed + "ms!");
}
if (timeUsed > 1000)
{
string source = m_client.TcpEndpoint;
if (log.IsWarnEnabled)
{
log.Warn("(" + source + ") Handle packet Thread " + Thread.CurrentThread.ManagedThreadId + " " + packetHandler + " took " + timeUsed + "ms!");
}
}
}
}
public virtual void HandlePacket(int code, GamePacket packet)
{
if (packet == null)
{
log.Error("Packet is null!");
return;
}
IPacketHandler handler = null;
if (m_packagesHandlers.ContainsKey(code))
{
handler = m_packagesHandlers[code];
}
else
{
log.ErrorFormat("Receive package's code is not exists! Code: {0}", code);
log.Error(Marshal.ToHexDump(string.Format("Code: {0}", code), packet.Buffer, 0, packet.Length));
return;
}
long timeUsed = Environment.TickCount;
try
{
handler.HandlePacket(m_client, packet);
}
catch (Exception ex)
{
log.ErrorFormat("Error while processing package (handler={0})", handler.GetType().FullName);
log.Error("Handle package error!", ex);
}
timeUsed = Environment.TickCount - timeUsed;
log.InfoFormat("Package process time: {0}ms", timeUsed);
if (timeUsed > 1000)
{
log.WarnFormat("Handle package thread {0} {1} took {2}ms!", System.Threading.Thread.CurrentThread.ManagedThreadId, handler, timeUsed);
}
}
/// <summary>
/// Registers a packet handler
/// </summary>
/// <param name="handler">The packet handler to register</param>
/// <param name="packetCode">The packet ID to register it with</param>
public void RegisterPacketHandler(int packetCode, IPacketHandler handler, IPacketHandler[] packetHandlers)
{
if (packetHandlers[packetCode] != null)
{
log.InfoFormat("Overwriting Client Packet Code {0}, with handler {1} in PacketProcessor", packetCode, handler.GetType().FullName);
}
packetHandlers[packetCode] = handler;
}
public void AddPacketHandler(IPAddress remoteAddress, String sharedSecret, IPacketHandler packetHandler)
{
_log.Info($"Adding packet handler of type {packetHandler.GetType()} for remote IP {remoteAddress} to {_serverType}Server");
_packetHandlerRepository.AddPacketHandler(remoteAddress, packetHandler, sharedSecret);
}
/// <summary>
/// Parses a packet and gets a response packet from the handler
/// </summary>
/// <param name="packetHandler"></param>
/// <param name="sharedSecret"></param>
/// <param name="packetBytes"></param>
/// <param name="remoteEndpoint"></param>
/// <returns></returns>
internal IRadiusPacket GetResponsePacket(IPacketHandler packetHandler, String sharedSecret, Byte[] packetBytes, IPEndPoint remoteEndpoint)
{
var requestPacket = RadiusPacket.Parse(packetBytes, _dictionary, Encoding.UTF8.GetBytes(sharedSecret));
_log.Info($"Received {requestPacket.Code} from {remoteEndpoint} Id={requestPacket.Identifier}");
if (_log.IsDebugEnabled)
{
DumpPacket(requestPacket);
}
_log.Debug(packetBytes.ToHexString());
// Handle status server requests in server outside packet handler
if (requestPacket.Code == PacketCode.StatusServer)
{
var responseCode = _serverType == RadiusServerType.Authentication ? PacketCode.AccessAccept : PacketCode.AccountingResponse;
_log.Debug($"Sending {responseCode} for StatusServer request from {remoteEndpoint}");
return(requestPacket.CreateResponsePacket(responseCode));
}
_log.Debug($"Handling packet for remote ip {remoteEndpoint.Address} with {packetHandler.GetType()}");
var sw = Stopwatch.StartNew();
var responsePacket = packetHandler.HandlePacket(requestPacket);
sw.Stop();
_log.Debug($"{remoteEndpoint} Id={responsePacket.Identifier}, Received {responsePacket.Code} from handler in {sw.ElapsedMilliseconds}ms");
if (sw.ElapsedMilliseconds >= 5000)
{
_log.Warn($"Slow response for Id {responsePacket.Identifier}, check logs");
}
if (requestPacket.Attributes.ContainsKey("Proxy-State"))
{
responsePacket.Attributes.Add("Proxy-State", requestPacket.Attributes.SingleOrDefault(o => o.Key == "Proxy-State").Value);
}
return(responsePacket);
}
public void HandlePacket(GSPacketIn packet)
{
if (packet == null || m_client == null)
return;
int code = packet.ID;
Statistics.BytesIn += packet.PacketSize;
Statistics.PacketsIn++;
SavePacket(packet);
IPacketHandler packetHandler = null;
if (code < m_packetHandlers.Length)
{
packetHandler = m_packetHandlers[code];
}
else if (log.IsErrorEnabled)
{
log.ErrorFormat("Received packet code is outside of m_packetHandlers array bounds! " + m_client);
log.Error(Marshal.ToHexDump(
String.Format("===> <{2}> Packet 0x{0:X2} (0x{1:X2}) length: {3} (ThreadId={4})", code, code ^ 168,
(m_client.Account != null) ? m_client.Account.Name : m_client.TcpEndpoint,
packet.PacketSize, Thread.CurrentThread.ManagedThreadId),
packet.ToArray()));
}
// make sure we can handle this packet at this stage
var preprocess = m_packetPreprocessor.CanProcessPacket(m_client, packet);
if(!preprocess)
{
// this packet can't be processed by this client right now, for whatever reason
log.Info("PacketPreprocessor: Preprocessor prevents handling of a packet with packet.ID=" + packet.ID);
return;
}
if (packetHandler != null)
{
Timer monitorTimer = null;
if (log.IsDebugEnabled)
{
try
{
monitorTimer = new Timer(10000);
m_activePacketHandler = packetHandler;
m_handlerThreadID = Thread.CurrentThread.ManagedThreadId;
monitorTimer.Elapsed += HandlePacketTimeout;
monitorTimer.Start();
}
catch (Exception e)
{
if (log.IsErrorEnabled)
log.Error("Starting packet monitor timer", e);
if (monitorTimer != null)
{
monitorTimer.Stop();
monitorTimer.Close();
monitorTimer = null;
}
}
}
#if LOGACTIVESTACKS
//Put the current thread into the active thread list!
//No need to lock the hashtable since we created it
//synchronized! One reader, multiple writers supported!
m_activePacketThreads.Add(Thread.CurrentThread, m_client);
#endif
long start = Environment.TickCount;
try
{
packetHandler.HandlePacket(m_client, packet);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
string client = (m_client == null ? "null" : m_client.ToString());
log.Error(
"Error while processing packet (handler=" + packetHandler.GetType().FullName + " client: " + client + ")", e);
}
}
#if LOGACTIVESTACKS
finally
{
//Remove the thread from the active list after execution
//No need to lock the hashtable since we created it
//synchronized! One reader, multiple writers supported!
m_activePacketThreads.Remove(Thread.CurrentThread);
}
#endif
long timeUsed = Environment.TickCount - start;
if (monitorTimer != null)
{
monitorTimer.Stop();
monitorTimer.Close();
}
m_activePacketHandler = null;
if (timeUsed > 1000)
{
string source = ((m_client.Account != null) ? m_client.Account.Name : m_client.TcpEndpoint);
if (log.IsWarnEnabled)
log.Warn("(" + source + ") Handle packet Thread " + Thread.CurrentThread.ManagedThreadId + " " + packetHandler +
" took " + timeUsed + "ms!");
}
}
}
/// <summary>
/// Registers a packet handler
/// </summary>
/// <param name="handler">The packet handler to register</param>
/// <param name="packetCode">The packet ID to register it with</param>
public void RegisterPacketHandler(int packetCode, IPacketHandler handler, IPacketHandler[] packetHandlers)
{
if (packetHandlers[packetCode] != null)
{
log.InfoFormat("Overwriting Client Packet Code {0}, with handler {1} in PacketProcessor", packetCode, handler.GetType().FullName);
}
packetHandlers[packetCode] = handler;
}
public static void SpamTrash(this IPacketHandler h, IEntity ent)
{
const int defaultShortSize = 1024; // size used for short size opcodes
var s = Server();
var p = Player(s);
void Spam(int size, bool randomSize, int op)
{
var iterations = (int)Math.Pow(2, 13);
for (var i = 0; i < iterations; i++)
{
Blob b = randomSize
? RandomData(Rng.Next(0, size + 1))
: RandomData(size);
h.Handle(ent, PacketMessage.Success((byte)op, b));
}
}
if (PacketDb == null)
{
var dirBuild = Path.GetDirectoryName(typeof(MockServer).GetTypeInfo().Assembly.Location);
PacketDb = new JsonPacketDatabase(Path.Combine(dirBuild, "packet-lengths.json"));
}
foreach (var op in h.Handles)
{
// chose size
var size = PacketDb.GetIncoming(op);
switch (size)
{
case PacketLength.NextByte:
Spam(byte.MaxValue, true, op);
break;
case PacketLength.NextShort:
Spam(defaultShortSize, true, op);
break;
case PacketLength.Undefined: throw new NotSupportedException($"Undefined packet in {h.GetType().Name}");
default:
var finalSize = (int) size;
if (finalSize == 0)
return;
Spam(finalSize, false, op);
break;
}
}
}
public void HandlePacket(GSPacketIn packet)
{
int code = (int)packet.Code;
Statistics.BytesIn += (long)packet.Length;
Statistics.PacketsIn += 1L;
IPacketHandler packetHandler = null;
if (code < PacketProcessor.m_packetHandlers.Length)
{
packetHandler = PacketProcessor.m_packetHandlers[code];
Console.WriteLine(string.Concat(new object[]
{
"ClientID: " + packet.ClientID,
" received code: ",
code,
" <",
string.Format("0x{0:x}", code),
">"
}));
Console.WriteLine(" ==>" + packetHandler.ToString());
}
if (code < PacketProcessor.m_packetHandlers.Length)
{
packetHandler = PacketProcessor.m_packetHandlers[code];
try
{
packetHandler.ToString();
goto IL_157;
}
catch
{
Console.WriteLine("______________ERROR______________");
Console.WriteLine(string.Concat(new object[]
{
"___ Received code: ",
code,
" <",
string.Format("0x{0:x}", code),
"> ____"
}));
Console.WriteLine("_________________________________");
goto IL_157;
}
}
if (PacketProcessor.log.IsErrorEnabled)
{
PacketProcessor.log.ErrorFormat("Received packet code is outside of m_packetHandlers array bounds! " + this.m_client.ToString(), new object[0]);
PacketProcessor.log.Error(Marshal.ToHexDump(string.Format("===> <{2}> Packet 0x{0:X2} (0x{1:X2}) length: {3} (ThreadId={4})", new object[]
{
code,
code ^ 168,
this.m_client.TcpEndpoint,
packet.Length,
Thread.CurrentThread.ManagedThreadId
}), packet.Buffer));
}
IL_157:
if (packetHandler != null)
{
long num = (long)Environment.TickCount;
try
{
if (this.m_client != null && packet != null && this.m_client.TcpEndpoint != "not connected")
{
packetHandler.HandlePacket(this.m_client, packet);
}
}
catch (Exception exception)
{
if (PacketProcessor.log.IsErrorEnabled)
{
string tcpEndpoint = this.m_client.TcpEndpoint;
PacketProcessor.log.Error(string.Concat(new string[]
{
"Error while processing packet (handler=",
packetHandler.GetType().FullName,
" client: ",
tcpEndpoint,
")"
}), exception);
PacketProcessor.log.Error(Marshal.ToHexDump("Package Buffer:", packet.Buffer, 0, packet.Length));
}
}
long num2 = (long)Environment.TickCount - num;
this.m_activePacketHandler = null;
if (PacketProcessor.log.IsDebugEnabled)
{
PacketProcessor.log.Debug("Package process Time:" + num2 + "ms!");
}
if (num2 > 1000L)
{
string tcpEndpoint2 = this.m_client.TcpEndpoint;
if (PacketProcessor.log.IsWarnEnabled)
{
PacketProcessor.log.Warn(string.Concat(new object[]
{
"(",
tcpEndpoint2,
") Handle packet Thread ",
Thread.CurrentThread.ManagedThreadId,
" ",
packetHandler,
" took ",
num2,
"ms!"
}));
}
}
}
}
/// <summary>
/// Registers a packet handler
/// </summary>
/// <param name="handler">The packet handler to register</param>
/// <param name="packetCode">The packet ID to register it with</param>
public static void RegisterPacketHandler(int packetCode, IPacketHandler handler)
{
if (m_packetHandlers[packetCode] != null)
{
log.InfoFormat("Overwriting Client Packet Code {0}, with handler {1}", packetCode, handler.GetType().FullName);
}
m_packetHandlers[packetCode] = handler;
}
/// <summary>
/// Registers a packet handler
/// </summary>
/// <param name="handler">The packet handler to register</param>
/// <param name="packetCode">The packet ID to register it with</param>
public static void RegisterPacketHandler(int packetCode, IPacketHandler handler)
{
if (m_packetHandlers[packetCode] != null)
{
log.InfoFormat("Overwriting Client Packet Code {0}, with handler {1}", packetCode, handler.GetType().FullName);
}
m_packetHandlers[packetCode] = handler;
}
public void HandlePacket(GSPacketIn packet)
{
if (packet == null || _client == null)
{
return;
}
int code = packet.ID;
Statistics.BytesIn += packet.PacketSize;
Statistics.PacketsIn++;
SavePacket(packet);
IPacketHandler packetHandler = null;
if (code < _packetHandlers.Length)
{
packetHandler = _packetHandlers[code];
}
else if (Log.IsErrorEnabled)
{
Log.Error($"Received packet code is outside of m_packetHandlers array bounds! {_client}");
Log.Error(Marshal.ToHexDump($"===> <{(_client.Account != null ? _client.Account.Name : _client.TcpEndpoint)}> Packet 0x{code:X2} (0x{code ^ 168:X2}) length: {packet.PacketSize} (ThreadId={Thread.CurrentThread.ManagedThreadId})", packet.ToArray()));
}
// make sure we can handle this packet at this stage
var preprocess = _packetPreprocessor.CanProcessPacket(_client, packet);
if (!preprocess)
{
// this packet can't be processed by this client right now, for whatever reason
Log.Info($"PacketPreprocessor: Preprocessor prevents handling of a packet with packet.ID={packet.ID}");
return;
}
if (packetHandler != null)
{
Timer monitorTimer = null;
if (Log.IsDebugEnabled)
{
try
{
monitorTimer = new Timer(10000);
_activePacketHandler = packetHandler;
_handlerThreadId = Thread.CurrentThread.ManagedThreadId;
monitorTimer.Elapsed += HandlePacketTimeout;
monitorTimer.Start();
}
catch (Exception e)
{
if (Log.IsErrorEnabled)
{
Log.Error("Starting packet monitor timer", e);
}
if (monitorTimer != null)
{
monitorTimer.Stop();
monitorTimer.Close();
monitorTimer = null;
}
}
}
#if LOGACTIVESTACKS
// Put the current thread into the active thread list!
// No need to lock the hashtable since we created it
// synchronized! One reader, multiple writers supported!
ActivePacketThreads.Add(Thread.CurrentThread, _client);
#endif
long start = Environment.TickCount;
try
{
packetHandler.HandlePacket(_client, packet);
}
catch (Exception e)
{
if (Log.IsErrorEnabled)
{
string client = _client?.ToString() ?? "null";
Log.Error($"Error while processing packet (handler={packetHandler.GetType().FullName} client: {client})", e);
}
}
#if LOGACTIVESTACKS
finally
{
// Remove the thread from the active list after execution
// No need to lock the hashtable since we created it
// synchronized! One reader, multiple writers supported!
ActivePacketThreads.Remove(Thread.CurrentThread);
}
#endif
long timeUsed = Environment.TickCount - start;
if (monitorTimer != null)
{
monitorTimer.Stop();
monitorTimer.Close();
}
_activePacketHandler = null;
if (timeUsed > 1000)
{
string source = _client.Account != null ? _client.Account.Name : _client.TcpEndpoint;
if (Log.IsWarnEnabled)
{
Log.Warn($"({source}) Handle packet Thread {Thread.CurrentThread.ManagedThreadId} {packetHandler} took {timeUsed}ms!");
}
}
}
}
/// <summary>
/// Registers a packet handler
/// </summary>
/// <param name="handler">The packet handler to register</param>
/// <param name="packetCode">The packet ID to register it with</param>
public void RegisterPacketHandler(int packetCode, IPacketHandler handler, IPacketHandler[] packetHandlers)
{
if (packetHandlers[packetCode] != null)
{
Log.Info($"Overwriting Client Packet Code {packetCode}, with handler {handler.GetType().FullName} in PacketProcessor");
}
packetHandlers[packetCode] = handler;
}
public void HandlePacket(GSPacketIn packet)
{
int code = (int)packet.Code;
Statistics.BytesIn += (long)packet.Length;
Statistics.PacketsIn += 1L;
IPacketHandler packetHandler = null;
if (code < PacketProcessor.m_packetHandlers.Length)
{
packetHandler = PacketProcessor.m_packetHandlers[code];
}
else
{
{
PacketProcessor.log.ErrorFormat("Received packet code is outside of m_packetHandlers array bounds! " + this.m_client.ToString(), new object[0]);
PacketProcessor.log.Error(Marshal.ToHexDump(string.Format("===> <{2}> Packet 0x{0:X2} (0x{1:X2}) length: {3} (ThreadId={4})", new object[]
{
code,
code ^ 168,
this.m_client.TcpEndpoint,
packet.Length,
Thread.CurrentThread.ManagedThreadId
}), packet.Buffer));
}
}
if (packetHandler != null)
{
long start = (long)Environment.TickCount;
try
{
packetHandler.HandlePacket(this.m_client, packet);
}
catch (Exception e)
{
{
string client = this.m_client.TcpEndpoint;
PacketProcessor.log.Error(string.Concat(new string[]
{
"Error while processing packet (handler=",
packetHandler.GetType().FullName,
" client: ",
client,
")"
}), e);
PacketProcessor.log.Error(Marshal.ToHexDump("Package Buffer:", packet.Buffer, 0, packet.Length));
}
}
long timeUsed = (long)Environment.TickCount - start;
this.m_activePacketHandler = null;
if (timeUsed > 1000L)
{
string source = this.m_client.TcpEndpoint;
PacketProcessor.log.Warn(string.Concat(new object[]
{
"(",
source,
") Handle packet Thread ",
Thread.CurrentThread.ManagedThreadId,
" ",
packetHandler,
" took ",
timeUsed,
"ms!"
}));
}
}
}