ObjectReader

1. // ==++==
2. // 
3. //   
4. //    Copyright (c) 2002 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 {
26.     using System;
27.     using System.IO;
28.     using System.Reflection;
29.     using System.Collections;
30.     using System.Text;
31.     using System.Runtime.Remoting;
32.     using System.Runtime.Remoting.Metadata.W3cXsd2001;
33.     using System.Runtime.Remoting.Messaging;    
34.     using System.Runtime.Serialization;
35.     using System.Security;
36.     using System.Security.Permissions;
37.     using System.Diagnostics;
38.     using System.Globalization;
40.     internal sealed class ObjectReader
41.     {
43.         // System.Serializer information
44.         internal ObjectIDGenerator m_idGenerator;
45.         internal Stream m_stream;
46.         internal ISurrogateSelector m_surrogates;
47.         internal StreamingContext m_context;
48.         internal ObjectManager m_objectManager;
49.         internal InternalFE formatterEnums;
50.         internal SerializationBinder m_binder;
52.         internal SoapHandler soapHandler; //Set from SoapHandler
54.         // Fake Top object and headers
55.         internal long topId = 0;
56.         internal SerStack topStack; // Stack for placing ProcessRecords if the top record cannot be serialized on the first pass.
57.         internal bool isTopObjectSecondPass = false;
58.         internal bool isTopObjectResolved = true;
59.         internal bool isHeaderHandlerCalled = false;
60.         internal Exception deserializationSecurityException = null;
61.         internal Object handlerObject = null;
62.         internal Object topObject;
63.         internal long soapFaultId;
64.         internal Header[] headers;
65.         internal Header[] newheaders;
66.         internal bool IsFakeTopObject = false;
67.         internal HeaderHandler handler;
68.         internal SerObjectInfoInit serObjectInfoInit = null;
69.         internal IFormatterConverter m_formatterConverter = null;
71.         // Stack of Object ParseRecords
72.         internal SerStack stack = new SerStack("ObjectReader Object Stack");
74.         // ValueType Fixup Stack
75.         internal SerStack valueFixupStack = new SerStack("ValueType Fixup Stack");
77.         // Generate Object Id's
78.         internal Hashtable objectIdTable = new Hashtable(25); // holds the keyId value from the XML input and associated internal Id
79.         internal long objectIds = 0;
81.         internal int paramPosition = 0; //Position of parameter if soap top fake record.
83.         internal int majorVersion = 0;
84.         internal int minorVersion = 0;
86.         internal String faultString = null;
88.         // GetType - eliminate redundant Type.GetType()
89.         //internal Hashtable typeTable = new Hashtable(10);     
91.         internal static SecurityPermission serializationPermission = new SecurityPermission(SecurityPermissionFlag.SerializationFormatter);
94.         
95.         internal ObjectReader(Stream stream, ISurrogateSelector selector, StreamingContext context, InternalFE formatterEnums, SerializationBinder binder)
96.         {
97.             InternalST.Soap( this, "Constructor ISurrogateSelector ",((selector == null)?"null selector ":"selector present"));                 
99.             if (stream==null)
100.             {
101.                 throw new ArgumentNullException("stream", SoapUtil.GetResourceString("ArgumentNull_Stream"));
102.             }
104.             m_stream=stream;
105.             m_surrogates = selector;
106.             m_context = context;
107.             m_binder =  binder;
108.             this.formatterEnums = formatterEnums;
110.             InternalST.Soap( this, "Constructor formatterEnums.FEtopObject ",formatterEnums.FEtopObject);
111.             if (formatterEnums.FEtopObject != null) 
112.                 IsFakeTopObject = true;
113.             else
114.                 IsFakeTopObject = false;
116.             m_formatterConverter = new FormatterConverter();
117.         }
120.         private ObjectManager GetObjectManager() {
121.             new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).Assert();
122.             return new ObjectManager(m_surrogates, m_context);
123.       }
128.         // Deserialize the stream into an object graph.
129.         internal Object Deserialize(HeaderHandler handler, ISerParser serParser)
130.         {
132.             InternalST.Soap( this, "Deserialize Entry handler", handler);
134.             if (serParser == null)
135.                 throw new ArgumentNullException("serParser", String.Format(SoapUtil.GetResourceString("ArgumentNull_WithParamName"), serParser));
138.             deserializationSecurityException = null;
139.             try {
140.                 serializationPermission.Demand();
141.             } catch(Exception e ) {
142.                 deserializationSecurityException = e;
143.             }
145.             this.handler = handler;
146.             isTopObjectSecondPass = false;
147.             isHeaderHandlerCalled = false;
149.             if (handler != null)
150.                 IsFakeTopObject = true;
152.             m_idGenerator = new ObjectIDGenerator();
155.             m_objectManager = GetObjectManager();
157.             serObjectInfoInit = new SerObjectInfoInit();
158.             objectIdTable.Clear();
159.             objectIds = 0;
161.             // Will call back to ParseObject, ParseHeader for each object found
162.             serParser.Run();
164.             if (handler != null)
165.             {
166.                 InternalST.Soap( this, "Deserialize Fixup Before Delegate Invoke");         
167.                 m_objectManager.DoFixups(); // Fixup for headers
169.                 // Header handler isn't invoked until method name is known from body fake record
170.                 // Except for SoapFault, in which case it is invoked below
171.                 if (handlerObject == null)
172.                 {
173.                     InternalST.Soap( this, "Deserialize Before SoapFault Delegate Invoke ");
174.                     handlerObject = handler(newheaders);
175.                     InternalST.Soap( this, "Deserialize after SoapFault Delegate Invoke");
176.                 }
179.                 // SoapFault creation Create a fake Pr for the handlerObject to use.
180.                 // Create a member for the fake pr with name __fault;
181.                 if ((soapFaultId > 0) && (handlerObject != null))
182.                 {
183.                     InternalST.Soap( this, "Deserialize SoapFault ");
184.                     topStack = new SerStack("Top ParseRecords");                
185.                     ParseRecord pr = new ParseRecord();
186.                     pr.PRparseTypeEnum = InternalParseTypeE.Object;
187.                     pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
188.                     pr.PRparseStateEnum = InternalParseStateE.Object;
189.                     pr.PRname = "Response";
190.                     topStack.Push(pr);
191.                     pr = new ParseRecord();
192.                     pr.PRparseTypeEnum = InternalParseTypeE.Member;
193.                     pr.PRobjectPositionEnum = InternalObjectPositionE.Child;
194.                     pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
195.                     pr.PRmemberValueEnum = InternalMemberValueE.Reference;
196.                     pr.PRparseStateEnum = InternalParseStateE.Member;
197.                     pr.PRname = "__fault";
198.                     pr.PRidRef = soapFaultId;
199.                     topStack.Push(pr);
200.                     pr = new ParseRecord();
201.                     pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
202.                     pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
203.                     pr.PRparseStateEnum = InternalParseStateE.Object;
204.                     pr.PRname = "Response";
205.                     topStack.Push(pr);
206.                     isTopObjectResolved = false;
207.                 }
208.             }
211.             // Resolve fake top object if necessary
212.             if (!isTopObjectResolved)
213.             {
214.                 //resolve top object
215.                 InternalST.Soap( this, "Deserialize TopObject Second Pass");                
216.                 isTopObjectSecondPass = true;
217.                 topStack.Reverse();
218.                 // The top of the stack now contains the fake record
219.                 // When it is Parsed, the handler object will be substituted
220.                 // for it in ParseObject.
221.                 int topStackLength = topStack.Count();
222.                 ParseRecord pr = null;
223.                 for (int i=0; i<topStackLength; i++)
224.                 {
225.                     pr = (ParseRecord)topStack.Pop();
226.                     Parse(pr);
227.                 }
228.             }
231.             InternalST.Soap( this, "Deserialize Finished Parsing DoFixups");
233.             m_objectManager.DoFixups();
235.             if (topObject == null)
236.                 throw new SerializationException(SoapUtil.GetResourceString("Serialization_TopObject"));
238.             if (topObject is IObjectReference) {
239.                 topObject = ((IObjectReference)topObject).GetRealObject(m_context);
240.             }       
242.             InternalST.Soap( this, "Deserialize Exit ",topObject);
244.             m_objectManager.RaiseDeserializationEvent();
246.             if ((formatterEnums.FEtopObject != null) &
247.                   (topObject is InternalSoapMessage))
250.             {
251.                 // Convert InternalSoapMessage to SoapMessage           
252.                 InternalST.Soap( this, "Deserialize SoapMessage Entry ");           
254.                 InternalSoapMessage ismc = (InternalSoapMessage)topObject;
255.                 ISoapMessage smc = (ISoapMessage)formatterEnums.FEtopObject;
256.                 smc.MethodName = ismc.methodName;
257.                 smc.XmlNameSpace = ismc.xmlNameSpace;
258.                 smc.ParamNames = ismc.paramNames;
259.                 smc.ParamValues = ismc.paramValues;
260.                 smc.Headers = headers;
261.                 topObject = smc;
262.                 isTopObjectResolved = true;
263.                 InternalST.Soap( this, "Deserialize SoapMessage Exit topObject ",topObject," method name ",smc.MethodName);                         
264.             }
266.             return topObject;
267.         }
269.         internal ReadObjectInfo CreateReadObjectInfo(Type objectType, String assemblyName)
270.         {
271.             ReadObjectInfo objectInfo = ReadObjectInfo.Create(objectType, m_surrogates, m_context, m_objectManager, serObjectInfoInit, m_formatterConverter, assemblyName);
272.             objectInfo.SetVersion(majorVersion, minorVersion);
273.             return objectInfo;
274.         }
276.         internal ReadObjectInfo CreateReadObjectInfo(Type objectType, String[] memberNames, String assemblyName)
277.         {
278.             ReadObjectInfo objectInfo = ReadObjectInfo.Create(objectType, memberNames, null, m_surrogates, m_context, m_objectManager, serObjectInfoInit, m_formatterConverter, assemblyName);
279.             objectInfo.SetVersion(majorVersion, minorVersion);
280.             return objectInfo;
281.         }
283.         internal ReadObjectInfo CreateReadObjectInfo(Type objectType, String[] memberNames, Type[] memberTypes, String assemblyName)
284.         {
285.             ReadObjectInfo objectInfo = ReadObjectInfo.Create(objectType, memberNames, memberTypes, m_surrogates, m_context, m_objectManager, serObjectInfoInit, m_formatterConverter, assemblyName);
286.             objectInfo.SetVersion(majorVersion, minorVersion);
287.             return objectInfo;
288.         }
291.         // Main Parse routine, called by the XML Parse Handlers in XMLParser and also called internally to
292.         // parse the fake top object.
293.         internal void Parse(ParseRecord pr)
294.         {
295.             InternalST.Soap( this, "Parse Entry");
296.             stack.Dump();
297.             pr.Dump();
299.             switch(pr.PRparseTypeEnum)
300.             {
301.                 case InternalParseTypeE.SerializedStreamHeader:
302.                     ParseSerializedStreamHeader(pr);
303.                     break;
304.                 case InternalParseTypeE.SerializedStreamHeaderEnd:
305.                     ParseSerializedStreamHeaderEnd(pr);
306.                     break;                  
307.                 case InternalParseTypeE.Object:
308.                     ParseObject(pr);
309.                     break;
310.                 case InternalParseTypeE.ObjectEnd:
311.                     ParseObjectEnd(pr);
312.                     break;
313.                 case InternalParseTypeE.Member:
314.                     ParseMember(pr);
315.                     break;
316.                 case InternalParseTypeE.MemberEnd:
317.                     ParseMemberEnd(pr);
318.                     break;
319.                 case InternalParseTypeE.Body:
320.                 case InternalParseTypeE.BodyEnd:
321.                 case InternalParseTypeE.Envelope:
322.                 case InternalParseTypeE.EnvelopeEnd:
323.                     break;
324.                 case InternalParseTypeE.Empty:
325.                 default:
326.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_XMLElement"), pr.PRname));                 
328.             }
329.         }
331.         // Styled ParseError output
332.         private void ParseError(ParseRecord processing, ParseRecord onStack)
333.         {
334.             InternalST.Soap( this, " ParseError ",processing," ",onStack);
335.             throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_ParseError"),onStack.PRname+" "+((Enum)onStack.PRparseTypeEnum).ToString()+" "+processing.PRname+" "+((Enum)processing.PRparseTypeEnum).ToString()));                              
336.         }
338.         // Parse the SerializedStreamHeader element. This is the first element in the stream if present
339.         private void ParseSerializedStreamHeader(ParseRecord pr)
340.         {
341.             InternalST.Soap( this, "SerializedHeader ",pr);
342.             stack.Push(pr);
343.         }
345.         // Parse the SerializedStreamHeader end element. This is the last element in the stream if present
346.         private void ParseSerializedStreamHeaderEnd(ParseRecord pr)
347.         {
348.             InternalST.Soap( this, "SerializedHeaderEnd ",pr);
349.             stack.Pop();
350.         }
353.         private bool IsRemoting {
354.             get {
355.                 //return (m_context.State & (StreamingContextStates.Persistence|StreamingContextStates.File|StreamingContextStates.Clone)) == 0;
356.                 return  IsFakeTopObject;
357.             }
358.         }
359.     
360.         private void CheckSecurity(ParseRecord pr)
361.          {
362.             InternalST.SoapAssert(pr!=null, "[BinaryObjectReader.CheckSecurity]pr!=null");
363.             Type t = pr.PRdtType;
365.             if (t != null && IsRemoting){
366.                 if (typeof(MarshalByRefObject).IsAssignableFrom(t))
367.                     throw new ArgumentException(String.Format(SoapUtil.GetResourceString("Serialization_MBRAsMBV"), t.FullName));
368.             }
370.             //If we passed the security check, they can do whatever they'd like,
371.             //so we'll just short-circuit this.
372.             if (deserializationSecurityException==null) {
373.                 return;
374.             }
376.             // BaseTypes and Array of basetypes allowed
378.             if (t != null)
379.             {
380.                 if (t.IsPrimitive || t == Converter.typeofString)
381.                     return;
383.                 if (typeof(Enum).IsAssignableFrom(t))
384.                     return;
386.                 if (t.IsArray)
387.                 {
388.                     Type type = t.GetElementType();
389.                     if (type.IsPrimitive || type == Converter.typeofString)
390.                         return;
391.                 }
392.             }
394.             throw deserializationSecurityException;
395.         }
397.         // New object encountered in stream
398.         private void ParseObject(ParseRecord pr)
399.         {
400.             InternalST.Soap( this, "ParseObject Entry ");
402.             if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
403.                 topId = pr.PRobjectId;
405.             if (pr.PRparseTypeEnum == InternalParseTypeE.Object)
406.             {
407.                 InternalST.Soap( this, "ParseObject Push "+pr.PRname);
408.                 stack.Push(pr); // Nested objects member names are already on stack
409.             }
411.             if (pr.PRobjectTypeEnum == InternalObjectTypeE.Array)
412.             {
413.                 ParseArray(pr);
414.                 InternalST.Soap( this, "ParseObject Exit, ParseArray ");
415.                 return;
416.             }
418.             if ((pr.PRdtType == null) && !IsFakeTopObject)
419.                 throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TopObjectInstantiate"),pr.PRname));
422.             if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top && IsFakeTopObject && pr.PRdtType != Converter.typeofSoapFault)
423.             {
425.                 // Soap fake top object
426.                 if (handler != null) 
427.                 {
428.                     // Handler object will supply real top object
429.                     InternalST.Soap( this, "ParseObject FakeTopObject with handlerObject ");    
431.                     // Now know the method name, can call header handler 
432.                     //Create header for method name
433.                     if (!isHeaderHandlerCalled)
434.                     {
435.                         newheaders = null;
436.                         isHeaderHandlerCalled = true;
437.                         if (headers == null)
438.                         {
439.                             newheaders = new Header[1];
440.                         }
441.                         else
442.                         {
443.                             newheaders = new Header[headers.Length+1];
444.                             Array.Copy(headers, 0, newheaders, 1, headers.Length);
445.                         }
447.                         Header methodNameHeader = new Header("__methodName", pr.PRname, false, pr.PRnameXmlKey);
448.                         newheaders[0] = methodNameHeader;
449.                         InternalST.Soap( this, "Deserialize Before Delegate Invoke ");
450.                         handlerObject = handler(newheaders);
452.                         InternalST.Soap( this, "Deserialize after Delegate Invoke");
453.                         InternalST.Soap( this, "Deserialize delgate object ",((handlerObject == null)?"null":handlerObject));                   
454.                     }
456.                     if (isHeaderHandlerCalled)
457.                     {
458.                         // Handler object has supplied the real object for the fake object
459.                         // which is on top of the stack
460.                         pr.PRnewObj = handlerObject;
461.                         pr.PRdtType = handlerObject.GetType();
462.                         CheckSecurity(pr);
463.                         if (pr.PRnewObj is IFieldInfo)
464.                         {
465.                             IFieldInfo fi = (IFieldInfo)pr.PRnewObj;
466.                             if ((fi.FieldTypes != null) && (fi.FieldTypes.Length > 0))
467.                             {
468.                                 pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, fi.FieldNames, fi.FieldTypes, pr.PRassemblyName);
469.                             }
470.                         }                       
471.                     }
472.                     else
473.                     {
474.                         // Handler object has not yet been asked for the real object
475.                         // Stack the parse record until the second pass
476.                         isTopObjectResolved = false;
477.                         topStack = new SerStack("Top ParseRecords");
478.                         InternalST.Soap( this, "ParseObject Handler Push "+pr.PRname);
479.                         topStack.Push(pr.Copy());
480.                         return;
481.                     }
482.                 }
483.                 else if (formatterEnums.FEtopObject != null)
484.                 {
485.                     // SoapMessage will be used as the real object
486.                     InternalST.Soap( this, "ParseObject FakeTopObject with SoapMessage ");                                  
487.                     if (isTopObjectSecondPass)
488.                     {
489.                         // This creates a the SoapMessage object as the real object, at this point it is an unitialized object.
490.                         pr.PRnewObj = new InternalSoapMessage();
491.                         pr.PRdtType = typeof(InternalSoapMessage);
492.                         CheckSecurity(pr);
493.                         if (formatterEnums.FEtopObject != null)
494.                         {
495.                             ISoapMessage soapMessage = (ISoapMessage)formatterEnums.FEtopObject;
496.                             pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, soapMessage.ParamNames, soapMessage.ParamTypes, pr.PRassemblyName);
497.                         }
498.                     }
499.                     else
500.                     {
501.                         // Stack the parse record until the second pass
502.                         isTopObjectResolved = false;
503.                         topStack = new SerStack("Top ParseRecords");
504.                         topStack.Push(pr.Copy());
505.                         return;
506.                     }
507.                 }
508.             }
509.             else if (pr.PRdtType == Converter.typeofString)
510.             {
511.                 // String as a top level object
512.                 if (pr.PRvalue != null)
513.                 {
514.                     pr.PRnewObj = pr.PRvalue;
515.                     if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
516.                     {
517.                         InternalST.Soap( this, "ParseObject String as top level, Top Object Resolved");
518.                         isTopObjectResolved = true;
519.                         topObject = pr.PRnewObj;
520.                         //stack.Pop();
521.                         return;
522.                     }
523.                     else
524.                     {
525.                         InternalST.Soap( this, "ParseObject  String as an object");
526.                         stack.Pop();                        
527.                         RegisterObject(pr.PRnewObj, pr, (ParseRecord)stack.Peek());                         
528.                         return;
529.                     }
530.                 }
531.                 else
532.                 {
533.                     // xml Doesn't have the value until later
534.                     return;
535.                 }
536.             }
537.             else 
538.             {
539.                 if (pr.PRdtType == null)
540.                 {
541.                     ParseRecord objectPr = (ParseRecord)stack.Peek();
542.                     if (objectPr.PRdtType == Converter.typeofSoapFault)
543.                     {
544.                         InternalST.Soap( this, "ParseObject unknown SoapFault detail");
545.                         throw new ServerException(String.Format(SoapUtil.GetResourceString("Serialization_SoapFault"),faultString));                
546.                     }
548.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname));             
549.                 }
551.                 pr.PRnewObj = FormatterServices.GetUninitializedObject(pr.PRdtType);    
552.                 CheckSecurity(pr);
553.             }
555.             if (pr.PRnewObj == null)
556.                 throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TopObjectInstantiate"),pr.PRdtType));              
558.             long genId = pr.PRobjectId;
559.             if (genId < 1)
560.                 pr.PRobjectId = GetId("GenId-"+objectIds);
563.             if (IsFakeTopObject && pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
564.             {
565.                 InternalST.Soap( this, "ParseObject fake Top object resolved ",pr.PRnewObj);
566.                 isTopObjectResolved = true;
567.                 topObject = pr.PRnewObj;
568.             }
570.             if (pr.PRobjectInfo == null)
571.                 pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, pr.PRassemblyName);
572.             pr.PRobjectInfo.obj = pr.PRnewObj;
574.             if (IsFakeTopObject && pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
575.             {
576.                 InternalST.Soap( this, "ParseObject AddValue to fake object ",pr.PRobjectInfo.obj);
577.                 // Add the methodName to top object, either InternalSoapMessage or object returned by handler
578.                 pr.PRobjectInfo.AddValue("__methodName", pr.PRname);
579.                 pr.PRobjectInfo.AddValue("__keyToNamespaceTable", soapHandler.keyToNamespaceTable);
580.                 pr.PRobjectInfo.AddValue("__paramNameList", pr.PRobjectInfo.SetFakeObject());
581.                 if (formatterEnums.FEtopObject != null)
582.                     pr.PRobjectInfo.AddValue("__xmlNameSpace", pr.PRxmlNameSpace);
583.             }
585.             InternalST.Soap( this, "ParseObject Exit ");        
586.         }
589.         private bool IsWhiteSpace(String value)
590.         {
591.             for (int i=0; i<value.Length; i++)
592.             {
593.                 if (value[i] == ' ' || value[i] == '/n' || value[i] == '/r')
594.                     continue;
595.                 else
596.                     return false;
597.             }
598.             return true;
599.         }
601.         // End of object encountered in stream
602.         
603.         private void ParseObjectEnd(ParseRecord pr)
604.         {
605.             InternalST.Soap( this, "ParseObjectEnd Entry ",pr.Trace());
606.             ParseRecord objectPr = (ParseRecord)stack.Peek();
607.             if (objectPr == null)
608.                 objectPr = pr;
611.             //BCLDebug.Assert(objectPr != null, "[System.Runtime.Serialization.Formatters.ParseObjectEnd]objectPr != null");
613.             InternalST.Soap( this, "ParseObjectEnd objectPr ",objectPr.Trace());
615.             if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top) 
616.             {
617.                 InternalST.Soap( this, "ParseObjectEnd Top Object dtType ",objectPr.PRdtType);
618.                 if (objectPr.PRdtType == Converter.typeofString)
619.                 {
620.                     InternalST.Soap( this, "ParseObjectEnd Top String");
621.                     if (objectPr.PRvalue == null)
622.                         objectPr.PRvalue = String.Empty; // Not a null object, but an empty string
624.                     objectPr.PRnewObj = objectPr.PRvalue;
625.                     CheckSecurity(objectPr);
626.                     isTopObjectResolved = true;
627.                     topObject = objectPr.PRnewObj;
628.                     return;
629.                 }
630.                 else if (objectPr.PRdtType != null  && objectPr.PRvalue != null && !IsWhiteSpace(objectPr.PRvalue) && (objectPr.PRdtType.IsPrimitive || objectPr.PRdtType == Converter.typeofTimeSpan))
631.                 {
632.                     // When an xsd type is transmitted as a top level string <xsd:int>111</xsd:int>
633.                     objectPr.PRnewObj = Converter.FromString(objectPr.PRvalue, Converter.ToCode(objectPr.PRdtType));
634.                     CheckSecurity(objectPr);
635.                     isTopObjectResolved = true;
636.                     topObject = objectPr.PRnewObj;
637.                     return;
639.                 }
640.                 else if ((!isTopObjectResolved) && (objectPr.PRdtType != Converter.typeofSoapFault))
641.                 {
642.                     InternalST.Soap( this, "ParseObjectEnd Top but not String");                    
643.                     // Need to keep top record on object stack until finished building top stack
644.                     topStack.Push(pr.Copy());
645.                     // Note this is PRparseRecordId and not objectId
646.                     if (objectPr.PRparseRecordId == pr.PRparseRecordId)
647.                     {
648.                         // This handles the case of top stack containing nested objects and
649.                         // referenced objects. If nested objects the objects are not placed
650.                         // on stack, only topstack. If referenced objects they are placed on
651.                         // stack and need to be popped.
652.                         stack.Pop();
653.                     }
654.                     return;
655.                 }
656.             }
658.             stack.Pop();
660.             ParseRecord parentPr = (ParseRecord)stack.Peek();
662.             if (objectPr.PRobjectTypeEnum == InternalObjectTypeE.Array)
663.             {
664.                 if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top)
665.                 {
666.                     InternalST.Soap( this, "ParseObjectEnd  Top Object (Array) Resolved");
667.                     isTopObjectResolved = true;
668.                     topObject = objectPr.PRnewObj;
669.                 }
671.                 InternalST.Soap( this, "ParseArray  RegisterObject ",objectPr.PRobjectId," ",objectPr.PRnewObj.GetType());
672.                 RegisterObject(objectPr.PRnewObj, objectPr, parentPr);                  
674.                 return;
675.             }
677.             if (objectPr.PRobjectInfo != null)
678.             {
679.                 objectPr.PRobjectInfo.PopulateObjectMembers();
680.             }
682.             if (objectPr.PRnewObj == null)
683.             {
684.                 if (objectPr.PRdtType == Converter.typeofString)
685.                 {
686.                     InternalST.Soap( this, "ParseObjectEnd String ");
687.                     if (objectPr.PRvalue == null)
688.                         objectPr.PRvalue = String.Empty; // Not a null object, but an empty string
689.                     objectPr.PRnewObj = objectPr.PRvalue;
690.                     CheckSecurity(objectPr);
691.                 }
692.                 else
693.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_ObjectMissing"),pr.PRname));               
694.             }
696.             // Registration is after object is populated
697.             if (!objectPr.PRisRegistered && objectPr.PRobjectId > 0)
698.             {
699.                 InternalST.Soap( this, "ParseObjectEnd Register Object ",objectPr.PRobjectId," ",objectPr.PRnewObj.GetType());
700.                 RegisterObject(objectPr.PRnewObj, objectPr, parentPr);
701.             }
703.             if (objectPr.PRisValueTypeFixup)
704.             {
705.                 InternalST.Soap( this, "ParseObjectEnd  ValueTypeFixup ",objectPr.PRnewObj.GetType());
706.                 ValueFixup fixup = (ValueFixup)valueFixupStack.Pop(); //Value fixup
707.                 fixup.Fixup(objectPr, parentPr);  // Value fixup
708.             }
710.             if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top)
711.             {
712.                 InternalST.Soap( this, "ParseObjectEnd  Top Object Resolved ",objectPr.PRnewObj.GetType());
713.                 isTopObjectResolved = true;
714.                 topObject = objectPr.PRnewObj;
715.             }
717.             if (objectPr.PRnewObj is SoapFault)
718.                 soapFaultId = objectPr.PRobjectId;
720.             if (objectPr.PRobjectInfo != null)
721.             {
722.                 if (objectPr.PRobjectInfo.bfake && !objectPr.PRobjectInfo.bSoapFault)
723.                     objectPr.PRobjectInfo.AddValue("__fault", null); // need this because SerializationObjectInfo throws an exception if a name being referenced is missing
725.                 objectPr.PRobjectInfo.ObjectEnd();
726.             }
728.             InternalST.Soap( this, "ParseObjectEnd  Exit ",objectPr.PRnewObj," id: ",objectPr.PRobjectId);      
729.         }
733.         // Array object encountered in stream
734.         private void ParseArray(ParseRecord pr)
735.         {
736.             InternalST.Soap( this, "ParseArray Entry");
737.             pr.Dump();
739.             long genId = pr.PRobjectId;
740.             if (genId < 1)
741.                 pr.PRobjectId = GetId("GenId-"+objectIds);
743.             if ((pr.PRarrayElementType != null) && (pr.PRarrayElementType.IsEnum))
744.                 pr.PRisEnum = true;
746.             if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
747.             {
748.                 if (pr.PRvalue == null)
749.                 {
750.                     pr.PRnewObj = new Byte[0];
751.                     CheckSecurity(pr);
752.                 }
753.                 else
754.                 {
755.                     // Used for arrays of Base64 and also for a parameter of Base64
756.                     InternalST.Soap( this, "ParseArray bin.base64 ",pr.PRvalue.Length," ",pr.PRvalue);
758.                     if (pr.PRdtType == Converter.typeofSoapBase64Binary)
759.                     {
760.                         // Parameter - Case where the return type is a SoapENC:base64 but the parameter type is xsd:base64Binary
761.                         pr.PRnewObj = SoapBase64Binary.Parse(pr.PRvalue);
762.                         CheckSecurity(pr);
763.                     }
764.                     else
765.                     {
766.                         // ByteArray
767.                         if (pr.PRvalue.Length > 0)
768.                         {
769.                             pr.PRnewObj = Convert.FromBase64String(FilterBin64(pr.PRvalue));
770.                             CheckSecurity(pr);
771.                         }
772.                         else
773.                         {
774.                             pr.PRnewObj = new Byte[0];
775.                             CheckSecurity(pr);
776.                         }
777.                     }
778.                 }
780.                 if (stack.Peek() == pr)
781.                 {
782.                     InternalST.Soap( this, "ParseArray, bin.base64 has been stacked");
783.                     stack.Pop();
784.                 }
785.                 if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
786.                 {
787.                     InternalST.Soap( this, "ParseArray, bin.base64 Top Object");
788.                     topObject = pr.PRnewObj;
789.                     isTopObjectResolved = true;
790.                 }
792.                 ParseRecord parentPr = (ParseRecord)stack.Peek();                                           
794.                 // Base64 can be registered at this point because it is populated
795.                 InternalST.Soap( this, "ParseArray  RegisterObject ",pr.PRobjectId," ",pr.PRnewObj.GetType());
796.                 RegisterObject(pr.PRnewObj, pr, parentPr);
798.             }
799.             else if ((pr.PRnewObj != null) && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
800.             {
801.                 // Primtive typed Array has already been read
802.                 if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
803.                 {
804.                     topObject = pr.PRnewObj;
805.                     isTopObjectResolved = true;
806.                 }
808.                 ParseRecord parentPr = (ParseRecord)stack.Peek();                                           
810.                 // Primitive typed array can be registered at this point because it is populated
811.                 InternalST.Soap( this, "ParseArray  RegisterObject ",pr.PRobjectId," ",pr.PRnewObj.GetType());
812.                 RegisterObject(pr.PRnewObj, pr, parentPr);
813.             }
814.             else if ((pr.PRarrayTypeEnum == InternalArrayTypeE.Jagged) || (pr.PRarrayTypeEnum == InternalArrayTypeE.Single))
815.             {
816.                 // Multidimensional jagged array or single array
817.                 InternalST.Soap( this, "ParseArray Before Jagged,Simple create ",pr.PRarrayElementType," ",(pr.PRrank >0?pr.PRlengthA[0].ToString():"0"));
818.                 if ((pr.PRlowerBoundA == null) || (pr.PRlowerBoundA[0] == 0))
819.                 {
820.                     pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, (pr.PRrank>0?pr.PRlengthA[0]:0));
821.                     pr.PRisLowerBound = false;
822.                 }
823.                 else
824.                 {
825.                     pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
826.                     pr.PRisLowerBound = true;
827.                 }
829.                 if (pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
830.                 {
831.                     if (!pr.PRisLowerBound && (Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode)))
832.                     {
833.                         pr.PRprimitiveArray = new PrimitiveArray(pr.PRarrayElementTypeCode, (Array)pr.PRnewObj);
834.                     }
835.                     else if (!pr.PRarrayElementType.IsValueType)
836.                         pr.PRobjectA = (Object[])pr.PRnewObj;
837.                 }
838.                 CheckSecurity(pr);
839.                     
840.                 InternalST.Soap( this, "ParseArray Jagged,Simple Array ",pr.PRnewObj.GetType());
842.                 // For binary, headers comes in as an array of header objects
843.                 if (pr.PRobjectPositionEnum == InternalObjectPositionE.Headers)
844.                 {
845.                     InternalST.Soap( this, "ParseArray header array");
846.                     headers = (Header[])pr.PRnewObj;
847.                 }
849.                 pr.PRindexMap = new int[1];
852.             }
853.             else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Rectangular)
854.             {
855.                 // Rectangle array
857.                 pr.PRisLowerBound = false;
858.                 if (pr.PRlowerBoundA != null)
859.                 {
860.                     for (int i=0; i<pr.PRrank; i++)
861.                     {
862.                         if (pr.PRlowerBoundA[i] != 0)
863.                             pr.PRisLowerBound = true;
864.                     }
865.                 }
868.                 if (!pr.PRisLowerBound)
869.                     pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA);
870.                 else
871.                     pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
872.                 CheckSecurity(pr);
874.                 InternalST.Soap( this, "ParseArray Rectangle Array ",pr.PRnewObj.GetType()," lower Bound ",pr.PRisLowerBound);
876.                 // Calculate number of items
877.                 int sum = 1;
878.                 for (int i=0; i<pr.PRrank; i++)
879.                 {
880.                     sum = sum*pr.PRlengthA[i];
881.                 }
882.                 pr.PRindexMap = new int[pr.PRrank];
883.                 pr.PRrectangularMap = new int[pr.PRrank];
884.                 pr.PRlinearlength = sum;
885.             }
886.             else
887.                 throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_ArrayType"),((Enum)pr.PRarrayTypeEnum).ToString()));                               
889.             InternalST.Soap( this, "ParseArray Exit");      
890.         }
893.         // Builds a map for each item in an incoming rectangle array. The map specifies where the item is placed in the output Array Object
895.         private void NextRectangleMap(ParseRecord pr)
896.         {
897.             // For each invocation, calculate the next rectangular array position
898.             // example
899.             // indexMap 0 [0,0,0]
900.             // indexMap 1 [0,0,1]
901.             // indexMap 2 [0,0,2]
902.             // indexMap 3 [0,0,3]
903.             // indexMap 4 [0,1,0]       
904.             for (int irank = pr.PRrank-1; irank>-1; irank--)
905.             {
906.                 // Find the current or lower dimension which can be incremented.
907.                 if (pr.PRrectangularMap[irank] < pr.PRlengthA[irank]-1)
908.                 {
909.                     // The current dimension is at maximum. Increase the next lower dimension by 1
910.                     pr.PRrectangularMap[irank]++;
911.                     if (irank < pr.PRrank-1)
912.                     {
913.                         // The current dimension and higher dimensions are zeroed.
914.                         for (int i = irank+1; i<pr.PRrank; i++)
915.                             pr.PRrectangularMap[i] = 0;
916.                     }
917.                     Array.Copy(pr.PRrectangularMap, pr.PRindexMap, pr.PRrank);              
918.                     break;                  
919.                 }
921.             }
922.         }
925.         // Array object item encountered in stream
926.         private void ParseArrayMember(ParseRecord pr)
927.         {
928.             InternalST.Soap( this, "ParseArrayMember Entry");
929.             ParseRecord objectPr = (ParseRecord)stack.Peek();
931.             // Set up for inserting value into correct array position
932.             if (objectPr.PRarrayTypeEnum == InternalArrayTypeE.Rectangular)
933.             {
935.                 if (objectPr.PRmemberIndex > 0)
936.                     NextRectangleMap(objectPr); // Rectangle array, calculate position in array
937.                 if (objectPr.PRisLowerBound)
938.                 {
939.                     for (int i=0; i<objectPr.PRrank; i++)
940.                     {
941.                         if (objectPr.PRpositionA == null)
942.                             objectPr.PRindexMap[i] = objectPr.PRrectangularMap[i] + objectPr.PRlowerBoundA[i];
943.                         else
944.                             objectPr.PRindexMap[i] = objectPr.PRpositionA[i];
945.                     }
946.                 }
947.             }
948.             else
949.             {
950.                 if (!objectPr.PRisLowerBound)
951.                 {
952.                     if (objectPr.PRpositionA == null)
953.                         objectPr.PRindexMap[0] = objectPr.PRmemberIndex; // Zero based array
954.                     else
955.                         objectPr.PRindexMap[0] = objectPr.PRpositionA[0]; // item position specified in SOAP stream
956.                 }
957.                 else
958.                     objectPr.PRindexMap[0] = objectPr.PRlowerBoundA[0]+objectPr.PRmemberIndex; // Lower Bound based array
959.             }
960.             IndexTraceMessage("ParseArrayMember isLowerBound "+objectPr.PRisLowerBound+" indexMap  ", objectPr.PRindexMap);     
962.             // Set Array element according to type of element
964.             if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
965.             {
966.                 // Object Reference
968.                 // See if object has already been instantiated
969.                 Object refObj = m_objectManager.GetObject(pr.PRidRef);
970.                 if (refObj == null)
971.                 {
972.                     // Object not instantiated
973.                     // Array fixup manager
974.                     IndexTraceMessage("ParseArrayMember Record Fixup  "+objectPr.PRnewObj.GetType(), objectPr.PRindexMap);
975.                     int[] fixupIndex = new int[objectPr.PRrank];
976.                     Array.Copy(objectPr.PRindexMap, 0, fixupIndex, 0, objectPr.PRrank);
978.                     InternalST.Soap( this, "ParseArrayMember RecordArrayElementFixup objectId ",objectPr.PRobjectId," idRef ",pr.PRidRef);                                                          
979.                     m_objectManager.RecordArrayElementFixup(objectPr.PRobjectId, fixupIndex, pr.PRidRef);
980.                 }
981.                 else
982.                 {
983.                     IndexTraceMessage("ParseArrayMember SetValue ObjectReference "+objectPr.PRnewObj.GetType()+" "+refObj, objectPr.PRindexMap);
984.                     if (objectPr.PRobjectA != null)
985.                         objectPr.PRobjectA[objectPr.PRindexMap[0]] = refObj;
986.                     else
987.                         ((Array)objectPr.PRnewObj).SetValue(refObj, objectPr.PRindexMap); // Object has been instantiated
988.                 }
989.             }
990.             else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
991.             {
992.                 //Set up dtType for ParseObject
993.                 InternalST.Soap( this, "ParseArrayMember Nested ");
994.                 if (pr.PRdtType == null)
995.                 {
996.                     pr.PRdtType = objectPr.PRarrayElementType;
997.                 }
999.                 ParseObject(pr);
1001.                 InternalST.Soap( "ParseArrayMember Push object "+pr.PRname);
1002.                 stack.Push(pr);
1004.                 if ((objectPr.PRarrayElementType.IsValueType) && (pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Invalid))
1005.                 {
1006.                     InternalST.Soap( "ParseArrayMember ValueType ObjectPr ",objectPr.PRnewObj," index ",objectPr.PRmemberIndex);
1007.                     pr.PRisValueTypeFixup = true; //Valuefixup
1008.                     valueFixupStack.Push(new ValueFixup((Array)objectPr.PRnewObj, objectPr.PRindexMap)); //valuefixup
1009.                     RegisterObject(pr.PRnewObj, pr, objectPr);                  
1010.                 }
1011.                 else
1012.                 {
1013.                     InternalST.Soap( "ParseArrayMember SetValue Nested, memberIndex ",objectPr.PRmemberIndex);
1014.                     IndexTraceMessage("ParseArrayMember SetValue Nested ContainerObject "+objectPr.PRnewObj.GetType()+" "+objectPr.PRnewObj+" item Object "+pr.PRnewObj+" index ", objectPr.PRindexMap);
1016.                     stack.Dump();               
1017.                     InternalST.Soap( "ParseArrayMember SetValue Nested ContainerObject objectPr ",objectPr.Trace());
1018.                     InternalST.Soap( "ParseArrayMember SetValue Nested ContainerObject pr ",pr.Trace());
1020.                     if (objectPr.PRobjectA != null)
1021.                         objectPr.PRobjectA[objectPr.PRindexMap[0]] = pr.PRnewObj;
1022.                     else
1023.                         ((Array)objectPr.PRnewObj).SetValue(pr.PRnewObj, objectPr.PRindexMap);
1024.                 }
1025.             }
1026.             else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
1027.             {
1028.                 if (objectPr.PRarrayElementType == Converter.typeofString)
1029.                 {
1030.                     // String
1031.                     ParseString(pr, objectPr);
1032.                     IndexTraceMessage("ParseArrayMember SetValue String "+objectPr.PRnewObj.GetType()+" "+pr.PRvalue, objectPr.PRindexMap);
1033.                     if (objectPr.PRobjectA != null)
1034.                         objectPr.PRobjectA[objectPr.PRindexMap[0]] = (Object)pr.PRvalue;
1035.                     else
1036.                         ((Array)objectPr.PRnewObj).SetValue((Object)pr.PRvalue, objectPr.PRindexMap);
1037.                 }
1038.                 else if (objectPr.PRisEnum)
1039.                 {
1040.                             // Soap sends Enums as strings
1041.                     Object var = Enum.Parse(objectPr.PRarrayElementType, pr.PRvalue);
1042.                     if (objectPr.PRobjectA != null)
1043.                         objectPr.PRobjectA[objectPr.PRindexMap[0]] = (Enum)var;
1044.                     else
1045.                         ((Array)objectPr.PRnewObj).SetValue((Enum)var, objectPr.PRindexMap);                    
1046.                     InternalST.Soap( this, "ParseArrayMember Enum 1");
1047.                 }
1048.                 else if (objectPr.PRisArrayVariant)
1049.                 {
1050.                     // Array of type object
1051.                     if (pr.PRdtType == null && pr.PRkeyDt == null)
1052.                         throw new SerializationException(SoapUtil.GetResourceString("Serialization_ArrayTypeObject"));
1054.                     Object var = null;
1056.                     if (pr.PRdtType == Converter.typeofString)
1057.                     {
1058.                         ParseString(pr, objectPr);
1059.                         var = pr.PRvalue;
1060.                     }
1061.                     else if (pr.PRdtType.IsEnum)
1062.                     {
1063.                             // Soap sends Enums as strings
1064.                         var = Enum.Parse(pr.PRdtType, pr.PRvalue);
1065.                         InternalST.Soap( this, "ParseArrayMember Enum 2");
1066.                     }
1067.                     else if (pr.PRdtTypeCode == InternalPrimitiveTypeE.Invalid)
1068.                     {
1069.                         // Not nested and invalid, so it is an empty object
1070.                         var = FormatterServices.GetUninitializedObject(pr.PRdtType);
1071.                     }
1072.                     else 
1073.                     {
1074.                         if (pr.PRvarValue != null)
1075.                             var = pr.PRvarValue;
1076.                         else
1077.                             var = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
1078.                     }
1079.                     IndexTraceMessage("ParseArrayMember SetValue variant or Object "+objectPr.PRnewObj.GetType()+" var "+var+" indexMap ", objectPr.PRindexMap);
1080.                     if (objectPr.PRobjectA != null)
1081.                         objectPr.PRobjectA[objectPr.PRindexMap[0]] = var;
1082.                     else
1083.                         ((Array)objectPr.PRnewObj).SetValue(var, objectPr.PRindexMap); // Primitive type
1084.                 }
1085.                 else
1086.                 {
1087.                     // Primitive type
1088.                     if (objectPr.PRprimitiveArray != null)
1089.                     {
1090.                         // Fast path for Soap primitive arrays. Binary was handled in the BinaryParser
1091.                         objectPr.PRprimitiveArray.SetValue(pr.PRvalue, objectPr.PRindexMap[0]);
1092.                     }
1093.                     else
1094.                     {
1096.                         Object var = null;
1097.                         if (pr.PRvarValue != null)
1098.                             var = pr.PRvarValue;
1099.                         else
1100.                             var = Converter.FromString(pr.PRvalue, objectPr.PRarrayElementTypeCode);
1102.                         if (objectPr.PRarrayElementTypeCode == InternalPrimitiveTypeE.QName)
1103.                         {
1104.                             InternalST.Soap( this, "ParseArrayMember Primitive QName");
1105.                             SoapQName soapQName = (SoapQName)var;
1106.                             if (soapQName.Key.Length == 0)
1107.                                 soapQName.Namespace = (String)soapHandler.keyToNamespaceTable["xmlns"];
1108.                             else
1109.                                 soapQName.Namespace = (String)soapHandler.keyToNamespaceTable["xmlns"+":"+soapQName.Key];
1110.                         }
1112.                         InternalST.Soap( this, "ParseArrayMember SetValue Primitive pr.PRvalue "+var," elementTypeCode ",((Enum)objectPr.PRdtTypeCode).ToString());
1113.                         IndexTraceMessage("ParseArrayMember SetValue Primitive "+objectPr.PRnewObj.GetType()+" var: "+var+" varType "+var.GetType(), objectPr.PRindexMap);
1114.                         if (objectPr.PRobjectA != null)
1115.                             objectPr.PRobjectA[objectPr.PRindexMap[0]] = var;
1116.                         else
1117.                             ((Array)objectPr.PRnewObj).SetValue(var, objectPr.PRindexMap); // Primitive type   
1118.                         InternalST.Soap( this, "ParseArrayMember SetValue Primitive after");
1119.                     }
1120.                 }
1121.             }
1122.             else if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
1123.             {
1124.                 InternalST.Soap( "ParseArrayMember Null item ",pr.PRmemberIndex);
1125.             }
1126.             else
1127.                 ParseError(pr, objectPr);
1129.             InternalST.Soap( "ParseArrayMember increment memberIndex ",objectPr.PRmemberIndex," ",objectPr.Trace());                
1130.             objectPr.PRmemberIndex++;
1131.             InternalST.Soap( "ParseArrayMember Exit");      
1132.         }
1134.         private void ParseArrayMemberEnd(ParseRecord pr)
1135.         {
1136.             InternalST.Soap( this, "ParseArrayMemberEnd");
1137.             // If this is a nested array object, then pop the stack
1138.             if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
1139.             {
1140.                 ParseObjectEnd(pr);
1141.             }
1142.         }
1145.         // Object member encountered in stream
1146.         private void ParseMember(ParseRecord pr)
1147.         {
1148.             InternalST.Soap( this, "ParseMember Entry ");
1151.             ParseRecord objectPr = (ParseRecord)stack.Peek();
1152.             String objName = null;
1153.             if (objectPr != null)
1154.                 objName = objectPr.PRname;
1155.                 
1156.             InternalST.Soap( this, "ParseMember ",objectPr.PRobjectId," ",pr.PRname);
1157.             InternalST.Soap( this, "ParseMember objectPr ",objectPr.Trace());
1158.             InternalST.Soap( this, "ParseMember pr ",pr.Trace());
1160.             if (objectPr.PRdtType == Converter.typeofSoapFault && pr.PRname.ToLower(CultureInfo.InvariantCulture) == "faultstring")
1161.                 faultString = pr.PRvalue; // Save fault string in case rest of SoapFault cannot be parsed
1164.             if ((objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top) && !isTopObjectResolved)
1165.             {
1166.                 InternalST.Soap( this, "ParseMember Top not resolved");
1167.                 if (pr.PRdtType == Converter.typeofString)
1168.                 {
1169.                     ParseString(pr, objectPr);
1170.                 }
1171.                 topStack.Push(pr.Copy());
1172.                 return;
1173.             }
1175.             switch(pr.PRmemberTypeEnum)
1176.             {
1177.                 case InternalMemberTypeE.Item:
1178.                     ParseArrayMember(pr);
1179.                     return;
1180.                 case InternalMemberTypeE.Field:
1181.                     break;
1182.             }
1183.             
1185.             if (objectPr.PRobjectInfo != null)
1186.                 objectPr.PRobjectInfo.AddMemberSeen();
1188.             bool bParams = (IsFakeTopObject &
1189.                     objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top && 
1190.                     objectPr.PRobjectInfo != null && objectPr.PRdtType != Converter.typeofSoapFault);
1192.             if ((pr.PRdtType == null) && objectPr.PRobjectInfo.isTyped)         
1193.             {
1194.                 InternalST.Soap( this, "ParseMember pr.PRdtType null and not isSi");
1196.                 if (bParams)
1197.                 {
1198.                     // Get type of parameters
1199.                     InternalST.Soap( this, "ParseMember pr.PRdtType Get Param Type position "+paramPosition+" name "+pr.PRname);    
1200.                     pr.PRdtType = objectPr.PRobjectInfo.GetType(paramPosition++);
1201.                     InternalST.Soap( this, "ParseMember pr.PRdtType Get Param Type Type "+pr.PRdtType);
1202.                 }
1203.                 else
1204.                     pr.PRdtType = objectPr.PRobjectInfo.GetType(pr.PRname);
1206.                 if (pr.PRdtType == null)
1207.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeResolved"), objectPr.PRnewObj+" "+pr.PRname));
1209.                 pr.PRdtTypeCode = Converter.ToCode(pr.PRdtType);
1210.             }
1211.             else
1212.             {
1213.                 if (bParams)
1214.                 {
1215.                     paramPosition++;
1216.                 }
1217.             }
1220.             if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
1221.             {
1222.                 // Value is Null
1223.                 InternalST.Soap( this, "ParseMember null member: ",pr.PRname);
1224.                 InternalST.Soap( this, "AddValue 1");
1225.                 objectPr.PRobjectInfo.AddValue(pr.PRname, null);
1226.             }
1227.             else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
1228.             {
1229.                 InternalST.Soap( this, "ParseMember Nested Type member: ",pr.PRname," objectPr.PRnewObj ",objectPr.PRnewObj);
1230.                 ParseObject(pr);
1231.                 InternalST.Soap( "ParseMember Push object "+pr.PRname);
1232.                 stack.Push(pr);
1233.                 InternalST.Soap( this, "AddValue 2 ",pr.PRnewObj," is value type ",pr.PRnewObj.GetType().IsValueType);
1235.                 if ((pr.PRobjectInfo != null) && (pr.PRobjectInfo.objectType.IsValueType))
1236.                 {
1237.                     InternalST.Soap( "ParseMember ValueType ObjectPr ",objectPr.PRnewObj," memberName  ",pr.PRname," nested object ",pr.PRnewObj);
1238.                     if (IsFakeTopObject)
1239.                         objectPr.PRobjectInfo.AddParamName(pr.PRname);
1240.                     
1241.                     pr.PRisValueTypeFixup = true; //Valuefixup
1242.                     valueFixupStack.Push(new ValueFixup(objectPr.PRnewObj, pr.PRname, objectPr.PRobjectInfo));//valuefixup
1243.                 }
1244.                 else
1245.                 {
1246.                     InternalST.Soap( this, "AddValue 2A ");
1247.                     objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRnewObj);
1248.                 }
1249.             }
1250.             else if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
1251.             {
1252.                 InternalST.Soap( this, "ParseMember Reference Type member: ",pr.PRname);            
1253.                 // See if object has already been instantiated
1254.                 Object refObj = m_objectManager.GetObject(pr.PRidRef);
1255.                 if (refObj == null)
1256.                 {
1257.                     InternalST.Soap( this, "ParseMember RecordFixup: ",pr.PRname);
1258.                     InternalST.Soap( this, "AddValue 3");                   
1259.                     objectPr.PRobjectInfo.AddValue(pr.PRname, null);                    
1260.                     objectPr.PRobjectInfo.RecordFixup(objectPr.PRobjectId, pr.PRname, pr.PRidRef); // Object not instantiated
1261.                 }
1262.                 else
1263.                 {
1264.                     InternalST.Soap( this, "ParseMember Referenced Object Known ",pr.PRname," ",refObj);
1265.                     InternalST.Soap( this, "AddValue 5");               
1266.                     objectPr.PRobjectInfo.AddValue(pr.PRname, refObj);
1267.                 }
1268.             }
1270.             else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue) 
1271.             {
1272.                 // Primitive type or String
1273.                 InternalST.Soap( this, "ParseMember primitive or String member: ",pr.PRname);
1275.                 if (pr.PRdtType == Converter.typeofString)
1276.                 {
1277.                     ParseString(pr, objectPr);
1278.                     InternalST.Soap( this, "AddValue 6");               
1279.                     objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);  
1280.                 }
1281.                 else if (pr.PRdtTypeCode == InternalPrimitiveTypeE.Invalid)
1282.                 {
1283.                     // The member field was an object put the value is Inline either  bin.Base64 or invalid
1284.                     if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
1285.                     {
1286.                         InternalST.Soap( this, "AddValue 7");                   
1287.                         objectPr.PRobjectInfo.AddValue(pr.PRname, Convert.FromBase64String(FilterBin64(pr.PRvalue)));                                   
1288.                     }
1289.                     else if (pr.PRdtType == Converter.typeofObject && pr.PRvalue != null) 
1290.                     {
1291.                         if (objectPr != null && objectPr.PRdtType == Converter.typeofHeader)
1292.                         {
1293.                             // assume the type is a string for a header
1294.                             pr.PRdtType = Converter.typeofString;
1295.                             ParseString(pr, objectPr);
1296.                             InternalST.Soap( this, "AddValue 6");               
1297.                             objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);  
1298.                         }
1299.                         else
1300.                             throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeMissing"), pr.PRname));
1301.                     }
1302.                     else
1303.                     {
1304.                         InternalST.Soap( this, "Object Class with no memberInfo data  Member "+pr.PRname+" type "+pr.PRdtType);
1306.                         if (pr.PRdtType != null && pr.PRdtType.IsEnum)
1307.                         {
1308.                             // Soap sends Enums as strings
1309.                             Object obj = Enum.Parse(pr.PRdtType, pr.PRvalue);
1310.                             InternalST.Soap( this, "AddValue 8");                           
1311.                             objectPr.PRobjectInfo.AddValue(pr.PRname, obj);                         
1312.                         }
1313.                         else if (pr.PRdtType != null && pr.PRdtType == Converter.typeofTypeArray)
1314.                         {
1315.                             // Soap sends MethodSignature as an array of types
1316.                             InternalST.Soap( this, "AddValue 8A");                          
1317.                             objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvarValue);                                                       
1318.                         }
1319.                         else
1320.                         {
1321.                             if  ((!pr.PRisRegistered) && (pr.PRobjectId > 0))
1322.                             {
1323.                                 if (pr.PRvalue == null)
1324.                                     pr.PRvalue = ""; //can't register null value, this must be a string so set to empty string.
1326.                                 InternalST.Soap( this, "ParseMember RegisterObject ",pr.PRvalue," ",pr.PRobjectId);                         
1327.                                 RegisterObject(pr.PRvalue, pr, objectPr);
1328.                             }
1330.                             // Object Class with no memberInfo data
1331.                             if (pr.PRdtType == Converter.typeofSystemVoid)
1332.                             {
1333.                                 InternalST.Soap( this, "AddValue 9");
1334.                                 objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRdtType);
1335.                             }
1336.                             else if (objectPr.PRobjectInfo.isSi)
1337.                             {
1338.                                 // ISerializable are added as strings, the conversion to type is done by the
1339.                                 // ISerializable object
1340.                                 InternalST.Soap( this, "AddValue 10");
1341.                                 objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);                          
1342.                             }
1343.                         }
1344.                     }
1345.                 }
1346.                 else
1347.                 {
1348.                     Object var = null;
1349.                     if (pr.PRvarValue != null)
1350.                         var = pr.PRvarValue;
1351.                     else
1352.                         var = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
1353.                     // Not a string, convert the value
1354.                     InternalST.Soap( this, "ParseMember Converting primitive and storing");
1355.                     stack.Dump();
1356.                     InternalST.Soap( this, "ParseMember pr "+pr.Trace());
1357.                     InternalST.Soap( this, "ParseMember objectPr ",objectPr.Trace());
1359.                     InternalST.Soap( this, "AddValue 11");  
1360.                     if (pr.PRdtTypeCode == InternalPrimitiveTypeE.QName && var != null)
1361.                     {
1362.                         SoapQName soapQName = (SoapQName)var;
1363.                         if (soapQName.Key != null)
1364.                         {
1365.                             if (soapQName.Key.Length == 0)
1366.                                 soapQName.Namespace = (String)soapHandler.keyToNamespaceTable["xmlns"];
1367.                             else
1368.                                 soapQName.Namespace = (String)soapHandler.keyToNamespaceTable["xmlns"+":"+soapQName.Key];
1369.                         }
1370.                     }
1371.                     objectPr.PRobjectInfo.AddValue(pr.PRname, var);             
1372.                 }
1373.             }
1374.             else
1375.                 ParseError(pr, objectPr);
1376.         }
1378.         // Object member end encountered in stream
1379.         private void ParseMemberEnd(ParseRecord pr)
1380.         {
1381.             InternalST.Soap( this, "ParseMemberEnd");
1382.             switch(pr.PRmemberTypeEnum)
1383.             {
1384.                 case InternalMemberTypeE.Item:
1385.                     ParseArrayMemberEnd(pr);
1386.                     return;
1387.                 case InternalMemberTypeE.Field:
1388.                     if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
1389.                         ParseObjectEnd(pr);
1390.                     break;
1391.                 default:
1392.                     if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
1393.                         ParseObjectEnd(pr);
1394.                     else
1395.                         ParseError(pr, (ParseRecord)stack.Peek());
1396.                     break;
1397.             }
1398.         }
1400.         // Processes a string object by getting an internal ID for it and registering it with the objectManager
1401.         private void ParseString(ParseRecord pr, ParseRecord parentPr)
1402.         {
1403.             InternalST.Soap( this, "ParseString Entry ",pr.PRobjectId," ",pr.PRvalue," ",pr.PRisRegistered);
1405.             // If there is a string and it wasn't marked as a null object, then it is an empty string
1406.             if (pr.PRvalue == null)
1407.                 pr.PRvalue = ""; 
1409.             // Process String class
1410.             if  ((!pr.PRisRegistered) && (pr.PRobjectId > 0))
1411.             {
1412.                 InternalST.Soap( this, "ParseString  RegisterObject ",pr.PRvalue," ",pr.PRobjectId);                            
1413.                 // String is treated as an object if it has an id
1414.                 //m_objectManager.RegisterObject(pr.PRvalue, pr.PRobjectId);
1415.                 RegisterObject(pr.PRvalue, pr, parentPr);
1416.             }
1417.         }
1420.         private void RegisterObject(Object obj, ParseRecord pr, ParseRecord objectPr)
1421.         {
1422.             if (!pr.PRisRegistered)
1423.             {
1424.                 pr.PRisRegistered = true;
1426.                 SerializationInfo si = null;
1427.                 long parentId = 0;
1428.                 MemberInfo memberInfo = null;
1429.                 int[] indexMap = null;
1431.                 if (objectPr != null)
1432.                 {
1433.                     indexMap = objectPr.PRindexMap;
1434.                     parentId = objectPr.PRobjectId;                 
1436.                     if (objectPr.PRobjectInfo != null)
1437.                     {
1438.                         if (!objectPr.PRobjectInfo.isSi)
1439.                         {
1440.                             // ParentId is only used if there is a memberInfo
1441.                             InternalST.Soap( this, "RegisterObject GetMemberInfo parent ",objectPr.PRobjectInfo.objectType," name looking for ", pr.PRname," field obj "+obj); 
1442.                             memberInfo = objectPr.PRobjectInfo.GetMemberInfo(pr.PRname);
1443.                         }
1444.                     }
1445.                 }
1446.                 if (pr.PRobjectInfo != null)
1447.                 {
1448.                     // SerializationInfo is always needed for ISerialization                        
1449.                     si = pr.PRobjectInfo.si;
1450.                 }
1452.                 InternalST.Soap( this, "RegisterObject 0bj ",obj," objectId ",pr.PRobjectId," si ", si," parentId ",parentId," memberInfo ",memberInfo, " indexMap "+indexMap);
1453.                 m_objectManager.RegisterObject(obj, pr.PRobjectId, si, parentId, memberInfo, indexMap); 
1454.             }
1455.         }
1458.         internal void SetVersion(int major, int minor)
1459.         {
1460.             // Don't do version checking if property is set to Simple
1461.             if (formatterEnums.FEassemblyFormat != FormatterAssemblyStyle.Simple)
1462.             {
1463.                 this.majorVersion = major;
1464.                 this.minorVersion = minor;
1465.             }
1466.         }
1469.         // Assigns an internal ID associated with the xml id attribute
1471.         String inKeyId = null;
1472.         long outKeyId = 0;      
1473.         internal long GetId(String keyId)
1474.         {
1475.             if (keyId == null)
1476.                 throw new ArgumentNullException("keyId", String.Format(SoapUtil.GetResourceString("ArgumentNull_WithParamName"), "keyId"));
1478.             if (keyId != inKeyId)
1479.             {               
1480.                 inKeyId = keyId;
1481.                 String idString = null;
1482.                 InternalST.Soap( this, "GetId Entry ",keyId);
1483.                 if (keyId[0] == '#')
1484.                     idString = keyId.Substring(1);
1485.                 else
1486.                     idString = keyId;
1488.                 Object idObj = objectIdTable[idString];
1489.                 if (idObj == null)
1490.                 {
1491.                     outKeyId = ++objectIds;
1492.                     objectIdTable[idString] = outKeyId;
1493.                     InternalST.Soap( this, "GetId Exit new ID ",outKeyId);
1494.                 }
1495.                 else
1496.                 {
1497.                     InternalST.Soap( this, "GetId Exit oldId ",(Int64)idObj);           
1498.                     outKeyId =  (Int64)idObj;
1499.                 }
1500.             }
1501.             InternalST.Soap( this, "GetId  in id ",keyId, " out id ", outKeyId);
1502.             return outKeyId;
1503.         }
1505.         // Assigns an internal ID associated with the binary id number
1507.         long inId = 0;
1508.         long outId = 0;
1509.         internal long GetId(long objectId)
1510.         {
1511.             if (inId != objectId)
1512.             {
1514.                 inId = objectId;
1515.                 Object idObj = null;
1516.                 if (objectId > 0)
1517.                     idObj = objectIdTable[objectId];
1518.                 if (idObj == null)          
1519.                 {
1520.                     outId = ++objectIds;
1521.                     objectIdTable[objectId] = outId;
1522.                     InternalST.Soap( this, "GetId Exit new ID ",outId);
1523.                 }
1524.                 else
1525.                 {
1526.                     InternalST.Soap( this, "GetId Exit oldId ",(Int64)idObj);           
1527.                     outId = (Int64)idObj;
1528.                 }
1529.             }
1530.             return outId;
1531.         }
1534.         // Trace which includes a single dimensional int array
1535.         [Conditional("SER_LOGGING")]                        
1536.         private void IndexTraceMessage(String message, int[] index)
1537.         {
1538.             StringBuilder sb = new StringBuilder(10);
1539.             sb.Append("[");     
1540.             for (int i=0; i<index.Length; i++)
1541.             {
1542.                 sb.Append(index[i]);
1543.                 if (i != index.Length -1)
1544.                     sb.Append(",");
1545.             }
1546.             sb.Append("]");             
1547.             InternalST.Soap( this, message," ",sb.ToString());
1548.         }
1550.         internal Assembly LoadAssemblyFromString(String assemblyString)
1551.         {
1552.             Assembly assm = null;
1553.             if(formatterEnums.FEassemblyFormat == FormatterAssemblyStyle.Simple) {
1554.                 assm  = Assembly.LoadWithPartialName(assemblyString);
1555.             }
1556.             else {
1557.                 try
1558.                     {
1559.                         assm = Assembly.Load(assemblyString);
1560.                     }
1561.                 catch (Exception)
1562.                     {
1563.                     }
1564.             }
1566.             return assm;
1567.         }
1569.         internal Type Bind(String assemblyString, String typeString)
1570.         {
1571.             Type type = null;
1572.             if (m_binder != null)
1573.                 type = m_binder.BindToType(assemblyString, typeString);
1574.             return type;
1575.         }
1577.         internal class TypeNAssembly
1578.         {
1579.             public Type type;
1580.             public String assemblyName;
1581.         }
1583.         NameCache typeCache = new NameCache();
1584.         internal Type FastBindToType(String assemblyName, String typeName)
1585.         {
1586.             Type type = null;
1588.             TypeNAssembly entry = (TypeNAssembly)typeCache.GetCachedValue(typeName);
1590.             if (entry == null || entry.assemblyName != assemblyName)
1591.             {
1592.                 Assembly assm = LoadAssemblyFromString(assemblyName);
1593.                 if (assm == null)
1594.                     return null;
1596.                 type = FormatterServices.GetTypeFromAssembly(assm, typeName);
1598.                 if (type == null)
1599.                     return null;
1601.                 entry = new TypeNAssembly();
1602.                 entry.type = type;
1603.                 entry.assemblyName = assemblyName;
1604.                 typeCache.SetCachedValue(entry);
1605.             }
1606.            return entry.type;
1607.         }
1609.         /*
1610.         static Hashtable typeNames = new Hashtable();
1611.         static int s_numEntries = 0;
1612.         private const int MAX_CACHE_ENTRIES = 128; // No data gathered to arrive at this number !
1614.         internal Type FastBindToType(String assemblyName, String typeName)
1615.         {
1616.             TypeNAssembly match = (TypeNAssembly)typeNames[typeName];
1617.             if (match == null)
1618.             {
1619.                 match = new TypeNAssembly();
1620.                 Assembly assm = null;
1621.                 try
1622.                 {
1623.                     assm = Assembly.Load(assemblyName);
1624.                 }
1625.                 catch (Exception)
1626.                 {
1627.                     return null;
1628.                 }
1630.                 if (assm == null)
1631.                     return null;
1633.                 match.type = FormatterServices.GetTypeFromAssembly(assm, typeName);
1634.                 if (match.type == null)
1635.                     return null;
1637.                 match.assemblyName = assemblyName;
1638.                 lock (typeNames)
1639.                 {
1640.                     if (s_numEntries == MAX_CACHE_ENTRIES)
1641.                     {
1642.                         typeNames.Clear();
1643.                         s_numEntries = 0;
1644.                     }
1645.                     typeNames[typeName] = match;
1646.                     s_numEntries ++;
1647.                 }
1649.                 return match.type;
1650.             }
1651.             if (match.assemblyName.Equals(assemblyName))
1652.                 return match.type;
1654.             // So if same type name occurs in 2 assemblies, the second guy loses
1655.             return null;
1656.         }
1657.         */
1659.         StringBuilder sbf = new StringBuilder();
1660.         internal String FilterBin64(String value)
1661.         {
1662.             sbf.Length = 0;
1663.             for (int i=0; i<value.Length; i++)
1664.             {
1665.                 if (!(value[i] == ' '|| value[i] == '/n' || value[i] == '/r'))
1666.                     sbf.Append(value[i]);
1667.             }
1668.             return sbf.ToString();
1669.         }
1671.     }
1672. }