protected virtual int GetLength(PacketParser parser, ParsedSegment parent)
{
try
{
if (LengthSegment != null)
{
ParsedSegment lengthSegment;
if (!parser.LastParsedSegmentsByName.TryGetValue(LengthSegmentName, out lengthSegment))
{
throw new Exception(string.Format(
"Could not find one occurance of List {0}'s Length-Segment '{1}' in parsed packet {2}",
this, LengthSegmentName, parser.Packet));
}
var len = (int)Convert.ChangeType(lengthSegment.Value, typeof(int));
var expr = LengthSegmentExpr;
if (!string.IsNullOrEmpty(expr))
{
len = ParseLengthExpr(len);
}
return(len);
}
return(ListCountReaders[(int)Type](parser.Packet));
}
catch (Exception e)
{
throw new Exception("Could not parse List-Count for List " + Name + " in Packet " + parser.Packet, e);
}
}
public override void Parse(PacketParser parser, ParsedSegment parent)
{
ParsedSegment refSegment;
if (!parser.LastParsedSegmentsByName.TryGetValue(ReferenceName, out refSegment))
{
throw new Exception(string.Format(
"Could not find one occurance of Switch {0}'s CompareWith-Segment '{1}' in parsed packet {2}",
this, ReferenceName, parser.Packet));
}
var value = refSegment.Value;
if (value == null)
{
throw new Exception(string.Format(
"Value of Switch {0}'s CompareWith-Segment '{1}' in parsed packet {2} is null.",
this, ReferenceName, parser.Packet));
}
var segments = MatchSegments(value);
foreach (var segment in segments)
{
segment.Parse(parser, parent);
}
}
public override void Parse(PacketParser parser, ParsedSegment parent)
{
var length = GetLength(parser, parent);
if (length > MaxListLength)
{
log.Warn("Found list with length {0} which exceeds the MaxLength: {1} in PacketDefinition {2}, Segment {3} - " +
"Packet definition is probably outdated.",
length, MaxListLength, parser.Definition, this);
#if DEBUG
return;
#endif
}
var parsedSegment = new ParsedSegment(this, length);
parent.AddChild(parser, parsedSegment);
while (length-- > 0)
{
var element = new ParsedSegment(this, null);
parsedSegment.List.Add(element);
foreach (var segment in Segments)
{
segment.Parse(parser, element);
}
}
}
// ArraySegment<byte> m_remainder;
//public void RenderRealmStream(byte[] bytes)
//{
// Parse(ServiceType.Realm, new ArraySegment<byte>(bytes));
//}
//public void RenderRealmStream(ArraySegment<byte> bytes)
//{
// Parse(ServiceType.Realm, bytes);
//}
//public void Parse(ServiceType type, byte[] bytes)
//{
// Parse(type, new ArraySegment<byte>(bytes, 0, bytes.Length));
//}
///// <summary>
///// Renders a part of an unencrypted WoW byte-stream
///// </summary>
///// <param name="bytes">Part of an unencrypted WoW byte-stream</param>
//public void Parse(ServiceType type, ArraySegment<byte> bytes)
//{
// if (m_remainder.Count > 0)
// {
// // parts coming together
// var newBytes = new byte[bytes.Count + m_remainder.Count];
// Array.Copy(m_remainder.Array, m_remainder.Offset, newBytes, 0, m_remainder.Count);
// Array.Copy(bytes.Array, bytes.Offset, newBytes, m_remainder.Count, bytes.Count);
// bytes = new ArraySegment<byte>(newBytes);
// m_remainder = EmptyBytes;
// }
// while (bytes.Count > 2)
// {
// int length = (bytes.Array[bytes.Offset] << 8) + bytes.Array[bytes.Offset + 1] + 2; // 2 bytes for length
// if (length >= bytes.Count)
// {
// var packet = PacketMgr.CreatePacket(type, bytes);
// packet.Initialize();
// Render(packet);
// }
// }
// // remaining bytes
// if (bytes.Count > 0)
// {
// m_remainder = bytes;
// }
//}
#endregion
#region IDisposable Members
public void Dispose()
{
((IDisposable)Packet).Dispose();
if (m_parsedPacket != null)
{
m_parsedPacket = null;
}
}
public void AddChild(PacketParser parser, ParsedSegment segment)
{
var name = segment.Structure.NotEmptyName;
parser.LastParsedSegmentsByName[name] = segment;
if (m_subSegments.ContainsKey(name))
{
throw new Exception(string.Format("Segment '{0}' exists twice in PacketDefinition: " + parser.Packet.PacketId, name));
}
m_subSegments.Add(name, segment);
}
public override void Parse(PacketParser parser, ParsedSegment parent)
{
if (Segments.Count > 1 && Name != null)
{
var parsedSegment = new ParsedSegment(this, null);
parent.AddChild(parser, parsedSegment);
parent = parsedSegment;
}
foreach (var segment in Segments)
{
segment.Parse(parser, parent);
}
}
public void Parse()
{
if (!PacketAnalyzer.IsInitialized)
{
throw new InvalidOperationException("The PacketAnalyzer has not been initialized. " +
"Make sure to load definitions before starting to use the PA.");
}
if (Definition != null)
{
m_parsedSegmentsByName = new Dictionary <string, ParsedSegment>();
Definition.Structure.Parse(this, m_parsedPacket = new ParsedSegment());
m_parsedSegmentsByName.Clear();
m_parsedSegmentsByName = null;
}
}
public override void Parse(PacketParser parser, ParsedSegment parent)
{
var list = new List <ParsedSegment>();
while (parser.Packet.Position < parser.Packet.Length)
{
var element = new ParsedSegment(this, null);
list.Add(element);
foreach (var segment in Segments)
{
segment.Parse(parser, element);
}
}
var parsedSegment = new ParsedSegment(this, list.Count);
parsedSegment.List.AddRange(list);
parent.AddChild(parser, parsedSegment);
}
public virtual void Parse(PacketParser parser, ParsedSegment parent)
{
var reader = SimpleTypes.GetReader(Type);
var value = reader(this, parser);
if (SegmentType != null)
{
try
{
value = Utility.ChangeType(value, SegmentType, true);
}
catch (OverflowException e)
{
throw new Exception(string.Format("Wrong underlying type {0} for Enum {1} in PacketDefinition {2} in Segment {3}",
Type, m_segmentType, parser.Packet, Name), e);
}
catch (Exception e)
{
Console.WriteLine("Could not parse value " + value + " in Segment \"" + this + "\": " + e);
}
}
parent.AddChild(parser, new ParsedSegment(this, value));
}
public void AddChild(PacketParser parser, ParsedSegment segment)
{
var name = segment.Structure.NotEmptyName;
parser.LastParsedSegmentsByName[name] = segment;
if (m_subSegments.ContainsKey(name))
{
throw new Exception(string.Format("Segment '{0}' exists twice in PacketDefinition: " + parser.Packet.PacketId, name));
}
m_subSegments.Add(name, segment);
}
void CheckRemainder(ParsedSegment parsedPacket)
{
var listEle = parsedPacket["StaticList1"][0];
Assert.IsNotNull(listEle);
Assert.AreEqual(10, listEle["Number1"].IntValue);
listEle = parsedPacket["StaticList2"][0];
Assert.IsNotNull(listEle);
Assert.AreEqual(20, listEle["Number2"].IntValue);
listEle = parsedPacket["StaticList2"][1];
Assert.IsNotNull(listEle);
Assert.AreEqual(30, listEle["Number2"].IntValue);
var listLength = parsedPacket["ListLength"];
var list = parsedPacket["SomeList3"];
Assert.AreEqual(2, ((ParsedSegment)list).List.Count);
Assert.AreEqual(5, list[0]["SomeListEle"].IntValue);
Assert.AreEqual(7, list[1]["SomeListEle"].IntValue);
}
protected override int GetLength(PacketParser parser, ParsedSegment parent)
{
throw new Exception(GetType().Name + " has no fixed length.");
}
protected override int GetLength(PacketParser parser, ParsedSegment parent)
{
return(Length);
}
public void Parse()
{
if (!PacketAnalyzer.IsInitialized)
{
throw new InvalidOperationException("The PacketAnalyzer has not been initialized. " +
"Make sure to load definitions before starting to use the PA.");
}
if (Definition != null)
{
m_parsedSegmentsByName = new Dictionary<string, ParsedSegment>();
Definition.Structure.Parse(this, m_parsedPacket = new ParsedSegment());
m_parsedSegmentsByName.Clear();
m_parsedSegmentsByName = null;
}
}
// ArraySegment<byte> m_remainder;
//public void RenderRealmStream(byte[] bytes)
//{
// Parse(ServiceType.Realm, new ArraySegment<byte>(bytes));
//}
//public void RenderRealmStream(ArraySegment<byte> bytes)
//{
// Parse(ServiceType.Realm, bytes);
//}
//public void Parse(ServiceType type, byte[] bytes)
//{
// Parse(type, new ArraySegment<byte>(bytes, 0, bytes.Length));
//}
///// <summary>
///// Renders a part of an unencrypted WoW byte-stream
///// </summary>
///// <param name="bytes">Part of an unencrypted WoW byte-stream</param>
//public void Parse(ServiceType type, ArraySegment<byte> bytes)
//{
// if (m_remainder.Count > 0)
// {
// // parts coming together
// var newBytes = new byte[bytes.Count + m_remainder.Count];
// Array.Copy(m_remainder.Array, m_remainder.Offset, newBytes, 0, m_remainder.Count);
// Array.Copy(bytes.Array, bytes.Offset, newBytes, m_remainder.Count, bytes.Count);
// bytes = new ArraySegment<byte>(newBytes);
// m_remainder = EmptyBytes;
// }
// while (bytes.Count > 2)
// {
// int length = (bytes.Array[bytes.Offset] << 8) + bytes.Array[bytes.Offset + 1] + 2; // 2 bytes for length
// if (length >= bytes.Count)
// {
// var packet = PacketMgr.CreatePacket(type, bytes);
// packet.Initialize();
// Render(packet);
// }
// }
// // remaining bytes
// if (bytes.Count > 0)
// {
// m_remainder = bytes;
// }
//}
#endregion
#region IDisposable Members
public void Dispose()
{
((IDisposable)Packet).Dispose();
if (m_parsedPacket != null)
{
m_parsedPacket = null;
}
}
private static void AssertSameFaction(ParsedSegment whoList, FactionGroup factionGroup)
{
RaceId raceId;
for (int i = 0; i < whoList.SubSegments["Characters"].List.Count; i++)
{
raceId = (RaceId)Enum.Parse(typeof(RaceId), whoList.SubSegments["Characters"].List[i]["Race"].Value.ToString(), true);
Assert.AreEqual(factionGroup, ArchetypeMgr.GetRace(raceId).Faction.Group);
}
}
