private void ReadValue(BinaryReader reader, object parentObject, long parentObjectId, SerializationInfo info, Type valueType, string fieldName, MemberInfo memberInfo, int[] indices)
{
object obj;
if (BinaryCommon.IsPrimitive(valueType))
{
obj = ObjectReader.ReadPrimitiveTypeValue(reader, valueType);
this.SetObjectValue(parentObject, fieldName, memberInfo, info, obj, valueType, indices);
return;
}
BinaryElement binaryElement = (BinaryElement)reader.ReadByte();
if (binaryElement == BinaryElement.ObjectReference)
{
long childObjectId = (long)((ulong)reader.ReadUInt32());
this.RecordFixup(parentObjectId, childObjectId, parentObject, info, fieldName, memberInfo, indices);
return;
}
long num;
SerializationInfo info2;
this.ReadObject(binaryElement, reader, out num, out obj, out info2);
bool flag = false;
if (num != 0L)
{
if (obj.GetType().IsValueType)
{
this.RecordFixup(parentObjectId, num, parentObject, info, fieldName, memberInfo, indices);
flag = true;
}
if (info == null && !(parentObject is Array))
{
this.RegisterObject(num, obj, info2, parentObjectId, memberInfo, null);
}
else
{
this.RegisterObject(num, obj, info2, parentObjectId, null, indices);
}
}
if (!flag)
{
this.SetObjectValue(parentObject, fieldName, memberInfo, info, obj, valueType, indices);
}
}
private object ReadBoxedPrimitiveTypeValue(BinaryReader reader)
{
Type type = this.ReadType(reader, TypeTag.PrimitiveType);
return(ObjectReader.ReadPrimitiveTypeValue(reader, type));
}
public static object ReadMethodResponse(BinaryElement elem, BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, IMethodCallMessage methodCallMessage, BinaryFormatter formatter)
{
if (elem != BinaryElement.MethodResponse)
{
throw new SerializationException("Invalid format. Expected BinaryElement.MethodResponse, found " + elem);
}
MethodFlags flags = (MethodFlags)reader.ReadByte();
ReturnTypeTag typeTag = (ReturnTypeTag)reader.ReadByte();
bool hasContextInfo = (flags & MethodFlags.IncludesLogicalCallContext) > 0;
// FIXME: find a meaning for those 2 bytes
reader.ReadByte();
reader.ReadByte();
object returnValue = null;
object[] outArgs = null;
LogicalCallContext callContext = null;
Exception exception = null;
object[] extraProperties = null;
Header[] headers = null;
if ((typeTag & ReturnTypeTag.PrimitiveType) > 0)
{
Type type = BinaryCommon.GetTypeFromCode(reader.ReadByte());
returnValue = ObjectReader.ReadPrimitiveTypeValue(reader, type);
}
if ((flags & MethodFlags.PrimitiveArguments) > 0)
{
uint count = reader.ReadUInt32();
outArgs = new object[count];
for (int n = 0; n < count; n++)
{
Type type = BinaryCommon.GetTypeFromCode(reader.ReadByte());
outArgs[n] = ObjectReader.ReadPrimitiveTypeValue(reader, type);
}
}
if (hasContextInfo || (typeTag & ReturnTypeTag.ObjectType) > 0 ||
(typeTag & ReturnTypeTag.Exception) > 0 ||
(flags & MethodFlags.ArgumentsInSimpleArray) > 0 ||
(flags & MethodFlags.ArgumentsInMultiArray) > 0)
{
// There objects that need to be deserialized using an ObjectReader
ObjectReader objectReader = new ObjectReader(formatter);
object result;
objectReader.ReadObjectGraph(reader, hasHeaders, out result, out headers);
object[] msgInfo = (object[])result;
if ((typeTag & ReturnTypeTag.Exception) > 0)
{
exception = (Exception)msgInfo[0];
if (hasContextInfo)
{
callContext = (LogicalCallContext)msgInfo[1];
}
}
else if ((flags & MethodFlags.NoArguments) > 0 || (flags & MethodFlags.PrimitiveArguments) > 0)
{
int n = 0;
if ((typeTag & ReturnTypeTag.ObjectType) > 0)
{
returnValue = msgInfo [n++];
}
if (hasContextInfo)
{
callContext = (LogicalCallContext)msgInfo[n++];
}
if (n < msgInfo.Length)
{
extraProperties = (object[])msgInfo[n];
}
}
else if ((flags & MethodFlags.ArgumentsInSimpleArray) > 0)
{
outArgs = msgInfo;
}
else
{
int n = 0;
outArgs = (object[])msgInfo[n++];
if ((typeTag & ReturnTypeTag.ObjectType) > 0)
{
returnValue = msgInfo[n++];
}
if (hasContextInfo)
{
callContext = (LogicalCallContext)msgInfo[n++];
}
if (n < msgInfo.Length)
{
extraProperties = (object[])msgInfo[n];
}
}
}
else
{
reader.ReadByte(); // Reads the stream ender
}
if (headerHandler != null)
{
headerHandler(headers);
}
if (exception != null)
{
return(new ReturnMessage(exception, methodCallMessage));
}
else
{
int argCount = (outArgs != null) ? outArgs.Length : 0;
ReturnMessage result = new ReturnMessage(returnValue, outArgs, argCount, callContext, methodCallMessage);
if (extraProperties != null)
{
foreach (DictionaryEntry entry in extraProperties)
{
result.Properties [(string)entry.Key] = entry.Value;
}
}
return(result);
}
}
public static object ReadMethodCall(BinaryElement elem, BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, BinaryFormatter formatter)
{
if (elem != BinaryElement.MethodCall)
{
throw new SerializationException("Invalid format. Expected BinaryElement.MethodCall, found " + elem);
}
MethodFlags flags = (MethodFlags)reader.ReadInt32();
if (((BinaryTypeCode)reader.ReadByte()) != BinaryTypeCode.String)
{
throw new SerializationException("Invalid format");
}
string methodName = reader.ReadString();
if (((BinaryTypeCode)reader.ReadByte()) != BinaryTypeCode.String)
{
throw new SerializationException("Invalid format");
}
string className = reader.ReadString();
//bool hasContextInfo = (flags & MethodFlags.IncludesLogicalCallContext) > 0;
object[] arguments = null;
object methodSignature = null;
object callContext = null;
object[] extraProperties = null;
Header[] headers = null;
Type[] genericArguments = null;
if ((flags & MethodFlags.PrimitiveArguments) > 0)
{
uint count = reader.ReadUInt32();
arguments = new object[count];
for (int n = 0; n < count; n++)
{
Type type = BinaryCommon.GetTypeFromCode(reader.ReadByte());
arguments[n] = ObjectReader.ReadPrimitiveTypeValue(reader, type);
}
}
if ((flags & MethodFlags.NeedsInfoArrayMask) > 0)
{
ObjectReader objectReader = new ObjectReader(formatter);
object result;
objectReader.ReadObjectGraph(reader, hasHeaders, out result, out headers);
object[] msgInfo = (object[])result;
if ((flags & MethodFlags.ArgumentsInSimpleArray) > 0)
{
arguments = msgInfo;
}
else
{
int n = 0;
if ((flags & MethodFlags.ArgumentsInMultiArray) > 0)
{
if (msgInfo.Length > 1)
{
arguments = (object[])msgInfo[n++];
}
else
{
arguments = new object[0];
}
}
if ((flags & MethodFlags.GenericArguments) > 0)
{
genericArguments = (Type[])msgInfo[n++];
}
if ((flags & MethodFlags.IncludesSignature) > 0)
{
methodSignature = msgInfo[n++];
}
if ((flags & MethodFlags.IncludesLogicalCallContext) > 0)
{
callContext = msgInfo[n++];
}
if (n < msgInfo.Length)
{
extraProperties = (object[])msgInfo[n];
}
}
}
else
{
reader.ReadByte(); // Reads the stream ender
}
if (arguments == null)
{
arguments = new object[0];
}
string uri = null;
if (headerHandler != null)
{
uri = headerHandler(headers) as string;
}
Header[] methodInfo = new Header[7];
methodInfo[0] = new Header("__MethodName", methodName);
methodInfo[1] = new Header("__MethodSignature", methodSignature);
methodInfo[2] = new Header("__TypeName", className);
methodInfo[3] = new Header("__Args", arguments);
methodInfo[4] = new Header("__CallContext", callContext);
methodInfo[5] = new Header("__Uri", uri);
methodInfo[6] = new Header("__GenericArguments", genericArguments);
MethodCall call = new MethodCall(methodInfo);
if (extraProperties != null)
{
foreach (DictionaryEntry entry in extraProperties)
{
call.Properties [(string)entry.Key] = entry.Value;
}
}
return(call);
}
public static object ReadMethodResponse(BinaryElement elem, BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, IMethodCallMessage methodCallMessage, BinaryFormatter formatter)
{
if (elem != BinaryElement.MethodResponse)
{
throw new SerializationException("Invalid format. Expected BinaryElement.MethodResponse, found " + elem);
}
MethodFlags methodFlags = (MethodFlags)reader.ReadByte();
ReturnTypeTag returnTypeTag = (ReturnTypeTag)reader.ReadByte();
bool flag = (methodFlags & MethodFlags.IncludesLogicalCallContext) > (MethodFlags)0;
reader.ReadByte();
reader.ReadByte();
object ret = null;
object[] array = null;
LogicalCallContext callCtx = null;
Exception ex = null;
object[] array2 = null;
Header[] headers = null;
if ((byte)(returnTypeTag & ReturnTypeTag.PrimitiveType) > 0)
{
Type typeFromCode = BinaryCommon.GetTypeFromCode((int)reader.ReadByte());
ret = ObjectReader.ReadPrimitiveTypeValue(reader, typeFromCode);
}
if ((methodFlags & MethodFlags.PrimitiveArguments) > (MethodFlags)0)
{
uint num = reader.ReadUInt32();
array = new object[num];
int num2 = 0;
while ((long)num2 < (long)((ulong)num))
{
Type typeFromCode2 = BinaryCommon.GetTypeFromCode((int)reader.ReadByte());
array[num2] = ObjectReader.ReadPrimitiveTypeValue(reader, typeFromCode2);
num2++;
}
}
if (flag || (byte)(returnTypeTag & ReturnTypeTag.ObjectType) > 0 || (byte)(returnTypeTag & ReturnTypeTag.Exception) > 0 || (methodFlags & MethodFlags.ArgumentsInSimpleArray) > (MethodFlags)0 || (methodFlags & MethodFlags.ArgumentsInMultiArray) > (MethodFlags)0)
{
ObjectReader objectReader = new ObjectReader(formatter);
object obj;
objectReader.ReadObjectGraph(reader, hasHeaders, out obj, out headers);
object[] array3 = (object[])obj;
if ((byte)(returnTypeTag & ReturnTypeTag.Exception) > 0)
{
ex = (Exception)array3[0];
if (flag)
{
callCtx = (LogicalCallContext)array3[1];
}
}
else if ((methodFlags & MethodFlags.NoArguments) > (MethodFlags)0 || (methodFlags & MethodFlags.PrimitiveArguments) > (MethodFlags)0)
{
int num3 = 0;
if ((byte)(returnTypeTag & ReturnTypeTag.ObjectType) > 0)
{
ret = array3[num3++];
}
if (flag)
{
callCtx = (LogicalCallContext)array3[num3++];
}
if (num3 < array3.Length)
{
array2 = (object[])array3[num3];
}
}
else if ((methodFlags & MethodFlags.ArgumentsInSimpleArray) > (MethodFlags)0)
{
array = array3;
}
else
{
int num4 = 0;
array = (object[])array3[num4++];
if ((byte)(returnTypeTag & ReturnTypeTag.ObjectType) > 0)
{
ret = array3[num4++];
}
if (flag)
{
callCtx = (LogicalCallContext)array3[num4++];
}
if (num4 < array3.Length)
{
array2 = (object[])array3[num4];
}
}
}
else
{
reader.ReadByte();
}
if (headerHandler != null)
{
headerHandler(headers);
}
if (ex != null)
{
return(new ReturnMessage(ex, methodCallMessage));
}
int outArgsCount = (array == null) ? 0 : array.Length;
ReturnMessage returnMessage = new ReturnMessage(ret, array, outArgsCount, callCtx, methodCallMessage);
if (array2 != null)
{
foreach (DictionaryEntry dictionaryEntry in array2)
{
returnMessage.Properties[(string)dictionaryEntry.Key] = dictionaryEntry.Value;
}
}
return(returnMessage);
}
public static object ReadMethodCall(BinaryElement elem, BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, BinaryFormatter formatter)
{
if (elem != BinaryElement.MethodCall)
{
throw new SerializationException("Invalid format. Expected BinaryElement.MethodCall, found " + elem);
}
MethodFlags methodFlags = (MethodFlags)reader.ReadInt32();
if (reader.ReadByte() != 18)
{
throw new SerializationException("Invalid format");
}
string value = reader.ReadString();
if (reader.ReadByte() != 18)
{
throw new SerializationException("Invalid format");
}
string value2 = reader.ReadString();
object[] array = null;
object value3 = null;
object value4 = null;
object[] array2 = null;
Header[] headers = null;
Type[] value5 = null;
if ((methodFlags & MethodFlags.PrimitiveArguments) > (MethodFlags)0)
{
uint num = reader.ReadUInt32();
array = new object[num];
int num2 = 0;
while ((long)num2 < (long)((ulong)num))
{
Type typeFromCode = BinaryCommon.GetTypeFromCode((int)reader.ReadByte());
array[num2] = ObjectReader.ReadPrimitiveTypeValue(reader, typeFromCode);
num2++;
}
}
if ((methodFlags & MethodFlags.NeedsInfoArrayMask) > (MethodFlags)0)
{
ObjectReader objectReader = new ObjectReader(formatter);
object obj;
objectReader.ReadObjectGraph(reader, hasHeaders, out obj, out headers);
object[] array3 = (object[])obj;
if ((methodFlags & MethodFlags.ArgumentsInSimpleArray) > (MethodFlags)0)
{
array = array3;
}
else
{
int num3 = 0;
if ((methodFlags & MethodFlags.ArgumentsInMultiArray) > (MethodFlags)0)
{
if (array3.Length > 1)
{
array = (object[])array3[num3++];
}
else
{
array = new object[0];
}
}
if ((methodFlags & MethodFlags.GenericArguments) > (MethodFlags)0)
{
value5 = (Type[])array3[num3++];
}
if ((methodFlags & MethodFlags.IncludesSignature) > (MethodFlags)0)
{
value3 = array3[num3++];
}
if ((methodFlags & MethodFlags.IncludesLogicalCallContext) > (MethodFlags)0)
{
value4 = array3[num3++];
}
if (num3 < array3.Length)
{
array2 = (object[])array3[num3];
}
}
}
else
{
reader.ReadByte();
}
if (array == null)
{
array = new object[0];
}
string value6 = null;
if (headerHandler != null)
{
value6 = (headerHandler(headers) as string);
}
MethodCall methodCall = new MethodCall(new Header[]
{
new Header("__MethodName", value),
new Header("__MethodSignature", value3),
new Header("__TypeName", value2),
new Header("__Args", array),
new Header("__CallContext", value4),
new Header("__Uri", value6),
new Header("__GenericArguments", value5)
});
if (array2 != null)
{
foreach (DictionaryEntry dictionaryEntry in array2)
{
methodCall.Properties[(string)dictionaryEntry.Key] = dictionaryEntry.Value;
}
}
return(methodCall);
}
