We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Runtime.Serialization.Formatters.Soap \ ObjectReader

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. //============================================================
  16. //
  17. // Class: ObjectReader
  18. // Purpose: DeSerializes XML in SOAP Format into an an object graph
  19. //
  20. // Date: June 10, 1999
  21. //
  22. //============================================================
  24. namespace System.Runtime.Serialization.Formatters.Soap
  25. {
  26.    
  27.     using System;
  28.     using System.IO;
  29.     using System.Reflection;
  30.     using System.Collections;
  31.     using System.Text;
  32.     using System.Runtime.Remoting;
  33.     using System.Runtime.Remoting.Metadata.W3cXsd2001;
  34.     using System.Runtime.Remoting.Messaging;
  35.     using System.Runtime.Serialization;
  36.     using System.Security;
  37.     using System.Security.Permissions;
  38.     using System.Diagnostics;
  39.     using System.Globalization;
  40.    
  41.     internal sealed class ObjectReader
  42.     {
  43.        
  44.         // System.Serializer information
  45.         internal ObjectIDGenerator m_idGenerator;
  46.         internal Stream m_stream;
  47.         internal ISurrogateSelector m_surrogates;
  48.         internal StreamingContext m_context;
  49.         internal ObjectManager m_objectManager;
  50.         internal InternalFE formatterEnums;
  51.         internal SerializationBinder m_binder;
  52.        
  53.         internal SoapHandler soapHandler;
  54.         //Set from SoapHandler
  55.         // Fake Top object and headers
  56.         internal long topId = 0;
  57.         internal SerStack topStack;
  58.         // Stack for placing ProcessRecords if the top record cannot be serialized on the first pass.
  59.         internal bool isTopObjectSecondPass = false;
  60.         internal bool isTopObjectResolved = true;
  61.         internal bool isHeaderHandlerCalled = false;
  62.         internal Exception deserializationSecurityException = null;
  63.         internal object handlerObject = null;
  64.         internal object topObject;
  65.         internal long soapFaultId;
  66.         internal Header[] headers;
  67.         internal Header[] newheaders;
  68.         internal bool IsFakeTopObject = false;
  69.         internal HeaderHandler handler;
  70.         internal SerObjectInfoInit serObjectInfoInit = null;
  71.         internal IFormatterConverter m_formatterConverter = null;
  72.        
  73.         // Stack of Object ParseRecords
  74.         internal SerStack stack = new SerStack("ObjectReader Object Stack");
  75.        
  76.         // ValueType Fixup Stack
  77.         internal SerStack valueFixupStack = new SerStack("ValueType Fixup Stack");
  78.        
  79.         // Generate Object Id's
  80.         internal Hashtable objectIdTable = new Hashtable(25);
  81.         // holds the keyId value from the XML input and associated internal Id
  82.         internal long objectIds = 0;
  83.        
  84.         internal int paramPosition = 0;
  85.         //Position of parameter if soap top fake record.
  86.         internal int majorVersion = 0;
  87.         internal int minorVersion = 0;
  88.        
  89.         internal string faultString = null;
  90.        
  91.         // GetType - eliminate redundant Type.GetType()
  92.         //internal Hashtable typeTable = new Hashtable(10);
  93.        
  94.         static internal SecurityPermission serializationPermission = new SecurityPermission(SecurityPermissionFlag.SerializationFormatter);
  95.         private static FileIOPermission sfileIOPermission = new FileIOPermission(PermissionState.Unrestricted);
  96.        
  97.        
  98.         internal ObjectReader(Stream stream, ISurrogateSelector selector, StreamingContext context, InternalFE formatterEnums, SerializationBinder binder)
  99.         {
  100.             InternalST.Soap(this, "Constructor ISurrogateSelector ", ((selector == null) ? "null selector " : "selector present"));
  101.            
  102.             if (stream == null) {
  103.                 throw new ArgumentNullException("stream", SoapUtil.GetResourceString("ArgumentNull_Stream"));
  104.             }
  105.            
  106.             m_stream = stream;
  107.             m_surrogates = selector;
  108.             m_context = context;
  109.             m_binder = binder;
  110.             this.formatterEnums = formatterEnums;
  111.            
  112.             InternalST.Soap(this, "Constructor formatterEnums.FEtopObject ", formatterEnums.FEtopObject);
  113.             if (formatterEnums.FEtopObject != null)
  114.                 IsFakeTopObject = true;
  115.             else
  116.                 IsFakeTopObject = false;
  117.            
  118.             m_formatterConverter = new FormatterConverter();
  119.         }
  120.        
  121.        
  122.         private ObjectManager GetObjectManager()
  123.         {
  124.             new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).Assert();
  125.             return new ObjectManager(m_surrogates, m_context);
  126.         }
  127.        
  128.        
  129.        
  130.        
  131.         // Deserialize the stream into an object graph.
  132.         internal object Deserialize(HeaderHandler handler, ISerParser serParser)
  133.         {
  134.            
  135.             InternalST.Soap(this, "Deserialize Entry handler", handler);
  136.            
  137.             if (serParser == null)
  138.                 throw new ArgumentNullException("serParser", String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("ArgumentNull_WithParamName"), serParser));
  139.            
  140.            
  141.             deserializationSecurityException = null;
  142.             try {
  143.                 serializationPermission.Demand();
  144.             }
  145.             catch (Exception e) {
  146.                 deserializationSecurityException = e;
  147.             }
  148.             catch {
  149.                 deserializationSecurityException = new Exception(SoapUtil.GetResourceString("Serialization_NonClsCompliantException"));
  150.             }
  151.            
  152.             this.handler = handler;
  153.             isTopObjectSecondPass = false;
  154.             isHeaderHandlerCalled = false;
  155.            
  156.             if (handler != null)
  157.                 IsFakeTopObject = true;
  158.            
  159.             m_idGenerator = new ObjectIDGenerator();
  160.            
  161.            
  162.             m_objectManager = GetObjectManager();
  163.            
  164.             serObjectInfoInit = new SerObjectInfoInit();
  165.             objectIdTable.Clear();
  166.             objectIds = 0;
  167.            
  168.             // Will call back to ParseObject, ParseHeader for each object found
  169.             serParser.Run();
  170.            
  171.             if (handler != null) {
  172.                 InternalST.Soap(this, "Deserialize Fixup Before Delegate Invoke");
  173.                 m_objectManager.DoFixups();
  174.                 // Fixup for headers
  175.                 // Header handler isn't invoked until method name is known from body fake record
  176.                 // Except for SoapFault, in which case it is invoked below
  177.                 if (handlerObject == null) {
  178.                     InternalST.Soap(this, "Deserialize Before SoapFault Delegate Invoke ");
  179.                     handlerObject = handler(newheaders);
  180.                     InternalST.Soap(this, "Deserialize after SoapFault Delegate Invoke");
  181.                 }
  182.                
  183.                
  184.                 // SoapFault creation Create a fake Pr for the handlerObject to use.
  185.                 // Create a member for the fake pr with name __fault;
  186.                 if ((soapFaultId > 0) && (handlerObject != null)) {
  187.                     InternalST.Soap(this, "Deserialize SoapFault ");
  188.                     topStack = new SerStack("Top ParseRecords");
  189.                     ParseRecord pr = new ParseRecord();
  190.                     pr.PRparseTypeEnum = InternalParseTypeE.Object;
  191.                     pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
  192.                     pr.PRparseStateEnum = InternalParseStateE.Object;
  193.                     pr.PRname = "Response";
  194.                     topStack.Push(pr);
  195.                     pr = new ParseRecord();
  196.                     pr.PRparseTypeEnum = InternalParseTypeE.Member;
  197.                     pr.PRobjectPositionEnum = InternalObjectPositionE.Child;
  198.                     pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
  199.                     pr.PRmemberValueEnum = InternalMemberValueE.Reference;
  200.                     pr.PRparseStateEnum = InternalParseStateE.Member;
  201.                     pr.PRname = "__fault";
  202.                     pr.PRidRef = soapFaultId;
  203.                     topStack.Push(pr);
  204.                     pr = new ParseRecord();
  205.                     pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
  206.                     pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
  207.                     pr.PRparseStateEnum = InternalParseStateE.Object;
  208.                     pr.PRname = "Response";
  209.                     topStack.Push(pr);
  210.                     isTopObjectResolved = false;
  211.                 }
  212.             }
  213.            
  214.            
  215.             // Resolve fake top object if necessary
  216.             if (!isTopObjectResolved) {
  217.                 //resolve top object
  218.                 InternalST.Soap(this, "Deserialize TopObject Second Pass");
  219.                 isTopObjectSecondPass = true;
  220.                 topStack.Reverse();
  221.                 // The top of the stack now contains the fake record
  222.                 // When it is Parsed, the handler object will be substituted
  223.                 // for it in ParseObject.
  224.                 int topStackLength = topStack.Count();
  225.                 ParseRecord pr = null;
  226.                 for (int i = 0; i < topStackLength; i++) {
  227.                     pr = (ParseRecord)topStack.Pop();
  228.                     Parse(pr);
  229.                 }
  230.             }
  231.            
  232.            
  233.             InternalST.Soap(this, "Deserialize Finished Parsing DoFixups");
  234.            
  235.             m_objectManager.DoFixups();
  236.            
  237.             if (topObject == null)
  238.                 throw new SerializationException(SoapUtil.GetResourceString("Serialization_TopObject"));
  239.            
  240.             //if topObject has a surrogate then the actual object may be changed during special fixup
  241.             //So refresh it using topID.
  242.             if (HasSurrogate(topObject.GetType()) && topId != 0)
  243.                 //Not yet resolved
  244.                 topObject = m_objectManager.GetObject(topId);
  245.            
  246.             if (topObject is IObjectReference) {
  247.                 topObject = ((IObjectReference)topObject).GetRealObject(m_context);
  248.             }
  249.            
  250.             InternalST.Soap(this, "Deserialize Exit ", topObject);
  251.            
  252.             m_objectManager.RaiseDeserializationEvent();
  253.            
  254.            
  255.            
  256.             if ((formatterEnums.FEtopObject != null) && (topObject is InternalSoapMessage)) {
  257.                 // Convert InternalSoapMessage to SoapMessage
  258.                 InternalST.Soap(this, "Deserialize SoapMessage Entry ");
  259.                
  260.                 InternalSoapMessage ismc = (InternalSoapMessage)topObject;
  261.                 ISoapMessage smc = (ISoapMessage)formatterEnums.FEtopObject;
  262.                 smc.MethodName = ismc.methodName;
  263.                 smc.XmlNameSpace = ismc.xmlNameSpace;
  264.                 smc.ParamNames = ismc.paramNames;
  265.                 smc.ParamValues = ismc.paramValues;
  266.                 smc.Headers = headers;
  267.                 topObject = smc;
  268.                 isTopObjectResolved = true;
  269.                 InternalST.Soap(this, "Deserialize SoapMessage Exit topObject ", topObject, " method name ", smc.MethodName);
  270.             }
  271.            
  272.             return topObject;
  273.         }
  274.        
  275.         private bool HasSurrogate(Type t)
  276.         {
  277.             if (m_surrogates == null)
  278.                 return false;
  279.             ISurrogateSelector notUsed;
  280.             return m_surrogates.GetSurrogate(t, m_context, out notUsed) != null;
  281.         }
  282.        
  283.         private void CheckSerializable(Type t)
  284.         {
  285.             if (!t.IsSerializable && !HasSurrogate(t))
  286.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_NonSerType"), t.FullName, t.Module.Assembly.FullName));
  287.         }
  288.        
  289.         internal ReadObjectInfo CreateReadObjectInfo(Type objectType, string assemblyName)
  290.         {
  291.             ReadObjectInfo objectInfo = ReadObjectInfo.Create(objectType, m_surrogates, m_context, m_objectManager, serObjectInfoInit, m_formatterConverter, assemblyName);
  292.             objectInfo.SetVersion(majorVersion, minorVersion);
  293.             return objectInfo;
  294.         }
  295.        
  296.         internal ReadObjectInfo CreateReadObjectInfo(Type objectType, string[] memberNames, Type[] memberTypes, string assemblyName)
  297.         {
  298.             ReadObjectInfo objectInfo = ReadObjectInfo.Create(objectType, memberNames, memberTypes, m_surrogates, m_context, m_objectManager, serObjectInfoInit, m_formatterConverter, assemblyName);
  299.             objectInfo.SetVersion(majorVersion, minorVersion);
  300.             return objectInfo;
  301.         }
  302.        
  303.        
  304.         // Main Parse routine, called by the XML Parse Handlers in XMLParser and also called internally to
  305.         // parse the fake top object.
  306.         internal void Parse(ParseRecord pr)
  307.         {
  308.             InternalST.Soap(this, "Parse Entry");
  309.             stack.Dump();
  310.             pr.Dump();
  311.            
  312.             switch (pr.PRparseTypeEnum) {
  313.                 case InternalParseTypeE.SerializedStreamHeader:
  314.                     ParseSerializedStreamHeader(pr);
  315.                     break;
  316.                 case InternalParseTypeE.SerializedStreamHeaderEnd:
  317.                     ParseSerializedStreamHeaderEnd(pr);
  318.                     break;
  319.                 case InternalParseTypeE.Object:
  320.                     ParseObject(pr);
  321.                     break;
  322.                 case InternalParseTypeE.ObjectEnd:
  323.                     ParseObjectEnd(pr);
  324.                     break;
  325.                 case InternalParseTypeE.Member:
  326.                     ParseMember(pr);
  327.                     break;
  328.                 case InternalParseTypeE.MemberEnd:
  329.                     ParseMemberEnd(pr);
  330.                     break;
  331.                 case InternalParseTypeE.Body:
  332.                 case InternalParseTypeE.BodyEnd:
  333.                 case InternalParseTypeE.Envelope:
  334.                 case InternalParseTypeE.EnvelopeEnd:
  335.                     break;
  336.                 case InternalParseTypeE.Empty:
  337.                 default:
  338.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_XMLElement"), pr.PRname));
  339.                     break;
  340.                
  341.             }
  342.         }
  343.        
  344.         // Styled ParseError output
  345.         private void ParseError(ParseRecord processing, ParseRecord onStack)
  346.         {
  347.             InternalST.Soap(this, " ParseError ", processing, " ", onStack);
  348.             throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_ParseError"), onStack.PRname + " " + ((Enum)onStack.PRparseTypeEnum).ToString() + " " + processing.PRname + " " + ((Enum)processing.PRparseTypeEnum).ToString()));
  349.         }
  350.        
  351.         // Parse the SerializedStreamHeader element. This is the first element in the stream if present
  352.         private void ParseSerializedStreamHeader(ParseRecord pr)
  353.         {
  354.             InternalST.Soap(this, "SerializedHeader ", pr);
  355.             stack.Push(pr);
  356.         }
  357.        
  358.         // Parse the SerializedStreamHeader end element. This is the last element in the stream if present
  359.         private void ParseSerializedStreamHeaderEnd(ParseRecord pr)
  360.         {
  361.             InternalST.Soap(this, "SerializedHeaderEnd ", pr);
  362.             stack.Pop();
  363.         }
  364.        
  365.        
  366.        
  367.         private bool IsRemoting {
  368. //return (m_context.State & (StreamingContextStates.Persistence|StreamingContextStates.File|StreamingContextStates.Clone)) == 0;
  369.             get { return IsFakeTopObject; }
  370.         }
  371.        
  372.         private void CheckSecurity(ParseRecord pr)
  373.         {
  374.             InternalST.SoapAssert(pr != null, "[BinaryObjectReader.CheckSecurity]pr!=null");
  375.             Type t = pr.PRdtType;
  376.            
  377.             if (t != null) {
  378.                 if (IsRemoting) {
  379.                     if (typeof(MarshalByRefObject).IsAssignableFrom(t))
  380.                         throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_MBRAsMBV"), t.FullName));
  381.                     FormatterServices.CheckTypeSecurity(t, formatterEnums.FEsecurityLevel);
  382.                 }
  383.             }
  384.            
  385.             //If we passed the security check, they can do whatever they'd like,
  386.             //so we'll just short-circuit this.
  387.             if (deserializationSecurityException == null) {
  388.                 return;
  389.             }
  390.            
  391.             // BaseTypes and Array of basetypes allowed
  392.            
  393.             if (t != null) {
  394.                 if (t.IsPrimitive || t == Converter.typeofString)
  395.                     return;
  396.                
  397.                 if (typeof(Enum).IsAssignableFrom(t))
  398.                     return;
  399.                
  400.                 if (t.IsArray) {
  401.                     Type type = t.GetElementType();
  402.                     if (type.IsPrimitive || type == Converter.typeofString)
  403.                         return;
  404.                 }
  405.             }
  406.            
  407.             throw deserializationSecurityException;
  408.         }
  409.        
  410.         // New object encountered in stream
  411.         private void ParseObject(ParseRecord pr)
  412.         {
  413.             InternalST.Soap(this, "ParseObject Entry ");
  414.            
  415.             if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
  416.                 topId = pr.PRobjectId;
  417.            
  418.             if (pr.PRparseTypeEnum == InternalParseTypeE.Object) {
  419.                 InternalST.Soap(this, "ParseObject Push " + pr.PRname);
  420.                 stack.Push(pr);
  421.                 // Nested objects member names are already on stack
  422.             }
  423.            
  424.             if (pr.PRobjectTypeEnum == InternalObjectTypeE.Array) {
  425.                 ParseArray(pr);
  426.                 InternalST.Soap(this, "ParseObject Exit, ParseArray ");
  427.                 return;
  428.             }
  429.            
  430.             if ((pr.PRdtType == null) && !IsFakeTopObject)
  431.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TopObjectInstantiate"), pr.PRname));
  432.            
  433.            
  434.             if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top && IsFakeTopObject && pr.PRdtType != Converter.typeofSoapFault) {
  435.                
  436.                 // Soap fake top object
  437.                 if (handler != null) {
  438.                     // Handler object will supply real top object
  439.                     InternalST.Soap(this, "ParseObject FakeTopObject with handlerObject ");
  440.                    
  441.                     // Now know the method name, can call header handler
  442.                     //Create header for method name
  443.                     if (!isHeaderHandlerCalled) {
  444.                         newheaders = null;
  445.                         isHeaderHandlerCalled = true;
  446.                         if (headers == null) {
  447.                             newheaders = new Header[1];
  448.                         }
  449.                         else {
  450.                             newheaders = new Header[headers.Length + 1];
  451.                             Array.Copy(headers, 0, newheaders, 1, headers.Length);
  452.                         }
  453.                        
  454.                         Header methodNameHeader = new Header("__methodName", pr.PRname, false, pr.PRnameXmlKey);
  455.                         newheaders[0] = methodNameHeader;
  456.                         InternalST.Soap(this, "Deserialize Before Delegate Invoke ");
  457.                         handlerObject = handler(newheaders);
  458.                        
  459.                         InternalST.Soap(this, "Deserialize after Delegate Invoke");
  460.                         InternalST.Soap(this, "Deserialize delgate object ", ((handlerObject == null) ? "null" : handlerObject));
  461.                     }
  462.                    
  463.                     if (isHeaderHandlerCalled) {
  464.                         // Handler object has supplied the real object for the fake object
  465.                         // which is on top of the stack
  466.                         pr.PRnewObj = handlerObject;
  467.                         pr.PRdtType = handlerObject.GetType();
  468.                         CheckSecurity(pr);
  469.                         if (pr.PRnewObj is IFieldInfo) {
  470.                             IFieldInfo fi = (IFieldInfo)pr.PRnewObj;
  471.                             if ((fi.FieldTypes != null) && (fi.FieldTypes.Length > 0)) {
  472.                                 pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, fi.FieldNames, fi.FieldTypes, pr.PRassemblyName);
  473.                             }
  474.                         }
  475.                     }
  476.                     else {
  477.                         // Handler object has not yet been asked for the real object
  478.                         // Stack the parse record until the second pass
  479.                         isTopObjectResolved = false;
  480.                         topStack = new SerStack("Top ParseRecords");
  481.                         InternalST.Soap(this, "ParseObject Handler Push " + pr.PRname);
  482.                         topStack.Push(pr.Copy());
  483.                         return;
  484.                     }
  485.                 }
  486.                 else if (formatterEnums.FEtopObject != null) {
  487.                     // SoapMessage will be used as the real object
  488.                     InternalST.Soap(this, "ParseObject FakeTopObject with SoapMessage ");
  489.                     if (isTopObjectSecondPass) {
  490.                         // This creates a the SoapMessage object as the real object, at this point it is an unitialized object.
  491.                         pr.PRnewObj = new InternalSoapMessage();
  492.                         pr.PRdtType = typeof(InternalSoapMessage);
  493.                         CheckSecurity(pr);
  494.                         if (formatterEnums.FEtopObject != null) {
  495.                             ISoapMessage soapMessage = (ISoapMessage)formatterEnums.FEtopObject;
  496.                             pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, soapMessage.ParamNames, soapMessage.ParamTypes, pr.PRassemblyName);
  497.                         }
  498.                     }
  499.                     else {
  500.                         // Stack the parse record until the second pass
  501.                         isTopObjectResolved = false;
  502.                         topStack = new SerStack("Top ParseRecords");
  503.                         topStack.Push(pr.Copy());
  504.                         return;
  505.                     }
  506.                 }
  507.             }
  508.             else if (pr.PRdtType == Converter.typeofString) {
  509.                 // String as a top level object
  510.                 if (pr.PRvalue != null) {
  511.                     pr.PRnewObj = pr.PRvalue;
  512.                     if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  513.                         InternalST.Soap(this, "ParseObject String as top level, Top Object Resolved");
  514.                         isTopObjectResolved = true;
  515.                         topObject = pr.PRnewObj;
  516.                         //stack.Pop();
  517.                         return;
  518.                     }
  519.                     else {
  520.                         InternalST.Soap(this, "ParseObject String as an object");
  521.                         stack.Pop();
  522.                         RegisterObject(pr.PRnewObj, pr, (ParseRecord)stack.Peek());
  523.                         return;
  524.                     }
  525.                 }
  526.                 else {
  527.                     // xml Doesn't have the value until later
  528.                     return;
  529.                 }
  530.             }
  531.             else {
  532.                 if (pr.PRdtType == null) {
  533.                     ParseRecord objectPr = (ParseRecord)stack.Peek();
  534.                     if (objectPr.PRdtType == Converter.typeofSoapFault) {
  535.                         InternalST.Soap(this, "ParseObject unknown SoapFault detail");
  536.                         throw new ServerException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_SoapFault"), faultString));
  537.                     }
  538.                    
  539.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TypeElement"), pr.PRname));
  540.                 }
  541.                 CheckSerializable(pr.PRdtType);
  542.                 if (IsRemoting && formatterEnums.FEsecurityLevel != TypeFilterLevel.Full)
  543.                     pr.PRnewObj = FormatterServices.GetSafeUninitializedObject(pr.PRdtType);
  544.                 else
  545.                     pr.PRnewObj = FormatterServices.GetUninitializedObject(pr.PRdtType);
  546.                
  547.                 CheckSecurity(pr);
  548.                 // Run the OnDeserializing methods
  549.                 m_objectManager.RaiseOnDeserializingEvent(pr.PRnewObj);
  550.                
  551.             }
  552.            
  553.             if (pr.PRnewObj == null)
  554.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TopObjectInstantiate"), pr.PRdtType));
  555.            
  556.             long genId = pr.PRobjectId;
  557.             if (genId < 1)
  558.                 pr.PRobjectId = GetId("GenId-" + objectIds);
  559.            
  560.            
  561.             if (IsFakeTopObject && pr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  562.                 InternalST.Soap(this, "ParseObject fake Top object resolved ", pr.PRnewObj);
  563.                 isTopObjectResolved = true;
  564.                 topObject = pr.PRnewObj;
  565.             }
  566.            
  567.             if (pr.PRobjectInfo == null)
  568.                 pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, pr.PRassemblyName);
  569.             pr.PRobjectInfo.obj = pr.PRnewObj;
  570.            
  571.             if (IsFakeTopObject && pr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  572.                 InternalST.Soap(this, "ParseObject AddValue to fake object ", pr.PRobjectInfo.obj);
  573.                 // Add the methodName to top object, either InternalSoapMessage or object returned by handler
  574.                 pr.PRobjectInfo.AddValue("__methodName", pr.PRname);
  575.                 pr.PRobjectInfo.AddValue("__keyToNamespaceTable", soapHandler.keyToNamespaceTable);
  576.                 pr.PRobjectInfo.AddValue("__paramNameList", pr.PRobjectInfo.SetFakeObject());
  577.                 if (formatterEnums.FEtopObject != null)
  578.                     pr.PRobjectInfo.AddValue("__xmlNameSpace", pr.PRxmlNameSpace);
  579.             }
  580.            
  581.             InternalST.Soap(this, "ParseObject Exit ");
  582.         }
  583.        
  584.        
  585.         private bool IsWhiteSpace(string value)
  586.         {
  587.             for (int i = 0; i < value.Length; i++) {
  588.                 if (value[i] == ' ' || value[i] == '\n' || value[i] == '\r')
  589.                     continue;
  590.                 else
  591.                     return false;
  592.             }
  593.             return true;
  594.         }
  595.        
  596.         // End of object encountered in stream
  597.        
  598.         private void ParseObjectEnd(ParseRecord pr)
  599.         {
  600.             InternalST.Soap(this, "ParseObjectEnd Entry ", pr.Trace());
  601.             ParseRecord objectPr = (ParseRecord)stack.Peek();
  602.             if (objectPr == null)
  603.                 objectPr = pr;
  604.            
  605.            
  606.             //BCLDebug.Assert(objectPr != null, "[System.Runtime.Serialization.Formatters.ParseObjectEnd]objectPr != null");
  607.            
  608.             InternalST.Soap(this, "ParseObjectEnd objectPr ", objectPr.Trace());
  609.            
  610.             if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  611.                 InternalST.Soap(this, "ParseObjectEnd Top Object dtType ", objectPr.PRdtType);
  612.                 if (objectPr.PRdtType == Converter.typeofString) {
  613.                     InternalST.Soap(this, "ParseObjectEnd Top String");
  614.                     if (objectPr.PRvalue == null)
  615.                         objectPr.PRvalue = String.Empty;
  616.                     // Not a null object, but an empty string
  617.                     objectPr.PRnewObj = objectPr.PRvalue;
  618.                     CheckSecurity(objectPr);
  619.                     isTopObjectResolved = true;
  620.                     topObject = objectPr.PRnewObj;
  621.                     return;
  622.                 }
  623.                 else if (objectPr.PRdtType != null && objectPr.PRvalue != null && !IsWhiteSpace(objectPr.PRvalue) && (objectPr.PRdtType.IsPrimitive || objectPr.PRdtType == Converter.typeofTimeSpan)) {
  624.                     // When an xsd type is transmitted as a top level string <xsd:int>111</xsd:int>
  625.                     objectPr.PRnewObj = Converter.FromString(objectPr.PRvalue, Converter.ToCode(objectPr.PRdtType));
  626.                     CheckSecurity(objectPr);
  627.                     isTopObjectResolved = true;
  628.                     topObject = objectPr.PRnewObj;
  629.                     return;
  630.                    
  631.                 }
  632.                 else if ((!isTopObjectResolved) && (objectPr.PRdtType != Converter.typeofSoapFault)) {
  633.                     InternalST.Soap(this, "ParseObjectEnd Top but not String");
  634.                     // Need to keep top record on object stack until finished building top stack
  635.                     topStack.Push(pr.Copy());
  636.                     // Note this is PRparseRecordId and not objectId
  637.                     if (objectPr.PRparseRecordId == pr.PRparseRecordId) {
  638.                         // This handles the case of top stack containing nested objects and
  639.                         // referenced objects. If nested objects the objects are not placed
  640.                         // on stack, only topstack. If referenced objects they are placed on
  641.                         // stack and need to be popped.
  642.                         stack.Pop();
  643.                     }
  644.                     return;
  645.                 }
  646.             }
  647.            
  648.             stack.Pop();
  649.            
  650.             ParseRecord parentPr = (ParseRecord)stack.Peek();
  651.            
  652.             if (objectPr.PRobjectTypeEnum == InternalObjectTypeE.Array) {
  653.                 if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  654.                     InternalST.Soap(this, "ParseObjectEnd Top Object (Array) Resolved");
  655.                     isTopObjectResolved = true;
  656.                     topObject = objectPr.PRnewObj;
  657.                 }
  658.                
  659.                 InternalST.Soap(this, "ParseArray RegisterObject ", objectPr.PRobjectId, " ", objectPr.PRnewObj.GetType());
  660.                 RegisterObject(objectPr.PRnewObj, objectPr, parentPr);
  661.                
  662.                 return;
  663.             }
  664.            
  665.             if (objectPr.PRobjectInfo != null) {
  666.                 objectPr.PRobjectInfo.PopulateObjectMembers();
  667.             }
  668.            
  669.             if (objectPr.PRnewObj == null) {
  670.                 if (objectPr.PRdtType == Converter.typeofString) {
  671.                     InternalST.Soap(this, "ParseObjectEnd String ");
  672.                     if (objectPr.PRvalue == null)
  673.                         objectPr.PRvalue = String.Empty;
  674.                     // Not a null object, but an empty string
  675.                     objectPr.PRnewObj = objectPr.PRvalue;
  676.                     CheckSecurity(objectPr);
  677.                 }
  678.                 else
  679.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_ObjectMissing"), pr.PRname));
  680.             }
  681.            
  682.             // Registration is after object is populated
  683.             if (!objectPr.PRisRegistered && objectPr.PRobjectId > 0) {
  684.                 InternalST.Soap(this, "ParseObjectEnd Register Object ", objectPr.PRobjectId, " ", objectPr.PRnewObj.GetType());
  685.                 RegisterObject(objectPr.PRnewObj, objectPr, parentPr);
  686.             }
  687.            
  688.             if (objectPr.PRisValueTypeFixup) {
  689.                 InternalST.Soap(this, "ParseObjectEnd ValueTypeFixup ", objectPr.PRnewObj.GetType());
  690.                 ValueFixup fixup = (ValueFixup)valueFixupStack.Pop();
  691.                 //Value fixup
  692.                 fixup.Fixup(objectPr, parentPr);
  693.                 // Value fixup
  694.             }
  695.            
  696.             if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  697.                 InternalST.Soap(this, "ParseObjectEnd Top Object Resolved ", objectPr.PRnewObj.GetType());
  698.                 isTopObjectResolved = true;
  699.                 topObject = objectPr.PRnewObj;
  700.             }
  701.            
  702.             if (objectPr.PRnewObj is SoapFault)
  703.                 soapFaultId = objectPr.PRobjectId;
  704.            
  705.             if (objectPr.PRobjectInfo != null) {
  706.                 if (objectPr.PRobjectInfo.bfake && !objectPr.PRobjectInfo.bSoapFault)
  707.                     objectPr.PRobjectInfo.AddValue("__fault", null);
  708.                 // need this because SerializationObjectInfo throws an exception if a name being referenced is missing
  709.                 objectPr.PRobjectInfo.ObjectEnd();
  710.             }
  711.            
  712.             InternalST.Soap(this, "ParseObjectEnd Exit ", objectPr.PRnewObj, " id: ", objectPr.PRobjectId);
  713.         }
  714.        
  715.        
  716.        
  717.         // Array object encountered in stream
  718.         private void ParseArray(