internal ClassInfo(BinarySerializationStreamAnalyzer analyzer)
{
ObjectID = analyzer.reader.ReadInt32();
LogInternal("ObjectID=" + ObjectID);
Name = analyzer.reader.ReadString();
LogInternal("Name=" + Name);
int numMembers = analyzer.reader.ReadInt32();
LogInternal("# Members=" + numMembers);
Members = new List <MemberInfo>(numMembers);
List <String> names = new List <String>(numMembers);
for (int i = 0; i < numMembers; i++)
{
MemberInfo info = new MemberInfo();
info.Name = analyzer.reader.ReadString();
info.RelevantObject = this;
Members.Add(info);
names.Add(info.Name);
}
LogInternal("Members=" + ToString(names));
}
internal BinaryArray(BinarySerializationStreamAnalyzer analyzer)
{
ObjectID = analyzer.ReadID();
ArrayType = (BinaryArrayTypeEnumeration)analyzer.reader.ReadByte();
Rank = analyzer.reader.ReadInt32();
Lengths = new List <int>(Rank);
for (int i = 0; i < Rank; i++)
{
Lengths.Add(analyzer.reader.ReadInt32());
}
if (ArrayType == BinaryArrayTypeEnumeration.SingleOffset ||
ArrayType == BinaryArrayTypeEnumeration.JaggedOffset ||
ArrayType == BinaryArrayTypeEnumeration.RectangularOffset)
{
LowerBounds = new List <int>(Rank);
for (int i = 0; i < Rank; i++)
{
LowerBounds.Add(analyzer.reader.ReadInt32());
}
}
BinaryType = (BinaryTypeEnumeration)analyzer.reader.ReadByte();
TypeHelper.GetTypeAdditionalInfo(this, analyzer);
}
internal static void GetTypeAdditionalInfo(TypeHoldingThing typeHolder, BinarySerializationStreamAnalyzer analyzer)
{
switch (typeHolder.BinaryType)
{
case BinaryTypeEnumeration.Primitive:
case BinaryTypeEnumeration.PrimitiveArray:
typeHolder.PrimitiveType = (PrimitiveTypeEnumeration)analyzer.reader.ReadByte();
break;
case BinaryTypeEnumeration.String:
break;
case BinaryTypeEnumeration.Object:
break;
case BinaryTypeEnumeration.SystemClass:
typeHolder.TypeInfo = new ClassTypeInfo();
typeHolder.TypeInfo.TypeName = analyzer.reader.ReadString();
break;
case BinaryTypeEnumeration.Class:
typeHolder.TypeInfo = new ClassTypeInfo();
typeHolder.TypeInfo.TypeName = analyzer.reader.ReadString();
typeHolder.TypeInfo.LibraryID = analyzer.ReadID();
break;
case BinaryTypeEnumeration.ObjectArray:
break;
case BinaryTypeEnumeration.StringArray:
break;
}
}
public void ReadValueInfo(BinarySerializationStreamAnalyzer analyzer)
{
//then get additional infos where appropriate
foreach (MemberInfo member in Members)
{
TypeHelper.GetTypeValue(member, member, analyzer);
}
}
internal SerializationHeaderRecord(BinarySerializationStreamAnalyzer analyzer)
{
ObjectID = analyzer.reader.ReadInt32();
HeaderID = analyzer.reader.ReadInt32();
MajorVersion = analyzer.reader.ReadInt32();
MinorVersion = analyzer.reader.ReadInt32();
recordLength = 16;
}
public void ReadValueInfo(BinarySerializationStreamAnalyzer analyzer)
{
MemberInfo junk = new MemberInfo();
for (int i = 0; i < Slots; i++)
{
TypeHelper.GetTypeValue(this, junk, analyzer);
}
}
public void ReadValueInfo(BinarySerializationStreamAnalyzer analyzer)
{
//then get additional infos where appropriate
foreach (MemberInfo member in Members)
{
LogInternal(" ############# GetTypeValue(" + member.Name + ") ################# ");
TypeHelper.GetTypeValue(member, member, analyzer);
}
}
internal ClassInfo(BinarySerializationStreamAnalyzer analyzer)
{
ObjectID = analyzer.ReadID();
Name = analyzer.reader.ReadString();
Members = new List <MemberInfo>(analyzer.reader.ReadInt32());
for (int i = 0; i < Members.Capacity; i++)
{
Members.Add(new MemberInfo());
Members[i].Name = analyzer.reader.ReadString();
Members[i].RelevantObject = this;
}
}
internal void ReadTypeInfo(BinarySerializationStreamAnalyzer analyzer)
{
//first get binary types
foreach (MemberInfo member in Members)
{
member.BinaryType = (BinaryTypeEnumeration)analyzer.reader.ReadByte();
}
//then get additional infos where appropriate
foreach (MemberInfo member in Members)
{
TypeHelper.GetTypeAdditionalInfo(member, analyzer);
}
}
internal void ReadTypeInfo(BinarySerializationStreamAnalyzer analyzer)
{
//first get binary types
foreach (MemberInfo member in Members)
{
member.BinaryType = (BinaryTypeEnumeration)analyzer.reader.ReadByte();
LogInternal(member.Name + " Type=" + Enum.GetName(typeof(BinaryTypeEnumeration), member.BinaryType));
}
//then get additional infos where appropriate
foreach (MemberInfo member in Members)
{
LogInternal(" ############# GetTypeAdditionalInfo(" + member.Name + ") ################# ");
TypeHelper.GetTypeAdditionalInfo(member, analyzer);
}
}
static void AnalyzeStream(string name, Stream stream)
{
BinarySerializationStreamAnalyzer analyzer = new BinarySerializationStreamAnalyzer();
try
{
analyzer.Read(stream);
}
catch (Exception e)
{
Console.Error.WriteLine(e.GetType().Name + ": " + e.Message);
}
Console.WriteLine(" ================== " + name + "==============================");
Console.Write(analyzer.Analyze());
Console.WriteLine();
}
internal static void GetTypeAdditionalInfo(TypeHoldingThing typeHolder, BinarySerializationStreamAnalyzer analyzer)
{
MemberInfo info = typeHolder as MemberInfo;
string varName = (info == null) ? "???" : info.Name;
switch (typeHolder.BinaryType)
{
case BinaryTypeEnumeration.Primitive:
typeHolder.PrimitiveType = (PrimitiveTypeEnumeration)analyzer.reader.ReadByte();
LogInternal(varName + ": PrimitiveType=" + Enum.GetName(typeof(PrimitiveTypeEnumeration), typeHolder.PrimitiveType));
break;
case BinaryTypeEnumeration.String:
break;
case BinaryTypeEnumeration.Object:
break;
case BinaryTypeEnumeration.SystemClass:
typeHolder.TypeInfo = new ClassTypeInfo();
typeHolder.TypeInfo.TypeName = analyzer.reader.ReadString();
LogInternal(varName + ": SystemClass=" + typeHolder.TypeInfo.TypeName);
break;
case BinaryTypeEnumeration.Class:
typeHolder.TypeInfo = new ClassTypeInfo();
typeHolder.TypeInfo.TypeName = analyzer.reader.ReadString();
typeHolder.TypeInfo.LibraryID = analyzer.reader.ReadInt32();
LogInternal(varName + ": Class=" + typeHolder.TypeInfo.TypeName + "@" + typeHolder.TypeInfo.LibraryID);
break;
case BinaryTypeEnumeration.ObjectArray:
break;
case BinaryTypeEnumeration.StringArray:
break;
case BinaryTypeEnumeration.PrimitiveArray:
typeHolder.PrimitiveType = (PrimitiveTypeEnumeration)analyzer.reader.ReadByte();
LogInternal(varName + ": PrimitiveArray=" + Enum.GetName(typeof(PrimitiveTypeEnumeration), typeHolder.PrimitiveType));
break;
}
}
static void Main(string[] args)
{
var analyzer = new BinarySerializationStreamAnalyzer();
if (args.Length > 1 && ("/s".Equals(args[1], StringComparison.OrdinalIgnoreCase) || "/SessionState".Equals(args[1], StringComparison.OrdinalIgnoreCase)))
{
StateItemData sessionItems;
HttpStaticObjectsCollection staticObjects;
using (var stream = File.OpenRead(args[0]))
Deserialize(stream, out sessionItems, out staticObjects);
if (sessionItems != null)
{
Console.WriteLine("SessionItems count: " + sessionItems.Count);
var buf = sessionItems.Buffer;
foreach (var k in sessionItems.Keys)
{
var si = sessionItems[k];
Console.WriteLine(k + ": " + (si.Length - 1));
if (buf[si.Offset] == 20)
{
analyzer.Read(new MemoryStream(buf, si.Offset + 1, si.Length - 1));
}
}
}
if (staticObjects != null)
{
Console.WriteLine("StaticObjects: " + staticObjects.Count);
#warning TODO: display stats
}
}
else
{
using (var stream = File.OpenRead(args[0]))
analyzer.Read(stream);
}
Console.WriteLine();
Console.WriteLine("Analyzer stats:");
Console.WriteLine(analyzer.Analyze());
}
static void Main()
{
//create a new Dummy Class
DummyClass test = new DummyClass();
//set some properties
test.someList = new List<int>();
test.someList.Add(1);
test.someList.Add(2);
test.someList.Add(3);
test.someString = "Some Value";
//set up a recursive reference
test.subObject = test;
//set up our serializer/formatter and analyser
System.Runtime.Serialization.IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
BinarySerializationStreamAnalyzer analyzer = new BinarySerializationStreamAnalyzer();
using (Stream stream = new MemoryStream())
{
//serialize the object to a new memory stream
formatter.Serialize(stream, test);
//reset the stream to the start
stream.Position = 0;
//analyse the binary serialization stream
analyzer.Read(stream);
}
//output the results to the console
Console.Write(analyzer.Analyze());
Console.WriteLine();
Console.Write("Press any key to exit");
Console.ReadKey();
}
static void Main()
{
//create a new Dummy Class
DummyClass test = new DummyClass();
//set some properties
test.someList = new List <int>();
test.someList.Add(1);
test.someList.Add(2);
test.someList.Add(3);
test.someString = "Some Value";
//set up a recursive reference
test.subObject = test;
//set up our serializer/formatter and analyser
System.Runtime.Serialization.IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
BinarySerializationStreamAnalyzer analyzer = new BinarySerializationStreamAnalyzer();
using (Stream stream = new MemoryStream())
{
//serialize the object to a new memory stream
formatter.Serialize(stream, test);
//reset the stream to the start
stream.Position = 0;
//analyse the binary serialization stream
analyzer.Read(stream);
}
//output the results to the console
Console.Write(analyzer.Analyze());
Console.WriteLine();
Console.Write("Press any key to exit");
Console.ReadKey();
}
internal BinaryArray(BinarySerializationStreamAnalyzer analyzer)
{
ObjectID = analyzer.reader.ReadInt32();
LogInternal("ObjectID=" + ObjectID);
ArrayType = (BinaryArrayTypeEnumeration)analyzer.reader.ReadByte();
LogInternal("ArrayType=" + Enum.GetName(typeof(BinaryArrayTypeEnumeration), ArrayType));
Rank = analyzer.reader.ReadInt32();
LogInternal("Rank=" + Rank);
Lengths = new List <int>(Rank);
for (int i = 0; i < Rank; i++)
{
Lengths.Add(analyzer.reader.ReadInt32());
}
LogInternal("Lengths=" + ToString(Lengths));
if (ArrayType == BinaryArrayTypeEnumeration.SingleOffset ||
ArrayType == BinaryArrayTypeEnumeration.JaggedOffset ||
ArrayType == BinaryArrayTypeEnumeration.RectangularOffset)
{
LowerBounds = new List <int>(Rank);
for (int i = 0; i < Rank; i++)
{
LowerBounds.Add(analyzer.reader.ReadInt32());
}
LogInternal("LowerBounds=" + ToString(LowerBounds));
}
BinaryType = (BinaryTypeEnumeration)analyzer.reader.ReadByte();
LogInternal("BinaryType=" + ((BinaryType == null) ? "???" : Enum.GetName(typeof(BinaryTypeEnumeration), BinaryType)));
TypeHelper.GetTypeAdditionalInfo(this, analyzer);
}
internal BinaryArray(BinarySerializationStreamAnalyzer analyzer)
{
ObjectID = analyzer.ReadID();
ArrayType = (BinaryArrayTypeEnumeration)analyzer.reader.ReadByte();
Rank = analyzer.reader.ReadInt32();
Lengths = new List<int>(Rank);
for(int i = 0;i < Rank;i++)
{
Lengths.Add(analyzer.reader.ReadInt32());
}
if(ArrayType == BinaryArrayTypeEnumeration.SingleOffset ||
ArrayType == BinaryArrayTypeEnumeration.JaggedOffset ||
ArrayType == BinaryArrayTypeEnumeration.RectangularOffset)
{
LowerBounds = new List<int>(Rank);
for(int i = 0;i < Rank;i++)
LowerBounds.Add(analyzer.reader.ReadInt32());
}
BinaryType = (BinaryTypeEnumeration)analyzer.reader.ReadByte();
TypeHelper.GetTypeAdditionalInfo(this, analyzer);
}
internal static void GetTypeValue(TypeHoldingThing typeHolder, ValueHoldingThing valueHolder, BinarySerializationStreamAnalyzer analyzer)
{
switch (typeHolder.BinaryType)
{
case BinaryTypeEnumeration.Primitive:
switch (typeHolder.PrimitiveType)
{
case PrimitiveTypeEnumeration.Boolean:
valueHolder.Value = analyzer.reader.ReadBoolean();
break;
case PrimitiveTypeEnumeration.Byte:
valueHolder.Value = analyzer.reader.ReadByte();
break;
case PrimitiveTypeEnumeration.Char:
valueHolder.Value = analyzer.reader.ReadChar();
break;
case PrimitiveTypeEnumeration.DateTime:
valueHolder.Value = DateTime.FromBinary(analyzer.reader.ReadInt64());
break;
case PrimitiveTypeEnumeration.Decimal:
string decimalValue = analyzer.reader.ReadString();
valueHolder.Value = decimal.Parse(decimalValue);
//valueHolder.Value = analyzer.reader.ReadDecimal();
break;
case PrimitiveTypeEnumeration.Double:
valueHolder.Value = analyzer.reader.ReadDouble();
break;
case PrimitiveTypeEnumeration.Int16:
valueHolder.Value = analyzer.reader.ReadInt16();
break;
case PrimitiveTypeEnumeration.Int32:
valueHolder.Value = analyzer.reader.ReadInt32();
break;
case PrimitiveTypeEnumeration.Int64:
valueHolder.Value = analyzer.reader.ReadInt64();
break;
case PrimitiveTypeEnumeration.Null:
valueHolder.Value = null;
break;
case PrimitiveTypeEnumeration.SByte:
valueHolder.Value = analyzer.reader.ReadSByte();
break;
case PrimitiveTypeEnumeration.Single:
valueHolder.Value = analyzer.reader.ReadSingle();
break;
case PrimitiveTypeEnumeration.String:
valueHolder.Value = analyzer.reader.ReadString();
break;
case PrimitiveTypeEnumeration.TimeSpan:
valueHolder.Value = TimeSpan.FromTicks(analyzer.reader.ReadInt64());
break;
case PrimitiveTypeEnumeration.UInt16:
valueHolder.Value = analyzer.reader.ReadUInt16();
break;
case PrimitiveTypeEnumeration.UInt32:
valueHolder.Value = analyzer.reader.ReadUInt32();
break;
case PrimitiveTypeEnumeration.UInt64:
valueHolder.Value = analyzer.reader.ReadUInt64();
break;
}
break;
case BinaryTypeEnumeration.String:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.Object:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.SystemClass:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.Class:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.ObjectArray:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.StringArray:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.PrimitiveArray:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
}
}
public void ReadValueInfo(BinarySerializationStreamAnalyzer analyzer)
{
TypeHelper.GetTypeValue(this, this, analyzer);
}
public void ReadValueInfo(BinarySerializationStreamAnalyzer analyzer)
{
throw new NotImplementedException("Unexpected call to read");
}
internal ClassInfo(BinarySerializationStreamAnalyzer analyzer)
{
ObjectID = analyzer.ReadID();
Name = analyzer.reader.ReadString();
Members = new List<MemberInfo>(analyzer.reader.ReadInt32());
for(int i = 0;i < Members.Capacity;i++)
{
Members.Add(new MemberInfo());
Members[i].Name = analyzer.reader.ReadString();
Members[i].RelevantObject = this;
}
}
public void ReadValueInfo(BinarySerializationStreamAnalyzer analyzer)
{
throw new NotImplementedException();
}
public void ReadValueInfo(BinarySerializationStreamAnalyzer analyzer)
{
//then get additional infos where appropriate
foreach(MemberInfo member in Members)
{
TypeHelper.GetTypeValue(member, member, analyzer);
}
}
internal void ReadTypeInfo(BinarySerializationStreamAnalyzer analyzer)
{
//first get binary types
foreach(MemberInfo member in Members)
{
member.BinaryType = (BinaryTypeEnumeration)analyzer.reader.ReadByte();
}
//then get additional infos where appropriate
foreach(MemberInfo member in Members)
{
TypeHelper.GetTypeAdditionalInfo(member, analyzer);
}
}
internal static void GetTypeValue(TypeHoldingThing typeHolder, ValueHoldingThing valueHolder, BinarySerializationStreamAnalyzer analyzer)
{
switch(typeHolder.BinaryType)
{
case BinaryTypeEnumeration.Primitive:
switch(typeHolder.PrimitiveType)
{
case PrimitiveTypeEnumeration.Boolean:
valueHolder.Value = analyzer.reader.ReadBoolean();
break;
case PrimitiveTypeEnumeration.Byte:
valueHolder.Value = analyzer.reader.ReadByte();
break;
case PrimitiveTypeEnumeration.Char:
valueHolder.Value = analyzer.reader.ReadChar();
break;
case PrimitiveTypeEnumeration.DateTime:
valueHolder.Value = DateTime.FromBinary(analyzer.reader.ReadInt64());
break;
case PrimitiveTypeEnumeration.Decimal:
string decimalValue = analyzer.reader.ReadString();
valueHolder.Value = decimal.Parse(decimalValue);
//valueHolder.Value = analyzer.reader.ReadDecimal();
break;
case PrimitiveTypeEnumeration.Double:
valueHolder.Value = analyzer.reader.ReadDouble();
break;
case PrimitiveTypeEnumeration.Int16:
valueHolder.Value = analyzer.reader.ReadInt16();
break;
case PrimitiveTypeEnumeration.Int32:
valueHolder.Value = analyzer.reader.ReadInt32();
break;
case PrimitiveTypeEnumeration.Int64:
valueHolder.Value = analyzer.reader.ReadInt64();
break;
case PrimitiveTypeEnumeration.Null:
valueHolder.Value = null;
break;
case PrimitiveTypeEnumeration.SByte:
valueHolder.Value = analyzer.reader.ReadSByte();
break;
case PrimitiveTypeEnumeration.Single:
valueHolder.Value = analyzer.reader.ReadSingle();
break;
case PrimitiveTypeEnumeration.String:
valueHolder.Value = analyzer.reader.ReadString();
break;
case PrimitiveTypeEnumeration.TimeSpan:
valueHolder.Value = TimeSpan.FromTicks(analyzer.reader.ReadInt64());
break;
case PrimitiveTypeEnumeration.UInt16:
valueHolder.Value = analyzer.reader.ReadUInt16();
break;
case PrimitiveTypeEnumeration.UInt32:
valueHolder.Value = analyzer.reader.ReadUInt32();
break;
case PrimitiveTypeEnumeration.UInt64:
valueHolder.Value = analyzer.reader.ReadUInt64();
break;
}
break;
case BinaryTypeEnumeration.String:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.Object:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.SystemClass:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.Class:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.ObjectArray:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.StringArray:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
case BinaryTypeEnumeration.PrimitiveArray:
valueHolder.ValueRefID = analyzer.ParseRecord(typeHolder.RelevantObject);
break;
}
}
internal static void GetTypeAdditionalInfo(TypeHoldingThing typeHolder, BinarySerializationStreamAnalyzer analyzer)
{
switch(typeHolder.BinaryType)
{
case BinaryTypeEnumeration.Primitive:
case BinaryTypeEnumeration.PrimitiveArray:
typeHolder.PrimitiveType = (PrimitiveTypeEnumeration)analyzer.reader.ReadByte();
break;
case BinaryTypeEnumeration.String:
break;
case BinaryTypeEnumeration.Object:
break;
case BinaryTypeEnumeration.SystemClass:
typeHolder.TypeInfo = new ClassTypeInfo();
typeHolder.TypeInfo.TypeName = analyzer.reader.ReadString();
break;
case BinaryTypeEnumeration.Class:
typeHolder.TypeInfo = new ClassTypeInfo();
typeHolder.TypeInfo.TypeName = analyzer.reader.ReadString();
typeHolder.TypeInfo.LibraryID = analyzer.ReadID();
break;
case BinaryTypeEnumeration.ObjectArray:
break;
case BinaryTypeEnumeration.StringArray:
break;
}
}
public void ReadValueInfo(BinarySerializationStreamAnalyzer analyzer)
{
MemberInfo junk = new MemberInfo();
for(int i = 0;i < Slots;i++)
TypeHelper.GetTypeValue(this, junk, analyzer);
}
internal MessagePrimitiveTyped(BinarySerializationStreamAnalyzer analyzer)
{
PrimitiveType = (PrimitiveTypeEnumeration)analyzer.reader.ReadByte();
LogInternal("PrimitiveType=" + Enum.GetName(typeof(PrimitiveTypeEnumeration), PrimitiveType));
}
public void ReadValueInfo(BinarySerializationStreamAnalyzer analyzer)
{
throw new NotImplementedException();
}
