public static PacketLogger GetInstance()
{
global::System.IntPtr cPtr = RakNetPINVOKE.PacketLogger_GetInstance();
PacketLogger ret = (cPtr == global::System.IntPtr.Zero) ? null : new PacketLogger(cPtr, false);
return(ret);
}
public static DsoChatPacket Parse(string rawXmlData, byte[] rawData)
{
PacketLogger.LogPacket(rawXmlData);
string xmlBody = SkipHeader(rawXmlData);
if (string.IsNullOrEmpty(xmlBody))
{
// Failed to match against XML
// Try AMF
DsoChatPacket amfPacket;
if ((amfPacket = TryParseAmf(rawXmlData, rawData)) == null)
{
return(null);
}
return(amfPacket);
}
if (BodyDetection.IsMatch(xmlBody) == false)
{
return(null);
}
PacketLogger.LogChatPacket(xmlBody);
// Remove namespaces..
xmlBody = Regex.Replace(xmlBody, " xmlns=(\"|')[^\"']*(\"|')", "");
// Get all messages
MatchCollection matches = RegexMessages.Matches(xmlBody);
if (matches == null || matches.Count == 0)
{
return(null);
}
// Build our xml struct
// <body><messages>...</messages></body>
string validXml = "<body><messages>";
foreach (Match match in matches)
{
validXml += match.Value;
}
validXml += "</messages></body>";
// Deserialize
try {
XmlSerializer serializer = new XmlSerializer(typeof(DsoChatPacket));
using (StringReader stringStream = new StringReader(validXml)) {
DsoChatPacket doc = (DsoChatPacket)serializer.Deserialize(stringStream);
return(doc);
}
} catch {
// Incomplete packet maybe..
return(null);
}
}
public ChatServer()
{
_packetLogger = new PacketLogger();
_logger = new Logger()
{
WriteToConsole = true
};
_logger.Load(Path.Combine("logs", string.Format("chat_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
Environment.Exit(0);
};
_packetLogger.Load("chat_packets.log");
_logger.Info("Loading chat_config.xml...");
ChatConfig.Load();
_logger.Info("Setting up servers...");
_server = new TcpServer(IPAddress.Parse(ChatConfig.Instance.IP), ChatConfig.Instance.Port);
_server.PacketReceived += HandlePacket;
_server.ClientDisconnected += ClientDisconnected;
_server.Error += Error;
var isMono = Type.GetType("Mono.Runtime") != null;
switch (ChatConfig.Instance.AuthRemote.Binding)
{
case "pipe":
if (isMono)
{
_logger.Error("pipe is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("localhost/AuthServer/{0}/", SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password)));
break;
case "tcp":
if (isMono)
{
_logger.Error("pipe is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("{0}:{1}/AuthServer/{2}/", ChatConfig.Instance.AuthRemote.Server, ChatConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password)));
break;
case "http":
_authRemoteClient = new RemoteClient(ERemoteBinding.Http, string.Format("{0}:{1}/AuthServer/{2}/", ChatConfig.Instance.AuthRemote.Server, ChatConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password)));
break;
default:
_logger.Error("Invalid remote binding '{0}' for AuthRemote", ChatConfig.Instance.AuthRemote.Binding);
Environment.Exit(1);
break;
}
}
public CoCProxy()
{
PacketLogger = new PacketLogger();
PacketDumper = new PacketDumper();
Clients = new List <CoCProxyClient>();
PacketHandlers = new Dictionary <ushort, PacketHandler>();
ProxyPacketHandlers.RegisterHanlders(this);
}
public ChatServer()
{
_packetLogger = new PacketLogger();
_logger = new Logger() { WriteToConsole = true };
_logger.Load(Path.Combine("logs", string.Format("chat_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
Environment.Exit(0);
};
_packetLogger.Load("chat_packets.log");
_logger.Info("Loading chat_config.xml...");
ChatConfig.Load();
_logger.Info("Setting up servers...");
_server = new TcpServer(IPAddress.Parse(ChatConfig.Instance.IP), ChatConfig.Instance.Port);
_server.PacketReceived += HandlePacket;
_server.ClientDisconnected += ClientDisconnected;
_server.Error += Error;
var isMono = Type.GetType("Mono.Runtime") != null;
switch (ChatConfig.Instance.AuthRemote.Binding)
{
case "pipe":
if (isMono)
{
_logger.Error("pipe is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("localhost/AuthServer/{0}/", SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password)));
break;
case "tcp":
if (isMono)
{
_logger.Error("pipe is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("{0}:{1}/AuthServer/{2}/", ChatConfig.Instance.AuthRemote.Server, ChatConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password)));
break;
case "http":
_authRemoteClient = new RemoteClient(ERemoteBinding.Http, string.Format("{0}:{1}/AuthServer/{2}/", ChatConfig.Instance.AuthRemote.Server, ChatConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password)));
break;
default:
_logger.Error("Invalid remote binding '{0}' for AuthRemote", ChatConfig.Instance.AuthRemote.Binding);
Environment.Exit(1);
break;
}
}
private void HandleReceivedPacket(SocketAsyncEventArgs args, IPacket packet)
{
PacketLogger.LogPacket(packet, PacketDirection.Client);
var handler = (PacketHandler)null;
if (!PacketHandlers.TryGetValue(packet.ID, out handler))
{
return;
}
handler(this, packet);
}
public void QueuePacket(IPacket packet)
{
if (packet == null)
{
throw new ArgumentNullException("packet");
}
if (NetworkManager == null)
{
throw new InvalidOperationException("Tried to send a packet before NetworkManager was initialized or before socket was connected.");
}
PacketLogger.LogPacket(packet, PacketDirection.Server);
NetworkManager.SendPacket(packet);
}
public CoCClient()
{
UserID = 0;
UserToken = null;
Connection = new Socket(SocketType.Stream, ProtocolType.Tcp);
PacketLogger = new PacketLogger()
{
LogConsole = false
};
PacketHandlers = new Dictionary <ushort, PacketHandler>();
KeepAliveManager = new KeepAliveManager(this);
LoginPacketHandlers.RegisterLoginPacketHandlers(this);
InGamePacketHandlers.RegisterInGamePacketHandler(this);
}
public CoCClient()
{
Fingerprint = new Fingerprint();
Home = new Village();
Avatar = new Avatar();
Connection = new Socket(SocketType.Stream, ProtocolType.Tcp);
PacketHandlers = new Dictionary <ushort, PacketHandler>();
KeepAliveManager = new KeepAliveManager(this);
PacketLogger = new PacketLogger()
{
LogConsole = false
};
LoginPacketHandlers.RegisterLoginPacketHandlers(this);
InGamePacketHandlers.RegisterInGamePacketHandler(this);
}
public static bool HandlePacket(Models.Entities.Player player, CharacterCreationPacket packet)
{
switch (packet.PacketSubType)
{
case 0:
return(HandleCreation(player, packet));
case 1:
return(HandleBackButton(player, packet));
default:
#if LOCAL
PacketLogger.Log(packet, true, true);
#else
PacketLogger.Log(packet, false, true);
#endif
break;
}
return(true);
}
public RelayServer()
{
_packetLogger = new PacketLogger();
_logger = new Logger()
{
WriteToConsole = true
};
_logger.Load(Path.Combine("logs", string.Format("relay_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
Environment.Exit(0);
};
_packetLogger.Load("relay_packets.log");
_logger.Info("Loading relay_config.xml...");
RelayConfig.Load();
_logger.Info("Setting up servers...");
_server = new TcpServer(IPAddress.Parse(RelayConfig.Instance.IP), RelayConfig.Instance.Port);
_server.PacketReceived += HandlePacket;
_server.ClientDisconnected += ClientDisconnected;
_server.Error += Error;
}
public AuthServer()
{
_packetLogger = new PacketLogger();
_logger = new Logger()
{
WriteToConsole = true
};
_logger.Load(Path.Combine("logs", string.Format("auth_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
Environment.Exit(0);
};
_packetLogger.Load("auth_packets.log");
_logger.Info("Loaded Packet Logger");
Stopwatch sw = Stopwatch.StartNew();
AuthConfig.Load();
sw.Stop();
_logger.Info("Loaded Auth Configuration in {0} ms", sw.Elapsed.TotalMilliseconds);
_logger.Info("Starting up server connections...");
_server = new TcpServer(IPAddress.Parse(AuthConfig.Instance.IP), AuthConfig.Instance.Port);
_server.PacketReceived += HandlePacket;
_server.Error += Error;
//
// Initalize a list of ports
//
ushort[] ports = { 38915, 38917 };
for (uint i = 0; ports.Length > i; i++)
{
// Handle NAT tests before starting...
switch (i)
{
case 0:
_natServer = new UDPClient(ports[0]);
_natServer.PacketReceived += HandleNATTest;
_natServer.Error += Error;
_logger.InfoAuth("NAT Test successful at Port {0}", ports[0]);
break;
case 1:
_natServer2 = new UDPClient(ports[1]);
_natServer2.PacketReceived += HandleNATTest2;
_natServer2.Error += Error;
_logger.InfoAuth("NAT Test successful at Port {0}", ports[1]);
break;
default:
break;
}
}
// Bind to pipe/tcp/http settings in configuration
var isMono = Type.GetType("Mono.Runtime") != null;
switch (AuthConfig.Instance.Remote.Binding)
{
case "pipe":
if (isMono)
{
_logger.Error("pipe is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_remoteServer = new RemoteServer(this, ERemoteBinding.Pipe, string.Format("localhost/AuthServer/{0}/", SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
break;
case "tcp":
if (isMono)
{
_logger.Error("tcp is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_remoteServer = new RemoteServer(this, ERemoteBinding.Pipe, string.Format("{0}:{1}/AuthServer/{2}/", AuthConfig.Instance.Remote.Server, AuthConfig.Instance.Remote.Port, SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
break;
case "http":
_remoteServer = new RemoteServer(this, ERemoteBinding.Http, string.Format("{0}:{1}/AuthServer/{2}/", AuthConfig.Instance.Remote.Server, AuthConfig.Instance.Remote.Port, SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
break;
default:
_logger.Error("Invalid remote binding '{0}'", AuthConfig.Instance.Remote.Binding);
Environment.Exit(1);
return;
}
_remoteServer.AddServiceEndpoint(typeof(IAuthRemote), "IAuthRemote");
}
public static void DestroyInstance(PacketLogger i)
{
RakNetPINVOKE.PacketLogger_DestroyInstance(PacketLogger.getCPtr(i));
}
private void HandleNetwork()
{
while (true)
{
if (ShuttingDown)
{
return;
}
for (int i = 0; i < Clients.Count; i++)
{
//TODO: Kick client due to keep alive timeouts.
while (Clients[i].Client.NetworkManager.DataAvailable)
{
try
{
/* S <- P <- C
* Proxying data from client to server.
*/
var rawPacket = (byte[])null; // raw encrypted packet
var decryptedPacket = (byte[])null;
var packet = Clients[i].Client.NetworkManager.ReadPacket(out rawPacket, out decryptedPacket); // receive data from client
if (packet != null)
{
HandlePacket(Clients[i], packet);
}
if (rawPacket != null && packet != null)
{
Clients[i].Server.NetworkManager.CoCStream.Write(rawPacket, 0, rawPacket.Length); // sends data back to server
PacketLogger.LogPacket(packet, PacketDirection.Server);
PacketDumper.LogPacket(packet, PacketDirection.Server, decryptedPacket);
}
}
catch (Exception ex)
{
Console.WriteLine("[{0}]: Client => {1}", ex.GetType().Name, ex.Message);
Clients.RemoveAt(i);
goto ResetLoop;
}
}
if (Clients[i].Server == null)
{
continue;
}
while (Clients[i].Server.NetworkManager.DataAvailable)
{
try
{
/* S -> P -> C
* Proxying data from server to client.
*/
var rawPacket = (byte[])null;
var decryptedPacket = (byte[])null;
var packet = Clients[i].Server.NetworkManager.ReadPacket(out rawPacket, out decryptedPacket); // receive data from server
if (packet != null)
{
HandlePacket(Clients[i], packet);
}
if (rawPacket != null && packet != null)
{
Clients[i].Client.NetworkManager.CoCStream.Write(rawPacket, 0, rawPacket.Length); // sends data back to client
PacketLogger.LogPacket(packet, PacketDirection.Client);
PacketDumper.LogPacket(packet, PacketDirection.Client, decryptedPacket);
}
}
catch (Exception ex)
{
Console.WriteLine("[{0}]: Server => {1}", ex.GetType().Name, ex.Message);
Clients.RemoveAt(i);
goto ResetLoop;
}
}
ResetLoop:
break;
}
Thread.Sleep(1);
}
}
public virtual void LogPacket(IPacket packet, bool clientToServer)
{
Stream.Write(PacketLogger.LogPacket(packet, clientToServer ? Craft.Net.PacketDirection.Serverbound : Craft.Net.PacketDirection.Clientbound));
}
public AuthServer()
{
_packetLogger = new PacketLogger();
_logger = new Logger() { WriteToConsole = true };
_logger.Load(Path.Combine("logs", string.Format("auth_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
Environment.Exit(0);
};
_packetLogger.Load("auth_packets.log");
_logger.Info("Loaded Packet Logger");
Stopwatch sw = Stopwatch.StartNew();
AuthConfig.Load();
sw.Stop();
_logger.Info("Loaded Auth Configuration in {0} ms", sw.Elapsed.TotalMilliseconds);
_logger.Info("Starting up server connections...");
_server = new TcpServer(IPAddress.Parse(AuthConfig.Instance.IP), AuthConfig.Instance.Port);
_server.PacketReceived += HandlePacket;
_server.Error += Error;
//
// Initalize a list of ports
//
ushort[] ports = { 38915, 38917 };
for (uint i = 0; ports.Length > i; i++ )
{
// Handle NAT tests before starting...
switch (i)
{
case 0:
_natServer = new UDPClient(ports[0]);
_natServer.PacketReceived += HandleNATTest;
_natServer.Error += Error;
_logger.InfoAuth("NAT Test successful at Port {0}", ports[0]);
break;
case 1:
_natServer2 = new UDPClient(ports[1]);
_natServer2.PacketReceived += HandleNATTest2;
_natServer2.Error += Error;
_logger.InfoAuth("NAT Test successful at Port {0}", ports[1]);
break;
default:
break;
}
}
// Bind to pipe/tcp/http settings in configuration
var isMono = Type.GetType("Mono.Runtime") != null;
switch (AuthConfig.Instance.Remote.Binding)
{
case "pipe":
if (isMono)
{
_logger.Error("pipe is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_remoteServer = new RemoteServer(this, ERemoteBinding.Pipe, string.Format("localhost/AuthServer/{0}/", SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
break;
case "tcp":
if (isMono)
{
_logger.Error("tcp is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_remoteServer = new RemoteServer(this, ERemoteBinding.Pipe, string.Format("{0}:{1}/AuthServer/{2}/", AuthConfig.Instance.Remote.Server, AuthConfig.Instance.Remote.Port, SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
break;
case "http":
_remoteServer = new RemoteServer(this, ERemoteBinding.Http, string.Format("{0}:{1}/AuthServer/{2}/", AuthConfig.Instance.Remote.Server, AuthConfig.Instance.Remote.Port, SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
break;
default:
_logger.Error("Invalid remote binding '{0}'", AuthConfig.Instance.Remote.Binding);
Environment.Exit(1);
return;
}
_remoteServer.AddServiceEndpoint(typeof(IAuthRemote), "IAuthRemote");
}
public GameServer()
{
Channels = new ChannelCollection();
Rooms = new RoomCollection();
Players = new PlayerCollection();
Logger = new Logger() { WriteToConsole = true };
_packetLogger = new PacketLogger();
Logger.Load(Path.Combine("logs", string.Format("game_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
Environment.Exit(0);
};
_packetLogger.Load("game_packets.log");
Logger.Info("Loading game_config.xml...");
GameConfig.Load();
Logger.Info("Setting up servers...");
_server = new TcpServer(IPAddress.Parse(GameConfig.Instance.IP), GameConfig.Instance.Port);
_server.PacketReceived += HandlePacket;
_server.ClientDisconnected += ClientDisconnected;
_server.Error += Error;
var isMono = Type.GetType("Mono.Runtime") != null;
switch (GameConfig.Instance.AuthRemote.Binding)
{
case "pipe":
if (isMono)
{
Logger.Error("pipe is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("localhost/AuthServer/{0}/", SHA256.ComputeHash(GameConfig.Instance.AuthRemote.Password)));
break;
case "tcp":
if (isMono)
{
Logger.Error("pipe is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("{0}:{1}/AuthServer/{2}/", GameConfig.Instance.AuthRemote.Server, GameConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(GameConfig.Instance.AuthRemote.Password)));
break;
case "http":
_authRemoteClient = new RemoteClient(ERemoteBinding.Http, string.Format("{0}:{1}/AuthServer/{2}/", GameConfig.Instance.AuthRemote.Server, GameConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(GameConfig.Instance.AuthRemote.Password)));
break;
default:
Logger.Error("Invalid remote binding '{0}' for AuthRemote", GameConfig.Instance.AuthRemote.Binding);
Environment.Exit(1);
break;
}
Logger.Info("Loading plugins... {0}",AppDomain.CurrentDomain.BaseDirectory);
_pluginManager.Load();
foreach (var plugin in _pluginManager.Plugins)
Logger.Info("Loaded {0}", plugin.Name);
}
protected override void ConnectToPort(object obj)
{
base.ConnectToPort(obj);
RocketLogger = new PacketLogger(RocketData);
}
/// <summary>
/// SessionSocket Constructor
/// </summary>
public SessionSocket()
{
// Set the delegate event handlers
m_packetLogger = new PacketLogger(LogPacket);
}
public static void LogPacketHeader(bool incoming, uint circuit, byte flags, PacketType packetType, ushort size)
{
if (!m_shouldCollectStats)
{
return;
}
// Binary logging format is TTTTTTTTCCCCFPPPSS, T=Time, C=Circuit, F=Flags, P=PacketType, S=size
// Put the incoming bit into the least significant bit of the flags byte
if (incoming)
{
flags |= 0x01;
}
else
{
flags &= 0xFE;
}
// Put the flags byte into the most significant bits of the type integer
uint type = (uint)packetType;
type |= (uint)flags << 24;
// m_log.Debug("1 LogPacketHeader(): Outside lock");
lock (binStatsLogLock)
{
DateTime now = DateTime.Now;
// m_log.Debug("2 LogPacketHeader(): Inside lock. now is " + now.Ticks);
try
{
if (PacketLog == null || (now > PacketLog.StartTime + binStatsMaxFilesize))
{
if (PacketLog != null && PacketLog.Log != null)
{
PacketLog.Log.Close();
}
// First log file or time has expired, start writing to a new log file
PacketLog = new PacketLogger();
PacketLog.StartTime = now;
PacketLog.Path = (binStatsDir.Length > 0 ? binStatsDir + System.IO.Path.DirectorySeparatorChar.ToString() : "")
+ String.Format("packets-{0}.log", now.ToString("yyyyMMddHHmmss"));
PacketLog.Log = new BinaryWriter(File.Open(PacketLog.Path, FileMode.Append, FileAccess.Write));
}
// Serialize the data
byte[] output = new byte[18];
Buffer.BlockCopy(BitConverter.GetBytes(now.Ticks), 0, output, 0, 8);
Buffer.BlockCopy(BitConverter.GetBytes(circuit), 0, output, 8, 4);
Buffer.BlockCopy(BitConverter.GetBytes(type), 0, output, 12, 4);
Buffer.BlockCopy(BitConverter.GetBytes(size), 0, output, 16, 2);
// Write the serialized data to disk
if (PacketLog != null && PacketLog.Log != null)
{
PacketLog.Log.Write(output);
}
}
catch (Exception ex)
{
m_log.Error("Packet statistics gathering failed: " + ex.Message, ex);
if (PacketLog.Log != null)
{
PacketLog.Log.Close();
}
PacketLog = null;
}
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PacketLogger obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public static void LogPacketHeader(bool incoming, uint circuit, byte flags, PacketType packetType, ushort size)
{
if (m_aggregatedBWStats)
{
lock (aggBWStatsLock)
{
if (incoming)
m_aggregatedBytesIn += size;
else
m_aggregatedByestOut += size;
}
}
if (!m_shouldCollectStats) return;
// Binary logging format is TTTTTTTTCCCCFPPPSS, T=Time, C=Circuit, F=Flags, P=PacketType, S=size
// Put the incoming bit into the least significant bit of the flags byte
if (incoming)
flags |= 0x01;
else
flags &= 0xFE;
// Put the flags byte into the most significant bits of the type integer
uint type = (uint)packetType;
type |= (uint)flags << 24;
// m_log.Debug("1 LogPacketHeader(): Outside lock");
lock (binStatsLogLock)
{
DateTime now = DateTime.Now;
// m_log.Debug("2 LogPacketHeader(): Inside lock. now is " + now.Ticks);
try
{
if (PacketLog == null || (now > PacketLog.StartTime + binStatsMaxFilesize))
{
if (PacketLog != null && PacketLog.Log != null)
{
PacketLog.Log.Close();
}
// First log file or time has expired, start writing to a new log file
PacketLog = new PacketLogger();
PacketLog.StartTime = now;
PacketLog.Path = (binStatsDir.Length > 0 ? binStatsDir + System.IO.Path.DirectorySeparatorChar.ToString() : "")
+ String.Format("packets-{0}.log", now.ToString("yyyyMMddHHmmss"));
PacketLog.Log = new BinaryWriter(File.Open(PacketLog.Path, FileMode.Append, FileAccess.Write));
}
// Serialize the data
byte[] output = new byte[18];
Buffer.BlockCopy(BitConverter.GetBytes(now.Ticks), 0, output, 0, 8);
Buffer.BlockCopy(BitConverter.GetBytes(circuit), 0, output, 8, 4);
Buffer.BlockCopy(BitConverter.GetBytes(type), 0, output, 12, 4);
Buffer.BlockCopy(BitConverter.GetBytes(size), 0, output, 16, 2);
// Write the serialized data to disk
if (PacketLog != null && PacketLog.Log != null)
PacketLog.Log.Write(output);
}
catch (Exception ex)
{
m_log.Error("Packet statistics gathering failed: " + ex.Message, ex);
if (PacketLog.Log != null)
{
PacketLog.Log.Close();
}
PacketLog = null;
}
}
}
public AuthServer()
{
_packetLogger = new PacketLogger();
_logger = new Logger()
{
WriteToConsole = true
};
_logger.Load(Path.Combine("logs", string.Format("auth_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
Environment.Exit(0);
};
_packetLogger.Load("auth_packets.log");
_logger.Info("Loading auth_config.xml...");
AuthConfig.Load();
_logger.Info("Setting up servers...");
_server = new TcpServer(IPAddress.Parse(AuthConfig.Instance.IP), AuthConfig.Instance.Port);
_server.PacketReceived += HandlePacket;
_server.Error += Error;
_natServer = new UDPClient(38915);
_natServer.PacketReceived += HandleNATTest;
_natServer.Error += Error;
_natServer2 = new UDPClient(38917);
_natServer2.PacketReceived += HandleNATTest2;
_natServer2.Error += Error;
var isMono = Type.GetType("Mono.Runtime") != null;
switch (AuthConfig.Instance.Remote.Binding)
{
case "pipe":
if (isMono)
{
_logger.Error("pipe is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_remoteServer = new RemoteServer(this, ERemoteBinding.Pipe, string.Format("localhost/FagNetAuth/{0}/", SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
break;
case "tcp":
if (isMono)
{
_logger.Error("tcp is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_remoteServer = new RemoteServer(this, ERemoteBinding.Pipe, string.Format("{0}:{1}/FagNetAuth/{2}/", AuthConfig.Instance.Remote.Server, AuthConfig.Instance.Remote.Port, SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
break;
case "http":
_remoteServer = new RemoteServer(this, ERemoteBinding.Http, string.Format("{0}:{1}/FagNetAuth/{2}/", AuthConfig.Instance.Remote.Server, AuthConfig.Instance.Remote.Port, SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
break;
default:
_logger.Error("Invalid remote binding '{0}'", AuthConfig.Instance.Remote.Binding);
Environment.Exit(1);
return;
}
_remoteServer.AddServiceEndpoint(typeof(IAuthRemote), "IAuthRemote");
}
