mscorlib(4.0.0.0) API with additions
__BinaryParser.cs
1 using System.Globalization;
2 using System.IO;
3 using System.Security;
4 using System.Text;
5 
6 namespace System.Runtime.Serialization.Formatters.Binary
7 {
8  internal sealed class __BinaryParser
9  {
10  internal ObjectReader objectReader;
11 
12  internal Stream input;
13 
14  internal long topId;
15 
16  internal long headerId;
17 
18  internal SizedArray objectMapIdTable;
19 
20  internal SizedArray assemIdToAssemblyTable;
21 
22  internal SerStack stack = new SerStack("ObjectProgressStack");
23 
24  internal BinaryTypeEnum expectedType = BinaryTypeEnum.ObjectUrt;
25 
26  internal object expectedTypeInformation;
27 
28  internal ParseRecord PRS;
29 
30  private BinaryAssemblyInfo systemAssemblyInfo;
31 
32  private BinaryReader dataReader;
33 
34  private static Encoding encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
35 
36  private SerStack opPool;
37 
38  private BinaryObject binaryObject;
39 
40  private BinaryObjectWithMap bowm;
41 
42  private BinaryObjectWithMapTyped bowmt;
43 
44  internal BinaryObjectString objectString;
45 
46  internal BinaryCrossAppDomainString crossAppDomainString;
47 
48  internal MemberPrimitiveTyped memberPrimitiveTyped;
49 
50  private byte[] byteBuffer;
51 
52  private const int chunkSize = 4096;
53 
54  internal MemberPrimitiveUnTyped memberPrimitiveUnTyped;
55 
56  internal MemberReference memberReference;
57 
58  internal ObjectNull objectNull;
59 
60  internal static volatile MessageEnd messageEnd;
61 
62  internal BinaryAssemblyInfo SystemAssemblyInfo
63  {
64  get
65  {
66  if (systemAssemblyInfo == null)
67  {
68  systemAssemblyInfo = new BinaryAssemblyInfo(Converter.urtAssemblyString, Converter.urtAssembly);
69  }
70  return systemAssemblyInfo;
71  }
72  }
73 
74  internal SizedArray ObjectMapIdTable
75  {
76  get
77  {
78  if (objectMapIdTable == null)
79  {
80  objectMapIdTable = new SizedArray();
81  }
82  return objectMapIdTable;
83  }
84  }
85 
86  internal SizedArray AssemIdToAssemblyTable
87  {
88  get
89  {
90  if (assemIdToAssemblyTable == null)
91  {
92  assemIdToAssemblyTable = new SizedArray(2);
93  }
94  return assemIdToAssemblyTable;
95  }
96  }
97 
98  internal ParseRecord prs
99  {
100  get
101  {
102  if (PRS == null)
103  {
104  PRS = new ParseRecord();
105  }
106  return PRS;
107  }
108  }
109 
110  internal __BinaryParser(Stream stream, ObjectReader objectReader)
111  {
112  input = stream;
113  this.objectReader = objectReader;
114  dataReader = new BinaryReader(input, encoding);
115  }
116 
117  [SecurityCritical]
118  internal void Run()
119  {
120  try
121  {
122  bool flag = true;
123  ReadBegin();
124  ReadSerializationHeaderRecord();
125  while (flag)
126  {
127  BinaryHeaderEnum binaryHeaderEnum = BinaryHeaderEnum.Object;
128  switch (expectedType)
129  {
130  case BinaryTypeEnum.String:
131  case BinaryTypeEnum.Object:
132  case BinaryTypeEnum.ObjectUrt:
133  case BinaryTypeEnum.ObjectUser:
134  case BinaryTypeEnum.ObjectArray:
135  case BinaryTypeEnum.StringArray:
136  case BinaryTypeEnum.PrimitiveArray:
137  {
138  byte b = dataReader.ReadByte();
139  binaryHeaderEnum = (BinaryHeaderEnum)b;
140  switch (binaryHeaderEnum)
141  {
142  case BinaryHeaderEnum.Assembly:
143  case BinaryHeaderEnum.CrossAppDomainAssembly:
144  ReadAssembly(binaryHeaderEnum);
145  break;
146  case BinaryHeaderEnum.Object:
147  ReadObject();
148  break;
149  case BinaryHeaderEnum.CrossAppDomainMap:
150  ReadCrossAppDomainMap();
151  break;
152  case BinaryHeaderEnum.ObjectWithMap:
153  case BinaryHeaderEnum.ObjectWithMapAssemId:
154  ReadObjectWithMap(binaryHeaderEnum);
155  break;
156  case BinaryHeaderEnum.ObjectWithMapTyped:
157  case BinaryHeaderEnum.ObjectWithMapTypedAssemId:
158  ReadObjectWithMapTyped(binaryHeaderEnum);
159  break;
160  case BinaryHeaderEnum.MethodCall:
161  case BinaryHeaderEnum.MethodReturn:
162  ReadMethodObject(binaryHeaderEnum);
163  break;
164  case BinaryHeaderEnum.ObjectString:
165  case BinaryHeaderEnum.CrossAppDomainString:
166  ReadObjectString(binaryHeaderEnum);
167  break;
168  case BinaryHeaderEnum.Array:
169  case BinaryHeaderEnum.ArraySinglePrimitive:
170  case BinaryHeaderEnum.ArraySingleObject:
171  case BinaryHeaderEnum.ArraySingleString:
172  ReadArray(binaryHeaderEnum);
173  break;
174  case BinaryHeaderEnum.MemberPrimitiveTyped:
175  ReadMemberPrimitiveTyped();
176  break;
177  case BinaryHeaderEnum.MemberReference:
178  ReadMemberReference();
179  break;
180  case BinaryHeaderEnum.ObjectNull:
181  case BinaryHeaderEnum.ObjectNullMultiple256:
182  case BinaryHeaderEnum.ObjectNullMultiple:
183  ReadObjectNull(binaryHeaderEnum);
184  break;
185  case BinaryHeaderEnum.MessageEnd:
186  flag = false;
187  ReadMessageEnd();
188  ReadEnd();
189  break;
190  default:
191  throw new SerializationException(Environment.GetResourceString("Serialization_BinaryHeader", b));
192  }
193  break;
194  }
195  case BinaryTypeEnum.Primitive:
196  ReadMemberPrimitiveUnTyped();
197  break;
198  default:
199  throw new SerializationException(Environment.GetResourceString("Serialization_TypeExpected"));
200  }
201  if (binaryHeaderEnum != BinaryHeaderEnum.Assembly)
202  {
203  bool flag2 = false;
204  while (!flag2)
205  {
206  ObjectProgress objectProgress = (ObjectProgress)stack.Peek();
207  if (objectProgress == null)
208  {
209  expectedType = BinaryTypeEnum.ObjectUrt;
210  expectedTypeInformation = null;
211  flag2 = true;
212  }
213  else
214  {
215  flag2 = objectProgress.GetNext(out objectProgress.expectedType, out objectProgress.expectedTypeInformation);
216  expectedType = objectProgress.expectedType;
217  expectedTypeInformation = objectProgress.expectedTypeInformation;
218  if (!flag2)
219  {
220  prs.Init();
221  if (objectProgress.memberValueEnum == InternalMemberValueE.Nested)
222  {
223  prs.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
224  prs.PRmemberTypeEnum = objectProgress.memberTypeEnum;
225  prs.PRmemberValueEnum = objectProgress.memberValueEnum;
226  objectReader.Parse(prs);
227  }
228  else
229  {
230  prs.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
231  prs.PRmemberTypeEnum = objectProgress.memberTypeEnum;
232  prs.PRmemberValueEnum = objectProgress.memberValueEnum;
233  objectReader.Parse(prs);
234  }
235  stack.Pop();
236  PutOp(objectProgress);
237  }
238  }
239  }
240  }
241  }
242  }
243  catch (EndOfStreamException)
244  {
245  throw new SerializationException(Environment.GetResourceString("Serialization_StreamEnd"));
246  }
247  }
248 
249  internal void ReadBegin()
250  {
251  }
252 
253  internal void ReadEnd()
254  {
255  }
256 
257  internal bool ReadBoolean()
258  {
259  return dataReader.ReadBoolean();
260  }
261 
262  internal byte ReadByte()
263  {
264  return dataReader.ReadByte();
265  }
266 
267  internal byte[] ReadBytes(int length)
268  {
269  return dataReader.ReadBytes(length);
270  }
271 
272  internal void ReadBytes(byte[] byteA, int offset, int size)
273  {
274  while (size > 0)
275  {
276  int num = dataReader.Read(byteA, offset, size);
277  if (num == 0)
278  {
279  __Error.EndOfFile();
280  }
281  offset += num;
282  size -= num;
283  }
284  }
285 
286  internal char ReadChar()
287  {
288  return dataReader.ReadChar();
289  }
290 
291  internal char[] ReadChars(int length)
292  {
293  return dataReader.ReadChars(length);
294  }
295 
296  internal decimal ReadDecimal()
297  {
298  return decimal.Parse(dataReader.ReadString(), CultureInfo.InvariantCulture);
299  }
300 
301  internal float ReadSingle()
302  {
303  return dataReader.ReadSingle();
304  }
305 
306  internal double ReadDouble()
307  {
308  return dataReader.ReadDouble();
309  }
310 
311  internal short ReadInt16()
312  {
313  return dataReader.ReadInt16();
314  }
315 
316  internal int ReadInt32()
317  {
318  return dataReader.ReadInt32();
319  }
320 
321  internal long ReadInt64()
322  {
323  return dataReader.ReadInt64();
324  }
325 
326  internal sbyte ReadSByte()
327  {
328  return (sbyte)ReadByte();
329  }
330 
331  internal string ReadString()
332  {
333  return dataReader.ReadString();
334  }
335 
336  internal TimeSpan ReadTimeSpan()
337  {
338  return new TimeSpan(ReadInt64());
339  }
340 
341  internal DateTime ReadDateTime()
342  {
343  return DateTime.FromBinaryRaw(ReadInt64());
344  }
345 
346  internal ushort ReadUInt16()
347  {
348  return dataReader.ReadUInt16();
349  }
350 
351  internal uint ReadUInt32()
352  {
353  return dataReader.ReadUInt32();
354  }
355 
356  internal ulong ReadUInt64()
357  {
358  return dataReader.ReadUInt64();
359  }
360 
361  [SecurityCritical]
362  internal void ReadSerializationHeaderRecord()
363  {
364  SerializationHeaderRecord serializationHeaderRecord = new SerializationHeaderRecord();
365  serializationHeaderRecord.Read(this);
366  serializationHeaderRecord.Dump();
367  topId = ((serializationHeaderRecord.topId > 0) ? objectReader.GetId(serializationHeaderRecord.topId) : serializationHeaderRecord.topId);
368  headerId = ((serializationHeaderRecord.headerId > 0) ? objectReader.GetId(serializationHeaderRecord.headerId) : serializationHeaderRecord.headerId);
369  }
370 
371  [SecurityCritical]
372  internal void ReadAssembly(BinaryHeaderEnum binaryHeaderEnum)
373  {
374  BinaryAssembly binaryAssembly = new BinaryAssembly();
375  if (binaryHeaderEnum == BinaryHeaderEnum.CrossAppDomainAssembly)
376  {
377  BinaryCrossAppDomainAssembly binaryCrossAppDomainAssembly = new BinaryCrossAppDomainAssembly();
378  binaryCrossAppDomainAssembly.Read(this);
379  binaryCrossAppDomainAssembly.Dump();
380  binaryAssembly.assemId = binaryCrossAppDomainAssembly.assemId;
381  binaryAssembly.assemblyString = (objectReader.CrossAppDomainArray(binaryCrossAppDomainAssembly.assemblyIndex) as string);
382  if (binaryAssembly.assemblyString == null)
383  {
384  throw new SerializationException(Environment.GetResourceString("Serialization_CrossAppDomainError", "String", binaryCrossAppDomainAssembly.assemblyIndex));
385  }
386  }
387  else
388  {
389  binaryAssembly.Read(this);
390  binaryAssembly.Dump();
391  }
392  AssemIdToAssemblyTable[binaryAssembly.assemId] = new BinaryAssemblyInfo(binaryAssembly.assemblyString);
393  }
394 
395  [SecurityCritical]
396  internal void ReadMethodObject(BinaryHeaderEnum binaryHeaderEnum)
397  {
398  if (binaryHeaderEnum == BinaryHeaderEnum.MethodCall)
399  {
400  BinaryMethodCall binaryMethodCall = new BinaryMethodCall();
401  binaryMethodCall.Read(this);
402  binaryMethodCall.Dump();
403  objectReader.SetMethodCall(binaryMethodCall);
404  }
405  else
406  {
407  BinaryMethodReturn binaryMethodReturn = new BinaryMethodReturn();
408  binaryMethodReturn.Read(this);
409  binaryMethodReturn.Dump();
410  objectReader.SetMethodReturn(binaryMethodReturn);
411  }
412  }
413 
414  [SecurityCritical]
415  private void ReadObject()
416  {
417  if (binaryObject == null)
418  {
419  binaryObject = new BinaryObject();
420  }
421  binaryObject.Read(this);
422  binaryObject.Dump();
423  ObjectMap objectMap = (ObjectMap)ObjectMapIdTable[binaryObject.mapId];
424  if (objectMap == null)
425  {
426  throw new SerializationException(Environment.GetResourceString("Serialization_Map", binaryObject.mapId));
427  }
428  ObjectProgress op = GetOp();
429  ParseRecord pr = op.pr;
430  stack.Push(op);
431  op.objectTypeEnum = InternalObjectTypeE.Object;
432  op.binaryTypeEnumA = objectMap.binaryTypeEnumA;
433  op.memberNames = objectMap.memberNames;
434  op.memberTypes = objectMap.memberTypes;
435  op.typeInformationA = objectMap.typeInformationA;
436  op.memberLength = op.binaryTypeEnumA.Length;
437  ObjectProgress objectProgress = (ObjectProgress)stack.PeekPeek();
438  if (objectProgress == null || objectProgress.isInitial)
439  {
440  op.name = objectMap.objectName;
441  pr.PRparseTypeEnum = InternalParseTypeE.Object;
442  op.memberValueEnum = InternalMemberValueE.Empty;
443  }
444  else
445  {
446  pr.PRparseTypeEnum = InternalParseTypeE.Member;
447  pr.PRmemberValueEnum = InternalMemberValueE.Nested;
448  op.memberValueEnum = InternalMemberValueE.Nested;
449  switch (objectProgress.objectTypeEnum)
450  {
451  case InternalObjectTypeE.Object:
452  pr.PRname = objectProgress.name;
453  pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
454  op.memberTypeEnum = InternalMemberTypeE.Field;
455  break;
456  case InternalObjectTypeE.Array:
457  pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
458  op.memberTypeEnum = InternalMemberTypeE.Item;
459  break;
460  default:
461  throw new SerializationException(Environment.GetResourceString("Serialization_Map", objectProgress.objectTypeEnum.ToString()));
462  }
463  }
464  pr.PRobjectId = objectReader.GetId(binaryObject.objectId);
465  pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
466  if (pr.PRobjectId == topId)
467  {
468  pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
469  }
470  pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
471  pr.PRkeyDt = objectMap.objectName;
472  pr.PRdtType = objectMap.objectType;
473  pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
474  objectReader.Parse(pr);
475  }
476 
477  [SecurityCritical]
478  internal void ReadCrossAppDomainMap()
479  {
480  BinaryCrossAppDomainMap binaryCrossAppDomainMap = new BinaryCrossAppDomainMap();
481  binaryCrossAppDomainMap.Read(this);
482  binaryCrossAppDomainMap.Dump();
483  object obj = objectReader.CrossAppDomainArray(binaryCrossAppDomainMap.crossAppDomainArrayIndex);
484  BinaryObjectWithMap binaryObjectWithMap = obj as BinaryObjectWithMap;
485  if (binaryObjectWithMap != null)
486  {
487  binaryObjectWithMap.Dump();
488  ReadObjectWithMap(binaryObjectWithMap);
489  return;
490  }
491  BinaryObjectWithMapTyped binaryObjectWithMapTyped = obj as BinaryObjectWithMapTyped;
492  if (binaryObjectWithMapTyped != null)
493  {
494  ReadObjectWithMapTyped(binaryObjectWithMapTyped);
495  return;
496  }
497  throw new SerializationException(Environment.GetResourceString("Serialization_CrossAppDomainError", "BinaryObjectMap", obj));
498  }
499 
500  [SecurityCritical]
501  internal void ReadObjectWithMap(BinaryHeaderEnum binaryHeaderEnum)
502  {
503  if (bowm == null)
504  {
505  bowm = new BinaryObjectWithMap(binaryHeaderEnum);
506  }
507  else
508  {
509  bowm.binaryHeaderEnum = binaryHeaderEnum;
510  }
511  bowm.Read(this);
512  bowm.Dump();
513  ReadObjectWithMap(bowm);
514  }
515 
516  [SecurityCritical]
517  private void ReadObjectWithMap(BinaryObjectWithMap record)
518  {
519  BinaryAssemblyInfo binaryAssemblyInfo = null;
520  ObjectProgress op = GetOp();
521  ParseRecord pr = op.pr;
522  stack.Push(op);
523  if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapAssemId)
524  {
525  if (record.assemId < 1)
526  {
527  throw new SerializationException(Environment.GetResourceString("Serialization_Assembly", record.name));
528  }
529  binaryAssemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId];
530  if (binaryAssemblyInfo == null)
531  {
532  throw new SerializationException(Environment.GetResourceString("Serialization_Assembly", record.assemId + " " + record.name));
533  }
534  }
535  else if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMap)
536  {
537  binaryAssemblyInfo = SystemAssemblyInfo;
538  }
539  Type type = objectReader.GetType(binaryAssemblyInfo, record.name);
540  ObjectMap objectMap = ObjectMap.Create(record.name, type, record.memberNames, objectReader, record.objectId, binaryAssemblyInfo);
541  ObjectMapIdTable[record.objectId] = objectMap;
542  op.objectTypeEnum = InternalObjectTypeE.Object;
543  op.binaryTypeEnumA = objectMap.binaryTypeEnumA;
544  op.typeInformationA = objectMap.typeInformationA;
545  op.memberLength = op.binaryTypeEnumA.Length;
546  op.memberNames = objectMap.memberNames;
547  op.memberTypes = objectMap.memberTypes;
548  ObjectProgress objectProgress = (ObjectProgress)stack.PeekPeek();
549  if (objectProgress == null || objectProgress.isInitial)
550  {
551  op.name = record.name;
552  pr.PRparseTypeEnum = InternalParseTypeE.Object;
553  op.memberValueEnum = InternalMemberValueE.Empty;
554  }
555  else
556  {
557  pr.PRparseTypeEnum = InternalParseTypeE.Member;
558  pr.PRmemberValueEnum = InternalMemberValueE.Nested;
559  op.memberValueEnum = InternalMemberValueE.Nested;
560  switch (objectProgress.objectTypeEnum)
561  {
562  case InternalObjectTypeE.Object:
563  pr.PRname = objectProgress.name;
564  pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
565  op.memberTypeEnum = InternalMemberTypeE.Field;
566  break;
567  case InternalObjectTypeE.Array:
568  pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
569  op.memberTypeEnum = InternalMemberTypeE.Field;
570  break;
571  default:
572  throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", objectProgress.objectTypeEnum.ToString()));
573  }
574  }
575  pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
576  pr.PRobjectId = objectReader.GetId(record.objectId);
577  pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
578  if (pr.PRobjectId == topId)
579  {
580  pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
581  }
582  pr.PRkeyDt = record.name;
583  pr.PRdtType = objectMap.objectType;
584  pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
585  objectReader.Parse(pr);
586  }
587 
588  [SecurityCritical]
589  internal void ReadObjectWithMapTyped(BinaryHeaderEnum binaryHeaderEnum)
590  {
591  if (bowmt == null)
592  {
593  bowmt = new BinaryObjectWithMapTyped(binaryHeaderEnum);
594  }
595  else
596  {
597  bowmt.binaryHeaderEnum = binaryHeaderEnum;
598  }
599  bowmt.Read(this);
600  ReadObjectWithMapTyped(bowmt);
601  }
602 
603  [SecurityCritical]
604  private void ReadObjectWithMapTyped(BinaryObjectWithMapTyped record)
605  {
606  BinaryAssemblyInfo binaryAssemblyInfo = null;
607  ObjectProgress op = GetOp();
608  ParseRecord pr = op.pr;
609  stack.Push(op);
610  if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTypedAssemId)
611  {
612  if (record.assemId < 1)
613  {
614  throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", record.name));
615  }
616  binaryAssemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId];
617  if (binaryAssemblyInfo == null)
618  {
619  throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", record.assemId + " " + record.name));
620  }
621  }
622  else if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTyped)
623  {
624  binaryAssemblyInfo = SystemAssemblyInfo;
625  }
626  ObjectMap objectMap = ObjectMap.Create(record.name, record.memberNames, record.binaryTypeEnumA, record.typeInformationA, record.memberAssemIds, objectReader, record.objectId, binaryAssemblyInfo, AssemIdToAssemblyTable);
627  ObjectMapIdTable[record.objectId] = objectMap;
628  op.objectTypeEnum = InternalObjectTypeE.Object;
629  op.binaryTypeEnumA = objectMap.binaryTypeEnumA;
630  op.typeInformationA = objectMap.typeInformationA;
631  op.memberLength = op.binaryTypeEnumA.Length;
632  op.memberNames = objectMap.memberNames;
633  op.memberTypes = objectMap.memberTypes;
634  ObjectProgress objectProgress = (ObjectProgress)stack.PeekPeek();
635  if (objectProgress == null || objectProgress.isInitial)
636  {
637  op.name = record.name;
638  pr.PRparseTypeEnum = InternalParseTypeE.Object;
639  op.memberValueEnum = InternalMemberValueE.Empty;
640  }
641  else
642  {
643  pr.PRparseTypeEnum = InternalParseTypeE.Member;
644  pr.PRmemberValueEnum = InternalMemberValueE.Nested;
645  op.memberValueEnum = InternalMemberValueE.Nested;
646  switch (objectProgress.objectTypeEnum)
647  {
648  case InternalObjectTypeE.Object:
649  pr.PRname = objectProgress.name;
650  pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
651  op.memberTypeEnum = InternalMemberTypeE.Field;
652  break;
653  case InternalObjectTypeE.Array:
654  pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
655  op.memberTypeEnum = InternalMemberTypeE.Item;
656  break;
657  default:
658  throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", objectProgress.objectTypeEnum.ToString()));
659  }
660  }
661  pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
662  pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
663  pr.PRobjectId = objectReader.GetId(record.objectId);
664  if (pr.PRobjectId == topId)
665  {
666  pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
667  }
668  pr.PRkeyDt = record.name;
669  pr.PRdtType = objectMap.objectType;
670  pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
671  objectReader.Parse(pr);
672  }
673 
674  [SecurityCritical]
675  private void ReadObjectString(BinaryHeaderEnum binaryHeaderEnum)
676  {
677  if (objectString == null)
678  {
679  objectString = new BinaryObjectString();
680  }
681  if (binaryHeaderEnum == BinaryHeaderEnum.ObjectString)
682  {
683  objectString.Read(this);
684  objectString.Dump();
685  }
686  else
687  {
688  if (crossAppDomainString == null)
689  {
690  crossAppDomainString = new BinaryCrossAppDomainString();
691  }
692  crossAppDomainString.Read(this);
693  crossAppDomainString.Dump();
694  objectString.value = (objectReader.CrossAppDomainArray(crossAppDomainString.value) as string);
695  if (objectString.value == null)
696  {
697  throw new SerializationException(Environment.GetResourceString("Serialization_CrossAppDomainError", "String", crossAppDomainString.value));
698  }
699  objectString.objectId = crossAppDomainString.objectId;
700  }
701  prs.Init();
702  prs.PRparseTypeEnum = InternalParseTypeE.Object;
703  prs.PRobjectId = objectReader.GetId(objectString.objectId);
704  if (prs.PRobjectId == topId)
705  {
706  prs.PRobjectPositionEnum = InternalObjectPositionE.Top;
707  }
708  prs.PRobjectTypeEnum = InternalObjectTypeE.Object;
709  ObjectProgress objectProgress = (ObjectProgress)stack.Peek();
710  prs.PRvalue = objectString.value;
711  prs.PRkeyDt = "System.String";
712  prs.PRdtType = Converter.typeofString;
713  prs.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
714  prs.PRvarValue = objectString.value;
715  if (objectProgress == null)
716  {
717  prs.PRparseTypeEnum = InternalParseTypeE.Object;
718  prs.PRname = "System.String";
719  }
720  else
721  {
722  prs.PRparseTypeEnum = InternalParseTypeE.Member;
723  prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
724  switch (objectProgress.objectTypeEnum)
725  {
726  case InternalObjectTypeE.Object:
727  prs.PRname = objectProgress.name;
728  prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
729  break;
730  case InternalObjectTypeE.Array:
731  prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
732  break;
733  default:
734  throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", objectProgress.objectTypeEnum.ToString()));
735  }
736  }
737  objectReader.Parse(prs);
738  }
739 
740  [SecurityCritical]
741  private void ReadMemberPrimitiveTyped()
742  {
743  if (memberPrimitiveTyped == null)
744  {
745  memberPrimitiveTyped = new MemberPrimitiveTyped();
746  }
747  memberPrimitiveTyped.Read(this);
748  memberPrimitiveTyped.Dump();
749  prs.PRobjectTypeEnum = InternalObjectTypeE.Object;
750  ObjectProgress objectProgress = (ObjectProgress)stack.Peek();
751  prs.Init();
752  prs.PRvarValue = memberPrimitiveTyped.value;
753  prs.PRkeyDt = Converter.ToComType(memberPrimitiveTyped.primitiveTypeEnum);
754  prs.PRdtType = Converter.ToType(memberPrimitiveTyped.primitiveTypeEnum);
755  prs.PRdtTypeCode = memberPrimitiveTyped.primitiveTypeEnum;
756  if (objectProgress == null)
757  {
758  prs.PRparseTypeEnum = InternalParseTypeE.Object;
759  prs.PRname = "System.Variant";
760  }
761  else
762  {
763  prs.PRparseTypeEnum = InternalParseTypeE.Member;
764  prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
765  switch (objectProgress.objectTypeEnum)
766  {
767  case InternalObjectTypeE.Object:
768  prs.PRname = objectProgress.name;
769  prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
770  break;
771  case InternalObjectTypeE.Array:
772  prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
773  break;
774  default:
775  throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", objectProgress.objectTypeEnum.ToString()));
776  }
777  }
778  objectReader.Parse(prs);
779  }
780 
781  [SecurityCritical]
782  private void ReadArray(BinaryHeaderEnum binaryHeaderEnum)
783  {
784  BinaryAssemblyInfo binaryAssemblyInfo = null;
785  BinaryArray binaryArray = new BinaryArray(binaryHeaderEnum);
786  binaryArray.Read(this);
787  if (binaryArray.binaryTypeEnum == BinaryTypeEnum.ObjectUser)
788  {
789  if (binaryArray.assemId < 1)
790  {
791  throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", binaryArray.typeInformation));
792  }
793  binaryAssemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[binaryArray.assemId];
794  }
795  else
796  {
797  binaryAssemblyInfo = SystemAssemblyInfo;
798  }
799  ObjectProgress op = GetOp();
800  ParseRecord pr = op.pr;
801  op.objectTypeEnum = InternalObjectTypeE.Array;
802  op.binaryTypeEnum = binaryArray.binaryTypeEnum;
803  op.typeInformation = binaryArray.typeInformation;
804  ObjectProgress objectProgress = (ObjectProgress)stack.PeekPeek();
805  if (objectProgress == null || binaryArray.objectId > 0)
806  {
807  op.name = "System.Array";
808  pr.PRparseTypeEnum = InternalParseTypeE.Object;
809  op.memberValueEnum = InternalMemberValueE.Empty;
810  }
811  else
812  {
813  pr.PRparseTypeEnum = InternalParseTypeE.Member;
814  pr.PRmemberValueEnum = InternalMemberValueE.Nested;
815  op.memberValueEnum = InternalMemberValueE.Nested;
816  switch (objectProgress.objectTypeEnum)
817  {
818  case InternalObjectTypeE.Object:
819  pr.PRname = objectProgress.name;
820  pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
821  op.memberTypeEnum = InternalMemberTypeE.Field;
822  pr.PRkeyDt = objectProgress.name;
823  pr.PRdtType = objectProgress.dtType;
824  break;
825  case InternalObjectTypeE.Array:
826  pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
827  op.memberTypeEnum = InternalMemberTypeE.Item;
828  break;
829  default:
830  throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", objectProgress.objectTypeEnum.ToString()));
831  }
832  }
833  pr.PRobjectId = objectReader.GetId(binaryArray.objectId);
834  if (pr.PRobjectId == topId)
835  {
836  pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
837  }
838  else if (headerId > 0 && pr.PRobjectId == headerId)
839  {
840  pr.PRobjectPositionEnum = InternalObjectPositionE.Headers;
841  }
842  else
843  {
844  pr.PRobjectPositionEnum = InternalObjectPositionE.Child;
845  }
846  pr.PRobjectTypeEnum = InternalObjectTypeE.Array;
847  BinaryConverter.TypeFromInfo(binaryArray.binaryTypeEnum, binaryArray.typeInformation, objectReader, binaryAssemblyInfo, out pr.PRarrayElementTypeCode, out pr.PRarrayElementTypeString, out pr.PRarrayElementType, out pr.PRisArrayVariant);
848  pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
849  pr.PRrank = binaryArray.rank;
850  pr.PRlengthA = binaryArray.lengthA;
851  pr.PRlowerBoundA = binaryArray.lowerBoundA;
852  bool flag = false;
853  switch (binaryArray.binaryArrayTypeEnum)
854  {
855  case BinaryArrayTypeEnum.Single:
856  case BinaryArrayTypeEnum.SingleOffset:
857  op.numItems = binaryArray.lengthA[0];
858  pr.PRarrayTypeEnum = InternalArrayTypeE.Single;
859  if (Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode) && binaryArray.lowerBoundA[0] == 0)
860  {
861  flag = true;
862  ReadArrayAsBytes(pr);
863  }
864  break;
865  case BinaryArrayTypeEnum.Jagged:
866  case BinaryArrayTypeEnum.JaggedOffset:
867  op.numItems = binaryArray.lengthA[0];
868  pr.PRarrayTypeEnum = InternalArrayTypeE.Jagged;
869  break;
870  case BinaryArrayTypeEnum.Rectangular:
871  case BinaryArrayTypeEnum.RectangularOffset:
872  {
873  int num = 1;
874  for (int i = 0; i < binaryArray.rank; i++)
875  {
876  num *= binaryArray.lengthA[i];
877  }
878  op.numItems = num;
879  pr.PRarrayTypeEnum = InternalArrayTypeE.Rectangular;
880  break;
881  }
882  default:
883  throw new SerializationException(Environment.GetResourceString("Serialization_ArrayType", binaryArray.binaryArrayTypeEnum.ToString()));
884  }
885  if (!flag)
886  {
887  stack.Push(op);
888  }
889  else
890  {
891  PutOp(op);
892  }
893  objectReader.Parse(pr);
894  if (flag)
895  {
896  pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
897  objectReader.Parse(pr);
898  }
899  }
900 
901  [SecurityCritical]
902  private void ReadArrayAsBytes(ParseRecord pr)
903  {
904  if (pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Byte)
905  {
906  pr.PRnewObj = ReadBytes(pr.PRlengthA[0]);
907  return;
908  }
909  if (pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Char)
910  {
911  pr.PRnewObj = ReadChars(pr.PRlengthA[0]);
912  return;
913  }
914  int num = Converter.TypeLength(pr.PRarrayElementTypeCode);
915  pr.PRnewObj = Converter.CreatePrimitiveArray(pr.PRarrayElementTypeCode, pr.PRlengthA[0]);
916  Array array = (Array)pr.PRnewObj;
917  int i = 0;
918  if (byteBuffer == null)
919  {
920  byteBuffer = new byte[4096];
921  }
922  int num2;
923  for (; i < array.Length; i += num2)
924  {
925  num2 = Math.Min(4096 / num, array.Length - i);
926  int num3 = num2 * num;
927  ReadBytes(byteBuffer, 0, num3);
928  Buffer.InternalBlockCopy(byteBuffer, 0, array, i * num, num3);
929  }
930  }
931 
932  [SecurityCritical]
933  private void ReadMemberPrimitiveUnTyped()
934  {
935  ObjectProgress objectProgress = (ObjectProgress)stack.Peek();
936  if (memberPrimitiveUnTyped == null)
937  {
938  memberPrimitiveUnTyped = new MemberPrimitiveUnTyped();
939  }
940  memberPrimitiveUnTyped.Set((InternalPrimitiveTypeE)expectedTypeInformation);
941  memberPrimitiveUnTyped.Read(this);
942  memberPrimitiveUnTyped.Dump();
943  prs.Init();
944  prs.PRvarValue = memberPrimitiveUnTyped.value;
945  prs.PRdtTypeCode = (InternalPrimitiveTypeE)expectedTypeInformation;
946  prs.PRdtType = Converter.ToType(prs.PRdtTypeCode);
947  prs.PRparseTypeEnum = InternalParseTypeE.Member;
948  prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
949  if (objectProgress.objectTypeEnum == InternalObjectTypeE.Object)
950  {
951  prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
952  prs.PRname = objectProgress.name;
953  }
954  else
955  {
956  prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
957  }
958  objectReader.Parse(prs);
959  }
960 
961  [SecurityCritical]
962  private void ReadMemberReference()
963  {
964  if (memberReference == null)
965  {
966  memberReference = new MemberReference();
967  }
968  memberReference.Read(this);
969  memberReference.Dump();
970  ObjectProgress objectProgress = (ObjectProgress)stack.Peek();
971  prs.Init();
972  prs.PRidRef = objectReader.GetId(memberReference.idRef);
973  prs.PRparseTypeEnum = InternalParseTypeE.Member;
974  prs.PRmemberValueEnum = InternalMemberValueE.Reference;
975  if (objectProgress.objectTypeEnum == InternalObjectTypeE.Object)
976  {
977  prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
978  prs.PRname = objectProgress.name;
979  prs.PRdtType = objectProgress.dtType;
980  }
981  else
982  {
983  prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
984  }
985  objectReader.Parse(prs);
986  }
987 
988  [SecurityCritical]
989  private void ReadObjectNull(BinaryHeaderEnum binaryHeaderEnum)
990  {
991  if (objectNull == null)
992  {
993  objectNull = new ObjectNull();
994  }
995  objectNull.Read(this, binaryHeaderEnum);
996  objectNull.Dump();
997  ObjectProgress objectProgress = (ObjectProgress)stack.Peek();
998  prs.Init();
999  prs.PRparseTypeEnum = InternalParseTypeE.Member;
1000  prs.PRmemberValueEnum = InternalMemberValueE.Null;
1001  if (objectProgress.objectTypeEnum == InternalObjectTypeE.Object)
1002  {
1003  prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
1004  prs.PRname = objectProgress.name;
1005  prs.PRdtType = objectProgress.dtType;
1006  }
1007  else
1008  {
1009  prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
1010  prs.PRnullCount = objectNull.nullCount;
1011  objectProgress.ArrayCountIncrement(objectNull.nullCount - 1);
1012  }
1013  objectReader.Parse(prs);
1014  }
1015 
1016  [SecurityCritical]
1017  private void ReadMessageEnd()
1018  {
1019  if (messageEnd == null)
1020  {
1021  messageEnd = new MessageEnd();
1022  }
1023  messageEnd.Read(this);
1024  messageEnd.Dump();
1025  if (!stack.IsEmpty())
1026  {
1027  throw new SerializationException(Environment.GetResourceString("Serialization_StreamEnd"));
1028  }
1029  }
1030 
1031  internal object ReadValue(InternalPrimitiveTypeE code)
1032  {
1033  object obj = null;
1034  switch (code)
1035  {
1036  case InternalPrimitiveTypeE.Boolean:
1037  return ReadBoolean();
1038  case InternalPrimitiveTypeE.Byte:
1039  return ReadByte();
1040  case InternalPrimitiveTypeE.Char:
1041  return ReadChar();
1042  case InternalPrimitiveTypeE.Double:
1043  return ReadDouble();
1044  case InternalPrimitiveTypeE.Int16:
1045  return ReadInt16();
1046  case InternalPrimitiveTypeE.Int32:
1047  return ReadInt32();
1048  case InternalPrimitiveTypeE.Int64:
1049  return ReadInt64();
1050  case InternalPrimitiveTypeE.SByte:
1051  return ReadSByte();
1052  case InternalPrimitiveTypeE.Single:
1053  return ReadSingle();
1054  case InternalPrimitiveTypeE.UInt16:
1055  return ReadUInt16();
1056  case InternalPrimitiveTypeE.UInt32:
1057  return ReadUInt32();
1058  case InternalPrimitiveTypeE.UInt64:
1059  return ReadUInt64();
1060  case InternalPrimitiveTypeE.Decimal:
1061  return ReadDecimal();
1062  case InternalPrimitiveTypeE.TimeSpan:
1063  return ReadTimeSpan();
1064  case InternalPrimitiveTypeE.DateTime:
1065  return ReadDateTime();
1066  default:
1067  throw new SerializationException(Environment.GetResourceString("Serialization_TypeCode", code.ToString()));
1068  }
1069  }
1070 
1071  private ObjectProgress GetOp()
1072  {
1073  ObjectProgress objectProgress = null;
1074  if (opPool != null && !opPool.IsEmpty())
1075  {
1076  objectProgress = (ObjectProgress)opPool.Pop();
1077  objectProgress.Init();
1078  }
1079  else
1080  {
1081  objectProgress = new ObjectProgress();
1082  }
1083  return objectProgress;
1084  }
1085 
1086  private void PutOp(ObjectProgress op)
1087  {
1088  if (opPool == null)
1089  {
1090  opPool = new SerStack("opPool");
1091  }
1092  opPool.Push(op);
1093  }
1094  }
1095 }
System.Text.Encoding
Represents a character encoding.To browse the .NET Framework source code for this type,...
Definition: Encoding.cs:15
System.Text
Definition: ASCIIEncoding.cs:4
System.Globalization.CultureInfo.InvariantCulture
static CultureInfo InvariantCulture
Gets the T:System.Globalization.CultureInfo object that is culture-independent (invariant).
Definition: CultureInfo.cs:263
System.IO.EndOfStreamException
The exception that is thrown when reading is attempted past the end of a stream.
Definition: EndOfStreamException.cs:10
System.IO.BinaryReader.ReadChars
virtual char [] ReadChars(int count)
Reads the specified number of characters from the current stream, returns the data in a character arr...
Definition: BinaryReader.cs:608
System.IO.BinaryReader.ReadInt32
virtual int ReadInt32()
Reads a 4-byte signed integer from the current stream and advances the current position of the stream...
Definition: BinaryReader.cs:269
System.IO.BinaryReader.ReadUInt64
virtual ulong ReadUInt64()
Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by e...
Definition: BinaryReader.cs:318
System.Math.Min
static sbyte Min(sbyte val1, sbyte val2)
Returns the smaller of two 8-bit signed integers.
Definition: Math.cs:762
System
Definition: __Canon.cs:3
System.DateTime
Represents an instant in time, typically expressed as a date and time of day. To browse the ....
Definition: DateTime.cs:13
System.IO.BinaryReader.ReadByte
virtual byte ReadByte()
Reads the next byte from the current stream and advances the current position of the stream by one by...
Definition: BinaryReader.cs:194
System.IO.BinaryReader.ReadUInt16
virtual ushort ReadUInt16()
Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the...
Definition: BinaryReader.cs:257
System.IO.BinaryReader.ReadInt16
virtual short ReadInt16()
Reads a 2-byte signed integer from the current stream and advances the current position of the stream...
Definition: BinaryReader.cs:244
System.IO.BinaryReader.ReadUInt32
virtual uint ReadUInt32()
Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by fo...
Definition: BinaryReader.cs:291
System.Environment
Provides information about, and means to manipulate, the current environment and platform....
Definition: Environment.cs:21
System.IO.BinaryReader.ReadBytes
virtual byte [] ReadBytes(int count)
Reads the specified number of bytes from the current stream into a byte array and advances the curren...
Definition: BinaryReader.cs:680
System.IO.BinaryReader.ReadBoolean
virtual bool ReadBoolean()
Reads a Boolean value from the current stream and advances the current position of the stream by one ...
Definition: BinaryReader.cs:182
System.IO.BinaryReader
Reads primitive data types as binary values in a specific encoding.
Definition: BinaryReader.cs:10
System.Text.UTF8Encoding
Represents a UTF-8 encoding of Unicode characters.
Definition: UTF8Encoding.cs:11
System.Array
Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the ba...
Definition: Array.cs:17
System.Type
Represents type declarations: class types, interface types, array types, value types,...
Definition: Type.cs:18
System.Runtime.Serialization.SerializationException
The exception thrown when an error occurs during serialization or deserialization.
Definition: SerializationException.cs:9
System.IO.BinaryReader.Read
virtual int Read()
Reads characters from the underlying stream and advances the current position of the stream in accord...
Definition: BinaryReader.cs:166
System.IO.BinaryReader.ReadChar
virtual char ReadChar()
Reads the next character from the current stream and advances the current position of the stream in a...
Definition: BinaryReader.cs:228
System.IO.BinaryReader.ReadSingle
virtual unsafe float ReadSingle()
Reads a 4-byte floating point value from the current stream and advances the current position of the ...
Definition: BinaryReader.cs:333
System.TimeSpan
Represents a time interval.To browse the .NET Framework source code for this type,...
Definition: TimeSpan.cs:12
System.IO.BinaryReader.ReadDouble
virtual unsafe double ReadDouble()
Reads an 8-byte floating point value from the current stream and advances the current position of the...
Definition: BinaryReader.cs:347
System.Buffer
Manipulates arrays of primitive types.
Definition: Buffer.cs:11
System.Type.GetType
static Type GetType(string typeName, bool throwOnError, bool ignoreCase)
Gets the T:System.Type with the specified name, specifying whether to throw an exception if the type ...
Definition: Type.cs:853
System.IO.BinaryReader.ReadString
virtual string ReadString()
Reads a string from the current stream. The string is prefixed with the length, encoded as an integer...
Definition: BinaryReader.cs:381
System.Math
Provides constants and static methods for trigonometric, logarithmic, and other common mathematical f...
Definition: Math.cs:10
System.Globalization.CultureInfo
Provides information about a specific culture (called a locale for unmanaged code development)....
Definition: CultureInfo.cs:16
System.IO.BinaryReader.ReadInt64
virtual long ReadInt64()
Reads an 8-byte signed integer from the current stream and advances the current position of the strea...
Definition: BinaryReader.cs:303
System.IO.Stream
Provides a generic view of a sequence of bytes. This is an abstract class.To browse the ....
Definition: Stream.cs:16