void HandleEntry(PacketLogReader reader, PacketLogEntry entry, PacketStatistics stats,
PacketSerializer serializer, StreamWriter result)
{
stats.TotalPackets++;
var name = serializer.GameMessages.CodeToName[entry.MessageCode];
if (_regexes.All(r => !r.IsMatch(name)))
{
stats.IgnoredPackets++;
return;
}
result.WriteLine("[{0:yyyy-MM-dd HH:mm:ss:fff}] {1} {2}: {3} ({4} bytes)",
entry.Timestamp.ToLocalTime(), reader.Servers[entry.ServerId].Name,
entry.Direction.ToDirectionString(), name, entry.Payload.Count);
var parsed = serializer.Create(entry.MessageCode);
var payload = entry.Payload.ToArray();
if (payload.Length != 0)
{
if ((_hex == HexDumpMode.Unknown && parsed == null) || _hex == HexDumpMode.All)
{
result.WriteLine();
result.WriteLine(new RawPacket(name)
{
Payload = payload,
});
}
if ((_analysis == AnalysisMode.Unknown && parsed == null) || _analysis == AnalysisMode.All)
{
var arrays = PacketAnalysis.FindArrays(payload);
if (arrays.Any())
{
result.WriteLine();
result.WriteLine("Potential arrays:");
result.WriteLine();
foreach (var arr in arrays)
{
stats.PotentialArrays++;
result.WriteLine(arr);
}
}
var strings = PacketAnalysis.FindStrings(payload, _whiteSpace, _control, _length);
if (strings.Any())
{
result.WriteLine();
result.WriteLine("Potential strings:");
result.WriteLine();
foreach (var str in strings)
{
stats.PotentialStrings++;
result.WriteLine(str);
}
}
}
}
stats.AddPacket(name, parsed != null, payload.Length);
if (parsed != null && _parse)
{
stats.ParsedPackets++;
serializer.Deserialize(payload, parsed);
for (var i = 0; i < _roundtrips; i++)
{
var payload2 = serializer.Serialize(parsed);
var len = payload.Length;
var len2 = payload2.Length;
Assert.Check(len2 == len,
$"Payload lengths for {name} don't match ({len2} versus {len}).");
if (i > 0)
{
Assert.Check(payload2.SequenceEqual(payload),
$"Payloads for {name} don't match after roundtrip.");
}
if (i != _roundtrips - 1)
{
serializer.Deserialize(payload2, parsed);
}
payload = payload2;
}
result.WriteLine();
result.WriteLine(parsed);
}
result.WriteLine();
}
void PrintStatistics(PacketStatistics stats)
{
if (_stats)
{
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);
}
