public void Deserialize(byte[] payload, Packet packet)
{
using (var reader = new TeraBinaryReader(payload))
DeserializeObject(reader, packet);
packet.OnDeserialize(this);
}
public DataCenter(string fileName)
{
DataCenterSegmentedRegion attributeRegion;
DataCenterSegmentedRegion elementRegion;
DataCenterSegmentedRegion nameRegion;
DataCenterSimpleRegion nameAddressRegion;
using (var reader = new TeraBinaryReader(File.OpenRead(fileName)))
{
Header = ReadHeader(reader);
ReadRegions(reader, out attributeRegion, out elementRegion,
out _stringRegion, out nameRegion, out nameAddressRegion);
Footer = ReadFooter(reader);
}
Attributes = attributeRegion;
Elements = elementRegion;
Names = ReadAddresses(nameAddressRegion)
.Select(x => ReadString(nameRegion, x))
.ToArray();
Root = new DataCenterElement(this, DataCenterAddress.Zero);
}
public PacketInfoForm(RawPacket packet)
{
InitializeComponent();
GUIHelpers.DragControl dc = new GUIHelpers.DragControl(this);
dc.Add(pnlHeader, lblCaption);
btnExit.Click += (s, e) => Close();
string opName = PacketController.Client.Processor.Serializer.Tables.Game.OpCodeToName[packet.OpCode];
lblOpCode.Text = packet.OpCode.ToString();
lblOpName.Text = opName;
lblLength.Text = packet.Length.ToString();
tbData.Text = packet.Data.AsString(10000);
PacketController.Client.Processor.Serializer.Info.TryGetValue(opName, out PacketReflectionInfo info);
if (info != null)
{
pnlFields.Controls.Clear();
using (TeraBinaryReader reader = new TeraBinaryReader(packet.GetPayloadData()))
{
foreach (FieldInfo field in info.Fields)
{
FieldInfoControl ctrl = new FieldInfoControl(field.Name, reader.ReadString(field.FieldType))
{
Dock = DockStyle.Top
};
pnlFields.Controls.Add(ctrl);
ctrl.BringToFront();
}
}
}
}
internal static DataCenterAddress ReadAddress(TeraBinaryReader reader)
{
var segment = reader.ReadUInt16();
var element = reader.ReadUInt16();
return(new DataCenterAddress(segment, element));
}
static DataCenterSegment ReadSegment(TeraBinaryReader reader, uint elementSize)
{
var full = reader.ReadUInt32();
var used = reader.ReadUInt32();
var data = reader.ReadBytes((int)(full * elementSize));
return(new DataCenterSegment(elementSize, full, used, data));
}
public TeraBinaryReader GetReader(uint elementIndex)
{
var reader = _reader ?? (_reader = new TeraBinaryReader(Data));
reader.Position = (int)(elementIndex * ElementSize);
return(reader);
}
internal static PacketHeader ReadHeader(byte[] buffer)
{
using var reader = new TeraBinaryReader(buffer);
var length = (ushort)(reader.ReadUInt16() - PacketHeader.HeaderSize);
var opCode = reader.ReadUInt16();
return(new PacketHeader(length, opCode));
}
static DataCenterSimpleSegmentedRegion ReadSimpleSegmentedRegion(
TeraBinaryReader reader, uint count, uint elementSize)
{
var segments = new List <DataCenterSimpleRegion>();
for (var i = 0; i < count; i++)
{
segments.Add(ReadSimpleRegion(reader, false, elementSize));
}
return(new DataCenterSimpleSegmentedRegion(elementSize, segments));
}
static DataCenterHeader ReadHeader(TeraBinaryReader reader)
{
var unk1 = reader.ReadUInt32();
var unk2 = reader.ReadUInt32();
var unk3 = reader.ReadUInt32();
var version = reader.ReadUInt32();
var unk4 = reader.ReadUInt32();
var unk5 = reader.ReadUInt32();
var unk6 = reader.ReadUInt32();
var unk7 = reader.ReadUInt32();
return(new DataCenterHeader(unk1, unk2, unk3, version, unk4, unk5, unk6, unk7));
}
static DataCenterSegmentedRegion ReadSegmentedRegion(
TeraBinaryReader reader, uint elementSize)
{
var segments = new List <DataCenterSegment>();
var count = reader.ReadUInt32();
for (var i = 0; i < count; i++)
{
segments.Add(ReadSegment(reader, elementSize));
}
return(new DataCenterSegmentedRegion(elementSize, segments));
}
static DataCenterSimpleRegion ReadSimpleRegion(TeraBinaryReader reader,
bool offByOne, uint elementSize)
{
var count = reader.ReadUInt32();
if (offByOne)
{
count--;
}
var data = reader.ReadBytes((int)(count * elementSize));
return(new DataCenterSimpleRegion(elementSize, count, data));
}
public void Deserialize(byte[] payload, Packet packet)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
using (var reader = new TeraBinaryReader(payload))
OnDeserialize(reader, packet);
packet.OnDeserialize(this);
}
public Packet Deserialize(RawPacket packet)
{
PacketReflectionInfo info;
if (!_info.TryGetValue(Tables.Game.OpCodeToName[packet.OpCode], out info))
{
return(null);
}
object obj = Activator.CreateInstance(info.Type);
using (TeraBinaryReader reader = new TeraBinaryReader(packet.GetPayloadData()))
{
foreach (FieldInfo field in info.Fields)
{
field.SetValue(obj, reader.Read(field.FieldType));
}
}
return((Packet)obj);
}
static unsafe void ReadRegions(TeraBinaryReader reader,
out DataCenterSegmentedRegion attributeRegion,
out DataCenterSegmentedRegion elementRegion,
out DataCenterSegmentedRegion stringRegion,
out DataCenterSegmentedRegion nameRegion,
out DataCenterSimpleRegion nameAddressRegion)
{
ReadSimpleRegion(reader, false, Unknown1Size);
attributeRegion = ReadSegmentedRegion(reader, AttributeSize);
elementRegion = ReadSegmentedRegion(reader, ElementSize);
stringRegion = ReadSegmentedRegion(reader, sizeof(char));
ReadSimpleSegmentedRegion(reader, 1024, Unknown2Size);
ReadSimpleRegion(reader, true, (uint)sizeof(DataCenterAddress));
nameRegion = ReadSegmentedRegion(reader, sizeof(char));
ReadSimpleSegmentedRegion(reader, 512, Unknown2Size);
nameAddressRegion = ReadSimpleRegion(reader, true, (uint)sizeof(DataCenterAddress));
}
void DeserializeObject(TeraBinaryReader reader, object target)
{
var fields = GetPacketFields(target.GetType());
foreach (var info in fields.Where(x => x.IsPrimitive))
{
var type = info.Property.PropertyType;
if (type.IsEnum)
{
type = type.GetEnumUnderlyingType();
}
info.Property.SetValue(target, DeserializePrimitive(reader, type));
}
foreach (var info in fields.Where(x => !x.IsPrimitive))
{
var type = info.Property.PropertyType;
var offset = (ushort)info.OffsetField.GetValue(target);
object value;
if (type.IsArray)
{
var count = (ushort)info.CountField.GetValue(target);
var array = (Array)Activator.CreateInstance(type, (int)count);
var elemType = type.GetElementType();
if (elemType.IsEnum)
{
elemType = elemType.GetEnumUnderlyingType();
}
if (offset != 0)
{
reader.Seek(offset - PacketHeader.HeaderSize, (r, op) =>
{
for (var i = 0; i < count; i++)
{
var next = 0;
if (!IsByte(elemType))
{
reader.ReadUInt16();
next = reader.ReadUInt16();
}
object elem;
if (!elemType.IsPrimitive)
{
elem = Activator.CreateInstance(elemType);
DeserializeObject(reader, elem);
}
else
{
elem = DeserializePrimitive(reader, elemType);
}
array.SetValue(elem, i);
if (!IsByte(elemType) && i != count - 1)
{
reader.Position = next -
PacketHeader.HeaderSize;
}
}
});
}
value = array;
}
else
{
value = reader.Seek(offset - PacketHeader.HeaderSize,
(r, op) => r.ReadString());
}
info.Property.SetValue(target, value);
}
}
public static IEnumerable <PotentialString> FindStrings(
byte[] payload, bool whiteSpace, bool control, int minLength)
{
using (var reader = new TeraBinaryReader(payload))
{
for (var i = 0; i < reader.Length; i++)
{
reader.Position = i;
if (!reader.CanRead(sizeof(ushort)))
{
break;
}
var offsetPos = reader.Position;
var offset = reader.ReadUInt16() - PacketHeader.HeaderSize;
if (offset < 0 || offset < offsetPos + sizeof(ushort) ||
offset > reader.Length - sizeof(char))
{
continue;
}
reader.Position = offset;
string str;
try
{
str = reader.ReadString();
if (offset < offsetPos &&
reader.Position > offsetPos)
{
continue;
}
TeraBinaryReader.Encoding.GetString(
TeraBinaryReader.Encoding.GetBytes(str));
}
catch (Exception e) when(IsStringException(e))
{
continue;
}
if (!whiteSpace && string.IsNullOrWhiteSpace(str))
{
continue;
}
if (minLength != 0 && str.Length < minLength)
{
continue;
}
var hasBadChars = str.Any(c =>
{
var cat = char.GetUnicodeCategory(c);
return(cat == UnicodeCategory.Control ||
cat == UnicodeCategory.Format ||
cat == UnicodeCategory.OtherNotAssigned ||
cat == UnicodeCategory.PrivateUse ||
cat == UnicodeCategory.Surrogate);
});
if (!control && hasBadChars)
{
continue;
}
yield return(new PotentialString(offsetPos,
(ushort)offset, str));
}
}
}
public static IEnumerable <PotentialArray> FindArrays(
byte[] payload)
{
using (var reader = new TeraBinaryReader(payload))
{
for (var i = 0; i < reader.Length; i++)
{
reader.Position = i;
if (!reader.CanRead(sizeof(ushort) * 2))
{
break;
}
var countPos = reader.Position;
var count = reader.ReadUInt16();
var offsetPos = reader.Position;
var offset = reader.ReadUInt16() -
PacketHeader.HeaderSize;
if (count == 0 ||
(count * (sizeof(ushort) * 2 + sizeof(byte)) +
sizeof(ushort) * 2) > reader.Length)
{
continue;
}
var positions = new HashSet <int>
{
countPos,
countPos + sizeof(byte),
offsetPos,
offsetPos + sizeof(byte)
};
var elems = new List <PotentialArrayElement>();
var good = true;
var last = offsetPos;
var next = offset;
while (next != -PacketHeader.HeaderSize)
{
if (!(good = next >= 0 && next > last &&
next <= reader.Length - sizeof(ushort) * 2 - sizeof(byte)))
{
break;
}
last = next + sizeof(ushort) * 2;
reader.Position = next;
var herePos = reader.Position;
var here = reader.ReadUInt16() -
PacketHeader.HeaderSize;
if (!(good = here == herePos && here == next &&
positions.Add(herePos) &&
positions.Add(herePos + sizeof(byte))))
{
break;
}
var nextPos = reader.Position;
next = reader.ReadUInt16() -
PacketHeader.HeaderSize;
if (!(good = positions.Add(nextPos) &&
positions.Add(nextPos + sizeof(byte))))
{
break;
}
elems.Add(new PotentialArrayElement((ushort)here,
nextPos, (ushort)(next == -PacketHeader.HeaderSize ?
0 : next)));
}
if (good && elems.Count == count)
{
yield return(new PotentialArray(countPos, count,
offsetPos, (ushort)offset, elems));
}
}
}
}
protected abstract void OnDeserialize(TeraBinaryReader reader,
Packet packet);
static DataCenterFooter ReadFooter(TeraBinaryReader reader)
{
var unk1 = reader.ReadUInt32();
return(new DataCenterFooter(unk1));
}
public PacketLogReader(string fileName)
{
Stream stream = File.OpenRead(fileName);
var magic = new byte[PacketLogEntry.Magic.Count];
if (stream.Read(magic, 0, magic.Length) != magic.Length)
{
throw new EndOfStreamException();
}
if (!magic.SequenceEqual(PacketLogEntry.Magic))
{
throw new InvalidDataException();
}
Compressed = stream.ReadByte() != 0;
if (Compressed)
{
stream = new DeflateStream(stream, CompressionMode.Decompress);
}
_reader = new TeraBinaryReader(stream);
Version = _reader.ReadUInt32();
if (Version != PacketLogEntry.Version)
{
throw new InvalidDataException();
}
var region = (Region)_reader.ReadByte();
if (!Enum.IsDefined(typeof(Region), region))
{
throw new InvalidDataException();
}
var clientVersion = _reader.ReadUInt32();
if (!OpCodeTable.Versions.Values.Contains(clientVersion))
{
throw new InvalidDataException();
}
Messages = new MessageTables(region, clientVersion);
var serverCount = (int)_reader.ReadUInt32();
if (serverCount < 0)
{
throw new InvalidDataException();
}
var servers = new Dictionary <int, ServerInfo>(serverCount);
for (var i = 0; i < serverCount; i++)
{
var id = _reader.ReadInt32();
if (servers.ContainsKey(id))
{
throw new InvalidDataException();
}
var name = _reader.ReadString();
var size = _reader.ReadBoolean() ? 16 : 4;
var realIPBytes = _reader.ReadBytes(size);
var realPort = _reader.ReadUInt16();
var proxyIPBytes = _reader.ReadBytes(size);
var proxyPort = _reader.ReadUInt16();
IPEndPoint realEP;
IPEndPoint proxyEP;
try
{
realEP = new IPEndPoint(new IPAddress(realIPBytes), realPort);
proxyEP = new IPEndPoint(new IPAddress(proxyIPBytes), proxyPort);
}
catch (ArgumentException)
{
throw new InvalidDataException();
}
servers.Add(id, new ServerInfo(id, name, realEP, proxyEP));
}
Servers = servers;
}
void DeserializeObject(TeraBinaryReader reader, object target)
{
foreach (var info in
GetPacketFields <ReflectionPacketFieldInfo>(target.GetType()))
{
if (info.IsByteArray)
{
var offset = reader.ReadOffset();
var count = reader.ReadUInt16();
var list = (List <byte>)info.Property.GetValue(target);
list.Clear();
if (count == 0)
{
continue;
}
reader.Seek(offset, (r, op) => list.AddRange(r.ReadBytes(count)));
}
else if (info.IsArray)
{
var count = reader.ReadUInt16();
var offset = reader.ReadOffset();
var list = (IList)info.Property.GetValue(target);
list.Clear();
if (count == 0)
{
continue;
}
var next = offset;
for (var i = 0; i < count; i++)
{
reader.Seek(next, (r, op) =>
{
r.ReadOffset();
next = r.ReadOffset();
var elem = info.ElementConstructor();
DeserializeObject(r, elem);
list.Add(elem);
});
}
}
else if (info.IsString)
{
var offset = reader.ReadOffset();
info.Property.SetValue(target, reader.Seek(offset, (r, op) => r.ReadString()));
}
else
{
var val = info.PrimitiveDeserializer(reader);
info.EnumValidator?.Invoke(val);
info.Property.SetValue(target, val);
}
}
}
static object DeserializePrimitive(TeraBinaryReader reader, Type type)
{
object value;
if (type == typeof(bool))
{
value = reader.ReadBoolean();
}
else if (type == typeof(byte))
{
value = reader.ReadByte();
}
else if (type == typeof(sbyte))
{
value = reader.ReadSByte();
}
else if (type == typeof(ushort))
{
value = reader.ReadUInt16();
}
else if (type == typeof(short))
{
value = reader.ReadInt16();
}
else if (type == typeof(uint))
{
value = reader.ReadUInt32();
}
else if (type == typeof(int))
{
value = reader.ReadInt32();
}
else if (type == typeof(ulong))
{
value = reader.ReadUInt64();
}
else if (type == typeof(long))
{
value = reader.ReadInt64();
}
else if (type == typeof(float))
{
value = reader.ReadSingle();
}
else if (type == typeof(Vector3))
{
value = reader.ReadVector3();
}
else if (type == typeof(EntityId))
{
value = reader.ReadEntityId();
}
else if (type == typeof(SkillId))
{
value = reader.ReadSkillId();
}
else if (type == typeof(Angle))
{
value = reader.ReadAngle();
}
else
{
throw Assert.Unreachable();
}
return(value);
}
protected override void OnDeserialize(TeraBinaryReader reader,
Packet packet)
{
_deserializers[packet.GetType()](reader, packet);
}
protected override void OnDeserialize(TeraBinaryReader reader, Packet packet)
{
DeserializeObject(reader, packet);
}