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 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();
}
}
}
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 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 ProcessHeaderMemberEnd(ParseRecord pr)
{
ParseRecord record = null;
if (this.headerState == HeaderStateEnum.NestedObject)
{
ParseRecord record2 = pr.Copy();
this.headerList.Add(record2);
}
else
{
record = this.GetPr();
record.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
record.PRmemberTypeEnum = InternalMemberTypeE.Field;
record.PRmemberValueEnum = pr.PRmemberValueEnum;
record.PRisHeaderRoot = true;
this.headerList.Add(record);
record = this.GetPr();
record.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
record.PRmemberTypeEnum = InternalMemberTypeE.Item;
record.PRmemberValueEnum = InternalMemberValueE.Nested;
record.PRisHeaderRoot = true;
this.headerList.Add(record);
}
}
private void ProcessHeaderMember(ParseRecord pr)
{
if (this.headerState == HeaderStateEnum.NestedObject)
{
ParseRecord record2 = pr.Copy();
this.headerList.Add(record2);
}
else
{
ParseRecord record = this.GetPr();
record.PRparseTypeEnum = InternalParseTypeE.Member;
record.PRmemberTypeEnum = InternalMemberTypeE.Item;
record.PRmemberValueEnum = InternalMemberValueE.Nested;
record.PRisHeaderRoot = true;
this.headerArrayLength++;
this.headerList.Add(record);
record = this.GetPr();
record.PRparseTypeEnum = InternalParseTypeE.Member;
record.PRmemberTypeEnum = InternalMemberTypeE.Field;
record.PRmemberValueEnum = InternalMemberValueE.InlineValue;
record.PRisHeaderRoot = true;
record.PRname = "Name";
record.PRvalue = pr.PRname;
record.PRdtType = SoapUtil.typeofString;
record.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
this.headerList.Add(record);
record = this.GetPr();
record.PRparseTypeEnum = InternalParseTypeE.Member;
record.PRmemberTypeEnum = InternalMemberTypeE.Field;
record.PRmemberValueEnum = InternalMemberValueE.InlineValue;
record.PRisHeaderRoot = true;
record.PRname = "HeaderNamespace";
record.PRvalue = pr.PRxmlNameSpace;
record.PRdtType = SoapUtil.typeofString;
record.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
this.headerList.Add(record);
record = this.GetPr();
record.PRparseTypeEnum = InternalParseTypeE.Member;
record.PRmemberTypeEnum = InternalMemberTypeE.Field;
record.PRmemberValueEnum = InternalMemberValueE.InlineValue;
record.PRisHeaderRoot = true;
record.PRname = "MustUnderstand";
if (pr.PRisMustUnderstand)
{
record.PRvarValue = true;
}
else
{
record.PRvarValue = false;
}
record.PRdtType = SoapUtil.typeofBoolean;
record.PRdtTypeCode = InternalPrimitiveTypeE.Boolean;
this.headerList.Add(record);
record = this.GetPr();
record.PRparseTypeEnum = InternalParseTypeE.Member;
record.PRmemberTypeEnum = InternalMemberTypeE.Field;
record.PRmemberValueEnum = pr.PRmemberValueEnum;
record.PRisHeaderRoot = true;
record.PRname = "Value";
switch (pr.PRmemberValueEnum)
{
case InternalMemberValueE.InlineValue:
record.PRvalue = pr.PRvalue;
record.PRvarValue = pr.PRvarValue;
record.PRdtType = pr.PRdtType;
record.PRdtTypeCode = pr.PRdtTypeCode;
record.PRkeyDt = pr.PRkeyDt;
this.headerList.Add(record);
this.ProcessHeaderMemberEnd(pr);
return;
case InternalMemberValueE.Nested:
record.PRdtType = pr.PRdtType;
record.PRdtTypeCode = pr.PRdtTypeCode;
record.PRkeyDt = pr.PRkeyDt;
this.headerList.Add(record);
return;
case InternalMemberValueE.Reference:
record.PRidRef = pr.PRidRef;
this.headerList.Add(record);
this.ProcessHeaderMemberEnd(pr);
return;
case InternalMemberValueE.Null:
this.headerList.Add(record);
this.ProcessHeaderMemberEnd(pr);
return;
}
}
}
// End of object encountered in stream
private void ParseObjectEnd(ParseRecord pr)
{
InternalST.Soap( this, "ParseObjectEnd Entry ",pr.Trace());
ParseRecord objectPr = (ParseRecord)stack.Peek();
if (objectPr == null)
objectPr = pr;
//BCLDebug.Assert(objectPr != null, "[System.Runtime.Serialization.Formatters.ParseObjectEnd]objectPr != null");
InternalST.Soap( this, "ParseObjectEnd objectPr ",objectPr.Trace());
if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
InternalST.Soap( this, "ParseObjectEnd Top Object dtType ",objectPr.PRdtType);
if (objectPr.PRdtType == Converter.typeofString)
{
InternalST.Soap( this, "ParseObjectEnd Top String");
if (objectPr.PRvalue == null)
objectPr.PRvalue = String.Empty; // Not a null object, but an empty string
objectPr.PRnewObj = objectPr.PRvalue;
CheckSecurity(objectPr);
isTopObjectResolved = true;
topObject = objectPr.PRnewObj;
return;
}
else if (objectPr.PRdtType != null && objectPr.PRvalue != null && !IsWhiteSpace(objectPr.PRvalue) && (objectPr.PRdtType.IsPrimitive || objectPr.PRdtType == Converter.typeofTimeSpan))
{
// When an xsd type is transmitted as a top level string <xsd:int>111</xsd:int>
objectPr.PRnewObj = Converter.FromString(objectPr.PRvalue, Converter.ToCode(objectPr.PRdtType));
CheckSecurity(objectPr);
isTopObjectResolved = true;
topObject = objectPr.PRnewObj;
return;
}
else if ((!isTopObjectResolved) && (objectPr.PRdtType != Converter.typeofSoapFault))
{
InternalST.Soap( this, "ParseObjectEnd Top but not String");
// Need to keep top record on object stack until finished building top stack
topStack.Push(pr.Copy());
// Note this is PRparseRecordId and not objectId
if (objectPr.PRparseRecordId == pr.PRparseRecordId)
{
// This handles the case of top stack containing nested objects and
// referenced objects. If nested objects the objects are not placed
// on stack, only topstack. If referenced objects they are placed on
// stack and need to be popped.
stack.Pop();
}
return;
}
}
stack.Pop();
ParseRecord parentPr = (ParseRecord)stack.Peek();
if (objectPr.PRobjectTypeEnum == InternalObjectTypeE.Array)
{
if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
InternalST.Soap( this, "ParseObjectEnd Top Object (Array) Resolved");
isTopObjectResolved = true;
topObject = objectPr.PRnewObj;
}
InternalST.Soap( this, "ParseArray RegisterObject ",objectPr.PRobjectId," ",objectPr.PRnewObj.GetType());
RegisterObject(objectPr.PRnewObj, objectPr, parentPr);
return;
}
if (objectPr.PRobjectInfo != null)
{
objectPr.PRobjectInfo.PopulateObjectMembers();
}
if (objectPr.PRnewObj == null)
{
if (objectPr.PRdtType == Converter.typeofString)
{
InternalST.Soap( this, "ParseObjectEnd String ");
if (objectPr.PRvalue == null)
objectPr.PRvalue = String.Empty; // Not a null object, but an empty string
objectPr.PRnewObj = objectPr.PRvalue;
CheckSecurity(objectPr);
}
else
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_ObjectMissing"),pr.PRname));
}
// Registration is after object is populated
if (!objectPr.PRisRegistered && objectPr.PRobjectId > 0)
{
InternalST.Soap( this, "ParseObjectEnd Register Object ",objectPr.PRobjectId," ",objectPr.PRnewObj.GetType());
RegisterObject(objectPr.PRnewObj, objectPr, parentPr);
}
if (objectPr.PRisValueTypeFixup)
{
InternalST.Soap( this, "ParseObjectEnd ValueTypeFixup ",objectPr.PRnewObj.GetType());
ValueFixup fixup = (ValueFixup)valueFixupStack.Pop(); //Value fixup
fixup.Fixup(objectPr, parentPr); // Value fixup
}
if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
InternalST.Soap( this, "ParseObjectEnd Top Object Resolved ",objectPr.PRnewObj.GetType());
isTopObjectResolved = true;
topObject = objectPr.PRnewObj;
}
if (objectPr.PRnewObj is SoapFault)
soapFaultId = objectPr.PRobjectId;
if (objectPr.PRobjectInfo != null)
{
if (objectPr.PRobjectInfo.bfake && !objectPr.PRobjectInfo.bSoapFault)
objectPr.PRobjectInfo.AddValue("__fault", null); // need this because SerializationObjectInfo throws an exception if a name being referenced is missing
objectPr.PRobjectInfo.ObjectEnd();
}
InternalST.Soap( this, "ParseObjectEnd Exit ",objectPr.PRnewObj," id: ",objectPr.PRobjectId);
}
// New object encountered in stream
private void ParseObject(ParseRecord pr)
{
InternalST.Soap( this, "ParseObject Entry ");
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
topId = pr.PRobjectId;
if (pr.PRparseTypeEnum == InternalParseTypeE.Object)
{
InternalST.Soap( this, "ParseObject Push "+pr.PRname);
stack.Push(pr); // Nested objects member names are already on stack
}
if (pr.PRobjectTypeEnum == InternalObjectTypeE.Array)
{
ParseArray(pr);
InternalST.Soap( this, "ParseObject Exit, ParseArray ");
return;
}
if ((pr.PRdtType == null) && !IsFakeTopObject)
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TopObjectInstantiate"),pr.PRname));
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top && IsFakeTopObject && pr.PRdtType != Converter.typeofSoapFault)
{
// Soap fake top object
if (handler != null)
{
// Handler object will supply real top object
InternalST.Soap( this, "ParseObject FakeTopObject with handlerObject ");
// Now know the method name, can call header handler
//Create header for method name
if (!isHeaderHandlerCalled)
{
newheaders = null;
isHeaderHandlerCalled = true;
if (headers == null)
{
newheaders = new Header[1];
}
else
{
newheaders = new Header[headers.Length+1];
Array.Copy(headers, 0, newheaders, 1, headers.Length);
}
Header methodNameHeader = new Header("__methodName", pr.PRname, false, pr.PRnameXmlKey);
newheaders[0] = methodNameHeader;
InternalST.Soap( this, "Deserialize Before Delegate Invoke ");
handlerObject = handler(newheaders);
InternalST.Soap( this, "Deserialize after Delegate Invoke");
InternalST.Soap( this, "Deserialize delgate object ",((handlerObject == null)?"null":handlerObject));
}
if (isHeaderHandlerCalled)
{
// Handler object has supplied the real object for the fake object
// which is on top of the stack
pr.PRnewObj = handlerObject;
pr.PRdtType = handlerObject.GetType();
CheckSecurity(pr);
if (pr.PRnewObj is IFieldInfo)
{
IFieldInfo fi = (IFieldInfo)pr.PRnewObj;
if ((fi.FieldTypes != null) && (fi.FieldTypes.Length > 0))
{
pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, fi.FieldNames, fi.FieldTypes, pr.PRassemblyName);
}
}
}
else
{
// Handler object has not yet been asked for the real object
// Stack the parse record until the second pass
isTopObjectResolved = false;
topStack = new SerStack("Top ParseRecords");
InternalST.Soap( this, "ParseObject Handler Push "+pr.PRname);
topStack.Push(pr.Copy());
return;
}
}
else if (formatterEnums.FEtopObject != null)
{
// SoapMessage will be used as the real object
InternalST.Soap( this, "ParseObject FakeTopObject with SoapMessage ");
if (isTopObjectSecondPass)
{
// This creates a the SoapMessage object as the real object, at this point it is an unitialized object.
pr.PRnewObj = new InternalSoapMessage();
pr.PRdtType = typeof(InternalSoapMessage);
CheckSecurity(pr);
if (formatterEnums.FEtopObject != null)
{
ISoapMessage soapMessage = (ISoapMessage)formatterEnums.FEtopObject;
pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, soapMessage.ParamNames, soapMessage.ParamTypes, pr.PRassemblyName);
}
}
else
{
// Stack the parse record until the second pass
isTopObjectResolved = false;
topStack = new SerStack("Top ParseRecords");
topStack.Push(pr.Copy());
return;
}
}
}
else if (pr.PRdtType == Converter.typeofString)
{
// String as a top level object
if (pr.PRvalue != null)
{
pr.PRnewObj = pr.PRvalue;
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
InternalST.Soap( this, "ParseObject String as top level, Top Object Resolved");
isTopObjectResolved = true;
topObject = pr.PRnewObj;
//stack.Pop();
return;
}
else
{
InternalST.Soap( this, "ParseObject String as an object");
stack.Pop();
RegisterObject(pr.PRnewObj, pr, (ParseRecord)stack.Peek());
return;
}
}
else
{
// xml Doesn't have the value until later
return;
}
}
else
{
if (pr.PRdtType == null)
{
ParseRecord objectPr = (ParseRecord)stack.Peek();
if (objectPr.PRdtType == Converter.typeofSoapFault)
{
InternalST.Soap( this, "ParseObject unknown SoapFault detail");
throw new ServerException(String.Format(SoapUtil.GetResourceString("Serialization_SoapFault"),faultString));
}
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname));
}
pr.PRnewObj = FormatterServices.GetUninitializedObject(pr.PRdtType);
CheckSecurity(pr);
}
if (pr.PRnewObj == null)
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TopObjectInstantiate"),pr.PRdtType));
long genId = pr.PRobjectId;
if (genId < 1)
pr.PRobjectId = GetId("GenId-"+objectIds);
if (IsFakeTopObject && pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
InternalST.Soap( this, "ParseObject fake Top object resolved ",pr.PRnewObj);
isTopObjectResolved = true;
topObject = pr.PRnewObj;
}
if (pr.PRobjectInfo == null)
pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, pr.PRassemblyName);
pr.PRobjectInfo.obj = pr.PRnewObj;
if (IsFakeTopObject && pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
InternalST.Soap( this, "ParseObject AddValue to fake object ",pr.PRobjectInfo.obj);
// Add the methodName to top object, either InternalSoapMessage or object returned by handler
pr.PRobjectInfo.AddValue("__methodName", pr.PRname);
pr.PRobjectInfo.AddValue("__keyToNamespaceTable", soapHandler.keyToNamespaceTable);
pr.PRobjectInfo.AddValue("__paramNameList", pr.PRobjectInfo.SetFakeObject());
if (formatterEnums.FEtopObject != null)
pr.PRobjectInfo.AddValue("__xmlNameSpace", pr.PRxmlNameSpace);
}
InternalST.Soap( this, "ParseObject Exit ");
}
// Object member encountered in stream
private void ParseMember(ParseRecord pr)
{
InternalST.Soap( this, "ParseMember Entry ");
ParseRecord objectPr = (ParseRecord)stack.Peek();
String objName = null;
if (objectPr != null)
objName = objectPr.PRname;
InternalST.Soap( this, "ParseMember ",objectPr.PRobjectId," ",pr.PRname);
InternalST.Soap( this, "ParseMember objectPr ",objectPr.Trace());
InternalST.Soap( this, "ParseMember pr ",pr.Trace());
if (objectPr.PRdtType == Converter.typeofSoapFault && pr.PRname.ToLower(CultureInfo.InvariantCulture) == "faultstring")
faultString = pr.PRvalue; // Save fault string in case rest of SoapFault cannot be parsed
if ((objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top) && !isTopObjectResolved)
{
InternalST.Soap( this, "ParseMember Top not resolved");
if (pr.PRdtType == Converter.typeofString)
{
ParseString(pr, objectPr);
}
topStack.Push(pr.Copy());
return;
}
switch(pr.PRmemberTypeEnum)
{
case InternalMemberTypeE.Item:
ParseArrayMember(pr);
return;
case InternalMemberTypeE.Field:
break;
}
if (objectPr.PRobjectInfo != null)
objectPr.PRobjectInfo.AddMemberSeen();
bool bParams = (IsFakeTopObject &&
objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top &&
objectPr.PRobjectInfo != null && objectPr.PRdtType != Converter.typeofSoapFault);
if ((pr.PRdtType == null) && objectPr.PRobjectInfo.isTyped)
{
InternalST.Soap( this, "ParseMember pr.PRdtType null and not isSi");
if (bParams)
{
// Get type of parameters
InternalST.Soap( this, "ParseMember pr.PRdtType Get Param Type position "+paramPosition+" name "+pr.PRname);
pr.PRdtType = objectPr.PRobjectInfo.GetType(paramPosition++);
InternalST.Soap( this, "ParseMember pr.PRdtType Get Param Type Type "+pr.PRdtType);
}
else
pr.PRdtType = objectPr.PRobjectInfo.GetType(pr.PRname);
if (pr.PRdtType == null)
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeResolved"), objectPr.PRnewObj+" "+pr.PRname));
pr.PRdtTypeCode = Converter.ToCode(pr.PRdtType);
}
else
{
if (bParams)
{
paramPosition++;
}
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
{
// Value is Null
InternalST.Soap( this, "ParseMember null member: ",pr.PRname);
InternalST.Soap( this, "AddValue 1");
objectPr.PRobjectInfo.AddValue(pr.PRname, null);
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
InternalST.Soap( this, "ParseMember Nested Type member: ",pr.PRname," objectPr.PRnewObj ",objectPr.PRnewObj);
ParseObject(pr);
InternalST.Soap( "ParseMember Push object "+pr.PRname);
stack.Push(pr);
InternalST.Soap( this, "AddValue 2 ",pr.PRnewObj," is value type ",pr.PRnewObj.GetType().IsValueType);
if ((pr.PRobjectInfo != null) && (pr.PRobjectInfo.objectType.IsValueType))
{
InternalST.Soap( "ParseMember ValueType ObjectPr ",objectPr.PRnewObj," memberName ",pr.PRname," nested object ",pr.PRnewObj);
if (IsFakeTopObject)
objectPr.PRobjectInfo.AddParamName(pr.PRname);
pr.PRisValueTypeFixup = true; //Valuefixup
valueFixupStack.Push(new ValueFixup(objectPr.PRnewObj, pr.PRname, objectPr.PRobjectInfo));//valuefixup
}
else
{
InternalST.Soap( this, "AddValue 2A ");
objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRnewObj);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
{
InternalST.Soap( this, "ParseMember Reference Type member: ",pr.PRname);
// See if object has already been instantiated
Object refObj = m_objectManager.GetObject(pr.PRidRef);
if (refObj == null)
{
InternalST.Soap( this, "ParseMember RecordFixup: ",pr.PRname);
InternalST.Soap( this, "AddValue 3");
objectPr.PRobjectInfo.AddValue(pr.PRname, null);
objectPr.PRobjectInfo.RecordFixup(objectPr.PRobjectId, pr.PRname, pr.PRidRef); // Object not instantiated
}
else
{
InternalST.Soap( this, "ParseMember Referenced Object Known ",pr.PRname," ",refObj);
InternalST.Soap( this, "AddValue 5");
objectPr.PRobjectInfo.AddValue(pr.PRname, refObj);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
// Primitive type or String
InternalST.Soap( this, "ParseMember primitive or String member: ",pr.PRname);
if (pr.PRdtType == Converter.typeofString)
{
ParseString(pr, objectPr);
InternalST.Soap( this, "AddValue 6");
objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);
}
else if (pr.PRdtTypeCode == InternalPrimitiveTypeE.Invalid)
{
// The member field was an object put the value is Inline either bin.Base64 or invalid
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
InternalST.Soap( this, "AddValue 7");
objectPr.PRobjectInfo.AddValue(pr.PRname, Convert.FromBase64String(FilterBin64(pr.PRvalue)));
}
else if (pr.PRdtType == Converter.typeofObject && pr.PRvalue != null)
{
if (objectPr != null && objectPr.PRdtType == Converter.typeofHeader)
{
// assume the type is a string for a header
pr.PRdtType = Converter.typeofString;
ParseString(pr, objectPr);
InternalST.Soap( this, "AddValue 6");
objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);
}
else
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeMissing"), pr.PRname));
}
else
{
InternalST.Soap( this, "Object Class with no memberInfo data Member "+pr.PRname+" type "+pr.PRdtType);
if (pr.PRdtType != null && pr.PRdtType.IsEnum)
{
// Soap sends Enums as strings
Object obj = Enum.Parse(pr.PRdtType, pr.PRvalue);
InternalST.Soap( this, "AddValue 8");
objectPr.PRobjectInfo.AddValue(pr.PRname, obj);
}
else if (pr.PRdtType != null && pr.PRdtType == Converter.typeofTypeArray)
{
// Soap sends MethodSignature as an array of types
InternalST.Soap( this, "AddValue 8A");
objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvarValue);
}
else
{
if ((!pr.PRisRegistered) && (pr.PRobjectId > 0))
{
if (pr.PRvalue == null)
pr.PRvalue = ""; //can't register null value, this must be a string so set to empty string.
InternalST.Soap( this, "ParseMember RegisterObject ",pr.PRvalue," ",pr.PRobjectId);
RegisterObject(pr.PRvalue, pr, objectPr);
}
// Object Class with no memberInfo data
if (pr.PRdtType == Converter.typeofSystemVoid)
{
InternalST.Soap( this, "AddValue 9");
objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRdtType);
}
else if (objectPr.PRobjectInfo.isSi)
{
// ISerializable are added as strings, the conversion to type is done by the
// ISerializable object
InternalST.Soap( this, "AddValue 10");
objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);
}
}
}
}
else
{
Object var = null;
if (pr.PRvarValue != null)
var = pr.PRvarValue;
else
var = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
// Not a string, convert the value
InternalST.Soap( this, "ParseMember Converting primitive and storing");
stack.Dump();
InternalST.Soap( this, "ParseMember pr "+pr.Trace());
InternalST.Soap( this, "ParseMember objectPr ",objectPr.Trace());
InternalST.Soap( this, "AddValue 11");
if (pr.PRdtTypeCode == InternalPrimitiveTypeE.QName && var != null)
{
SoapQName soapQName = (SoapQName)var;
if (soapQName.Key != null)
{
if (soapQName.Key.Length == 0)
soapQName.Namespace = (String)soapHandler.keyToNamespaceTable["xmlns"];
else
soapQName.Namespace = (String)soapHandler.keyToNamespaceTable["xmlns"+":"+soapQName.Key];
}
}
objectPr.PRobjectInfo.AddValue(pr.PRname, var);
}
}
else
ParseError(pr, objectPr);
}
