public static int Run(string[] args)
{
try
{
if (!HandleArguments(ref args))
{
return(0);
}
}
catch (OptionException e)
{
Console.Error.WriteLine(e.Message);
return(1);
}
if (args.Length != 1)
{
Console.Error.WriteLine("Expected exactly one input file argument.");
return(1);
}
Log.Level = LogLevel.Debug;
Log.TimestampFormat = "HH:mm:ss:fff";
var color = Console.ForegroundColor;
Log.Loggers.Add(new ConsoleLogger(false,
color, color, color, color, color));
if (!Debugger.IsAttached)
{
AppDomain.CurrentDomain.UnhandledException += UnhandledException;
}
var input = args[0];
var output = _output ?? Path.ChangeExtension(input, "txt");
var regexes = _regexes.Select(x => new Regex(x, RegexOptions))
.DefaultIfEmpty(new Regex(".*", RegexOptions))
.ToArray();
_log.Basic("Parsing {0}...", input);
var stats = new PacketStatistics();
using (var reader = new PacketLogReader(input))
{
if (_header)
{
_log.Info(string.Empty);
_log.Info("Version: {0}", reader.Version);
_log.Info("Compressed: {0}", reader.Compressed);
_log.Info("Region: {0}", reader.Messages.Region);
_log.Info("Servers:");
foreach (var srv in reader.Servers.Values)
{
_log.Info(" {0} ({1}): {2} -> {3}", srv.Name, srv.Id,
srv.RealEndPoint, srv.ProxyEndPoint);
}
_log.Info(string.Empty);
}
PacketSerializer serializer;
switch (_backend)
{
case PacketSerializerBackend.Reflection:
serializer = new ReflectionPacketSerializer(
reader.Messages);
break;
case PacketSerializerBackend.Compiler:
serializer = new CompilerPacketSerializer(
reader.Messages);
break;
default:
throw Assert.Unreachable();
}
using (var result = new StreamWriter(new FileStream(output,
FileMode.Create, FileAccess.Write)))
foreach (var entry in reader.EnumerateAll())
{
HandleEntry(reader, entry, regexes, stats, serializer,
result);
}
}
_log.Basic("Parsed packets to {0}", output);
PrintStats(stats);
return(0);
}
protected override int Invoke(string[] args)
{
if (args.Length != 1)
{
Console.Error.WriteLine("Expected exactly 1 argument");
return(1);
}
var input = args[0];
if (_output == null)
{
_output = Path.ChangeExtension(input, ParsedExtension);
}
if (_regexes.Count == 0)
{
_regexes.Add(new Regex(".*", FilterRegexOptions));
}
_log.Basic("Parsing {0}...", input);
var stats = new PacketStatistics();
using var reader = new PacketLogReader(input);
if (_header)
{
_log.Info(string.Empty);
_log.Info("Version: {0}", reader.Version);
_log.Info("Compression: {0}", reader.CompressionLevel);
_log.Info("Region: {0}", reader.Region);
_log.Info("Client Version: {0}", reader.GameMessages.Version);
_log.Info("Servers:");
foreach (var srv in reader.Servers.Values)
{
_log.Info(" {0} ({1}): {2} -> {3}", srv.Name, srv.Id, srv.RealEndPoint,
srv.ProxyEndPoint);
}
_log.Info(string.Empty);
}
PacketSerializer serializer;
switch (_backend)
{
case PacketSerializerBackend.Reflection:
serializer = new ReflectionPacketSerializer(reader.Region, reader.GameMessages,
reader.SystemMessages);
break;
case PacketSerializerBackend.Compiler:
serializer = new CompilerPacketSerializer(reader.Region, reader.GameMessages,
reader.SystemMessages);
break;
default:
throw Assert.Unreachable();
}
using var result = new StreamWriter(new FileStream(_output, FileMode.Create, FileAccess.Write));
foreach (var entry in reader.EnumerateAll())
{
HandleEntry(reader, entry, stats, serializer, result);
}
_log.Basic("Parsed packets to {0}", _output);
PrintStatistics(stats);
return(0);
}
static ServerInstance StartServer(Region region, HostsFileManager hosts)
{
_log.Basic("{0} proxy server starting...", region);
var sls = ServerListParameters.Uris[region];
var slsPort = Configuration.ServerListPort;
if (slsPort == 0)
{
slsPort = sls.Port;
}
var slsHost = sls.Host;
var slsAddress = Configuration.ServerListBaseAddress;
hosts?.RemoveEntry(slsHost, slsAddress);
var real = Dns.GetHostEntry(slsHost).AddressList[0];
_log.Info("Resolved {0} server list address: {1} -> {2}", region, slsHost, real);
hosts?.AddEntry(slsHost, slsAddress);
var slsProxy = new ServerListProxy(new ServerListParameters(real,
Configuration.ServerListBaseAddress, slsPort, Configuration.GameBaseAddress,
Configuration.GameBasePort, region, Configuration.ServerListTimeout,
Configuration.ServerListRetries));
var pool = new ObjectPool <SocketAsyncEventArgs>(() => new SocketAsyncEventArgs(),
x => x.Reset(), Configuration.PoolLimit != 0 ? (int?)Configuration.PoolLimit : null);
var version = DataCenter.ClientVersions[region];
var serializer = new CompilerPacketSerializer(region, new GameMessageTable(version),
new SystemMessageTable(version));
var proxies = slsProxy.Servers.Select(x => new GameProxy(x, pool, serializer,
Configuration.GameBacklog, Configuration.GameMaxClients, Configuration.GameTimeout))
.ToArray();
var path = Path.ChangeExtension(Path.Combine(Configuration.AssetDirectory,
DataCenter.FileNames[region]), DataCenter.UnpackedExtension);
using var file = File.Exists(path) ? File.OpenRead(path) : null;
var dc = file == null ? new DataCenter(version) : new DataCenter(file,
Configuration.DataCenterMode, Configuration.DataCenterStringOptions);
var loader = new PluginLoader(new PluginContext(region, dc, proxies),
Configuration.PluginDirectory, Configuration.PluginPattern, Configuration.DisablePlugins);
loader.Start();
if (Configuration.ServerListEnabled)
{
slsProxy.Start();
}
foreach (var proxy in proxies)
{
proxy.Start();
}
_log.Basic("{0} proxy server started", region);
return(new ServerInstance(slsProxy, loader, proxies));
}
