?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(DISTFILES): Comment out a few missing files.
[mono-project.git] / mcs / class / System.Runtime.Serialization.Formatters.Soap / System.Runtime.Serialization.Formatters.Soap / SoapReader.cs
bloba0188b32e3affc4ddad048a45b4a4595c747030e
1 // created on 24/04/2003 at 15:35
2 //
3 // System.Runtime.Serialization.Formatters.Soap.SoapReader
4 //
5 // Authors:
6 // Jean-Marc Andre (jean-marc.andre@polymtl.ca)
7 //
8
9 //
10 // Permission is hereby granted, free of charge, to any person obtaining
11 // a copy of this software and associated documentation files (the
12 // "Software"), to deal in the Software without restriction, including
13 // without limitation the rights to use, copy, modify, merge, publish,
14 // distribute, sublicense, and/or sell copies of the Software, and to
15 // permit persons to whom the Software is furnished to do so, subject to
16 // the following conditions:
17 //
18 // The above copyright notice and this permission notice shall be
19 // included in all copies or substantial portions of the Software.
20 //
21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 //
29
30 using System;
31 using System.IO;
32 using System.Xml;
33 using System.Xml.Schema;
34 using System.Reflection;
35 using System.Collections;
36 using System.Runtime.Remoting;
37 using System.Runtime.Serialization;
38 using System.Runtime.Remoting.Messaging;
39
40 namespace System.Runtime.Serialization.Formatters.Soap {
41 internal sealed class SoapReader {
42
43 #region Fields
44
45 private SerializationBinder _binder;
46 private SoapTypeMapper mapper;
47 private ObjectManager objMgr;
48 private StreamingContext _context;
49 private long _nextAvailableId = long.MaxValue;
50 private ISurrogateSelector _surrogateSelector;
51 private XmlTextReader xmlReader;
52 private Hashtable _fieldIndices;
53 private long _topObjectId = 1;
54
55 class TypeMetadata
56 {
57 public MemberInfo[] MemberInfos;
58 public Hashtable Indices;
59 }
60
61 #endregion
62
63 #region Properties
64
65 private long NextAvailableId
66 {
67 get
68 {
69 _nextAvailableId--;
70 return _nextAvailableId;
71 }
72 }
73
74 #endregion
75
76 #region Constructors
77
78 public SoapReader(SerializationBinder binder, ISurrogateSelector selector, StreamingContext context)
79 {
80 _binder = binder;
81 objMgr = new ObjectManager(selector, context);
82 _context = context;
83 _surrogateSelector = selector;
84 _fieldIndices = new Hashtable();
85 }
86
87 #endregion
88
89 #region Public Methods
90
91 public object Deserialize(Stream inStream, ISoapMessage soapMessage)
92 {
93 ArrayList headers = null;
94 xmlReader = new XmlTextReader(inStream);
95 xmlReader.WhitespaceHandling = WhitespaceHandling.None;
96 mapper = new SoapTypeMapper(_binder);
97
98 try
99 {
100 // SOAP-ENV:Envelope
101 xmlReader.MoveToContent();
102 xmlReader.ReadStartElement ();
103 xmlReader.MoveToContent();
104
105 // Read headers
106 while (!(xmlReader.NodeType == XmlNodeType.Element && xmlReader.LocalName == "Body" && xmlReader.NamespaceURI == SoapTypeMapper.SoapEnvelopeNamespace))
107 {
108 if (xmlReader.NodeType == XmlNodeType.Element && xmlReader.LocalName == "Header" && xmlReader.NamespaceURI == SoapTypeMapper.SoapEnvelopeNamespace)
109 {
110 if (headers == null) headers = new ArrayList ();
111 DeserializeHeaders (headers);
112 }
113 else
114 xmlReader.Skip ();
115 xmlReader.MoveToContent();
116 }
117
118 // SOAP-ENV:Body
119 xmlReader.ReadStartElement();
120 xmlReader.MoveToContent();
121
122 // The root object
123 if (soapMessage != null)
124 {
125 if (DeserializeMessage (soapMessage)) {
126 _topObjectId = NextAvailableId;
127 RegisterObject (_topObjectId, soapMessage, null, 0, null, null);
128 }
129 xmlReader.MoveToContent();
130
131 if (headers != null)
132 soapMessage.Headers = (Header[]) headers.ToArray (typeof(Header));
133 }
134
135 while (xmlReader.NodeType != XmlNodeType.EndElement)
136 Deserialize();
137
138 // SOAP-ENV:Body
139 xmlReader.ReadEndElement ();
140 xmlReader.MoveToContent();
141
142 // SOAP-ENV:Envelope
143 xmlReader.ReadEndElement ();
144 }
145 finally
146 {
147 if(xmlReader != null) xmlReader.Close();
148 }
149
150 return TopObject;
151 }
152
153 #endregion
154
155 #region Private Methods
156
157 private object TopObject
158 {
159 get
160 {
161 objMgr.DoFixups();
162 objMgr.RaiseDeserializationEvent();
163 return objMgr.GetObject(_topObjectId);
164 }
165 }
166
167 private bool IsNull()
168 {
169 string tmp = xmlReader["null", XmlSchema.InstanceNamespace];
170 return (tmp == null || tmp == string.Empty)?false:true;
171 }
172
173 private long GetId()
174 {
175 long id = 0;
176
177 string strId = xmlReader["id"];
178 if(strId == null || strId == String.Empty) return 0;
179 id = Convert.ToInt64(strId.Substring(4));
180 return id;
181 }
182
183 private long GetHref()
184 {
185 long href = 0;
186
187 string strHref = xmlReader["href"];
188 if(strHref == null || strHref == string.Empty) return 0;
189 href = Convert.ToInt64(strHref.Substring(5));
190 return href;
191 }
192
193 private Type GetComponentType()
194 {
195 Type type = null;
196
197 string strValue = xmlReader["type", XmlSchema.InstanceNamespace];
198 if(strValue == null) {
199 if(GetId() != 0) return typeof(string);
200 return null;
201 }
202 string[] strName = strValue.Split(':');
203 string namespaceURI = xmlReader.LookupNamespace(strName[0]);
204 type = mapper[new Element(string.Empty, strName[1], namespaceURI)];
205
206 return type;
207 }
208
209 private bool DeserializeMessage(ISoapMessage message)
210 {
211 string typeNamespace, assemblyName;
212
213 if(xmlReader.Name == SoapTypeMapper.SoapEnvelopePrefix + ":Fault")
214 {
215 Deserialize();
216 return false;
217 }
218
219 SoapServices.DecodeXmlNamespaceForClrTypeNamespace(
220 xmlReader.NamespaceURI,
221 out typeNamespace,
222 out assemblyName);
223 message.MethodName = xmlReader.LocalName;
224 message.XmlNameSpace = xmlReader.NamespaceURI;
225
226 ArrayList paramNames = new ArrayList();
227 ArrayList paramValues = new ArrayList();
228 long paramValuesId = NextAvailableId;
229 int[] indices = new int[1];
230
231 if (!xmlReader.IsEmptyElement)
232 {
233 int initialDepth = xmlReader.Depth;
234 xmlReader.Read();
235 int i = 0;
236 while(xmlReader.Depth > initialDepth)
237 {
238 long paramId, paramHref;
239 object objParam = null;
240 paramNames.Add (xmlReader.Name);
241 Type paramType = null;
242
243 if (message.ParamTypes != null) {
244 if (i >= message.ParamTypes.Length)
245 throw new SerializationException ("Not enough parameter types in SoapMessages");
246 paramType = message.ParamTypes [i];
247 }
248
249 indices[0] = i;
250 objParam = DeserializeComponent(
251 paramType,
252 out paramId,
253 out paramHref,
254 paramValuesId,
255 null,
256 indices);
257 indices[0] = paramValues.Add(objParam);
258 if(paramHref != 0)
259 {
260 RecordFixup(paramValuesId, paramHref, paramValues.ToArray(), null, null, null, indices);
261 }
262 else if(paramId != 0)
263 {
264 // RegisterObject(paramId, objParam, null, paramValuesId, null, indices);
265 }
266 else
267 {
268 }
269 i++;
270 }
271 xmlReader.ReadEndElement();
272 }
273 else
274 {
275 xmlReader.Read();
276 }
277
278 message.ParamNames = (string[]) paramNames.ToArray(typeof(string));
279 message.ParamValues = paramValues.ToArray();
280 RegisterObject(paramValuesId, message.ParamValues, null, 0, null, null);
281 return true;
282 }
283
284 void DeserializeHeaders (ArrayList headers)
285 {
286 xmlReader.ReadStartElement ();
287 xmlReader.MoveToContent ();
288
289 while (xmlReader.NodeType != XmlNodeType.EndElement)
290 {
291 if (xmlReader.NodeType != XmlNodeType.Element) { xmlReader.Skip(); continue; }
292
293 if (xmlReader.GetAttribute ("root", SoapTypeMapper.SoapEncodingNamespace) == "1")
294 headers.Add (DeserializeHeader ());
295 else
296 Deserialize ();
297
298 xmlReader.MoveToContent ();
299 }
300
301 xmlReader.ReadEndElement ();
302 }
303 Header DeserializeHeader ()
304 {
305 Header h = new Header (xmlReader.LocalName, null);
306 h.HeaderNamespace = xmlReader.NamespaceURI;
307 h.MustUnderstand = xmlReader.GetAttribute ("mustUnderstand", SoapTypeMapper.SoapEnvelopeNamespace) == "1";
308
309 object value;
310 long fieldId, fieldHref;
311 long idHeader = NextAvailableId;
312 FieldInfo fieldInfo = typeof(Header).GetField ("Value");
313
314 value = DeserializeComponent (null, out fieldId, out fieldHref, idHeader, fieldInfo, null);
315 h.Value = value;
316
317 if(fieldHref != 0 && value == null)
318 {
319 RecordFixup (idHeader, fieldHref, h, null, null, fieldInfo, null);
320 }
321 else if(value != null && value.GetType().IsValueType && fieldId != 0)
322 {
323 RecordFixup (idHeader, fieldId, h, null, null, fieldInfo, null);
324 }
325 else if(fieldId != 0)
326 {
327 RegisterObject (fieldId, value, null, idHeader, fieldInfo, null);
328 }
329
330 RegisterObject (idHeader, h, null, 0, null, null);
331 return h;
332 }
333
334
335 private object DeserializeArray(long id)
336 {
337 // Special case for base64 byte arrays
338 if (GetComponentType () == typeof(byte[])) {
339 byte[] data = Convert.FromBase64String (xmlReader.ReadElementString());
340 RegisterObject(id, data, null, 0, null, null);
341 return data;
342 }
343
344 // Get the array properties
345 string strArrayType = xmlReader["arrayType", SoapTypeMapper.SoapEncodingNamespace];
346 string[] arrayInfo = strArrayType.Split(':','[',',',']');
347 int numberOfDims = arrayInfo.Length - 3;
348 int[] lengths = new int[numberOfDims];
349 string[] arrayDims = new String[numberOfDims];
350 Array.Copy(arrayInfo, 2, arrayDims, 0, numberOfDims);
351 for (int i=0; i < numberOfDims; i++)
352 {
353 lengths[i] = Convert.ToInt32(arrayDims[i]);
354 }
355
356 int[] indices = new int[numberOfDims];
357
358 // Create the array
359 Type arrayType = mapper[new Element(arrayInfo[0], arrayInfo[1], xmlReader.LookupNamespace(arrayInfo[0]))];
360 Array array = Array.CreateInstance(
361 arrayType,
362 lengths);
363
364 for(int i = 0; i < numberOfDims; i++)
365 {
366 indices[i] = array.GetLowerBound(i);
367 }
368
369 // Deserialize the array items
370 int arrayDepth = xmlReader.Depth;
371 xmlReader.Read();
372 while(xmlReader.Depth > arrayDepth)
373 {
374 Type itemType = GetComponentType();
375 if(itemType == null)
376 itemType = array.GetType().GetElementType();
377 long itemId, itemHref;
378
379 object objItem = DeserializeComponent(itemType,
380 out itemId,
381 out itemHref,
382 id,
383 null,
384 indices);
385 if(itemHref != 0)
386 {
387 object obj = objMgr.GetObject(itemHref);
388 if(obj != null)
389 array.SetValue(obj, indices);
390 else
391 RecordFixup(id, itemHref, array, null, null, null, indices);
392 }
393 else if(objItem != null && objItem.GetType().IsValueType && itemId != 0)
394 {
395 RecordFixup(id, itemId, array, null, null, null, indices);
396 }
397 else if(itemId != 0)
398 {
399 RegisterObject(itemId, objItem, null, id, null, indices);
400 array.SetValue(objItem, indices);
401 }
402 else
403 {
404 array.SetValue(objItem, indices);
405 }
406
407 // Get the next indice
408 for(int dim = array.Rank - 1; dim >= 0; dim--)
409 {
410 indices[dim]++;
411 if(indices[dim] > array.GetUpperBound(dim))
412 {
413 if(dim > 0)
414 {
415 indices[dim] = array.GetLowerBound(dim);
416 continue;
417 }
418
419 }
420 break;
421 }
422 }
423
424 RegisterObject(id, array, null, 0, null, null);
425 xmlReader.ReadEndElement();
426 return array;
427
428 }
429
430
431 private object Deserialize()
432 {
433 object objReturn = null;
434 Element element = new Element(
435 xmlReader.Prefix,
436 xmlReader.LocalName,
437 xmlReader.NamespaceURI);
438
439
440 Type type = mapper[element];
441
442 // Get the Id
443 long id = GetId();
444 id = (id == 0)?1:id;
445
446 if(type == typeof(Array))
447 {
448 objReturn = DeserializeArray(id);
449 }
450 else
451 {
452 objReturn = DeserializeObject(type, id, 0, null, null);
453
454 }
455
456 return objReturn;
457 }
458
459
460 private object DeserializeObject(
461 Type type,
462 long id,
463 long parentId,
464 MemberInfo parentMemberInfo,
465 int[] indices)
466 {
467 SerializationInfo info = null;
468 bool NeedsSerializationInfo = false;
469 bool hasFixup;
470
471 if(SoapTypeMapper.CanBeValue(type))
472 {
473 string elementString = xmlReader.ReadElementString();
474 object obj = SoapTypeMapper.ParseXsdValue (elementString, type);
475
476 if(id != 0)
477 RegisterObject(id, obj, info, parentId, parentMemberInfo, indices);
478
479 return obj;
480 }
481 object objReturn =
482 FormatterServices.GetUninitializedObject(type);
483 if(objReturn is ISerializable)
484 NeedsSerializationInfo = true;
485
486 if(_surrogateSelector != null && NeedsSerializationInfo == false)
487 {
488 ISurrogateSelector selector;
489 ISerializationSurrogate surrogate = _surrogateSelector.GetSurrogate(
490 type,
491 _context,
492 out selector);
493 NeedsSerializationInfo |= (surrogate != null);
494 }
495
496 if(NeedsSerializationInfo)
497 {
498 objReturn =
499 DeserializeISerializableObject(objReturn, id, out info, out hasFixup);
500 }
501 else
502 {
503 objReturn =
504 DeserializeSimpleObject(objReturn, id, out hasFixup);
505 if(!hasFixup && objReturn is IObjectReference)
506 objReturn = ((IObjectReference)objReturn).GetRealObject(_context);
507 }
508
509 RegisterObject(id, objReturn, info, parentId, parentMemberInfo, indices);
510 xmlReader.ReadEndElement();
511 return objReturn;
512 }
513
514
515 private object DeserializeSimpleObject(
516 object obj,
517 long id,
518 out bool hasFixup
519 )
520 {
521 hasFixup = false;
522 Type currentType = obj.GetType();
523 TypeMetadata tm = GetTypeMetadata (currentType);
524
525 int objDepth = xmlReader.Depth;
526 object[] data = new object[tm.MemberInfos.Length];
527 xmlReader.Read();
528 for(int i = 0; i < tm.MemberInfos.Length; i++)
529 {
530 object fieldObject;
531 long fieldId, fieldHref;
532 int index = (int) tm.Indices[xmlReader.LocalName];
533 FieldInfo fieldInfo = (tm.MemberInfos[index]) as FieldInfo;
534 if(fieldInfo == null) continue;
535
536 fieldObject =
537 DeserializeComponent(fieldInfo.FieldType,
538 out fieldId,
539 out fieldHref,
540 id,
541 fieldInfo,
542 null);
543
544 data[index] = fieldObject;
545
546 if(fieldHref != 0 && fieldObject == null)
547 {
548 RecordFixup(id, fieldHref, obj, null, null, fieldInfo, null);
549 hasFixup = true;
550 continue;
551 }
552 if(fieldObject != null && fieldObject.GetType().IsValueType && fieldId != 0)
553 {
554 RecordFixup(id, fieldId, obj, null, null, fieldInfo, null);
555 hasFixup = true;
556 continue;
557 }
558
559 if(fieldId != 0)
560 {
561 RegisterObject(fieldId, fieldObject, null, id, fieldInfo, null);
562 }
563 }
564
565 FormatterServices.PopulateObjectMembers (obj, tm.MemberInfos, data);
566 return obj;
567 }
568
569
570 private object DeserializeISerializableObject(
571 object obj,
572 long id,
573 out SerializationInfo info,
574 out bool hasFixup
575 )
576 {
577 long fieldId, fieldHref;
578 info = new SerializationInfo(obj.GetType(), new FormatterConverter());
579 hasFixup = false;
580
581 int initialDepth = xmlReader.Depth;
582 xmlReader.Read();
583 while(xmlReader.Depth > initialDepth)
584 {
585 Type fieldType = GetComponentType();
586 string fieldName = xmlReader.LocalName;
587 object objField = DeserializeComponent(
588 fieldType,
589 out fieldId,
590 out fieldHref,
591 id,
592 null,
593 null);
594 if(fieldHref != 0 && objField == null)
595 {
596 RecordFixup(id, fieldHref, obj, info, fieldName, null, null);
597 hasFixup = true;
598 continue;
599 }
600 else if(fieldId != 0 && objField.GetType().IsValueType)
601 {
602 RecordFixup(id, fieldId, obj, info, fieldName, null, null);
603 hasFixup = true;
604 continue;
605 }
606
607 if(fieldId != 0)
608 {
609 RegisterObject(fieldId, objField, null, id, null, null);
610 }
611
612 info.AddValue(fieldName, objField, (fieldType != null)?fieldType:typeof(object));
613 }
614
615 return obj;
616 }
617
618
619 private object DeserializeComponent(
620 Type componentType,
621 out long componentId,
622 out long componentHref,
623 long parentId,
624 MemberInfo parentMemberInfo,
625 int[] indices)
626 {
627 object objReturn;
628 componentId = 0;
629 componentHref = 0;
630
631 if(IsNull())
632 {
633 xmlReader.Read();
634 return null;
635 }
636
637 Type xsiType = GetComponentType();
638 if(xsiType != null) componentType = xsiType;
639
640 if(xmlReader.HasAttributes)
641 {
642 componentId = GetId();
643 componentHref = GetHref();
644 }
645
646 if(componentId != 0)
647 {
648 // It's a string
649 return xmlReader.ReadElementString();
650 }
651 if(componentHref != 0)
652 {
653 // Move the cursor to the next node
654 xmlReader.Read();
655 return objMgr.GetObject(componentHref);
656 }
657
658 if(componentType == null)
659 return xmlReader.ReadElementString();
660
661 componentId = NextAvailableId;
662 objReturn = DeserializeObject(
663 componentType,
664 componentId,
665 parentId,
666 parentMemberInfo,
667 indices);
668 return objReturn;
669 }
670
671 public void RecordFixup(
672 long parentObjectId,
673 long childObjectId,
674 object parentObject,
675 SerializationInfo info,
676 string fieldName,
677 MemberInfo memberInfo,
678 int[] indices)
679 {
680 if(info != null)
681 {
682 objMgr.RecordDelayedFixup(parentObjectId, fieldName, childObjectId);
683 }
684 else if (parentObject is Array)
685 {
686 if (indices.Length == 1)
687 objMgr.RecordArrayElementFixup (parentObjectId, indices[0], childObjectId);
688 else
689 objMgr.RecordArrayElementFixup (parentObjectId, (int[])indices.Clone(), childObjectId);
690 }
691 else
692 {
693 objMgr.RecordFixup (parentObjectId, memberInfo, childObjectId);
694 }
695 }
696
697 private void RegisterObject (
698 long objectId,
699 object objectInstance,
700 SerializationInfo info,
701 long parentObjectId,
702 MemberInfo parentObjectMember,
703 int[] indices)
704 {
705 if (parentObjectId == 0) indices = null;
706
707 if (!objectInstance.GetType().IsValueType || parentObjectId == 0)
708 objMgr.RegisterObject (objectInstance, objectId, info, 0, null, null);
709 else
710 {
711 if(objMgr.GetObject(objectId) != null)
712 throw new SerializationException("Object already registered");
713 if (indices != null) indices = (int[])indices.Clone();
714 objMgr.RegisterObject (
715 objectInstance,
716 objectId,
717 info,
718 parentObjectId,
719 parentObjectMember,
720 indices);
721 }
722 }
723
724 TypeMetadata GetTypeMetadata (Type type)
725 {
726 TypeMetadata tm = _fieldIndices[type] as TypeMetadata;
727 if (tm != null) return tm;
728
729 tm = new TypeMetadata ();
730 tm.MemberInfos = FormatterServices.GetSerializableMembers (type, _context);
731
732 tm.Indices = new Hashtable();
733 for(int i = 0; i < tm.MemberInfos.Length; i++)
734 tm.Indices.Add (tm.MemberInfos[i].Name, i);
735
736 _fieldIndices[type] = tm;
737 return tm;
738 }
739
740 #endregion
741 }
742 }
Mirror of the official Mono project git repository