-//\r
-// System.Runtime.Remoting.MessageFormatter.cs\r
-//\r
-// Author: Lluis Sanchez Gual (lluis@ideary.com)\r
-//\r
-// (C) 2003, Lluis Sanchez Gual\r
-//\r
-\r
-//\r
-// Copyright (C) 2004 Novell, Inc (http://www.novell.com)\r
-//\r
-// Permission is hereby granted, free of charge, to any person obtaining\r
-// a copy of this software and associated documentation files (the\r
-// "Software"), to deal in the Software without restriction, including\r
-// without limitation the rights to use, copy, modify, merge, publish,\r
-// distribute, sublicense, and/or sell copies of the Software, and to\r
-// permit persons to whom the Software is furnished to do so, subject to\r
-// the following conditions:\r
-// \r
-// The above copyright notice and this permission notice shall be\r
-// included in all copies or substantial portions of the Software.\r
-// \r
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
-//\r
-\r
-using System;\r
-using System.IO;\r
-using System.Reflection;\r
-using System.Collections;\r
-using System.Runtime.Remoting;\r
-using System.Runtime.Serialization;\r
-using System.Runtime.Remoting.Messaging;\r
-\r
-namespace System.Runtime.Serialization.Formatters.Binary\r
-{\r
- internal class MessageFormatter\r
- {\r
- public static void WriteMethodCall (BinaryWriter writer, object obj, Header[] headers, ISurrogateSelector surrogateSelector, StreamingContext context, FormatterAssemblyStyle assemblyFormat, FormatterTypeStyle typeFormat)\r
- {\r
- IMethodCallMessage call = (IMethodCallMessage)obj;\r
- writer.Write ((byte) BinaryElement.MethodCall);\r
-\r
- MethodFlags methodFlags;\r
- int infoArraySize = 0;\r
- object info = null;\r
- object[] extraProperties = null;\r
-\r
- if (call.LogicalCallContext != null && call.LogicalCallContext.HasInfo)\r
- {\r
- methodFlags = MethodFlags.IncludesLogicalCallContext;\r
- infoArraySize++;\r
- }\r
- else\r
- methodFlags = MethodFlags.ExcludeLogicalCallContext;\r
-\r
- if (RemotingServices.IsMethodOverloaded (call))\r
- {\r
- infoArraySize++;\r
- methodFlags |= MethodFlags.IncludesSignature;\r
- }\r
-\r
- if (call.Properties.Count > MethodCallDictionary.InternalKeys.Length)\r
- {\r
- extraProperties = GetExtraProperties (call.Properties, MethodCallDictionary.InternalKeys);\r
- infoArraySize++;\r
- }\r
-\r
- if (call.ArgCount == 0)\r
- methodFlags |= MethodFlags.NoArguments;\r
- else {\r
- if (AllTypesArePrimitive (call.Args)) \r
- methodFlags |= MethodFlags.PrimitiveArguments;\r
- else {\r
- if (infoArraySize == 0)\r
- methodFlags |= MethodFlags.ArgumentsInSimpleArray;\r
- else {\r
- methodFlags |= MethodFlags.ArgumentsInMultiArray;\r
- infoArraySize++;\r
- }\r
- }\r
- }\r
-\r
- writer.Write ((byte) (methodFlags));\r
-\r
- // FIXME: what are the following 3 bytes for?\r
- writer.Write ((byte) 0);\r
- writer.Write ((byte) 0);\r
- writer.Write ((byte) 0);\r
-\r
- // Method name\r
- writer.Write ((byte) BinaryTypeCode.String);\r
- writer.Write (call.MethodName);\r
-\r
- // Class name\r
- writer.Write ((byte) BinaryTypeCode.String);\r
- writer.Write (call.TypeName);\r
-\r
- // Arguments\r
-\r
- if ((methodFlags & MethodFlags.PrimitiveArguments) > 0)\r
- {\r
- writer.Write ((uint)call.Args.Length);\r
- for (int n=0; n<call.ArgCount; n++)\r
- {\r
- object arg = call.GetArg(n);\r
- if (arg != null) {\r
- writer.Write (BinaryCommon.GetTypeCode (arg.GetType()));\r
- ObjectWriter.WritePrimitiveValue (writer, arg);\r
- }\r
- else\r
- writer.Write ((byte)BinaryTypeCode.Null);\r
- }\r
- }\r
-\r
- if ( infoArraySize > 0)\r
- {\r
- object[] ainfo = new object[infoArraySize];\r
- int n=0;\r
- if ((methodFlags & MethodFlags.ArgumentsInMultiArray) > 0) ainfo[n++] = call.Args;\r
- if ((methodFlags & MethodFlags.IncludesSignature) > 0) ainfo[n++] = call.MethodSignature;\r
- if ((methodFlags & MethodFlags.IncludesLogicalCallContext) > 0) ainfo[n++] = call.LogicalCallContext;\r
- if (extraProperties != null) ainfo[n++] = extraProperties;\r
- info = ainfo;\r
- }\r
- else if ((methodFlags & MethodFlags.ArgumentsInSimpleArray) > 0)\r
- info = call.Args;\r
-\r
- if (info != null)\r
- {\r
- ObjectWriter objectWriter = new ObjectWriter (surrogateSelector, context, assemblyFormat, typeFormat);\r
- objectWriter.WriteObjectGraph (writer, info, headers);\r
- }\r
- else\r
- writer.Write ((byte) BinaryElement.End);\r
- }\r
-\r
- public static void WriteMethodResponse (BinaryWriter writer, object obj, Header[] headers, ISurrogateSelector surrogateSelector, StreamingContext context, FormatterAssemblyStyle assemblyFormat, FormatterTypeStyle typeFormat)\r
- {\r
- IMethodReturnMessage resp = (IMethodReturnMessage)obj;\r
- writer.Write ((byte) BinaryElement.MethodResponse);\r
-\r
- string[] internalProperties = MethodReturnDictionary.InternalReturnKeys;\r
-\r
- int infoArrayLength = 0;\r
- object info = null;\r
- object[] extraProperties = null;\r
-\r
- // Type of return value\r
-\r
- ReturnTypeTag returnTypeTag;\r
-\r
- if (resp.Exception != null) {\r
- returnTypeTag = ReturnTypeTag.Exception | ReturnTypeTag.Null;\r
- info = new object[] {resp.Exception};\r
- internalProperties = MethodReturnDictionary.InternalExceptionKeys;\r
- }\r
- else if (resp.ReturnValue == null) {\r
- returnTypeTag = ReturnTypeTag.Null;\r
- }\r
- else if (IsMethodPrimitive(resp.ReturnValue.GetType())) {\r
- returnTypeTag = ReturnTypeTag.PrimitiveType;\r
- }\r
- else {\r
- returnTypeTag = ReturnTypeTag.ObjectType;\r
- infoArrayLength++;\r
- }\r
-\r
- // Message flags\r
-\r
- MethodFlags contextFlag;\r
- MethodFlags formatFlag;\r
-\r
- if ((resp.LogicalCallContext != null) && resp.LogicalCallContext.HasInfo && ((returnTypeTag & ReturnTypeTag.Exception) == 0)) \r
- {\r
- contextFlag = MethodFlags.IncludesLogicalCallContext;\r
- infoArrayLength++;\r
- }\r
- else\r
- contextFlag = MethodFlags.ExcludeLogicalCallContext;\r
-\r
- if (resp.Properties.Count > internalProperties.Length && ((returnTypeTag & ReturnTypeTag.Exception) == 0))\r
- {\r
- extraProperties = GetExtraProperties (resp.Properties, internalProperties);\r
- infoArrayLength++;\r
- }\r
-\r
- if (resp.OutArgCount == 0)\r
- formatFlag = MethodFlags.NoArguments;\r
- else \r
- {\r
- if (AllTypesArePrimitive (resp.Args)) \r
- formatFlag = MethodFlags.PrimitiveArguments;\r
- else \r
- {\r
- if (infoArrayLength == 0)\r
- formatFlag = MethodFlags.ArgumentsInSimpleArray; \r
- else {\r
- formatFlag = MethodFlags.ArgumentsInMultiArray;\r
- infoArrayLength++;\r
- }\r
- }\r
- }\r
-\r
- writer.Write ((byte) (contextFlag | formatFlag));\r
- writer.Write ((byte) returnTypeTag);\r
-\r
- // FIXME: what are the following 2 bytes for?\r
- writer.Write ((byte) 0);\r
- writer.Write ((byte) 0);\r
-\r
- // Arguments\r
-\r
- if (returnTypeTag == ReturnTypeTag.PrimitiveType)\r
- {\r
- writer.Write (BinaryCommon.GetTypeCode (resp.ReturnValue.GetType()));\r
- ObjectWriter.WritePrimitiveValue (writer, resp.ReturnValue);\r
- }\r
-\r
- if (formatFlag == MethodFlags.PrimitiveArguments)\r
- {\r
- writer.Write ((uint)resp.ArgCount);\r
- for (int n=0; n<resp.ArgCount; n++)\r
- {\r
- object val = resp.GetArg(n);\r
- if (val != null) {\r
- writer.Write (BinaryCommon.GetTypeCode (val.GetType()));\r
- ObjectWriter.WritePrimitiveValue (writer, val);\r
- }\r
- else\r
- writer.Write ((byte)BinaryTypeCode.Null);\r
- }\r
- }\r
-\r
- if (infoArrayLength > 0)\r
- {\r
- object[] infoArray = new object[infoArrayLength];\r
- int n = 0;\r
-\r
- if (formatFlag == MethodFlags.ArgumentsInMultiArray)\r
- infoArray[n++] = resp.Args;\r
-\r
- if (returnTypeTag == ReturnTypeTag.ObjectType)\r
- infoArray[n++] = resp.ReturnValue;\r
-\r
- if (contextFlag == MethodFlags.IncludesLogicalCallContext)\r
- infoArray[n++] = resp.LogicalCallContext;\r
-\r
- if (extraProperties != null)\r
- infoArray[n++] = extraProperties;\r
-\r
- info = infoArray;\r
- }\r
- else if ((formatFlag & MethodFlags.ArgumentsInSimpleArray) > 0)\r
- info = resp.Args;\r
-\r
- if (info != null)\r
- {\r
- ObjectWriter objectWriter = new ObjectWriter (surrogateSelector, context, assemblyFormat, typeFormat);\r
- objectWriter.WriteObjectGraph (writer, info, headers);\r
- }\r
- else\r
- writer.Write ((byte) BinaryElement.End);\r
- }\r
-\r
- public static object ReadMethodCall (BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, BinaryFormatter formatter)\r
- {\r
- BinaryElement elem = (BinaryElement)reader.ReadByte(); // The element code\r
- if (elem != BinaryElement.MethodCall) throw new SerializationException("Invalid format. Expected BinaryElement.MethodCall, found " + elem);\r
-\r
- MethodFlags flags = (MethodFlags) reader.ReadByte();\r
-\r
- // FIXME: find a meaning for those 3 bytes\r
- reader.ReadByte();\r
- reader.ReadByte();\r
- reader.ReadByte();\r
-\r
- if (((BinaryTypeCode)reader.ReadByte()) != BinaryTypeCode.String) throw new SerializationException ("Invalid format");\r
- string methodName = reader.ReadString();\r
-\r
- if (((BinaryTypeCode)reader.ReadByte()) != BinaryTypeCode.String) throw new SerializationException ("Invalid format");\r
- string className = reader.ReadString();\r
-\r
- //bool hasContextInfo = (flags & MethodFlags.IncludesLogicalCallContext) > 0;\r
-\r
- object[] arguments = null;\r
- object methodSignature = null;\r
- object callContext = null;\r
- object[] extraProperties = null;\r
- Header[] headers = null;\r
-\r
- if ((flags & MethodFlags.PrimitiveArguments) > 0)\r
- {\r
- uint count = reader.ReadUInt32();\r
- arguments = new object[count];\r
- for (int n=0; n<count; n++)\r
- {\r
- Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());\r
- arguments[n] = ObjectReader.ReadPrimitiveTypeValue (reader, type);\r
- }\r
- }\r
-\r
- if ((flags & MethodFlags.NeedsInfoArrayMask) > 0)\r
- {\r
- ObjectReader objectReader = new ObjectReader (formatter);\r
-\r
- object result;\r
- objectReader.ReadObjectGraph (reader, hasHeaders, out result, out headers);\r
- object[] msgInfo = (object[]) result;\r
-\r
- if ((flags & MethodFlags.ArgumentsInSimpleArray) > 0) {\r
- arguments = msgInfo;\r
- }\r
- else\r
- {\r
- int n = 0;\r
- if ((flags & MethodFlags.ArgumentsInMultiArray) > 0) {\r
- if (msgInfo.Length > 1) arguments = (object[]) msgInfo[n++];\r
- else arguments = new object[0];\r
- }\r
-\r
- if ((flags & MethodFlags.IncludesSignature) > 0)\r
- methodSignature = msgInfo[n++];\r
-\r
- if ((flags & MethodFlags.IncludesLogicalCallContext) > 0) \r
- callContext = msgInfo[n++];\r
-\r
- if (n < msgInfo.Length)\r
- extraProperties = (object[]) msgInfo[n];\r
- }\r
- }\r
- else {\r
- reader.ReadByte (); // Reads the stream ender\r
- }\r
-\r
- if (arguments == null) arguments = new object[0];\r
-\r
- string uri = null;\r
- if (headerHandler != null)\r
- uri = headerHandler(headers) as string;\r
-\r
- Header[] methodInfo = new Header[6];\r
- methodInfo[0] = new Header("__MethodName", methodName);\r
- methodInfo[1] = new Header("__MethodSignature", methodSignature);\r
- methodInfo[2] = new Header("__TypeName", className);\r
- methodInfo[3] = new Header("__Args", arguments);\r
- methodInfo[4] = new Header("__CallContext", callContext);\r
- methodInfo[5] = new Header("__Uri", uri);\r
-\r
- MethodCall call = new MethodCall (methodInfo);\r
-\r
- if (extraProperties != null) {\r
- foreach (DictionaryEntry entry in extraProperties)\r
- call.Properties [(string)entry.Key] = entry.Value;\r
- }\r
-\r
- return call;\r
- }\r
-\r
- public static object ReadMethodResponse (BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, IMethodCallMessage methodCallMessage, BinaryFormatter formatter)\r
- {\r
- BinaryElement elem = (BinaryElement)reader.ReadByte(); // The element code\r
- if (elem != BinaryElement.MethodResponse) throw new SerializationException("Invalid format. Expected BinaryElement.MethodResponse, found " + elem);\r
-\r
- MethodFlags flags = (MethodFlags) reader.ReadByte ();\r
- ReturnTypeTag typeTag = (ReturnTypeTag) reader.ReadByte ();\r
- bool hasContextInfo = (flags & MethodFlags.IncludesLogicalCallContext) > 0;\r
-\r
- // FIXME: find a meaning for those 2 bytes\r
- reader.ReadByte();\r
- reader.ReadByte();\r
-\r
- object returnValue = null;\r
- object[] outArgs = null;\r
- LogicalCallContext callContext = null;\r
- Exception exception = null;\r
- object[] extraProperties = null;\r
- Header[] headers = null;\r
-\r
- if ((typeTag & ReturnTypeTag.PrimitiveType) > 0)\r
- {\r
- Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());\r
- returnValue = ObjectReader.ReadPrimitiveTypeValue (reader, type);\r
- }\r
-\r
- if ((flags & MethodFlags.PrimitiveArguments) > 0)\r
- {\r
- uint count = reader.ReadUInt32();\r
- outArgs = new object[count];\r
- for (int n=0; n<count; n++) {\r
- Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());\r
- outArgs[n] = ObjectReader.ReadPrimitiveTypeValue (reader, type);\r
- }\r
- }\r
-\r
- if (hasContextInfo || (typeTag & ReturnTypeTag.ObjectType) > 0 || \r
- (typeTag & ReturnTypeTag.Exception) > 0 ||\r
- (flags & MethodFlags.ArgumentsInSimpleArray) > 0 || \r
- (flags & MethodFlags.ArgumentsInMultiArray) > 0)\r
- {\r
- // There objects that need to be deserialized using an ObjectReader\r
-\r
- ObjectReader objectReader = new ObjectReader (formatter);\r
- object result;\r
- objectReader.ReadObjectGraph (reader, hasHeaders, out result, out headers);\r
- object[] msgInfo = (object[]) result;\r
-\r
- if ((typeTag & ReturnTypeTag.Exception) > 0) {\r
- exception = (Exception) msgInfo[0];\r
- }\r
- else if ((flags & MethodFlags.NoArguments) > 0 || (flags & MethodFlags.PrimitiveArguments) > 0) {\r
- int n = 0;\r
- if ((typeTag & ReturnTypeTag.ObjectType) > 0) returnValue = msgInfo [n++];\r
- if (hasContextInfo) callContext = (LogicalCallContext)msgInfo[n++];\r
- if (n < msgInfo.Length) extraProperties = (object[]) msgInfo[n];\r
- }\r
- else if ((flags & MethodFlags.ArgumentsInSimpleArray) > 0) {\r
- outArgs = msgInfo;\r
- }\r
- else {\r
- int n = 0;\r
- outArgs = (object[]) msgInfo[n++];\r
- if ((typeTag & ReturnTypeTag.ObjectType) > 0) returnValue = msgInfo[n++];\r
- if (hasContextInfo) callContext = (LogicalCallContext)msgInfo[n++];\r
- if (n < msgInfo.Length) extraProperties = (object[]) msgInfo[n];\r
- }\r
- }\r
- else {\r
- reader.ReadByte (); // Reads the stream ender\r
- }\r
-\r
- if (headerHandler != null) \r
- headerHandler(headers);\r
-\r
- if (exception != null)\r
- return new ReturnMessage (exception, methodCallMessage);\r
- else\r
- {\r
- int argCount = (outArgs!=null) ? outArgs.Length : 0;\r
- ReturnMessage result = new ReturnMessage (returnValue, outArgs, argCount, callContext, methodCallMessage);\r
-\r
- if (extraProperties != null) {\r
- foreach (DictionaryEntry entry in extraProperties)\r
- result.Properties [(string)entry.Key] = entry.Value;\r
- }\r
-\r
- return result;\r
- }\r
- }\r
-\r
- private static bool AllTypesArePrimitive(object[] objects)\r
- {\r
- foreach (object ob in objects) \r
- {\r
- if (ob != null && !IsMethodPrimitive(ob.GetType())) \r
- return false;\r
- }\r
- return true;\r
- }\r
-\r
- // When serializing methods, string are considered primitive types\r
- public static bool IsMethodPrimitive (Type type)\r
- {\r
- return type.IsPrimitive || type == typeof(string) || type == typeof (DateTime) || type == typeof (Decimal);\r
- }\r
-\r
- static object[] GetExtraProperties (IDictionary properties, string[] internalKeys)\r
- {\r
- object[] extraProperties = new object [properties.Count - internalKeys.Length];\r
- \r
- int n = 0;\r
- IDictionaryEnumerator e = properties.GetEnumerator();\r
- while (e.MoveNext())\r
- if (!IsInternalKey ((string) e.Entry.Key, internalKeys)) extraProperties [n++] = e.Entry;\r
-\r
- return extraProperties;\r
- }\r
-\r
- static bool IsInternalKey (string key, string[] internalKeys)\r
- {\r
- foreach (string ikey in internalKeys)\r
- if (key == ikey) return true;\r
- return false;\r
- }\r
-\r
- }\r
-}\r
+//
+// System.Runtime.Remoting.MessageFormatter.cs
+//
+// Author: Lluis Sanchez Gual (lluis@ideary.com)
+//
+// (C) 2003, Lluis Sanchez Gual
+//
+
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.IO;
+using System.Reflection;
+using System.Collections;
+using System.Runtime.Remoting;
+using System.Runtime.Serialization;
+using System.Runtime.Remoting.Messaging;
+
+namespace System.Runtime.Serialization.Formatters.Binary
+{
+ internal class MessageFormatter
+ {
+ public static void WriteMethodCall (BinaryWriter writer, object obj, Header[] headers, BinaryFormatter formatter)
+ {
+ IMethodCallMessage call = (IMethodCallMessage)obj;
+ writer.Write ((byte) BinaryElement.MethodCall);
+
+ MethodFlags methodFlags;
+ int infoArraySize = 0;
+ object info = null;
+ object[] extraProperties = null;
+
+ if (call.LogicalCallContext != null && call.LogicalCallContext.HasInfo)
+ {
+ methodFlags = MethodFlags.IncludesLogicalCallContext;
+ infoArraySize++;
+ }
+ else
+ methodFlags = MethodFlags.ExcludeLogicalCallContext;
+
+ if (RemotingServices.IsMethodOverloaded (call))
+ {
+ infoArraySize++;
+ methodFlags |= MethodFlags.IncludesSignature;
+ }
+
+ if (call.Properties.Count > MethodCallDictionary.InternalKeys.Length)
+ {
+ extraProperties = GetExtraProperties (call.Properties, MethodCallDictionary.InternalKeys);
+ infoArraySize++;
+ }
+
+ if (call.MethodBase.IsGenericMethod) {
+ infoArraySize++;
+ methodFlags |= MethodFlags.GenericArguments;
+ }
+ if (call.ArgCount == 0)
+ methodFlags |= MethodFlags.NoArguments;
+ else {
+ if (AllTypesArePrimitive (call.Args))
+ methodFlags |= MethodFlags.PrimitiveArguments;
+ else {
+ if (infoArraySize == 0)
+ methodFlags |= MethodFlags.ArgumentsInSimpleArray;
+ else {
+ methodFlags |= MethodFlags.ArgumentsInMultiArray;
+ infoArraySize++;
+ }
+ }
+ }
+
+ writer.Write ((int) methodFlags);
+
+ // Method name
+ writer.Write ((byte) BinaryTypeCode.String);
+ writer.Write (call.MethodName);
+
+ // Class name
+ writer.Write ((byte) BinaryTypeCode.String);
+ writer.Write (call.TypeName);
+
+ // Arguments
+
+ if ((methodFlags & MethodFlags.PrimitiveArguments) > 0)
+ {
+ writer.Write ((uint)call.Args.Length);
+ for (int n=0; n<call.ArgCount; n++)
+ {
+ object arg = call.GetArg(n);
+ if (arg != null) {
+ writer.Write (BinaryCommon.GetTypeCode (arg.GetType()));
+ ObjectWriter.WritePrimitiveValue (writer, arg);
+ }
+ else
+ writer.Write ((byte)BinaryTypeCode.Null);
+ }
+ }
+
+ if ( infoArraySize > 0)
+ {
+ object[] ainfo = new object[infoArraySize];
+ int n=0;
+ if ((methodFlags & MethodFlags.ArgumentsInMultiArray) > 0) ainfo[n++] = call.Args;
+ if ((methodFlags & MethodFlags.GenericArguments) > 0) ainfo[n++] = call.MethodBase.GetGenericArguments ();
+ if ((methodFlags & MethodFlags.IncludesSignature) > 0) ainfo[n++] = call.MethodSignature;
+ if ((methodFlags & MethodFlags.IncludesLogicalCallContext) > 0) ainfo[n++] = call.LogicalCallContext;
+ if (extraProperties != null) ainfo[n++] = extraProperties;
+ info = ainfo;
+ }
+ else if ((methodFlags & MethodFlags.ArgumentsInSimpleArray) > 0)
+ info = call.Args;
+
+ if (info != null)
+ {
+ ObjectWriter objectWriter = new ObjectWriter (formatter);
+ objectWriter.WriteObjectGraph (writer, info, headers);
+ }
+ else
+ writer.Write ((byte) BinaryElement.End);
+ }
+
+ public static void WriteMethodResponse (BinaryWriter writer, object obj, Header[] headers, BinaryFormatter formatter)
+ {
+ IMethodReturnMessage resp = (IMethodReturnMessage)obj;
+ writer.Write ((byte) BinaryElement.MethodResponse);
+
+ string[] internalProperties = MethodReturnDictionary.InternalReturnKeys;
+
+ int infoArrayLength = 0;
+ object info = null;
+ object[] extraProperties = null;
+
+ // Type of return value
+
+ ReturnTypeTag returnTypeTag;
+ MethodFlags contextFlag = MethodFlags.ExcludeLogicalCallContext;
+
+ if (resp.Exception != null) {
+ returnTypeTag = ReturnTypeTag.Exception | ReturnTypeTag.Null;
+ internalProperties = MethodReturnDictionary.InternalExceptionKeys;
+ infoArrayLength = 1;
+ }
+ else if (resp.ReturnValue == null) {
+ returnTypeTag = ReturnTypeTag.Null;
+ }
+ else if (IsMethodPrimitive(resp.ReturnValue.GetType())) {
+ returnTypeTag = ReturnTypeTag.PrimitiveType;
+ }
+ else {
+ returnTypeTag = ReturnTypeTag.ObjectType;
+ infoArrayLength++;
+ }
+
+ // Message flags
+
+ MethodFlags formatFlag;
+
+ if ((resp.LogicalCallContext != null) && resp.LogicalCallContext.HasInfo)
+ {
+ contextFlag = MethodFlags.IncludesLogicalCallContext;
+ infoArrayLength++;
+ }
+
+ if (resp.Properties.Count > internalProperties.Length && ((returnTypeTag & ReturnTypeTag.Exception) == 0))
+ {
+ extraProperties = GetExtraProperties (resp.Properties, internalProperties);
+ infoArrayLength++;
+ }
+
+ if (resp.OutArgCount == 0)
+ formatFlag = MethodFlags.NoArguments;
+ else
+ {
+ if (AllTypesArePrimitive (resp.Args))
+ formatFlag = MethodFlags.PrimitiveArguments;
+ else
+ {
+ if (infoArrayLength == 0)
+ formatFlag = MethodFlags.ArgumentsInSimpleArray;
+ else {
+ formatFlag = MethodFlags.ArgumentsInMultiArray;
+ infoArrayLength++;
+ }
+ }
+ }
+
+ writer.Write ((byte) (contextFlag | formatFlag));
+ writer.Write ((byte) returnTypeTag);
+
+ // FIXME: what are the following 2 bytes for?
+ writer.Write ((byte) 0);
+ writer.Write ((byte) 0);
+
+ // Arguments
+
+ if (returnTypeTag == ReturnTypeTag.PrimitiveType)
+ {
+ writer.Write (BinaryCommon.GetTypeCode (resp.ReturnValue.GetType()));
+ ObjectWriter.WritePrimitiveValue (writer, resp.ReturnValue);
+ }
+
+ if (formatFlag == MethodFlags.PrimitiveArguments)
+ {
+ writer.Write ((uint)resp.ArgCount);
+ for (int n=0; n<resp.ArgCount; n++)
+ {
+ object val = resp.GetArg(n);
+ if (val != null) {
+ writer.Write (BinaryCommon.GetTypeCode (val.GetType()));
+ ObjectWriter.WritePrimitiveValue (writer, val);
+ }
+ else
+ writer.Write ((byte)BinaryTypeCode.Null);
+ }
+ }
+
+ if (infoArrayLength > 0)
+ {
+ object[] infoArray = new object[infoArrayLength];
+ int n = 0;
+
+ if ((returnTypeTag & ReturnTypeTag.Exception) != 0)
+ infoArray[n++] = resp.Exception;
+
+ if (formatFlag == MethodFlags.ArgumentsInMultiArray)
+ infoArray[n++] = resp.Args;
+
+ if (returnTypeTag == ReturnTypeTag.ObjectType)
+ infoArray[n++] = resp.ReturnValue;
+
+ if (contextFlag == MethodFlags.IncludesLogicalCallContext)
+ infoArray[n++] = resp.LogicalCallContext;
+
+ if (extraProperties != null)
+ infoArray[n++] = extraProperties;
+
+ info = infoArray;
+ }
+ else if ((formatFlag & MethodFlags.ArgumentsInSimpleArray) > 0)
+ info = resp.Args;
+
+ if (info != null)
+ {
+ ObjectWriter objectWriter = new ObjectWriter (formatter);
+ objectWriter.WriteObjectGraph (writer, info, headers);
+ }
+ else
+ writer.Write ((byte) BinaryElement.End);
+ }
+
+ public static object ReadMethodCall (BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, BinaryFormatter formatter)
+ {
+ BinaryElement elem = (BinaryElement)reader.ReadByte(); // The element code
+ return ReadMethodCall (elem, reader, hasHeaders, headerHandler, formatter);
+ }
+
+ 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 (BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, IMethodCallMessage methodCallMessage, BinaryFormatter formatter)
+ {
+ BinaryElement elem = (BinaryElement) reader.ReadByte ();
+ return ReadMethodResponse (elem, reader, hasHeaders, headerHandler, methodCallMessage, formatter);
+ }
+
+ 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;
+ }
+ }
+
+ private static bool AllTypesArePrimitive(object[] objects)
+ {
+ foreach (object ob in objects)
+ {
+ if (ob != null && !IsMethodPrimitive(ob.GetType()))
+ return false;
+ }
+ return true;
+ }
+
+ // When serializing methods, string are considered primitive types
+ public static bool IsMethodPrimitive (Type type)
+ {
+ return type.IsPrimitive || type == typeof(string) || type == typeof (DateTime) || type == typeof (Decimal);
+ }
+
+ static object[] GetExtraProperties (IDictionary properties, string[] internalKeys)
+ {
+ object[] extraProperties = new object [properties.Count - internalKeys.Length];
+
+ int n = 0;
+ IDictionaryEnumerator e = properties.GetEnumerator();
+ while (e.MoveNext())
+ if (!IsInternalKey ((string) e.Entry.Key, internalKeys)) extraProperties [n++] = e.Entry;
+
+ return extraProperties;
+ }
+
+ static bool IsInternalKey (string key, string[] internalKeys)
+ {
+ foreach (string ikey in internalKeys)
+ if (key == ikey) return true;
+ return false;
+ }
+
+ }
+}
projects / mono.git / blobdiff