public void Deserialize_Valid_ReturnsValidXml()
{
PacketSerializer serializer = PacketSerializer.Create("application/xml");
Payment etalon = new Payment {
OrderId = "1", AmountKop = 100, CardHolderName = "POVYSHEV NIKOLAY", CardNumber = "9999000088881111", CVV = "100", ExpiryMonth = 12, ExpiryYear = 2017
};
const string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><packet version=\"v1\"><Payment order_id=\"1\" card_number=\"9999000088881111\" expiry_month=\"12\" expiry_year=\"2017\" cvv=\"100\" cardholder_name=\"POVYSHEV NIKOLAY\" amount_kop=\"100\" /></packet>";
Payment payment = null;
using (MemoryStream stream = new MemoryStream())
{
stream.Write(Encoding.UTF8.GetBytes(xml), 0, xml.Length);
stream.Position = 0;
payment = serializer.Deserialize <Payment>(stream).Content;
}
Assert.Equal(etalon.OrderId, payment.OrderId);
Assert.Equal(etalon.AmountKop, payment.AmountKop);
Assert.Equal(etalon.CardHolderName, payment.CardHolderName);
Assert.Equal(etalon.CardNumber, payment.CardNumber);
Assert.Equal(etalon.CVV, payment.CVV);
Assert.Equal(etalon.ExpiryMonth, payment.ExpiryMonth);
Assert.Equal(etalon.ExpiryYear, payment.ExpiryYear);
}
public void Serialize_Valid_ReturnsValidXml()
{
PacketSerializer serializer = PacketSerializer.Create("application/xml");
Payment payment = new Payment {
OrderId = "1", AmountKop = 100, CardHolderName = "POVYSHEV NIKOLAY", CardNumber = "9999000088881111", CVV = "100", ExpiryMonth = 12, ExpiryYear = 2017
};
const string etalon = "<?xml version=\"1.0\" encoding=\"utf-8\"?><packet version=\"v1\"><Payment order_id=\"1\" card_number=\"9999000088881111\" expiry_month=\"12\" expiry_year=\"2017\" cvv=\"100\" cardholder_name=\"POVYSHEV NIKOLAY\" amount_kop=\"100\" /></packet>";
string xml = null;
using (MemoryStream stream = new MemoryStream())
using (StreamReader reader = new StreamReader(stream))
{
serializer.Serialize(new Packet <Payment>(payment)
{
Version = "v1"
}, stream);
stream.Position = 0;
xml = reader.ReadToEnd();
}
Assert.Equal(etalon, xml);
}
public TResp SendRequest <TReq, TResp>(TReq content)
where TReq : IPacketContent
where TResp : IPacketContent
{
HttpWebRequest request = WebRequest.Create(endpoint) as HttpWebRequest;
request.Method = "POST";
request.ContentType = contentType;
request.Timeout = 3000;
PacketSerializer serializer = PacketSerializer.Create(request.ContentType);
try
{
using (MemoryStream stream = new MemoryStream())
{
serializer.Serialize(new Packet <TReq>(content)
{
Version = "v1"
}, stream);
request.ContentLength = stream.Length;
stream.Position = 0;
stream.CopyTo(request.GetRequestStream());
}
HttpWebResponse response = request.GetResponse() as HttpWebResponse;
Stream responseStream = response.GetResponseStream();
Packet <TResp> responsePacket = serializer.Deserialize <TResp>(responseStream);
return(responsePacket.Content);
}
catch (WebException ex)
{
throw new PacketTransportException("Ошибка соединения с сервером", ex);
}
}
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 AcceptNewConnection(IAsyncResult result)
{
if (listener.IsListening)
{
listener.BeginGetContext(AcceptNewConnection, null); //Сразу продолжаем прием новых запросов
}
else
{
return;
}
HttpListenerContext context = listener.EndGetContext(result);
HttpListenerRequest request = context.Request;
HttpListenerResponse response = context.Response;
Out.WriteLine("{0} {1} {2}", DateTime.Now.ToString(), request.RemoteEndPoint, request.HttpMethod);
try
{
PacketSerializer serializer = PacketSerializer.Create(request.ContentType);
if (serializer == null)
{
throw new NotSupportedException(); //вместо исключения должен быть корректный ответ об ошибке
}
//Читаем что нам прислали
Packet <IPacketContent> packet = serializer.Deserialize <IPacketContent>(request.InputStream);
if (packet == null)
{
throw new ArgumentException();
}
//Подберем обработчик
PacketHandler handler = PacketHandler.Create(packet.Version);
handler.Out = Out;
//Получаем результат
Packet <IPacketContent> responsePacket = handler.Handle(packet);
//И отправляем обратно
using (MemoryStream mstream = new MemoryStream())
{
serializer.Serialize(responsePacket, mstream);
response.ContentLength64 = mstream.Length;
response.StatusCode = 200;
mstream.Position = 0;
mstream.CopyTo(response.OutputStream);
}
}
catch (Exception ex)
{
Out.Write("General Exception");
Out.Write(ex.Message);
Out.Write(ex.StackTrace);
response.StatusCode = 500;
}
finally
{
response.OutputStream.Close();
}
}
public static int Run(string[] args)
{
try
{
if (!HandleArguments(ref args))
{
return(0);
}
}
catch (OptionException e)
{
Console.WriteLine(e.Message);
return(1);
}
if (args.Length != 1)
{
Console.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));
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 reader = new PacketLogReader(input);
var serializer = new PacketSerializer(
new OpCodeTable(true, reader.Region),
new OpCodeTable(false, reader.Region));
var stats = new PacketStatistics();
using (var result = new StreamWriter(new FileStream(output,
FileMode.Create, FileAccess.Write)))
{
foreach (var entry in reader.EnumerateAll())
{
stats.TotalPackets++;
var name = serializer.GameMessages.OpCodeToName[entry.OpCode];
if (regexes.Any(r => !r.IsMatch(name)))
{
stats.IgnoredPackets++;
continue;
}
stats.RelevantPackets++;
result.WriteLine("[{0:yyyy-MM-dd HH:mm:ss:fff}] {1} {2}: {3} ({4} bytes)",
entry.Timestamp.ToLocalTime(), entry.ServerName,
entry.Direction.ToDirectionString(), name,
entry.Payload.Count);
var parsed = serializer.Create(entry.OpCode);
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);
}
}
}
}
else
{
stats.EmptyPackets++;
}
if (parsed != null)
{
stats.KnownPackets++;
if (_parse)
{
stats.ParsedPackets++;
for (var i = 0; i < _roundtrips + 1; i++)
{
serializer.Deserialize(payload, parsed);
var payload2 = serializer.Serialize(parsed);
Assert.Check(payload2.Length == payload.Length,
"Payload lengths must match after roundtrip.");
if (i > 0)
{
Assert.Check(payload2.SequenceEqual(payload),
"Payloads must match after first roundtrip.");
}
payload = payload2;
}
result.WriteLine();
result.WriteLine(parsed);
}
}
else
{
stats.UnknownPackets++;
}
result.WriteLine();
}
}
_log.Basic("Parsed packets to {0}", output);
if (_stats)
{
void PrintValue(string name, int value)
{
_log.Info("{0,17}: {1}", name, value);
}
void PrintPacketValue(string name, int value)
{
_log.Info("{0,17}: {1} ({2:P2})", name, value,
(double)value / stats.RelevantPackets);
}
PrintValue("Total packets", stats.TotalPackets);
PrintPacketValue("Relevant packets", stats.RelevantPackets);
PrintPacketValue("Ignored packets", stats.IgnoredPackets);
PrintPacketValue("Empty packets", stats.EmptyPackets);
PrintPacketValue("Unknown packets", stats.UnknownPackets);
PrintPacketValue("Known packets", stats.KnownPackets);
PrintPacketValue("Parsed packets", stats.ParsedPackets);
PrintValue("Potential arrays", stats.PotentialArrays);
PrintValue("Potential strings", stats.PotentialStrings);
}
return(0);
}
