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 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 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);
}
// Create a URT type from the XML dt type
private void ProcessType(ParseRecord pr, ParseRecord objectPr)
{
InternalST.Soap( this, "ProcessType nameXmlKey ",pr.PRnameXmlKey," typeXmlKey ",pr.PRtypeXmlKey);
pr.Dump();
if (pr.PRdtType != null)
return;
if ((pr.PRnameXmlKey.Equals(soapEnvKey)) && (String.Compare(pr.PRname, "Fault", true, CultureInfo.InvariantCulture) == 0))
{
// Fault object
InternalST.Soap( this, "ProcessType SoapFault");
pr.PRdtType = SoapUtil.typeofSoapFault;
pr.PRparseTypeEnum = InternalParseTypeE.Object;
}
else if (pr.PRname != null)
{
InternalST.Soap( this, "ProcessType Attribute 1");
String interopAssemblyNameString = null;
// determine interop assembly string if there is a namespace
if ((pr.PRnameXmlKey != null) && (pr.PRnameXmlKey.Length > 0))
{
interopAssemblyNameString = (String)assemKeyToInteropAssemblyTable[pr.PRnameXmlKey];
InternalST.Soap( this, "ProcessType Attribute 2 "+interopAssemblyNameString);
}
// look for interop data
Type type = null;
String name = null;
if (objectPr != null)
{
if (pr.PRisXmlAttribute)
{
// These should processed after containing element
// is processed.
SoapServices.GetInteropFieldTypeAndNameFromXmlAttribute(
objectPr.PRdtType, pr.PRname, interopAssemblyNameString,
out type, out name);
InternalST.Soap( this, "ProcessType Attribute 3 type "+type+" name "+name);
}
else
{
SoapServices.GetInteropFieldTypeAndNameFromXmlElement(
objectPr.PRdtType, pr.PRname, interopAssemblyNameString,
out type, out name);
InternalST.Soap( this, "ProcessType Attribute 4 type objectPr.PRdtType ",objectPr.PRdtType," pr.PRname ",pr.PRname, " interopAssemblyNameString ",interopAssemblyNameString, " type ",type," name ",name);
}
}
if (type != null)
{
pr.PRdtType = type;
pr.PRname = name;
pr.PRdtTypeCode = Converter.SoapToCode(pr.PRdtType);
InternalST.Soap(this, "ProcessType Attribute 5 typeCode "+((Enum)pr.PRdtTypeCode));
}
else
{
if (interopAssemblyNameString != null)
pr.PRdtType = objectReader.Bind(interopAssemblyNameString, pr.PRname); // try to get type from SerializationBinder
if (pr.PRdtType == null)
{
pr.PRdtType = SoapServices.GetInteropTypeFromXmlElement(pr.PRname, interopAssemblyNameString);
}
// Array item where the element name gives the element type
if (pr.PRkeyDt == null && pr.PRnameXmlKey != null && pr.PRnameXmlKey.Length > 0 && objectPr.PRobjectTypeEnum == InternalObjectTypeE.Array && objectPr.PRarrayElementType == Converter.typeofObject)
{
pr.PRdtType = ProcessGetType(pr.PRname, pr.PRnameXmlKey, out pr.PRassemblyName);
pr.PRdtTypeCode = Converter.SoapToCode(pr.PRdtType);
}
InternalST.Soap(this, "ProcessType Attribute 6 type pr.PRname ", pr.PRname, " interopAssemblyNameString ",interopAssemblyNameString, " pr.PRdtType ",pr.PRdtType);
}
}
if (pr.PRdtType != null)
return;
if ((pr.PRtypeXmlKey != null) && (pr.PRtypeXmlKey.Length > 0) &&
(pr.PRkeyDt != null) && (pr.PRkeyDt.Length > 0) &&
(assemKeyToInteropAssemblyTable.ContainsKey(pr.PRtypeXmlKey)))
{
InternalST.Soap(this, "ProcessType Attribute 7 ");
// Interop type get from dtType
int index = pr.PRkeyDt.IndexOf("[");
if (index > 0)
{
ProcessArray(pr, index, true);
}
else
{
String assemblyString = (String)assemKeyToInteropAssemblyTable[pr.PRtypeXmlKey];
pr.PRdtType = objectReader.Bind(assemblyString, pr.PRkeyDt); // try to get type from SerializationBinder
if (pr.PRdtType == null)
{
pr.PRdtType = SoapServices.GetInteropTypeFromXmlType(pr.PRkeyDt, assemblyString);
if (pr.PRdtType == null)
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname+" "+pr.PRkeyDt));
}
InternalST.Soap(this, "ProcessType Attribute 8 type pr.PRkeyDt ",pr.PRkeyDt," pr.PRdtType ",pr.PRdtType);
if (pr.PRdtType == null)
{
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname+" "+pr.PRkeyDt+", "+assemblyString));
}
}
}
else if (pr.PRkeyDt != null)
{
if (String.Compare(pr.PRkeyDt, "Base64", true, CultureInfo.InvariantCulture) == 0)
{
pr.PRobjectTypeEnum = InternalObjectTypeE.Array;
pr.PRarrayTypeEnum = InternalArrayTypeE.Base64;
}
else if (String.Compare(pr.PRkeyDt, "String", true, CultureInfo.InvariantCulture) == 0)
{
pr.PRdtType = SoapUtil.typeofString;
}
else if (String.Compare(pr.PRkeyDt, "methodSignature", true, CultureInfo.InvariantCulture) == 0)
{
// MethodSignature needs to be expanded to an array of types
InternalST.Soap( this, "ProcessType methodSignature ",pr.PRvalue);
try
{
pr.PRdtType = typeof(System.Type[]);
char[] c = {' ', ':'};
String[] typesStr = null;
if (pr.PRvalue != null)
typesStr = pr.PRvalue.Split(c);
Type[] types = null;
if ((typesStr == null) ||
(typesStr.Length == 1 && typesStr[0].Length == 0))
{
// Method signature with no parameters
types = new Type[0];
}
else
{
types = new Type[typesStr.Length/2];
//throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_MethodSignature"),pr.PRvalue));
for (int i=0; i<typesStr.Length; i+=2)
{
String prefix = typesStr[i];
String typeString = typesStr[i+1];
types[i/2] = ProcessGetType(typeString, prefix, out pr.PRassemblyName);
InternalST.Soap( this, "ProcessType methodSignature type string ",i+" "+" prefix "+prefix+" typestring "+typeString+" type "+types[i/2]); //Temp
}
}
pr.PRvarValue = types;
}
catch (Exception)
{
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_MethodSignature"),pr.PRvalue));
}
}
else
{
pr.PRdtTypeCode = Converter.ToCode(pr.PRkeyDt);
if (pr.PRdtTypeCode != InternalPrimitiveTypeE.Invalid)
{
pr.PRdtType = Converter.SoapToType(pr.PRdtTypeCode);
}
else
{
// Find out if it is an array
int index = pr.PRkeyDt.IndexOf("[");
if (index > 0)
{
// Array
ProcessArray(pr, index, false);
}
else
{
// Object
pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
pr.PRdtType = ProcessGetType(pr.PRkeyDt, pr.PRtypeXmlKey, out pr.PRassemblyName);
if ((pr.PRdtType == null) && (pr.PRobjectPositionEnum != InternalObjectPositionE.Top))
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname+" "+pr.PRkeyDt));
}
}
InternalST.Soap(this, "ProcessType Attribute 9 type "+pr.PRdtType);
}
}
else
{
if ((pr.PRparseTypeEnum == InternalParseTypeE.Object) && (!(objectReader.IsFakeTopObject && (pr.PRobjectPositionEnum == InternalObjectPositionE.Top))))
{
if (String.Compare(pr.PRname, "Array", true, CultureInfo.InvariantCulture) == 0)
pr.PRdtType = ProcessGetType(pr.PRkeyDt, pr.PRtypeXmlKey, out pr.PRassemblyName);
else
{
pr.PRdtType = ProcessGetType(pr.PRname, pr.PRnameXmlKey, out pr.PRassemblyName);
}
InternalST.Soap(this, "ProcessType Attribute 10 type "+pr.PRdtType);
}
}
}
// Array object encountered in stream
private void ParseArray(ParseRecord pr)
{
InternalST.Soap( this, "ParseArray Entry");
pr.Dump();
long genId = pr.PRobjectId;
if (genId < 1)
pr.PRobjectId = GetId("GenId-"+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];
CheckSecurity(pr);
}
else
{
// Used for arrays of Base64 and also for a parameter of Base64
InternalST.Soap( this, "ParseArray bin.base64 ",pr.PRvalue.Length," ",pr.PRvalue);
if (pr.PRdtType == Converter.typeofSoapBase64Binary)
{
// Parameter - Case where the return type is a SoapENC:base64 but the parameter type is xsd:base64Binary
pr.PRnewObj = SoapBase64Binary.Parse(pr.PRvalue);
CheckSecurity(pr);
}
else
{
// ByteArray
if (pr.PRvalue.Length > 0)
{
pr.PRnewObj = Convert.FromBase64String(FilterBin64(pr.PRvalue));
CheckSecurity(pr);
}
else
{
pr.PRnewObj = new Byte[0];
CheckSecurity(pr);
}
}
}
if (stack.Peek() == pr)
{
InternalST.Soap( this, "ParseArray, bin.base64 has been stacked");
stack.Pop();
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
InternalST.Soap( this, "ParseArray, bin.base64 Top Object");
topObject = pr.PRnewObj;
isTopObjectResolved = true;
}
ParseRecord parentPr = (ParseRecord)stack.Peek();
// Base64 can be registered at this point because it is populated
InternalST.Soap( this, "ParseArray RegisterObject ",pr.PRobjectId," ",pr.PRnewObj.GetType());
RegisterObject(pr.PRnewObj, pr, parentPr);
}
else if ((pr.PRnewObj != null) && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
// Primtive typed Array has already been read
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
topObject = pr.PRnewObj;
isTopObjectResolved = true;
}
ParseRecord parentPr = (ParseRecord)stack.Peek();
// Primitive typed array can be registered at this point because it is populated
InternalST.Soap( this, "ParseArray RegisterObject ",pr.PRobjectId," ",pr.PRnewObj.GetType());
RegisterObject(pr.PRnewObj, pr, parentPr);
}
else if ((pr.PRarrayTypeEnum == InternalArrayTypeE.Jagged) || (pr.PRarrayTypeEnum == InternalArrayTypeE.Single))
{
// Multidimensional jagged array or single array
InternalST.Soap( this, "ParseArray Before Jagged,Simple create ",pr.PRarrayElementType," ",(pr.PRrank >0?pr.PRlengthA[0].ToString():"0"));
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.PRobjectA = (Object[])pr.PRnewObj;
}
CheckSecurity(pr);
InternalST.Soap( this, "ParseArray Jagged,Simple Array ",pr.PRnewObj.GetType());
// For binary, headers comes in as an array of header objects
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Headers)
{
InternalST.Soap( this, "ParseArray header array");
headers = (Header[])pr.PRnewObj;
}
pr.PRindexMap = new int[1];
}
else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Rectangular)
{
// Rectangle array
pr.PRisLowerBound = false;
if (pr.PRlowerBoundA != null)
{
for (int i=0; i<pr.PRrank; i++)
{
if (pr.PRlowerBoundA[i] != 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);
CheckSecurity(pr);
InternalST.Soap( this, "ParseArray Rectangle Array ",pr.PRnewObj.GetType()," lower Bound ",pr.PRisLowerBound);
// Calculate number of items
int sum = 1;
for (int i=0; i<pr.PRrank; i++)
{
sum = sum*pr.PRlengthA[i];
}
pr.PRindexMap = new int[pr.PRrank];
pr.PRrectangularMap = new int[pr.PRrank];
pr.PRlinearlength = sum;
}
else
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_ArrayType"),((Enum)pr.PRarrayTypeEnum).ToString()));
InternalST.Soap( this, "ParseArray Exit");
}
// Main Parse routine, called by the XML Parse Handlers in XMLParser and also called internally to
// parse the fake top object.
internal void Parse(ParseRecord pr)
{
InternalST.Soap( this, "Parse Entry");
stack.Dump();
pr.Dump();
switch(pr.PRparseTypeEnum)
{
case InternalParseTypeE.SerializedStreamHeader:
ParseSerializedStreamHeader(pr);
break;
case InternalParseTypeE.SerializedStreamHeaderEnd:
ParseSerializedStreamHeaderEnd(pr);
break;
case InternalParseTypeE.Object:
ParseObject(pr);
break;
case InternalParseTypeE.ObjectEnd:
ParseObjectEnd(pr);
break;
case InternalParseTypeE.Member:
ParseMember(pr);
break;
case InternalParseTypeE.MemberEnd:
ParseMemberEnd(pr);
break;
case InternalParseTypeE.Body:
case InternalParseTypeE.BodyEnd:
case InternalParseTypeE.Envelope:
case InternalParseTypeE.EnvelopeEnd:
break;
case InternalParseTypeE.Empty:
default:
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_XMLElement"), pr.PRname));
}
}
