internal virtual void Fixup(ParseRecord record, ParseRecord parent)
{
object pRnewObj = record.PRnewObj;
switch (this.valueFixupEnum)
{
case ValueFixupEnum.Array:
this.arrayObj.SetValue(pRnewObj, this.indexMap);
return;
case ValueFixupEnum.Header:
break;
case ValueFixupEnum.Member:
if (!this.objectInfo.isSi)
{
MemberInfo memberInfo = this.objectInfo.GetMemberInfo(this.memberName);
this.objectInfo.objectManager.RecordFixup(parent.PRobjectId, memberInfo, record.PRobjectId);
break;
}
this.objectInfo.objectManager.RecordDelayedFixup(parent.PRobjectId, this.memberName, record.PRobjectId);
return;
default:
return;
}
}
private void ParseMemberEnd(ParseRecord pr)
{
switch (pr.PRmemberTypeEnum)
{
case InternalMemberTypeE.Field:
if (pr.PRmemberValueEnum != InternalMemberValueE.Nested)
{
break;
}
this.ParseObjectEnd(pr);
return;
case InternalMemberTypeE.Item:
this.ParseArrayMemberEnd(pr);
return;
default:
if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
this.ParseObjectEnd(pr);
return;
}
this.ParseError(pr, (ParseRecord) this.stack.Peek());
break;
}
}
private void ParseMember(ParseRecord pr)
{
ParseRecord parentPr = (ParseRecord) this.stack.Peek();
if (parentPr != null)
{
string pRname = parentPr.PRname;
}
if ((parentPr.PRdtType == Converter.typeofSoapFault) && (pr.PRname.ToLower(CultureInfo.InvariantCulture) == "faultstring"))
{
this.faultString = pr.PRvalue;
}
if ((parentPr.PRobjectPositionEnum == InternalObjectPositionE.Top) && !this.isTopObjectResolved)
{
if (pr.PRdtType == Converter.typeofString)
{
this.ParseString(pr, parentPr);
}
this.topStack.Push(pr.Copy());
}
else
{
switch (pr.PRmemberTypeEnum)
{
case InternalMemberTypeE.Item:
this.ParseArrayMember(pr);
return;
}
if (parentPr.PRobjectInfo != null)
{
parentPr.PRobjectInfo.AddMemberSeen();
}
bool flag = ((this.IsFakeTopObject && (parentPr.PRobjectPositionEnum == InternalObjectPositionE.Top)) && (parentPr.PRobjectInfo != null)) && (parentPr.PRdtType != Converter.typeofSoapFault);
if ((pr.PRdtType == null) && parentPr.PRobjectInfo.isTyped)
{
if (flag)
{
pr.PRdtType = parentPr.PRobjectInfo.GetType(this.paramPosition++);
}
else
{
pr.PRdtType = parentPr.PRobjectInfo.GetType(pr.PRname);
}
if (pr.PRdtType == null)
{
throw new SerializationException(string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TypeResolved"), new object[] { parentPr.PRnewObj + " " + pr.PRname }));
}
pr.PRdtTypeCode = Converter.ToCode(pr.PRdtType);
}
else if (flag)
{
this.paramPosition++;
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
{
parentPr.PRobjectInfo.AddValue(pr.PRname, null);
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
this.ParseObject(pr);
this.stack.Push(pr);
if ((pr.PRobjectInfo != null) && pr.PRobjectInfo.objectType.IsValueType)
{
if (this.IsFakeTopObject)
{
parentPr.PRobjectInfo.AddParamName(pr.PRname);
}
pr.PRisValueTypeFixup = true;
this.valueFixupStack.Push(new ValueFixup(parentPr.PRnewObj, pr.PRname, parentPr.PRobjectInfo));
}
else
{
parentPr.PRobjectInfo.AddValue(pr.PRname, pr.PRnewObj);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
{
object obj2 = this.m_objectManager.GetObject(pr.PRidRef);
if (obj2 == null)
{
parentPr.PRobjectInfo.AddValue(pr.PRname, null);
parentPr.PRobjectInfo.RecordFixup(parentPr.PRobjectId, pr.PRname, pr.PRidRef);
}
else
{
parentPr.PRobjectInfo.AddValue(pr.PRname, obj2);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
if (pr.PRdtType == Converter.typeofString)
{
this.ParseString(pr, parentPr);
parentPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);
}
else if (pr.PRdtTypeCode != InternalPrimitiveTypeE.Invalid)
{
object pRvarValue = null;
if (pr.PRvarValue != null)
{
pRvarValue = pr.PRvarValue;
}
else
{
pRvarValue = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
}
if ((pr.PRdtTypeCode == InternalPrimitiveTypeE.QName) && (pRvarValue != null))
{
SoapQName name = (SoapQName) pRvarValue;
if (name.Key != null)
{
if (name.Key.Length == 0)
{
name.Namespace = (string) this.soapHandler.keyToNamespaceTable["xmlns"];
}
else
{
name.Namespace = (string) this.soapHandler.keyToNamespaceTable["xmlns:" + name.Key];
}
}
}
parentPr.PRobjectInfo.AddValue(pr.PRname, pRvarValue);
}
else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
parentPr.PRobjectInfo.AddValue(pr.PRname, Convert.FromBase64String(this.FilterBin64(pr.PRvalue)));
}
else if ((pr.PRdtType != Converter.typeofObject) || (pr.PRvalue == null))
{
if ((pr.PRdtType != null) && pr.PRdtType.IsEnum)
{
object obj3 = Enum.Parse(pr.PRdtType, pr.PRvalue);
parentPr.PRobjectInfo.AddValue(pr.PRname, obj3);
}
else if ((pr.PRdtType != null) && (pr.PRdtType == Converter.typeofTypeArray))
{
parentPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvarValue);
}
else
{
if (!pr.PRisRegistered && (pr.PRobjectId > 0L))
{
if (pr.PRvalue == null)
{
pr.PRvalue = "";
}
this.RegisterObject(pr.PRvalue, pr, parentPr);
}
if (pr.PRdtType == Converter.typeofSystemVoid)
{
parentPr.PRobjectInfo.AddValue(pr.PRname, pr.PRdtType);
}
else if (parentPr.PRobjectInfo.isSi)
{
parentPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);
}
}
}
else if ((parentPr != null) && (parentPr.PRdtType == Converter.typeofHeader))
{
pr.PRdtType = Converter.typeofString;
this.ParseString(pr, parentPr);
parentPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);
}
}
else
{
this.ParseError(pr, parentPr);
}
}
}
private void ParseArrayMemberEnd(ParseRecord pr)
{
if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
this.ParseObjectEnd(pr);
}
}
private void ParseArray(ParseRecord pr)
{
if (pr.PRobjectId < 1L)
{
pr.PRobjectId = this.GetId("GenId-" + this.objectIds);
}
if ((pr.PRarrayElementType != null) && pr.PRarrayElementType.IsEnum)
{
pr.PRisEnum = true;
}
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
if (pr.PRvalue == null)
{
pr.PRnewObj = new byte[0];
this.CheckSecurity(pr);
}
else if (pr.PRdtType == Converter.typeofSoapBase64Binary)
{
pr.PRnewObj = SoapBase64Binary.Parse(pr.PRvalue);
this.CheckSecurity(pr);
}
else if (pr.PRvalue.Length > 0)
{
pr.PRnewObj = Convert.FromBase64String(this.FilterBin64(pr.PRvalue));
this.CheckSecurity(pr);
}
else
{
pr.PRnewObj = new byte[0];
this.CheckSecurity(pr);
}
if (this.stack.Peek() == pr)
{
this.stack.Pop();
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.topObject = pr.PRnewObj;
this.isTopObjectResolved = true;
}
ParseRecord objectPr = (ParseRecord) this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, objectPr);
}
else if ((pr.PRnewObj != null) && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.topObject = pr.PRnewObj;
this.isTopObjectResolved = true;
}
ParseRecord record2 = (ParseRecord) this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, record2);
}
else if ((pr.PRarrayTypeEnum == InternalArrayTypeE.Jagged) || (pr.PRarrayTypeEnum == InternalArrayTypeE.Single))
{
if ((pr.PRlowerBoundA == null) || (pr.PRlowerBoundA[0] == 0))
{
pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, (pr.PRrank > 0) ? pr.PRlengthA[0] : 0);
pr.PRisLowerBound = false;
}
else
{
pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
pr.PRisLowerBound = true;
}
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
{
if (!pr.PRisLowerBound && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
pr.PRprimitiveArray = new PrimitiveArray(pr.PRarrayElementTypeCode, (Array) pr.PRnewObj);
}
else if (!pr.PRarrayElementType.IsValueType && (pr.PRlowerBoundA == null))
{
pr.PRobjectA = (object[]) pr.PRnewObj;
}
}
this.CheckSecurity(pr);
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Headers)
{
this.headers = (Header[]) pr.PRnewObj;
}
pr.PRindexMap = new int[1];
}
else
{
if (pr.PRarrayTypeEnum != InternalArrayTypeE.Rectangular)
{
throw new SerializationException(string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_ArrayType"), new object[] { pr.PRarrayTypeEnum.ToString() }));
}
pr.PRisLowerBound = false;
if (pr.PRlowerBoundA != null)
{
for (int j = 0; j < pr.PRrank; j++)
{
if (pr.PRlowerBoundA[j] != 0)
{
pr.PRisLowerBound = true;
}
}
}
if (!pr.PRisLowerBound)
{
pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA);
}
else
{
pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
}
this.CheckSecurity(pr);
int num3 = 1;
for (int i = 0; i < pr.PRrank; i++)
{
num3 *= pr.PRlengthA[i];
}
pr.PRindexMap = new int[pr.PRrank];
pr.PRrectangularMap = new int[pr.PRrank];
pr.PRlinearlength = num3;
}
}
private void NextRectangleMap(ParseRecord pr)
{
for (int i = pr.PRrank - 1; i > -1; i--)
{
if (pr.PRrectangularMap[i] < (pr.PRlengthA[i] - 1))
{
pr.PRrectangularMap[i]++;
if (i < (pr.PRrank - 1))
{
for (int j = i + 1; j < pr.PRrank; j++)
{
pr.PRrectangularMap[j] = 0;
}
}
Array.Copy(pr.PRrectangularMap, pr.PRindexMap, pr.PRrank);
return;
}
}
}
private void RegisterObject(object obj, ParseRecord pr, ParseRecord objectPr)
{
if (!pr.PRisRegistered)
{
pr.PRisRegistered = true;
SerializationInfo si = null;
long idOfContainingObj = 0L;
MemberInfo member = null;
int[] arrayIndex = null;
if (objectPr != null)
{
arrayIndex = objectPr.PRindexMap;
idOfContainingObj = objectPr.PRobjectId;
if ((objectPr.PRobjectInfo != null) && !objectPr.PRobjectInfo.isSi)
{
member = objectPr.PRobjectInfo.GetMemberInfo(pr.PRname);
}
}
if (pr.PRobjectInfo != null)
{
si = pr.PRobjectInfo.si;
}
this.m_objectManager.RegisterObject(obj, pr.PRobjectId, si, idOfContainingObj, member, arrayIndex);
}
}
private void ParseSerializedStreamHeaderEnd(ParseRecord pr)
{
this.stack.Pop();
}
private ParseRecord GetPr()
{
ParseRecord pr = null;
if (!prPool.IsEmpty())
{
pr = (ParseRecord)prPool.Pop();
pr.Init();
}
else
pr = new ParseRecord();
return pr;
}
private void ProcessHeaderEnd(ParseRecord pr)
{
InternalST.Soap( this,"ProcessHeaderEnd ");
pr.Dump();
if (headerList == null)
return; // Empty header array
// Object End
ParseRecord headerPr = GetPr();
headerPr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
headerPr.PRobjectTypeEnum = InternalObjectTypeE.Array;
headerList.Add(headerPr);
headerPr = (ParseRecord)headerList[0];
headerPr = (ParseRecord)headerList[0];
headerPr.PRlengthA[0] = headerArrayLength;
headerPr.PRobjectPositionEnum = InternalObjectPositionE.Headers;
for (int i=0; i<headerList.Count; i++)
{
InternalST.Soap( this, "Parse Header Record ",i);
InternalST.Soap( this,"ObjectReader.Parse 9");
objectReader.Parse((ParseRecord)headerList[i]);
}
for (int i=0; i<headerList.Count; i++)
PutPr((ParseRecord)headerList[i]);
}
private void ProcessHeaderMemberEnd(ParseRecord pr)
{
ParseRecord headerPr = null;
InternalST.Soap( this,"ProcessHeaderMemberEnd HeaderState ",((Enum)headerState).ToString());
pr.Dump();
if (headerState == HeaderStateEnum.NestedObject)
{
ParseRecord newPr = pr.Copy();
headerList.Add(newPr);
}
else
{
// Member End
headerPr = GetPr();
headerPr.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
headerPr.PRmemberTypeEnum = InternalMemberTypeE.Field;
headerPr.PRmemberValueEnum = pr.PRmemberValueEnum;
headerPr.PRisHeaderRoot = true;
headerList.Add(headerPr);
// Item End
headerPr = GetPr();
headerPr.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
headerPr.PRmemberTypeEnum = InternalMemberTypeE.Item;
headerPr.PRmemberValueEnum = InternalMemberValueE.Nested;
headerPr.PRisHeaderRoot = true;
headerList.Add(headerPr);
}
}
private void ProcessHeaderMember(ParseRecord pr)
{
ParseRecord headerPr;
InternalST.Soap( this,"ProcessHeaderMember HeaderState ",((Enum)headerState).ToString());
pr.Dump();
if (headerState == HeaderStateEnum.NestedObject)
{
// Nested object in Header member
ParseRecord newPr = pr.Copy();
headerList.Add(newPr);
return;
}
// Item record
headerPr = GetPr();
headerPr.PRparseTypeEnum = InternalParseTypeE.Member;
headerPr.PRmemberTypeEnum = InternalMemberTypeE.Item;
headerPr.PRmemberValueEnum = InternalMemberValueE.Nested;
headerPr.PRisHeaderRoot = true;
headerArrayLength++;
headerList.Add(headerPr);
// Name field
headerPr = GetPr();
headerPr.PRparseTypeEnum = InternalParseTypeE.Member;
headerPr.PRmemberTypeEnum = InternalMemberTypeE.Field;
headerPr.PRmemberValueEnum = InternalMemberValueE.InlineValue;
headerPr.PRisHeaderRoot = true;
headerPr.PRname = "Name";
headerPr.PRvalue = pr.PRname;
headerPr.PRdtType = SoapUtil.typeofString;
headerPr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
headerList.Add(headerPr);
// Namespace field
headerPr = GetPr();
headerPr.PRparseTypeEnum = InternalParseTypeE.Member;
headerPr.PRmemberTypeEnum = InternalMemberTypeE.Field;
headerPr.PRmemberValueEnum = InternalMemberValueE.InlineValue;
headerPr.PRisHeaderRoot = true;
headerPr.PRname = "HeaderNamespace";
headerPr.PRvalue = pr.PRxmlNameSpace;
headerPr.PRdtType = SoapUtil.typeofString;
headerPr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
headerList.Add(headerPr);
// MustUnderstand Field
headerPr = GetPr();
headerPr.PRparseTypeEnum = InternalParseTypeE.Member;
headerPr.PRmemberTypeEnum = InternalMemberTypeE.Field;
headerPr.PRmemberValueEnum = InternalMemberValueE.InlineValue;
headerPr.PRisHeaderRoot = true;
headerPr.PRname = "MustUnderstand";
if (pr.PRisMustUnderstand)
headerPr.PRvarValue = true;
else
headerPr.PRvarValue = false;
headerPr.PRdtType = SoapUtil.typeofBoolean;
headerPr.PRdtTypeCode = InternalPrimitiveTypeE.Boolean;
headerList.Add(headerPr);
// Value field
headerPr = GetPr();
headerPr.PRparseTypeEnum = InternalParseTypeE.Member;
headerPr.PRmemberTypeEnum = InternalMemberTypeE.Field;
headerPr.PRmemberValueEnum = pr.PRmemberValueEnum;
headerPr.PRisHeaderRoot = true;
headerPr.PRname = "Value";
switch (pr.PRmemberValueEnum)
{
case InternalMemberValueE.Null:
headerList.Add(headerPr);
ProcessHeaderMemberEnd(pr);
break;
case InternalMemberValueE.Reference:
headerPr.PRidRef = pr.PRidRef;
headerList.Add(headerPr);
ProcessHeaderMemberEnd(pr);
break;
case InternalMemberValueE.Nested:
headerPr.PRdtType = pr.PRdtType;
headerPr.PRdtTypeCode = pr.PRdtTypeCode;
headerPr.PRkeyDt = pr.PRkeyDt;
headerList.Add(headerPr);
// ProcessHeaderMemberEnd will be called from the parse loop
break;
case InternalMemberValueE.InlineValue:
headerPr.PRvalue = pr.PRvalue;
headerPr.PRvarValue = pr.PRvarValue;
headerPr.PRdtType = pr.PRdtType;
headerPr.PRdtTypeCode = pr.PRdtTypeCode;
headerPr.PRkeyDt = pr.PRkeyDt;
headerList.Add(headerPr);
ProcessHeaderMemberEnd(pr);
break;
}
}
private void ProcessHeader(ParseRecord pr)
{
InternalST.Soap( this,"ProcessHeader ");
pr.Dump();
if (headerList == null)
headerList = new ArrayList(10);
ParseRecord headerPr = GetPr();
headerPr.PRparseTypeEnum = InternalParseTypeE.Object;
headerPr.PRobjectTypeEnum = InternalObjectTypeE.Array;
headerPr.PRobjectPositionEnum = InternalObjectPositionE.Headers;
headerPr.PRarrayTypeEnum = InternalArrayTypeE.Single;
headerPr.PRarrayElementType = typeof(System.Runtime.Remoting.Messaging.Header);
headerPr.PRisArrayVariant = false;
headerPr.PRarrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
headerPr.PRrank = 1;
headerPr.PRlengthA = new int[1];
headerList.Add(headerPr);
}
private void ProcessXmlAttribute(String prefix, String key, String value, ParseRecord objectPr)
{
InternalST.Soap( this,"ProcessXmlAttribute prefix ",prefix, " key ", key, " value ",value);
if (xmlAttributeList == null)
xmlAttributeList = new ArrayList(10);
ParseRecord pr = GetPr();
pr.PRparseTypeEnum = InternalParseTypeE.Member;
pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
pr.PRmemberValueEnum = InternalMemberValueE.InlineValue;
pr.PRname = key;
pr.PRvalue = value;
pr.PRnameXmlKey = prefix;
pr.PRisXmlAttribute = true;
ProcessType(pr, objectPr);
xmlAttributeList.Add(pr);
}
// Determine the Array information from the dt attribute
private void ProcessArray(ParseRecord pr, int firstIndex, bool IsInterop)
{
InternalST.Soap( this, "ProcessArray Enter ",firstIndex," ",pr.PRkeyDt);
String dimString = null;
String xmlKey = pr.PRtypeXmlKey;
InternalPrimitiveTypeE primitiveArrayTypeCode = InternalPrimitiveTypeE.Invalid;
pr.PRobjectTypeEnum = InternalObjectTypeE.Array;
pr.PRmemberTypeEnum = InternalMemberTypeE.Item; // Need this set in case this it is a nested empty array
pr.PRprimitiveArrayTypeString = pr.PRkeyDt.Substring(0, firstIndex);
dimString = pr.PRkeyDt.Substring(firstIndex);
if (IsInterop)
{
String assemblyString = (String)assemKeyToInteropAssemblyTable[pr.PRtypeXmlKey];
pr.PRarrayElementType = objectReader.Bind(assemblyString, pr.PRprimitiveArrayTypeString); // try to get type from SerializationBinder
if (pr.PRarrayElementType == null)
pr.PRarrayElementType = SoapServices.GetInteropTypeFromXmlType(pr.PRprimitiveArrayTypeString, assemblyString);
if (pr.PRarrayElementType == null)
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname+" "+pr.PRkeyDt));
pr.PRprimitiveArrayTypeString = pr.PRarrayElementType.FullName;
}
else
{
primitiveArrayTypeCode = Converter.ToCode(pr.PRprimitiveArrayTypeString);
if (primitiveArrayTypeCode != InternalPrimitiveTypeE.Invalid)
{
pr.PRprimitiveArrayTypeString = Converter.SoapToComType(primitiveArrayTypeCode);
xmlKey = urtKey;
}
else if (String.Compare(pr.PRprimitiveArrayTypeString, "string", false, CultureInfo.InvariantCulture) == 0)
{
pr.PRprimitiveArrayTypeString = "System.String";
xmlKey = urtKey;
}
else if (String.Compare(pr.PRprimitiveArrayTypeString, "anyType", false, CultureInfo.InvariantCulture) == 0 || String.Compare(pr.PRprimitiveArrayTypeString, "ur-type", false, CultureInfo.InvariantCulture) == 0)
{
pr.PRprimitiveArrayTypeString = "System.Object";
xmlKey = urtKey;
}
}
int beginIndex = firstIndex;
int endIndex = pr.PRkeyDt.IndexOf(']', beginIndex+1);
if (endIndex < 1)
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_ArrayDimensions"),pr.PRkeyDt));
int outRank = 0;
int[] outDimensions = null;
String outDimSignature = null;
InternalArrayTypeE outArrayTypeEnum = InternalArrayTypeE.Empty;
int numBrackets = 0;
StringBuilder elementSig = new StringBuilder(10);
while (true)
{
numBrackets++;
outDimensions = ParseArrayDimensions(pr.PRkeyDt.Substring(beginIndex, endIndex-beginIndex+1), out outRank, out outDimSignature, out outArrayTypeEnum);
if (endIndex+1 == pr.PRkeyDt.Length)
break;
elementSig.Append(outDimSignature); // Don't want last dimension in element sig
beginIndex = endIndex+1;
endIndex = pr.PRkeyDt.IndexOf(']', beginIndex);
}
pr.PRlengthA = outDimensions;
pr.PRrank = outRank;
if (numBrackets == 1)
{
pr.PRarrayElementTypeCode = primitiveArrayTypeCode;
pr.PRarrayTypeEnum = outArrayTypeEnum;
pr.PRarrayElementTypeString = pr.PRprimitiveArrayTypeString;
}
else
{
pr.PRarrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
pr.PRarrayTypeEnum = InternalArrayTypeE.Rectangular;
pr.PRarrayElementTypeString = pr.PRprimitiveArrayTypeString+elementSig.ToString();
}
InternalST.Soap( this, "ProcessArray GetType ",pr.PRarrayElementType);
if (!IsInterop || numBrackets > 1)
{
pr.PRarrayElementType = ProcessGetType(pr.PRarrayElementTypeString, xmlKey, out pr.PRassemblyName);
if (pr.PRarrayElementType == null)
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_ArrayType"),pr.PRarrayElementType));
if ((pr.PRarrayElementType == SoapUtil.typeofObject))
{
pr.PRisArrayVariant = true;
xmlKey = urtKey;
}
}
InternalST.Soap( this, "ProcessArray Exit");
}
private void ParseSerializedStreamHeader(ParseRecord pr)
{
this.stack.Push(pr);
}
private void PutPr(ParseRecord pr)
{
prPool.Push(pr);
}
private void ParseString(ParseRecord pr, ParseRecord parentPr)
{
if (pr.PRvalue == null)
{
pr.PRvalue = "";
}
if (!pr.PRisRegistered && (pr.PRobjectId > 0L))
{
this.RegisterObject(pr.PRvalue, pr, parentPr);
}
}
private static String SerTraceString(String handler, ParseRecord pr, String value, String prefix, String urn, InternalParseStateE currentState, HeaderStateEnum headerState)
{
String valueString = "";
if (value != null)
valueString = value;
String prString = "";
if (pr != null)
prString = ((Enum)pr.PRparseStateEnum).ToString();
return handler+" - name "+valueString+", prefix "+prefix+", urn "+urn+", CuurentState "+((Enum)currentState).ToString()+", HeaderState "+((Enum)headerState).ToString()+", PushState "+prString;
}
internal object Deserialize(HeaderHandler handler, ISerParser serParser)
{
if (serParser == null)
{
throw new ArgumentNullException("serParser", string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("ArgumentNull_WithParamName"), new object[] { serParser }));
}
this.deserializationSecurityException = null;
try
{
serializationPermission.Demand();
}
catch (Exception exception)
{
this.deserializationSecurityException = exception;
}
this.handler = handler;
this.isTopObjectSecondPass = false;
this.isHeaderHandlerCalled = false;
if (handler != null)
{
this.IsFakeTopObject = true;
}
this.m_idGenerator = new ObjectIDGenerator();
this.m_objectManager = this.GetObjectManager();
this.serObjectInfoInit = new SerObjectInfoInit();
this.objectIdTable.Clear();
this.objectIds = 0L;
serParser.Run();
if (handler != null)
{
this.m_objectManager.DoFixups();
if (this.handlerObject == null)
{
this.handlerObject = handler(this.newheaders);
}
if ((this.soapFaultId > 0L) && (this.handlerObject != null))
{
this.topStack = new SerStack("Top ParseRecords");
ParseRecord record = new ParseRecord {
PRparseTypeEnum = InternalParseTypeE.Object,
PRobjectPositionEnum = InternalObjectPositionE.Top,
PRparseStateEnum = InternalParseStateE.Object,
PRname = "Response"
};
this.topStack.Push(record);
record = new ParseRecord {
PRparseTypeEnum = InternalParseTypeE.Member,
PRobjectPositionEnum = InternalObjectPositionE.Child,
PRmemberTypeEnum = InternalMemberTypeE.Field,
PRmemberValueEnum = InternalMemberValueE.Reference,
PRparseStateEnum = InternalParseStateE.Member,
PRname = "__fault",
PRidRef = this.soapFaultId
};
this.topStack.Push(record);
record = new ParseRecord {
PRparseTypeEnum = InternalParseTypeE.ObjectEnd,
PRobjectPositionEnum = InternalObjectPositionE.Top,
PRparseStateEnum = InternalParseStateE.Object,
PRname = "Response"
};
this.topStack.Push(record);
this.isTopObjectResolved = false;
}
}
if (!this.isTopObjectResolved)
{
this.isTopObjectSecondPass = true;
this.topStack.Reverse();
int num = this.topStack.Count();
ParseRecord pr = null;
for (int i = 0; i < num; i++)
{
pr = (ParseRecord) this.topStack.Pop();
this.Parse(pr);
}
}
this.m_objectManager.DoFixups();
if (this.topObject == null)
{
throw new SerializationException(SoapUtil.GetResourceString("Serialization_TopObject"));
}
if (this.HasSurrogate(this.topObject.GetType()) && (this.topId != 0L))
{
this.topObject = this.m_objectManager.GetObject(this.topId);
}
if (this.topObject is IObjectReference)
{
this.topObject = ((IObjectReference) this.topObject).GetRealObject(this.m_context);
}
this.m_objectManager.RaiseDeserializationEvent();
if ((this.formatterEnums.FEtopObject != null) && (this.topObject is InternalSoapMessage))
{
InternalSoapMessage topObject = (InternalSoapMessage) this.topObject;
ISoapMessage fEtopObject = this.formatterEnums.FEtopObject;
fEtopObject.MethodName = topObject.methodName;
fEtopObject.XmlNameSpace = topObject.xmlNameSpace;
fEtopObject.ParamNames = topObject.paramNames;
fEtopObject.ParamValues = topObject.paramValues;
fEtopObject.Headers = this.headers;
this.topObject = fEtopObject;
this.isTopObjectResolved = true;
}
return this.topObject;
}
// Formats the error message and throws a SerializationException
private void MarshalError(String handler, ParseRecord pr, String value, InternalParseStateE currentState)
{
String traceString = SerTraceString(handler, pr, value, currentState, headerState);
InternalST.Soap( this,"MarshalError,",traceString);
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_Syntax"),traceString));
}
internal void Parse(ParseRecord pr)
{
switch (pr.PRparseTypeEnum)
{
case InternalParseTypeE.SerializedStreamHeader:
this.ParseSerializedStreamHeader(pr);
return;
case InternalParseTypeE.Object:
this.ParseObject(pr);
return;
case InternalParseTypeE.Member:
this.ParseMember(pr);
return;
case InternalParseTypeE.ObjectEnd:
this.ParseObjectEnd(pr);
return;
case InternalParseTypeE.MemberEnd:
this.ParseMemberEnd(pr);
return;
case InternalParseTypeE.SerializedStreamHeaderEnd:
this.ParseSerializedStreamHeaderEnd(pr);
return;
case InternalParseTypeE.Envelope:
case InternalParseTypeE.EnvelopeEnd:
case InternalParseTypeE.Body:
case InternalParseTypeE.BodyEnd:
return;
}
throw new SerializationException(string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_XMLElement"), new object[] { pr.PRname }));
}
private void ProcessAttributes(ParseRecord pr, ParseRecord objectPr)
{
InternalST.Soap( this, "ProcessAttributes Entry ",pr.Trace()," headerState ",((Enum)headerState).ToString());
String keyPosition = null;
String keyOffset = null;
String keyMustUnderstand = null;
pr.PRisProcessAttributes = true;
String SoapKeyUrl = "http://schemas.xmlsoap.org/soap/encoding/";
int SoapKeyUrlLength = SoapKeyUrl.Length;
String UrtKeyUrl = "http://schemas.microsoft.com/clr/id";
int UrtKeyUrlLength = UrtKeyUrl.Length;
String SoapEnvKeyUrl = "http://schemas.xmlsoap.org/soap/envelope/";
int SoapEnvKeyUrlLength = SoapEnvKeyUrl.Length;
String XSIKey2001 = "http://www.w3.org/2001/XMLSchema-instance";
int XSIKey2001Length = XSIKey2001.Length;
String XSIKey2000 = "http://www.w3.org/2000/10/XMLSchema-instance";
int XSIKey2000Length = XSIKey2000.Length;
String XSIKey1999 = "http://www.w3.org/1999/XMLSchema-instance";
int XSIKey1999Length = XSIKey1999.Length;
String XSDKey1999 = "http://www.w3.org/1999/XMLSchema";
int XSDKey1999Length = XSDKey1999.Length;
String XSDKey2000 = "http://www.w3.org/2000/10/XMLSchema";
int XSDKey2000Length = XSDKey2000.Length;
String XSDKey2001 = "http://www.w3.org/2001/XMLSchema";
int XSDKey2001Length = XSDKey2001.Length;
String clrNS = "http://schemas.microsoft.com/soap/encoding/clr/1.0";
int clrNSLength = clrNS.Length;
for (int i = 0; i<attributeValues.Count(); i++)
{
AttributeValueEntry attributeValueEntry = (AttributeValueEntry)attributeValues.GetItem(i);
String prefix = attributeValueEntry.prefix;
String key = attributeValueEntry.key;
if ((key == null) || (key.Length == 0))
key = pr.PRnameXmlKey; //case where there is a default key
String value = attributeValueEntry.value;
bool prefixMatchesXmlns = false;
String urn = attributeValueEntry.urn;
InternalST.Soap( this, "ProcessAttributes attribute prefix ",prefix," key ",key," value ",value," urn ", urn);
int keyLength = key.Length;
int valueLength = value.Length;
// table need for QName xsd types
if (key == null || keyLength == 0)
keyToNamespaceTable[prefix] = value;
else
keyToNamespaceTable[prefix+":"+key] = value;
if (keyLength == 2 && String.Compare(key, "id", true, CultureInfo.InvariantCulture) == 0)
pr.PRobjectId = objectReader.GetId(value);
else if (keyLength == 8 && String.Compare(key, "position", true, CultureInfo.InvariantCulture) == 0)
keyPosition = value;
else if (keyLength == 6 && String.Compare(key, "offset", true, CultureInfo.InvariantCulture) == 0)
keyOffset = value;
else if (keyLength == 14 && String.Compare(key, "MustUnderstand", true, CultureInfo.InvariantCulture) == 0)
keyMustUnderstand = value;
else if (keyLength == 4 && String.Compare(key, "null", true, CultureInfo.InvariantCulture) == 0)
{
pr.PRmemberValueEnum = InternalMemberValueE.Null;
pr.PRvalue = null;
}
else if (keyLength == 4 && String.Compare(key, "root", true, CultureInfo.InvariantCulture) == 0)
{
if (value.Equals("1"))
pr.PRisHeaderRoot = true;
}
else if (keyLength == 4 && String.Compare(key, "href", true, CultureInfo.InvariantCulture) == 0)
pr.PRidRef = objectReader.GetId(value);
else if (keyLength == 4 && String.Compare(key, "type", true, CultureInfo.InvariantCulture) == 0)
{
String currentPRtypeXmlKey = pr.PRtypeXmlKey;
String currentPRkeyDt = pr.PRkeyDt;
Type currentPRdtType = pr.PRdtType;
String typeValue = value;
int index = value.IndexOf(":");
if (index > 0)
{
pr.PRtypeXmlKey = value.Substring(0, index);
typeValue = value.Substring(++index);
}
else
{
pr.PRtypeXmlKey = prefix;
}
if (String.Compare(typeValue, "anyType", true, CultureInfo.InvariantCulture) == 0 || String.Compare(typeValue, "ur-type", true, CultureInfo.InvariantCulture) == 0)
{
pr.PRkeyDt = "System.Object";
pr.PRdtType = SoapUtil.typeofObject;
pr.PRtypeXmlKey = urtKey;
}
if (pr.PRtypeXmlKey == soapKey && typeValue == "Array") //Don't need to process xsi:type="SOAP-ENC:Array"
{
// Array values already found,use these value rather then the xsi:type values
pr.PRtypeXmlKey = currentPRtypeXmlKey;
pr.PRkeyDt = currentPRkeyDt;
pr.PRdtType = currentPRdtType;
InternalST.Soap( this,"ProcessAttributes, xsi:type='SOAP-ENC:Array' pr.PRtypeXmlKey ", pr.PRtypeXmlKey," pr.PRkeyDt "+pr.PRkeyDt);
}
else
{
pr.PRkeyDt = typeValue;
InternalST.Soap( this,"ProcessAttributes, not xsi:type='SOAP-ENC:Array' pr.PRtypeXmlKey ", pr.PRtypeXmlKey," pr.PRkeyDt "+pr.PRkeyDt);
}
}
else if (keyLength == 9 && String.Compare(key, "arraytype", true, CultureInfo.InvariantCulture) == 0)
{
String typeValue = value;
int index = value.IndexOf(":");
if (index > 0)
{
pr.PRtypeXmlKey = value.Substring(0, index);
pr.PRkeyDt = typeValue = value.Substring(++index);
}
if (typeValue.StartsWith("ur_type["))
{
pr.PRkeyDt = "System.Object"+typeValue.Substring(6);
pr.PRtypeXmlKey = urtKey;
}
}
else if (SoapServices.IsClrTypeNamespace(value))
{
if (!assemKeyToAssemblyTable.ContainsKey(key))
{
String typeNamespace = null;
String assemblyName = null;
SoapServices.DecodeXmlNamespaceForClrTypeNamespace(value, out typeNamespace, out assemblyName);
if (assemblyName == null)
{
assemKeyToAssemblyTable[key] = new SoapAssemblyInfo(SoapUtil.urtAssemblyString, SoapUtil.urtAssembly);
assemKeyToNameSpaceTable[key] = typeNamespace;
}
else
{
assemKeyToAssemblyTable[key] = new SoapAssemblyInfo(assemblyName);
if (typeNamespace != null)
assemKeyToNameSpaceTable[key] = typeNamespace;
}
}
}
else if ((prefixMatchesXmlns = prefix.Equals("xmlns")) && (valueLength == SoapKeyUrlLength && String.Compare(value, SoapKeyUrl, true, CultureInfo.InvariantCulture) == 0))
{
soapKey = key;
}
else if (prefixMatchesXmlns && (valueLength == UrtKeyUrlLength && String.Compare(value, UrtKeyUrl, true, CultureInfo.InvariantCulture) == 0))
{
urtKey = key;
assemKeyToAssemblyTable[urtKey] = new SoapAssemblyInfo(SoapUtil.urtAssemblyString, SoapUtil.urtAssembly);
}
else if (prefixMatchesXmlns && (valueLength == SoapEnvKeyUrlLength && String.Compare(value, SoapEnvKeyUrl, true) == 0))
{
soapEnvKey = key;
}
else if (key == "encodingStyle")
{
/*
String[] split = value.Split(' ');
foreach (String s in split)
{
if (s == "http://schemas.microsoft.com/soap/encoding/clr/1.0")
{
objectReader.SetVersion(1,0);
break;
}
}
*/
}
else if (prefixMatchesXmlns &&
((valueLength == XSIKey2001Length && String.Compare(value, XSIKey2001,true, CultureInfo.InvariantCulture) == 0) ||
(valueLength == XSIKey1999Length && String.Compare(value, XSIKey1999,true, CultureInfo.InvariantCulture) == 0) ||
(valueLength == XSIKey2000Length && String.Compare(value, XSIKey2000,true, CultureInfo.InvariantCulture) == 0)))
{
xsiKey = key;
}
else if (prefixMatchesXmlns &&
((valueLength == XSDKey2001Length && String.Compare(value, XSDKey2001 , true, CultureInfo.InvariantCulture) == 0)) ||
(valueLength == XSDKey1999Length && String.Compare(value, XSDKey1999, true, CultureInfo.InvariantCulture) == 0) ||
(valueLength == XSDKey2000Length && String.Compare(value, XSDKey2000, true, CultureInfo.InvariantCulture) == 0))
{
xsdKey = key;
}
else if (prefixMatchesXmlns && (valueLength == clrNSLength && String.Compare(value, clrNS, true, CultureInfo.InvariantCulture) == 0))
{
objectReader.SetVersion(1,0);
}
else
{
//String lowerCaseValue = value.ToLower(CultureInfo.InvariantCulture);
if (prefixMatchesXmlns)
{
// Assume it is an interop namespace
assemKeyToInteropAssemblyTable[key] = value;
InternalST.Soap( this,"ProcessAttributes, InteropType key "+key+" value ",value);
}
else if (String.Compare(prefix, soapKey, true, CultureInfo.InvariantCulture) == 0)
{
InternalST.Soap( this,"ProcessAttributes, Not processed key ",prefix,":",key," = ",value);
}
else
{
// See if it is a XmlAttribute
InternalST.Soap( this,"ProcessAttributes, XmlAttribute prefix ",prefix," key ",key," value ",value," urn ",urn, " hashtable ",assemKeyToInteropAssemblyTable[prefix]);
if ((assemKeyToInteropAssemblyTable.ContainsKey(prefix)) && ((String)assemKeyToInteropAssemblyTable[prefix]).Equals(urn))
{
ProcessXmlAttribute(prefix, key, value, objectPr);
}
else
{
InternalST.Soap( this,"ProcessAttributes, Not processed prefix ",prefix," key ",key," value ",value," urn ",urn);
}
}
}
}
attributeValues.Clear();
// reset the header state
// If no headers then headerState is None
//
// if parent is a header section then these are top level objects
// within the header section. If the object has a root set
// then it is a header record, if not then it is a toplevel object
// in the header section which is not a header record.
//
// if the parent is not a header section and is a header root
// then this is a nested object within a header record. All
// subsequent object will be nested until another header
// root is encountered
//
// The first header record is considered a root record
if (headerState != HeaderStateEnum.None)
{
if (objectPr.PRparseTypeEnum == InternalParseTypeE.Headers)
{
if (pr.PRisHeaderRoot || (headerState == HeaderStateEnum.FirstHeaderRecord))
{
headerState = HeaderStateEnum.HeaderRecord;
}
else
{
headerState = HeaderStateEnum.TopLevelObject;
currentState = InternalParseStateE.Object;
pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
pr.PRparseTypeEnum = InternalParseTypeE.Object;
pr.PRparseStateEnum = InternalParseStateE.Object;
pr.PRmemberTypeEnum = InternalMemberTypeE.Empty;
pr.PRmemberValueEnum = InternalMemberValueE.Empty;
}
}
else if (objectPr.PRisHeaderRoot)
headerState = HeaderStateEnum.NestedObject;
}
InternalST.Soap( this,"ProcessAttributes, headerState ",((Enum)headerState).ToString());
if (!isTopFound && (objectPr != null ) && (objectPr.PRparseTypeEnum == InternalParseTypeE.Body))
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
isTopFound = true;
}
else if (pr.PRobjectPositionEnum != InternalObjectPositionE.Top)
pr.PRobjectPositionEnum = InternalObjectPositionE.Child;
// Don't process type for envelop, topSoapElement unless it has a key of soapEnvKey (SOAP-ENV). Fault
// is the only top record which currently falls into this category.
if (!((pr.PRparseTypeEnum == InternalParseTypeE.Envelope)||
(pr.PRparseTypeEnum == InternalParseTypeE.Body) ||
(pr.PRparseTypeEnum == InternalParseTypeE.Headers) ||
(pr.PRobjectPositionEnum == InternalObjectPositionE.Top &&
objectReader.IsFakeTopObject &&
!pr.PRnameXmlKey.Equals(soapEnvKey))))
{
InternalST.Soap( this, "ProcessAttributes before Process Type ",((Enum)pr.PRparseTypeEnum).ToString());
ProcessType(pr, objectPr);
}
if (keyPosition != null)
{
int outRank;
String outDimSignature;
InternalArrayTypeE outArrayTypeEnum;
pr.PRpositionA = ParseArrayDimensions(keyPosition, out outRank, out outDimSignature, out outArrayTypeEnum);
}
if (keyOffset != null)
{
int outRank;
String outDimSignature;
InternalArrayTypeE outArrayTypeEnum;
pr.PRlowerBoundA = ParseArrayDimensions(keyOffset, out outRank, out outDimSignature, out outArrayTypeEnum);
}
if (keyMustUnderstand != null)
if (keyMustUnderstand.Equals("1"))
pr.PRisMustUnderstand = true;
else if (keyMustUnderstand.Equals("0"))
pr.PRisMustUnderstand = false;
else
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_MustUnderstand"),keyMustUnderstand));
if (pr.PRparseTypeEnum == InternalParseTypeE.Member)
{
// Process Member
InternalST.Soap( this, "ProcessAttributes Member ");
stack.Dump();
if (objectPr.PRparseTypeEnum == InternalParseTypeE.Headers)
pr.PRmemberTypeEnum = InternalMemberTypeE.Header;
else if (objectPr.PRobjectTypeEnum == InternalObjectTypeE.Array)
pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
else
pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
}
}
private void ParseArrayMember(ParseRecord pr)
{
ParseRecord record = (ParseRecord) this.stack.Peek();
if (record.PRarrayTypeEnum == InternalArrayTypeE.Rectangular)
{
if (pr.PRpositionA != null)
{
Array.Copy(pr.PRpositionA, record.PRindexMap, record.PRindexMap.Length);
if (record.PRlowerBoundA == null)
{
Array.Copy(pr.PRpositionA, record.PRrectangularMap, record.PRrectangularMap.Length);
}
else
{
for (int i = 0; i < record.PRrectangularMap.Length; i++)
{
record.PRrectangularMap[i] = pr.PRpositionA[i] - record.PRlowerBoundA[i];
}
}
}
else
{
if (record.PRmemberIndex > 0)
{
this.NextRectangleMap(record);
}
for (int j = 0; j < record.PRrank; j++)
{
int num3 = 0;
if (record.PRlowerBoundA != null)
{
num3 = record.PRlowerBoundA[j];
}
record.PRindexMap[j] = record.PRrectangularMap[j] + num3;
}
}
}
else if (!record.PRisLowerBound)
{
if (pr.PRpositionA == null)
{
record.PRindexMap[0] = record.PRmemberIndex;
}
else
{
record.PRindexMap[0] = record.PRmemberIndex = pr.PRpositionA[0];
}
}
else if (pr.PRpositionA == null)
{
record.PRindexMap[0] = record.PRmemberIndex + record.PRlowerBoundA[0];
}
else
{
record.PRindexMap[0] = pr.PRpositionA[0];
record.PRmemberIndex = pr.PRpositionA[0] - record.PRlowerBoundA[0];
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
{
object obj2 = this.m_objectManager.GetObject(pr.PRidRef);
if (obj2 == null)
{
int[] destinationArray = new int[record.PRrank];
Array.Copy(record.PRindexMap, 0, destinationArray, 0, record.PRrank);
this.m_objectManager.RecordArrayElementFixup(record.PRobjectId, destinationArray, pr.PRidRef);
}
else if (record.PRobjectA != null)
{
record.PRobjectA[record.PRindexMap[0]] = obj2;
}
else
{
((Array) record.PRnewObj).SetValue(obj2, record.PRindexMap);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
if (pr.PRdtType == null)
{
pr.PRdtType = record.PRarrayElementType;
}
this.ParseObject(pr);
this.stack.Push(pr);
if (record.PRarrayElementType.IsValueType && (pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Invalid))
{
pr.PRisValueTypeFixup = true;
this.valueFixupStack.Push(new ValueFixup((Array) record.PRnewObj, record.PRindexMap));
}
else if (record.PRobjectA != null)
{
record.PRobjectA[record.PRindexMap[0]] = pr.PRnewObj;
}
else
{
((Array) record.PRnewObj).SetValue(pr.PRnewObj, record.PRindexMap);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
if (record.PRarrayElementType == Converter.typeofString)
{
this.ParseString(pr, record);
if (record.PRobjectA != null)
{
record.PRobjectA[record.PRindexMap[0]] = pr.PRvalue;
}
else
{
((Array) record.PRnewObj).SetValue(pr.PRvalue, record.PRindexMap);
}
}
else if (record.PRisEnum)
{
object obj3 = Enum.Parse(record.PRarrayElementType, pr.PRvalue);
if (record.PRobjectA != null)
{
record.PRobjectA[record.PRindexMap[0]] = (Enum) obj3;
}
else
{
((Array) record.PRnewObj).SetValue((Enum) obj3, record.PRindexMap);
}
}
else if (record.PRisArrayVariant)
{
if ((pr.PRdtType == null) && (pr.PRkeyDt == null))
{
throw new SerializationException(SoapUtil.GetResourceString("Serialization_ArrayTypeObject"));
}
object pRvalue = null;
if (pr.PRdtType == Converter.typeofString)
{
this.ParseString(pr, record);
pRvalue = pr.PRvalue;
}
else if (pr.PRdtType.IsEnum)
{
pRvalue = Enum.Parse(pr.PRdtType, pr.PRvalue);
}
else if (pr.PRdtTypeCode == InternalPrimitiveTypeE.Invalid)
{
this.CheckSerializable(pr.PRdtType);
if (this.IsRemoting && (this.formatterEnums.FEsecurityLevel != TypeFilterLevel.Full))
{
pRvalue = FormatterServices.GetSafeUninitializedObject(pr.PRdtType);
}
else
{
pRvalue = FormatterServices.GetUninitializedObject(pr.PRdtType);
}
}
else if (pr.PRvarValue != null)
{
pRvalue = pr.PRvarValue;
}
else
{
pRvalue = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
}
if (record.PRobjectA != null)
{
record.PRobjectA[record.PRindexMap[0]] = pRvalue;
}
else
{
((Array) record.PRnewObj).SetValue(pRvalue, record.PRindexMap);
}
}
else if (record.PRprimitiveArray != null)
{
record.PRprimitiveArray.SetValue(pr.PRvalue, record.PRindexMap[0]);
}
else
{
object pRvarValue = null;
if (pr.PRvarValue != null)
{
pRvarValue = pr.PRvarValue;
}
else
{
pRvarValue = Converter.FromString(pr.PRvalue, record.PRarrayElementTypeCode);
}
if (record.PRarrayElementTypeCode == InternalPrimitiveTypeE.QName)
{
SoapQName name = (SoapQName) pRvarValue;
if (name.Key.Length == 0)
{
name.Namespace = (string) this.soapHandler.keyToNamespaceTable["xmlns"];
}
else
{
name.Namespace = (string) this.soapHandler.keyToNamespaceTable["xmlns:" + name.Key];
}
}
if (record.PRobjectA != null)
{
record.PRobjectA[record.PRindexMap[0]] = pRvarValue;
}
else
{
((Array) record.PRnewObj).SetValue(pRvarValue, record.PRindexMap);
}
}
}
else if (pr.PRmemberValueEnum != InternalMemberValueE.Null)
{
this.ParseError(pr, record);
}
record.PRmemberIndex++;
}
internal ParseRecord Copy()
{
ParseRecord newPr = new ParseRecord();
// Enums
newPr.PRparseTypeEnum = PRparseTypeEnum;
newPr.PRobjectTypeEnum = PRobjectTypeEnum;
newPr.PRarrayTypeEnum = PRarrayTypeEnum;
newPr.PRmemberTypeEnum = PRmemberTypeEnum;
newPr.PRmemberValueEnum = PRmemberValueEnum;
newPr.PRobjectPositionEnum = PRobjectPositionEnum;
// Object
newPr.PRname = PRname;
newPr.PRisParsed = PRisParsed;
newPr.PRisProcessAttributes = PRisProcessAttributes;
newPr.PRnameXmlKey = PRnameXmlKey;
newPr.PRxmlNameSpace = PRxmlNameSpace;
// Value
newPr.PRvalue = PRvalue;
// dt attribute
newPr.PRkeyDt = PRkeyDt;
newPr.PRdtType = PRdtType;
newPr.PRassemblyName = PRassemblyName;
newPr.PRdtTypeCode = PRdtTypeCode;
newPr.PRisEnum = PRisEnum;
// Object ID
newPr.PRobjectId = PRobjectId;
// Reference ID
newPr.PRidRef = PRidRef;
// Array
// Array Element Type
newPr.PRarrayElementTypeString = PRarrayElementTypeString;
newPr.PRarrayElementType = PRarrayElementType;
newPr.PRisArrayVariant = PRisArrayVariant;
newPr.PRarrayElementTypeCode = PRarrayElementTypeCode;
// Array Primitive Element type
newPr.PRprimitiveArrayTypeString = PRprimitiveArrayTypeString;
// Parsed array information
newPr.PRrank = PRrank;
newPr.PRlengthA = PRlengthA;
newPr.PRpositionA = PRpositionA;
newPr.PRlowerBoundA = PRlowerBoundA;
newPr.PRupperBoundA = PRupperBoundA;
// Array map for placing array elements in array
newPr.PRindexMap = PRindexMap;
newPr.PRmemberIndex = PRmemberIndex;
newPr.PRlinearlength = PRlinearlength;
newPr.PRrectangularMap = PRrectangularMap;
newPr.PRisLowerBound = PRisLowerBound;
// SerializedStreamHeader information
newPr.PRtopId = PRtopId;
newPr.PRheaderId = PRheaderId;
newPr.PRisHeaderRoot = PRisHeaderRoot;
newPr.PRisAttributesProcessed = PRisAttributesProcessed;
// Parsed HeaderMember Information
newPr.PRisMustUnderstand = PRisMustUnderstand;
// Parse State
newPr.PRparseStateEnum = PRparseStateEnum;
newPr.PRisWaitingForNestedObject = PRisWaitingForNestedObject;
// ValueType Fixup needed
newPr.PRisValueTypeFixup = PRisValueTypeFixup;
newPr.PRnewObj = PRnewObj;
newPr.PRobjectA = PRobjectA;
newPr.PRprimitiveArray = PRprimitiveArray;
newPr.PRobjectInfo = PRobjectInfo;
newPr.PRisRegistered = PRisRegistered;
newPr.PRisXmlAttribute = PRisXmlAttribute;
return newPr;
}
private void ParseError(ParseRecord processing, ParseRecord onStack)
{
throw new SerializationException(string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_ParseError"), new object[] { onStack.PRname + " " + onStack.PRparseTypeEnum.ToString() + " " + processing.PRname + " " + processing.PRparseTypeEnum.ToString() }));
}
internal virtual void Fixup(ParseRecord record, ParseRecord parent)
{
Object obj = record.PRnewObj;
InternalST.Soap(this, "Fixup ",obj," ",((Enum)valueFixupEnum).ToString());
switch(valueFixupEnum)
{
case ValueFixupEnum.Array:
arrayObj.SetValue(obj, indexMap);
break;
case ValueFixupEnum.Header:
Type type = typeof(Header);
if (valueInfo == null)
{
MemberInfo[] valueInfos = type.GetMember("Value");
if (valueInfos.Length != 1)
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_HeaderReflection"),valueInfos.Length));
valueInfo = valueInfos[0];
}
InternalST.SerializationSetValue((FieldInfo)valueInfo, header, obj);
break;
case ValueFixupEnum.Member:
InternalST.Soap(this, "Fixup Member new object value ",obj," memberObject ",memberObject);
if (objectInfo.isSi) {
InternalST.Soap(this, "Recording a fixup on member: ", memberName,
" in object id", parent.PRobjectId, " Required Object ", record.PRobjectId);
objectInfo.objectManager.RecordDelayedFixup(parent.PRobjectId, memberName, record.PRobjectId);
} else {
MemberInfo memberInfo = objectInfo.GetMemberInfo(memberName);
InternalST.Soap(this, "Recording a fixup on member:", memberInfo, " in object id ",
parent.PRobjectId," Required Object", record.PRobjectId);
objectInfo.objectManager.RecordFixup(parent.PRobjectId, memberInfo, record.PRobjectId);
}
break;
}
}
private void CheckSecurity(ParseRecord pr)
{
Type pRdtType = pr.PRdtType;
if ((pRdtType != null) && this.IsRemoting)
{
if (typeof(MarshalByRefObject).IsAssignableFrom(pRdtType))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_MBRAsMBV"), new object[] { pRdtType.FullName }));
}
FormatterServices.CheckTypeSecurity(pRdtType, this.formatterEnums.FEsecurityLevel);
}
if (this.deserializationSecurityException != null)
{
if (pRdtType != null)
{
if (pRdtType.IsPrimitive || (pRdtType == Converter.typeofString))
{
return;
}
if (typeof(Enum).IsAssignableFrom(pRdtType))
{
return;
}
if (pRdtType.IsArray)
{
Type elementType = pRdtType.GetElementType();
if (elementType.IsPrimitive || (elementType == Converter.typeofString))
{
return;
}
}
}
throw this.deserializationSecurityException;
}
}
private void ParseObject(ParseRecord pr)
{
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.topId = pr.PRobjectId;
}
if (pr.PRparseTypeEnum == InternalParseTypeE.Object)
{
this.stack.Push(pr);
}
if (pr.PRobjectTypeEnum == InternalObjectTypeE.Array)
{
this.ParseArray(pr);
}
else
{
if ((pr.PRdtType == null) && !this.IsFakeTopObject)
{
throw new SerializationException(string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TopObjectInstantiate"), new object[] { pr.PRname }));
}
if (((pr.PRobjectPositionEnum == InternalObjectPositionE.Top) && this.IsFakeTopObject) && (pr.PRdtType != Converter.typeofSoapFault))
{
if (this.handler == null)
{
if (this.formatterEnums.FEtopObject != null)
{
if (!this.isTopObjectSecondPass)
{
this.isTopObjectResolved = false;
this.topStack = new SerStack("Top ParseRecords");
this.topStack.Push(pr.Copy());
return;
}
pr.PRnewObj = new InternalSoapMessage();
pr.PRdtType = typeof(InternalSoapMessage);
this.CheckSecurity(pr);
if (this.formatterEnums.FEtopObject != null)
{
ISoapMessage fEtopObject = this.formatterEnums.FEtopObject;
pr.PRobjectInfo = this.CreateReadObjectInfo(pr.PRdtType, fEtopObject.ParamNames, fEtopObject.ParamTypes, pr.PRassemblyName);
}
}
}
else
{
if (!this.isHeaderHandlerCalled)
{
this.newheaders = null;
this.isHeaderHandlerCalled = true;
if (this.headers == null)
{
this.newheaders = new Header[1];
}
else
{
this.newheaders = new Header[this.headers.Length + 1];
Array.Copy(this.headers, 0, this.newheaders, 1, this.headers.Length);
}
Header header = new Header("__methodName", pr.PRname, false, pr.PRnameXmlKey);
this.newheaders[0] = header;
this.handlerObject = this.handler(this.newheaders);
}
if (!this.isHeaderHandlerCalled)
{
this.isTopObjectResolved = false;
this.topStack = new SerStack("Top ParseRecords");
this.topStack.Push(pr.Copy());
return;
}
pr.PRnewObj = this.handlerObject;
pr.PRdtType = this.handlerObject.GetType();
this.CheckSecurity(pr);
if (pr.PRnewObj is IFieldInfo)
{
IFieldInfo pRnewObj = (IFieldInfo) pr.PRnewObj;
if ((pRnewObj.FieldTypes != null) && (pRnewObj.FieldTypes.Length > 0))
{
pr.PRobjectInfo = this.CreateReadObjectInfo(pr.PRdtType, pRnewObj.FieldNames, pRnewObj.FieldTypes, pr.PRassemblyName);
}
}
}
}
else
{
if (pr.PRdtType == Converter.typeofString)
{
if (pr.PRvalue != null)
{
pr.PRnewObj = pr.PRvalue;
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.isTopObjectResolved = true;
this.topObject = pr.PRnewObj;
return;
}
this.stack.Pop();
this.RegisterObject(pr.PRnewObj, pr, (ParseRecord) this.stack.Peek());
}
return;
}
if (pr.PRdtType == null)
{
ParseRecord record = (ParseRecord) this.stack.Peek();
if (record.PRdtType == Converter.typeofSoapFault)
{
throw new ServerException(string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_SoapFault"), new object[] { this.faultString }));
}
throw new SerializationException(string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TypeElement"), new object[] { pr.PRname }));
}
this.CheckSerializable(pr.PRdtType);
if (this.IsRemoting && (this.formatterEnums.FEsecurityLevel != TypeFilterLevel.Full))
{
pr.PRnewObj = FormatterServices.GetSafeUninitializedObject(pr.PRdtType);
}
else
{
pr.PRnewObj = FormatterServices.GetUninitializedObject(pr.PRdtType);
}
this.CheckSecurity(pr);
this.m_objectManager.RaiseOnDeserializingEvent(pr.PRnewObj);
}
if (pr.PRnewObj == null)
{
throw new SerializationException(string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TopObjectInstantiate"), new object[] { pr.PRdtType }));
}
if (pr.PRobjectId < 1L)
{
pr.PRobjectId = this.GetId("GenId-" + this.objectIds);
}
if (this.IsFakeTopObject && (pr.PRobjectPositionEnum == InternalObjectPositionE.Top))
{
this.isTopObjectResolved = true;
this.topObject = pr.PRnewObj;
}
if (pr.PRobjectInfo == null)
{
pr.PRobjectInfo = this.CreateReadObjectInfo(pr.PRdtType, pr.PRassemblyName);
}
pr.PRobjectInfo.obj = pr.PRnewObj;
if (this.IsFakeTopObject && (pr.PRobjectPositionEnum == InternalObjectPositionE.Top))
{
pr.PRobjectInfo.AddValue("__methodName", pr.PRname);
pr.PRobjectInfo.AddValue("__keyToNamespaceTable", this.soapHandler.keyToNamespaceTable);
pr.PRobjectInfo.AddValue("__paramNameList", pr.PRobjectInfo.SetFakeObject());
if (this.formatterEnums.FEtopObject != null)
{
pr.PRobjectInfo.AddValue("__xmlNameSpace", pr.PRxmlNameSpace);
}
}
}
}
private void ParseObjectEnd(ParseRecord pr)
{
ParseRecord record = (ParseRecord) this.stack.Peek();
if (record == null)
{
record = pr;
}
if (record.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
if (record.PRdtType == Converter.typeofString)
{
if (record.PRvalue == null)
{
record.PRvalue = string.Empty;
}
record.PRnewObj = record.PRvalue;
this.CheckSecurity(record);
this.isTopObjectResolved = true;
this.topObject = record.PRnewObj;
return;
}
if ((((record.PRdtType != null) && (record.PRvalue != null)) && !this.IsWhiteSpace(record.PRvalue)) && (record.PRdtType.IsPrimitive || (record.PRdtType == Converter.typeofTimeSpan)))
{
record.PRnewObj = Converter.FromString(record.PRvalue, Converter.ToCode(record.PRdtType));
this.CheckSecurity(record);
this.isTopObjectResolved = true;
this.topObject = record.PRnewObj;
return;
}
if (!this.isTopObjectResolved && (record.PRdtType != Converter.typeofSoapFault))
{
this.topStack.Push(pr.Copy());
if (record.PRparseRecordId == pr.PRparseRecordId)
{
this.stack.Pop();
}
return;
}
}
this.stack.Pop();
ParseRecord objectPr = (ParseRecord) this.stack.Peek();
if (record.PRobjectTypeEnum == InternalObjectTypeE.Array)
{
if (record.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.isTopObjectResolved = true;
this.topObject = record.PRnewObj;
}
this.RegisterObject(record.PRnewObj, record, objectPr);
}
else
{
if (record.PRobjectInfo != null)
{
record.PRobjectInfo.PopulateObjectMembers();
}
if (record.PRnewObj == null)
{
if (record.PRdtType != Converter.typeofString)
{
throw new SerializationException(string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_ObjectMissing"), new object[] { pr.PRname }));
}
if (record.PRvalue == null)
{
record.PRvalue = string.Empty;
}
record.PRnewObj = record.PRvalue;
this.CheckSecurity(record);
}
if (!record.PRisRegistered && (record.PRobjectId > 0L))
{
this.RegisterObject(record.PRnewObj, record, objectPr);
}
if (record.PRisValueTypeFixup)
{
((ValueFixup) this.valueFixupStack.Pop()).Fixup(record, objectPr);
}
if (record.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.isTopObjectResolved = true;
this.topObject = record.PRnewObj;
}
if (record.PRnewObj is SoapFault)
{
this.soapFaultId = record.PRobjectId;
}
if (record.PRobjectInfo != null)
{
if (record.PRobjectInfo.bfake && !record.PRobjectInfo.bSoapFault)
{
record.PRobjectInfo.AddValue("__fault", null);
}
record.PRobjectInfo.ObjectEnd();
}
}
}
internal ParseRecord Copy()
{
ParseRecord newPr = new ParseRecord();
// Enums
newPr.PRparseTypeEnum = PRparseTypeEnum;
newPr.PRobjectTypeEnum = PRobjectTypeEnum;
newPr.PRarrayTypeEnum = PRarrayTypeEnum;
newPr.PRmemberTypeEnum = PRmemberTypeEnum;
newPr.PRmemberValueEnum = PRmemberValueEnum;
newPr.PRobjectPositionEnum = PRobjectPositionEnum;
// Object
newPr.PRname = PRname;
newPr.PRisParsed = PRisParsed;
newPr.PRisProcessAttributes = PRisProcessAttributes;
newPr.PRnameXmlKey = PRnameXmlKey;
newPr.PRxmlNameSpace = PRxmlNameSpace;
// Value
newPr.PRvalue = PRvalue;
// dt attribute
newPr.PRkeyDt = PRkeyDt;
newPr.PRdtType = PRdtType;
newPr.PRassemblyName = PRassemblyName;
newPr.PRdtTypeCode = PRdtTypeCode;
newPr.PRisEnum = PRisEnum;
// Object ID
newPr.PRobjectId = PRobjectId;
// Reference ID
newPr.PRidRef = PRidRef;
// Array
// Array Element Type
newPr.PRarrayElementTypeString = PRarrayElementTypeString;
newPr.PRarrayElementType = PRarrayElementType;
newPr.PRisArrayVariant = PRisArrayVariant;
newPr.PRarrayElementTypeCode = PRarrayElementTypeCode;
// Array Primitive Element type
newPr.PRprimitiveArrayTypeString = PRprimitiveArrayTypeString;
// Parsed array information
newPr.PRrank = PRrank;
newPr.PRlengthA = PRlengthA;
newPr.PRpositionA = PRpositionA;
newPr.PRlowerBoundA = PRlowerBoundA;
newPr.PRupperBoundA = PRupperBoundA;
// Array map for placing array elements in array
newPr.PRindexMap = PRindexMap;
newPr.PRmemberIndex = PRmemberIndex;
newPr.PRlinearlength = PRlinearlength;
newPr.PRrectangularMap = PRrectangularMap;
newPr.PRisLowerBound = PRisLowerBound;
// SerializedStreamHeader information
newPr.PRtopId = PRtopId;
newPr.PRheaderId = PRheaderId;
newPr.PRisHeaderRoot = PRisHeaderRoot;
newPr.PRisAttributesProcessed = PRisAttributesProcessed;
// Parsed HeaderMember Information
newPr.PRisMustUnderstand = PRisMustUnderstand;
// Parse State
newPr.PRparseStateEnum = PRparseStateEnum;
newPr.PRisWaitingForNestedObject = PRisWaitingForNestedObject;
// ValueType Fixup needed
newPr.PRisValueTypeFixup = PRisValueTypeFixup;
newPr.PRnewObj = PRnewObj;
newPr.PRobjectA = PRobjectA;
newPr.PRprimitiveArray = PRprimitiveArray;
newPr.PRobjectInfo = PRobjectInfo;
newPr.PRisRegistered = PRisRegistered;
newPr.PRisXmlAttribute = PRisXmlAttribute;
return(newPr);
}