public void read(byte[] bytes, ByteReader byteReader = null)
{
ByteReader reader = byteReader == null ? new ByteReader(bytes) : byteReader;
reader.Read(out messageType);
reader.Read(out error);
}
public static IDictionary <TK, TV> DeserializeDictionary <TK, TV>(this byte[] bytes)
where TK : struct where TV : struct
{
var reader = new ByteReader(bytes);
Dictionary <TK, TV> dictionary = new Dictionary <TK, TV>();
int count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
var key = reader.Read <TK>();
var value = reader.Read <TV>();
dictionary[key] = value;
}
return(dictionary);
}
public void ValueTest(int iVal, float fVal, double dVal)
{
var bw = new ByteWriter(m_buffer);
bw.Write(iVal); bw.Write(fVal); bw.Write(dVal);
var br = new ByteReader(m_buffer);
Assert.AreEqual(iVal, br.Read <int>());
Assert.AreEqual(fVal, br.Read <float>());
Assert.AreEqual(dVal, br.Read <double>());
Assert.AreEqual(16, bw.Offset);
Assert.AreEqual(br.Offset, bw.Offset);
}
void RoundTripSingleByte(int numValues)
{
var pocos = new List <SingleBytePoco>();
var random = new Random(123);
for (int i = 0; i < numValues; i++)
{
pocos.Add(new SingleBytePoco {
Byte = (byte)random.Next()
});
}
var stream = new MemoryStream();
Footer footer;
StripeStreamHelper.Write(stream, pocos, out footer);
var stripeStreams = StripeStreamHelper.GetStripeStreams(stream, footer);
var boolReader = new ByteReader(stripeStreams, 1);
var results = boolReader.Read().ToArray();
for (int i = 0; i < numValues; i++)
{
Assert.Equal(pocos[i].Byte, results[i]);
}
}
public void ReadBytes(byte[] buffer, int index, int count)
{
if (reader.Read(buffer, index, count) != count)
{
throw new ArgumentOutOfRangeException("tried to read past end of data stream");
}
}
public bool DeSerialize(Type _Type, byte[] _Bytes, out object _Object)
{
if (!_Type.IsNullable())
{
_Object = null;
return(false);
}
Type var_UnderlyingType = _Type.GetNullableUnderlyingType();
ByteReader var_Reader = new ByteReader(_Bytes);
bool var_IsNull = var_Reader.ReadBoolean();
if (var_IsNull)
{
_Object = null;
return(true);
}
//
if (PrimitiveTypeMatcher.TypeDictionary.ContainsKey(var_UnderlyingType))
{
_Object = var_Reader.Read(var_UnderlyingType);
}
else
{
byte[] var_Bytes = var_Reader.ReadBytesAndSize();
_Object = Serializer.DeSerialize(var_UnderlyingType, var_Bytes);
}
return(true);
}
/// <summary>
/// 加载纹理数据
/// </summary>
/// <param name="filepath">Filepath.</param>
public void LoadTextureDataFromFile(string filepath)
{
if (string.IsNullOrEmpty(filepath))
{
return;
}
_TextureDatas.Clear();
byte[] datas = ResourceManger.Instance.GetBytes(filepath);
if (datas == null || datas.Length == 0)
{
return;
}
ByteReader reader = new ByteReader(datas);
int count = reader.Read <int> ();
for (int i = 0; i < count; i++)
{
TextureData data = new TextureData();
data.Filepath = reader.ReadString();
_TextureDatas.Add(data);
}
}
public void read(byte[] bytes, ByteReader byteReader = null)
{
ByteReader reader = byteReader == null ? new ByteReader(bytes) : byteReader;
reader.Read(out messageType);
key = reader.ReadString();
value = reader.ReadString();
}
/// <summary>
/// 加载方块数据
/// </summary>
/// <param name="filepath">Filepath.</param>
public void LoadCubeDataFromFile(string filepath)
{
if (string.IsNullOrEmpty(filepath))
{
return;
}
_CubeDatas.Clear();
byte[] datas = ResourceManger.Instance.GetBytes(filepath);
if (datas == null || datas.Length == 0)
{
return;
}
ByteReader reader = new ByteReader(datas);
int count = reader.Read <int> ();
for (int i = 0; i < count; i++)
{
CubeData data = new CubeData();
data.Position = reader.ReadVector3();
data.FrontTexture = reader.Read <int> ();
data.BackTexture = reader.Read <int> ();
data.TopTexture = reader.Read <int> ();
data.BottomTexture = reader.Read <int> ();
data.LeftTexture = reader.Read <int> ();
data.RightTexture = reader.Read <int> ();
_CubeDatas.Add(data);
}
}
public void ByteRead()
{
ByteReader reader = new ByteReader(m_byteBuf);
for (int i = 0; i < AMOUNT; i++)
{
int result = reader.Read <int>();
}
}
public void ByteWrite()
{
ByteWriter writer = new ByteWriter(m_byteBuf);
for (int i = 0; i < AMOUNT / 2; i++)
{
writer.Write(i % 2 == 0);
writer.Write(i);
}
ByteReader reader = new ByteReader(m_byteBuf);
for (int i = 0; i < AMOUNT / 2; i++)
{
bool b = reader.Read <bool>();
int num = reader.Read <int>();
}
}
public void ByteReader_ReadToEnd()
{
var reader = new ByteReader(85);
Assert.IsTrue(reader.Read());
Assert.IsFalse(reader.Read());
Assert.IsTrue(reader.Read());
Assert.IsFalse(reader.Read());
Assert.IsTrue(reader.Read());
Assert.IsFalse(reader.Read());
Assert.IsTrue(reader.Read());
Assert.IsFalse(reader.Read());
}
public bool DeSerialize(Type _Type, byte[] _Bytes, out object _Object)
{
if (_Type.IsGenericType && _Type.GetGenericTypeDefinition() == typeof(Queue <>))
{
Type var_QueueType = typeof(Queue <>);
Type var_GenericItemType = _Type.GetGenericArguments()[0];
Type var_GenericQueueType = var_QueueType.MakeGenericType(var_GenericItemType);
ByteReader var_Reader = new ByteReader(_Bytes);
bool var_IsNull = var_Reader.ReadBoolean();
if (var_IsNull)
{
_Object = null;
return(true);
}
//
int var_ItemCount = var_Reader.ReadUInt16();
byte[] var_ItemBytes = var_Reader.ReadBytesAndSize();
ByteReader var_ItemReader = new ByteReader(var_ItemBytes);
Type var_ListType = typeof(List <>);
Type var_GenericListType = var_ListType.MakeGenericType(var_GenericItemType);
IList var_Items = Activator.CreateInstance(var_GenericListType) as IList;
if (PrimitiveTypeMatcher.TypeDictionary.ContainsKey(var_GenericItemType))
{
for (int i = 0; i < var_ItemCount; i++)
{
var_Items.Add(var_ItemReader.Read(var_GenericItemType));
}
}
else
{
for (int i = 0; i < var_ItemCount; i++)
{
byte[] var_Bytes = var_ItemReader.ReadBytesAndSize();
Object var_Item = Serializer.DeSerialize(var_GenericItemType, var_Bytes);
var_Items.Add(var_Item);
}
}
_Object = Activator.CreateInstance(var_GenericQueueType, var_Items);
return(true);
}
_Object = null;
return(false);
}
public bool DeSerialize(Type _Type, byte[] _Bytes, out object _Object)
{
if (!PrimitiveTypeMatcher.TypeHashSet.Contains(_Type))
{
_Object = null;
return(false);
}
ByteReader var_Reader = new ByteReader(_Bytes);
_Object = var_Reader.Read(_Type);
return(true);
}
public void read(byte[] bytes, ByteReader byteReader = null)
{
ByteReader reader = byteReader == null ? new ByteReader(bytes) : byteReader;
reader.Read(out messageType);
// read array settings
int s_settings;
reader.Read(out s_settings);
settings = new List <xmq.settings.Property>(s_settings);
for (int i_1 = 0; i_1 < s_settings; i_1++)
{
xmq.settings.Property e_name_2;
e_name_2 = new xmq.settings.Property();
e_name_2.read(null, reader);
settings.Add(e_name_2);
}
}
public bool DeSerialize(Type _Type, byte[] _Bytes, out object _Object)
{
if (_Type.IsGenericType && _Type.GetGenericTypeDefinition() == typeof(List <>))
{
if (_Type.GetGenericArguments().Length == 1)
{
//TODO: Kann man nicht _Type direkt nehemn :D
Type var_ListType = typeof(List <>);
Type var_GenericItemType = _Type.GetGenericArguments()[0];
Type var_GenericListType = var_ListType.MakeGenericType(var_GenericItemType);
IList var_List = Activator.CreateInstance(var_GenericListType) as IList;
ByteReader var_Reader = new ByteReader(_Bytes);
bool var_IsNull = var_Reader.ReadBoolean();
if (var_IsNull)
{
_Object = null;
return(true);
}
//
int var_Count = var_Reader.ReadUInt16();
if (PrimitiveTypeMatcher.TypeHashSet.Contains(_Type))
{
for (int i = 0; i < var_Count; i++)
{
var_List.Add(var_Reader.Read(var_GenericItemType));
}
}
else
{
for (int i = 0; i < var_Count; i++)
{
byte[] var_Bytes = var_Reader.ReadBytesAndSize();
Object var_Item = Serializer.DeSerialize(var_GenericItemType, var_Bytes);
var_List.Add(var_Item);
}
}
_Object = var_List;
return(true);
}
}
_Object = null;
return(false);
}
public void SizePrefixTest()
{
ByteWriter bw = new ByteWriter(16, false);
bw.ReserveSizePrefix();
bw.Write(1);
bw.Write(2);
bw.Write(3);
Assert.AreEqual(16, bw.Offset);
Assert.AreEqual(16, bw.Length);
Assert.AreEqual(16, bw.PrefixSize());
ByteReader br = new ByteReader(bw.Buffer);
Assert.AreEqual(16, br.Read <int>());
}
public bool DeSerialize(Type _Type, byte[] _Bytes, out object _Object)
{
if (!_Type.IsEnum)
{
_Object = null;
return(false);
}
System.Type var_EnumUnderlyingType = System.Enum.GetUnderlyingType(_Type);
ByteReader var_Reader = new ByteReader(_Bytes);
_Object = var_Reader.Read(var_EnumUnderlyingType);
_Object = Enum.ToObject(_Type, _Object);
return(true);
}
/// <summary>
/// 创建一个新阵型
/// </summary>
/// <returns>The foramtion.</returns>
/// <param name="url">URL.</param>
public static Formation CreateForamtion(string url)
{
byte[] bytes = ResourceManger.Instance.GetBytes(url);
if (bytes == null || bytes.Length == 0)
{
return(null);
}
ByteReader reader = new ByteReader(bytes);
int childCount = reader.Read <int> ();
Formation f = new Formation();
for (int i = 0; i < childCount; i++)
{
Vector3 pos = reader.ReadVector3();
f.AddPoint(pos);
}
return(f);
}
/// <summary>
/// 加载
/// </summary>
public override void Load()
{
ByteReader reader = LoadData();
if (reader == null)
{
return;
}
this.RemoveAllChildren();
int childCount = reader.Read <int> ();
for (int i = 0; i < childCount; i++)
{
GameObject go = CreateGameObject();
Vector3 pos = reader.ReadVector3();
go.transform.position = pos;
}
Debug.Log("Successful load!");
}
// Add some non-zero constants to the mix.
public void AddConstantsToTDB(RandoopConfiguration config)
{
foreach (SimpleTypeValues vs in config.simpleTypeValues)
{
Type type = Type.GetType(vs.simpleType);
if (type == null)
{
throw new Common.RandoopBareExceptions.InternalError("invalid simple type in XML config file.");
}
foreach (FileName fn in vs.fileNames)
{
string fileName = fn.fileName;
if (!File.Exists(fileName))
{
throw new Common.RandoopBareExceptions.InvalidUserParamsException("Configuration file does not exist: " + fileName);
}
if (type.Equals(typeof(sbyte)))
{
SByteReader r = new SByteReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(sbyte), o));
}
else if (type.Equals(typeof(byte)))
{
ByteReader r = new ByteReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(byte), o));
}
else if (type.Equals(typeof(short)))
{
ShortReader r = new ShortReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(short), o));
}
else if (type.Equals(typeof(ushort)))
{
UshortReader r = new UshortReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(ushort), o));
}
else if (type.Equals(typeof(int)))
{
IntReader r = new IntReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(int), o));
}
else if (type.Equals(typeof(uint)))
{
UintReader r = new UintReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(uint), o));
}
else if (type.Equals(typeof(long)))
{
LongReader r = new LongReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(long), o));
}
else if (type.Equals(typeof(ulong)))
{
UlongReader r = new UlongReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(ulong), o));
}
else if (type.Equals(typeof(char)))
{
CharReader r = new CharReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(char), o));
}
else if (type.Equals(typeof(float)))
{
FloatReader r = new FloatReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(float), o));
}
else if (type.Equals(typeof(double)))
{
DoubleReader r = new DoubleReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(double), o));
}
else if (type.Equals(typeof(bool)))
{
BoolReader r = new BoolReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(bool), o));
}
else if (type.Equals(typeof(decimal)))
{
DecimalReader r = new DecimalReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(decimal), o));
}
else
{
if (!type.Equals(typeof(string)))
{
throw new Common.RandoopBareExceptions.InternalError("invalid simple type in XML config file.");
}
Common.StringReader r = new Common.StringReader();
foreach (object o in r.Read(fileName))
this.AddPlan(Plan.Constant(typeof(string), o));
}
}
}
}
public void ByteReader_ReadPartial()
{
var reader = new ByteReader(15);
Assert.AreEqual(3, reader.Read(2));
}
// Add some non-zero constants to the mix.
public void AddConstantsToTDB(RandoopConfiguration config)
{
foreach (SimpleTypeValues vs in config.simpleTypeValues)
{
Type type = Type.GetType(vs.simpleType);
if (type == null)
{
throw new Common.RandoopBareExceptions.InternalError("invalid simple type in XML config file.");
}
foreach (FileName fn in vs.fileNames)
{
string fileName = fn.fileName;
if (!File.Exists(fileName))
{
throw new Common.RandoopBareExceptions.InvalidUserParamsException("Configuration file does not exist: " + fileName);
}
if (type.Equals(typeof(sbyte)))
{
SByteReader r = new SByteReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(sbyte), o));
}
}
else if (type.Equals(typeof(byte)))
{
ByteReader r = new ByteReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(byte), o));
}
}
else if (type.Equals(typeof(short)))
{
ShortReader r = new ShortReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(short), o));
}
}
else if (type.Equals(typeof(ushort)))
{
UshortReader r = new UshortReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(ushort), o));
}
}
else if (type.Equals(typeof(int)))
{
IntReader r = new IntReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(int), o));
}
}
else if (type.Equals(typeof(uint)))
{
UintReader r = new UintReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(uint), o));
}
}
else if (type.Equals(typeof(long)))
{
LongReader r = new LongReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(long), o));
}
}
else if (type.Equals(typeof(ulong)))
{
UlongReader r = new UlongReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(ulong), o));
}
}
else if (type.Equals(typeof(char)))
{
CharReader r = new CharReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(char), o));
}
}
else if (type.Equals(typeof(float)))
{
FloatReader r = new FloatReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(float), o));
}
}
else if (type.Equals(typeof(double)))
{
DoubleReader r = new DoubleReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(double), o));
}
}
else if (type.Equals(typeof(bool)))
{
BoolReader r = new BoolReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(bool), o));
}
}
else if (type.Equals(typeof(decimal)))
{
DecimalReader r = new DecimalReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(decimal), o));
}
}
else
{
if (!type.Equals(typeof(string)))
{
throw new Common.RandoopBareExceptions.InternalError("invalid simple type in XML config file.");
}
Common.StringReader r = new Common.StringReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(string), o));
}
}
}
}
}
public bool DeSerialize(Type _Type, byte[] _Bytes, out object _Object)
{
if (!_Type.IsArray)
{
_Object = null;
return(false);
}
ByteReader var_Reader = new ByteReader(_Bytes);
bool var_IsNull = var_Reader.ReadBoolean();
if (var_IsNull)
{
_Object = null;
return(true);
}
//
Type var_ElementType = _Type.GetElementType();
//Read rank
int var_Rank = var_Reader.ReadInt32();
//Go through each dimension and read the length!
int[] var_ArrayLength = new int[var_Rank];
for (int d = 0; d < var_Rank; d++)
{
var_ArrayLength[d] = var_Reader.ReadInt32();
}
//Go through each dimension and read the lowerbound!
int[] var_ArrayLowerBound = new int[var_Rank];
for (int d = 0; d < var_Rank; d++)
{
var_ArrayLowerBound[d] = var_Reader.ReadInt32();
}
var var_Array = Array.CreateInstance(var_ElementType, var_ArrayLength);
if (var_Rank == 1)
{
ArrayIndexer_D_1 arrayIndexer = new ArrayIndexer_D_1(var_ArrayLength[0], var_ArrayLowerBound[0]);
if (PrimitiveTypeMatcher.TypeHashSet.Contains(var_ElementType))
{
int[] var_IndexArray = new int[1];
while (arrayIndexer.MoveNext())
{
var_IndexArray[0] = arrayIndexer.Current_0;
var_Array.SetValue(var_Reader.Read(var_ElementType), var_IndexArray);
}
}
else
{
int[] var_IndexArray = new int[1];
while (arrayIndexer.MoveNext())
{
var_IndexArray[0] = arrayIndexer.Current_0;
byte[] var_Bytes = var_Reader.ReadBytesAndSize();
Object var_Item = Serializer.DeSerialize(_Type.GetElementType(), var_Bytes);
var_Array.SetValue(var_Item, var_IndexArray);
}
}
}
else if (var_Rank == 2)
{
ArrayIndexer_D_2 arrayIndexer = new ArrayIndexer_D_2(var_ArrayLength[0], var_ArrayLength[1], var_ArrayLowerBound[0], var_ArrayLowerBound[1]);
if (PrimitiveTypeMatcher.TypeHashSet.Contains(var_ElementType))
{
int[] var_IndexArray = new int[2];
while (arrayIndexer.MoveNext())
{
var_IndexArray[0] = arrayIndexer.Current_0;
var_IndexArray[1] = arrayIndexer.Current_1;
var_Array.SetValue(var_Reader.Read(var_ElementType), var_IndexArray);
}
}
else
{
int[] var_IndexArray = new int[2];
while (arrayIndexer.MoveNext())
{
var_IndexArray[0] = arrayIndexer.Current_0;
var_IndexArray[1] = arrayIndexer.Current_1;
byte[] var_Bytes = var_Reader.ReadBytesAndSize();
Object var_Item = Serializer.DeSerialize(_Type.GetElementType(), var_Bytes);
var_Array.SetValue(var_Item, var_IndexArray);
}
}
}
else
{
ArrayIndexer_D_N arrayIndexer = new ArrayIndexer_D_N(var_ArrayLength, var_ArrayLowerBound);
if (PrimitiveTypeMatcher.TypeHashSet.Contains(var_ElementType))
{
while (arrayIndexer.MoveNext())
{
var_Array.SetValue(var_Reader.Read(var_ElementType), arrayIndexer.Current);
}
}
else
{
while (arrayIndexer.MoveNext())
{
byte[] var_Bytes = var_Reader.ReadBytesAndSize();
Object var_Item = Serializer.DeSerialize(_Type.GetElementType(), var_Bytes);
var_Array.SetValue(var_Item, arrayIndexer.Current);
}
}
}
_Object = var_Array;
return(true);
}
private void InternDeSerialize(Object _Object, ByteReader _Reader, List <Type> _SerializeAbleBaseList, int _CurrentIndex)
{
Type var_CurrentType = _SerializeAbleBaseList[_CurrentIndex];
Dictionary <int, FieldInfo> var_FoundFieldDictionary = new Dictionary <int, FieldInfo>();
FieldInfo[] var_FoundFields;
int[] var_FoundFieldsId;
bool[] var_FoundFieldsOptional;
FieldContext.LoadFields(var_CurrentType, out var_FoundFields, out var_FoundFieldsId, out var_FoundFieldsOptional);
for (int i = 0; i < var_FoundFields.Length; i++)
{
var_FoundFieldDictionary.Add(var_FoundFieldsId[i], var_FoundFields[i]);
}
int var_FieldLength = _Reader.ReadByte();
for (int i = 0; i < var_FieldLength; i++)
{
int var_FieldId = _Reader.ReadByte();
FieldInfo var_FieldInfo;
if (var_FoundFieldDictionary.TryGetValue(var_FieldId, out var_FieldInfo))
{
var var_FieldType = var_FieldInfo.FieldType;
//
if (PrimitiveTypeMatcher.TypeHashSet.Contains(var_FieldType))
{
var_FieldInfo.SetValue(_Object, _Reader.Read(var_FieldType));
}
else
{
byte[] var_Bytes = _Reader.ReadBytesAndSize();
Object var_Value = Serializer.DeSerialize(var_FieldType, var_Bytes);
var_FieldInfo.SetValue(_Object, var_Value);
}
//
var_FoundFieldDictionary.Remove(var_FieldId);
}
else
{
Console.WriteLine(var_FieldId + " not found!");
}
}
foreach (var var_Pair in var_FoundFieldDictionary)
{
if (var_FoundFieldsOptional[var_Pair.Key])
{
Console.WriteLine(var_Pair.Key + " is optional!");
}
else
{
Console.WriteLine(var_Pair.Key + " is not optional and not set!");
}
}
//Inheritance
if (_Reader.Position != _Reader.Length)
{
this.InternDeSerialize(_Object, _Reader, _SerializeAbleBaseList, _CurrentIndex + 1);
}
}
public PngChunk(ByteReader stream)
{
// Read chunk length.
var lengthBuffer = new byte[4];
int numBytes = stream.Read(lengthBuffer, 0, 4);
if (numBytes >= 1 && numBytes <= 3)
{
Engine.Log.Warning($"Chunk length {numBytes} is not valid!", MessageSource.ImagePng);
return;
}
Array.Reverse(lengthBuffer);
var length = BitConverter.ToInt32(lengthBuffer, 0);
// Invalid chunk or after end chunk.
if (numBytes == 0)
{
return;
}
// Read the chunk type.
var typeBuffer = new byte[4];
int typeBufferNumBytes = stream.Read(typeBuffer, 0, 4);
if (typeBufferNumBytes >= 1 && typeBufferNumBytes <= 3)
{
throw new Exception("ImagePng: Chunk type header is not valid!");
}
var chars = new char[4];
chars[0] = (char)typeBuffer[0];
chars[1] = (char)typeBuffer[1];
chars[2] = (char)typeBuffer[2];
chars[3] = (char)typeBuffer[3];
Type = new string(chars);
ChunkReader = stream.Branch(0, false, length);
stream.Seek(length, SeekOrigin.Current);
// Read compressed chunk.
var crcBuffer = new byte[4];
int numBytesCompression = stream.Read(crcBuffer, 0, 4);
if (numBytesCompression >= 1 && numBytesCompression <= 3)
{
throw new Exception("ImagePng: Compressed data header is not valid!");
}
Array.Reverse(crcBuffer);
Crc = BitConverter.ToUInt32(crcBuffer, 0);
#if DEBUG
var crc = new Crc32();
crc.Update(typeBuffer);
crc.Update(ChunkReader.Data.Span);
// PNGs saved with Gimp spam the log with warnings.
// https://gitlab.gnome.org/GNOME/gimp/-/issues/2111
//if (crc.Value != Crc)
// Engine.Log.Warning($"CRC Error. PNG Image chunk {Type} is corrupt!", "ImagePng");
#endif
Valid = true;
}
private Results ProcessPacket(byte[] bytes, bool isOutbound, DateTime timestamp)
{
if (mTerminated)
{
return(Results.Terminated);
}
if (Build == 0)
{
var packet = new ByteReader(bytes);
packet.Read <ushort>(); // rawSeq
int length = packet.ReadInt();
if (bytes.Length - 6 < length)
{
logger.Debug($"Connection on port {mLocalEndpoint} did not have a MapleStory2 Handshake");
return(Results.CloseMe);
}
ushort opcode = packet.Read <ushort>();
if (opcode != 0x01)
{
// RequestVersion
logger.Debug($"Connection on port {mLocalEndpoint} did not have a valid MapleStory2 Connection Header");
return(Results.CloseMe);
}
uint version = packet.Read <uint>();
uint siv = packet.Read <uint>();
uint riv = packet.Read <uint>();
uint blockIV = packet.Read <uint>();
byte type = packet.ReadByte();
Build = version;
Locale = MapleLocale.UNKNOWN;
outDecryptor = new MapleCipher.Decryptor(Build, siv, blockIV);
inDecryptor = new MapleCipher.Decryptor(Build, riv, blockIV);
inDecryptor.Decrypt(bytes); // Advance the IV
// Generate HandShake packet
Definition definition = Config.Instance.GetDefinition(Build, Locale, false, opcode);
if (definition == null)
{
definition = new Definition {
Outbound = false,
Opcode = opcode,
Name = "RequestVersion",
};
SaveDefinition(Locale, Build, definition);
}
ArraySegment <byte> segment = new ArraySegment <byte>(packet.Buffer);
var maplePacket = new MaplePacket(timestamp, isOutbound, Build, opcode, segment);
// Add to list of not exist (TODO: SortedSet?)
if (!Opcodes.Exists(op => op.Outbound == maplePacket.Outbound && op.Header == maplePacket.Opcode))
{
// Should be false, but w/e
Opcodes.Add(new Opcode(maplePacket.Outbound, maplePacket.Opcode));
}
AddPacket(maplePacket, false, true);
logger.Info($"[CONNECTION] {mRemoteEndpoint} <-> {mLocalEndpoint}: MapleStory2 V{Build}");
return(Results.Show);
}
try {
MapleCipher.Decryptor decryptor = isOutbound ? outDecryptor : inDecryptor;
ByteReader packet = decryptor.Decrypt(bytes);
// It's possible to get an empty packet, just ignore it.
// Decryption is still necessary to advance sequence number.
if (packet.Available == 0)
{
return(Results.Continue);
}
ushort opcode = packet.Peek <ushort>();
ArraySegment <byte> segment = new ArraySegment <byte>(packet.Buffer, 2, packet.Length - 2);
var maplePacket = new MaplePacket(timestamp, isOutbound, Build, opcode, segment);
AddPacket(maplePacket);
return(Results.Continue);
} catch (ArgumentException ex) {
logger.Fatal(ex, "Exception while processing packets");
return(Results.CloseMe);
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage: <FILENAME>");
return;
}
var filename = args[0];
var stream = new FileStream(filename, FileMode.Open, FileAccess.Read);
var fileTail = new FileTail(stream);
foreach (var stripe in fileTail.Stripes)
{
Console.WriteLine($"Reading stripe with {stripe.NumRows} rows");
var stripeStreamCollection = stripe.GetStripeStreamCollection();
if (fileTail.Footer.Types[0].Kind != ColumnTypeKind.Struct)
{
throw new InvalidDataException($"The base type must be {nameof(ColumnTypeKind.Struct)}");
}
var names = fileTail.Footer.Types[0].FieldNames;
for (int columnId = 1; columnId < fileTail.Footer.Types.Count; columnId++)
{
var columnType = fileTail.Footer.Types[columnId];
var columnName = names[columnId - 1];
switch (columnType.Kind)
{
case ColumnTypeKind.Long:
case ColumnTypeKind.Int:
case ColumnTypeKind.Short:
{
Console.WriteLine($"Reading longs from column {columnId} ({columnName})");
var reader = new LongReader(stripeStreamCollection, (uint)columnId);
var count = reader.Read().Count();
Console.WriteLine($"Done reading {count} longs");
break;
}
case ColumnTypeKind.Byte:
{
Console.WriteLine($"Reading bytes from column {columnId} ({columnName})");
var reader = new ByteReader(stripeStreamCollection, (uint)columnId);
var count = reader.Read().Count();
Console.WriteLine($"Done reading {count} bytes");
break;
}
case ColumnTypeKind.Boolean:
{
Console.WriteLine($"Reading bools from column {columnId} ({columnName})");
var reader = new BooleanReader(stripeStreamCollection, (uint)columnId);
var count = reader.Read().Count();
Console.WriteLine($"Done reading {count} bools");
break;
}
case ColumnTypeKind.Float:
{
Console.WriteLine($"Reading floats from column {columnId} ({columnName})");
var reader = new FloatReader(stripeStreamCollection, (uint)columnId);
var count = reader.Read().Count();
Console.WriteLine($"Done reading {count} floats");
break;
}
case ColumnTypeKind.Double:
{
Console.WriteLine($"Reading doubles from column {columnId} ({columnName})");
var reader = new DoubleReader(stripeStreamCollection, (uint)columnId);
var count = reader.Read().Count();
Console.WriteLine($"Done reading {count} doubles");
break;
}
case ColumnTypeKind.Binary:
{
Console.WriteLine($"Reading binary from column {columnId} ({columnName})");
var reader = new ColumnTypes.BinaryReader(stripeStreamCollection, (uint)columnId);
var count = reader.Read().Count();
Console.WriteLine($"Done reading {count} binaries");
break;
}
case ColumnTypeKind.Decimal:
{
Console.WriteLine($"Reading decimals from column {columnId} ({columnName})");
var reader = new DecimalReader(stripeStreamCollection, (uint)columnId);
var count = reader.Read().Count();
Console.WriteLine($"Done reading {count} decimals");
break;
}
case ColumnTypeKind.Timestamp:
{
Console.WriteLine($"Reading timestamps from column {columnId} ({columnName})");
var reader = new TimestampReader(stripeStreamCollection, (uint)columnId);
var count = reader.Read().Count();
Console.WriteLine($"Done reading {count} timestamps");
break;
}
case ColumnTypeKind.Date:
{
Console.WriteLine($"Reading dates from column {columnId} ({columnName})");
var reader = new DateReader(stripeStreamCollection, (uint)columnId);
var count = reader.Read().Count();
Console.WriteLine($"Done reading {count} dates");
break;
}
case ColumnTypeKind.String:
{
Console.WriteLine($"Reading strings from column {columnId} ({columnName})");
var reader = new ColumnTypes.StringReader(stripeStreamCollection, (uint)columnId);
var count = reader.Read().Count();
Console.WriteLine($"Done reading {count} strings");
break;
}
default:
throw new NotImplementedException();
}
}
Console.WriteLine("Done reading stripe");
}
}
public T Read <T>() where T : struct => reader.Read <T>();
public bool DeSerialize(Type _Type, byte[] _Bytes, out object _Object)
{
if (!_Type.IsArray)
{
_Object = null;
return(false);
}
ByteReader var_Reader = new ByteReader(_Bytes);
bool var_IsNull = var_Reader.ReadBoolean();
if (var_IsNull)
{
_Object = null;
return(true);
}
//
Type var_ElementType = _Type.GetElementType();
//Read dimensions
int var_Dimensions = var_Reader.ReadInt32();
//Go through each dimension and read the length!
int[] var_ArrayLength = new int[var_Dimensions];
for (int d = 0; d < var_Dimensions; d++)
{
var_ArrayLength[d] = var_Reader.ReadInt32();
}
//Go through each dimension and read the lowerbound!
int[] var_ArrayLowerBound = new int[var_Dimensions];
for (int d = 0; d < var_Dimensions; d++)
{
var_ArrayLowerBound[d] = var_Reader.ReadInt32();
}
var var_Array = Array.CreateInstance(var_ElementType, var_ArrayLength);
ArrayIndexer arrayIndexer = new ArrayIndexer(var_ArrayLength, var_ArrayLowerBound);
if (PrimitiveTypeMatcher.TypeDictionary.ContainsKey(var_ElementType))
{
while (arrayIndexer.MoveNext())
{
var_Array.SetValue(var_Reader.Read(var_ElementType), arrayIndexer.Current);
}
}
else
{
while (arrayIndexer.MoveNext())
{
byte[] var_Bytes = var_Reader.ReadBytesAndSize();
Object var_Item = Serializer.DeSerialize(_Type.GetElementType(), var_Bytes);
var_Array.SetValue(var_Item, arrayIndexer.Current);
}
}
_Object = var_Array;
return(true);
}
