public void ReadNestedObjects()
{
reader = CreateReader("{\"A\": [123, {\"B\": \"456\", \"C\" :true}], \"D\" : {\"E\" : \"false\"}}");
Assert.IsTrue(reader.Read(), "#1"); // {
AssertNode(0, "root", XmlNodeType.Element, String.Empty, "object", reader, "#2");
Assert.IsTrue(reader.Read(), "#3"); // A
AssertNode(1, "A", XmlNodeType.Element, String.Empty, "array", reader, "#4");
Assert.IsTrue(reader.Read(), "#5"); // (<123>)
AssertNode(2, "item", XmlNodeType.Element, String.Empty, "number", reader, "#6");
Assert.IsTrue(reader.Read(), "#7"); // (123)
AssertNode(3, String.Empty, XmlNodeType.Text, "123", null, reader, "#8");
Assert.IsTrue(reader.Read(), "#9"); // (</123>)
AssertNode(2, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#10");
Assert.IsTrue(reader.Read(), "#11"); // {
AssertNode(2, "item", XmlNodeType.Element, String.Empty, "object", reader, "#12");
Assert.IsTrue(reader.Read(), "#13"); // B
AssertNode(3, "B", XmlNodeType.Element, String.Empty, "string", reader, "#14");
Assert.IsTrue(reader.Read(), "#15"); // "456"
AssertNode(4, String.Empty, XmlNodeType.Text, "456", null, reader, "#16");
Assert.IsTrue(reader.Read(), "#17"); // /B
AssertNode(3, "B", XmlNodeType.EndElement, String.Empty, null, reader, "#18");
Assert.IsTrue(reader.Read(), "#19"); // C
AssertNode(3, "C", XmlNodeType.Element, String.Empty, "boolean", reader, "#20");
Assert.IsTrue(reader.Read(), "#21"); // true
AssertNode(4, String.Empty, XmlNodeType.Text, "true", null, reader, "#22");
Assert.IsTrue(reader.Read(), "#23"); // /C
AssertNode(3, "C", XmlNodeType.EndElement, String.Empty, null, reader, "#24");
Assert.IsTrue(reader.Read(), "#25"); // }
AssertNode(2, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#26");
Assert.IsTrue(reader.Read(), "#27"); // ]
AssertNode(1, "A", XmlNodeType.EndElement, String.Empty, null, reader, "#28");
Assert.IsTrue(reader.Read(), "#29"); // {
AssertNode(1, "D", XmlNodeType.Element, String.Empty, "object", reader, "#30");
Assert.IsTrue(reader.Read(), "#31"); // D
AssertNode(2, "E", XmlNodeType.Element, String.Empty, "string", reader, "#32");
Assert.IsTrue(reader.Read(), "#33"); // "false"
AssertNode(3, String.Empty, XmlNodeType.Text, "false", null, reader, "#34");
Assert.IsTrue(reader.Read(), "#35"); // /D
AssertNode(2, "E", XmlNodeType.EndElement, String.Empty, null, reader, "#36");
Assert.IsTrue(reader.Read(), "#37"); // }
AssertNode(1, "D", XmlNodeType.EndElement, String.Empty, null, reader, "#38");
Assert.IsTrue(reader.Read(), "#39"); // }
AssertNode(0, "root", XmlNodeType.EndElement, String.Empty, null, reader, "#40");
Assert.IsFalse(reader.Read(), "#41"); // EOF
}
public void ReadArrayContent()
{
reader = CreateReader("[123, \"123\", true, \"true\"]");
// number value
reader.Read(); // element
AssertNode(0, "root", XmlNodeType.Element, String.Empty, "array", reader, "#1");
reader.Read(); // 123 - element
Assert.AreEqual("number", reader.GetAttribute("type"), "#2-0");
AssertNode(1, "item", XmlNodeType.Element, String.Empty, "number", reader, "#2");
reader.Read(); // 123 - text
AssertNode(2, String.Empty, XmlNodeType.Text, "123", null, reader, "#3");
reader.Read(); // 123 - endelement
AssertNode(1, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#4");
// string value #1
reader.Read(); // "123" - element
Assert.AreEqual("string", reader.GetAttribute("type"), "#5-0");
AssertNode(1, "item", XmlNodeType.Element, String.Empty, "string", reader, "#5");
reader.Read(); // "123" - text
AssertNode(2, String.Empty, XmlNodeType.Text, "123", null, reader, "#6");
reader.Read(); // "123" - endelement
AssertNode(1, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#7");
reader.Read(); // true - element
Assert.AreEqual("boolean", reader.GetAttribute("type"), "#8-0");
AssertNode(1, "item", XmlNodeType.Element, String.Empty, "boolean", reader, "#8");
reader.Read(); // true - text
AssertNode(2, String.Empty, XmlNodeType.Text, "true", null, reader, "#9");
reader.Read(); // true - endelement
AssertNode(1, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#10");
// string value #2
reader.Read(); // "true" - element
Assert.AreEqual("string", reader.GetAttribute("type"), "#11-0");
AssertNode(1, "item", XmlNodeType.Element, String.Empty, "string", reader, "#11");
reader.Read(); // "true" - text
AssertNode(2, String.Empty, XmlNodeType.Text, "true", null, reader, "#12");
reader.Read(); // "true" - endelement
AssertNode(1, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#13");
Assert.IsTrue(reader.Read(), "#14"); // ]
AssertNode(0, "root", XmlNodeType.EndElement, String.Empty, null, reader, "#15");
Assert.IsFalse(reader.Read(), "#16"); // EOF
}
public void ReadObjectContent()
{
reader = CreateReader("{\"A\":123, \"B\": \"123\", \"C\" :true, \"D\" : \"true\"}");
// number value
reader.Read(); // element
AssertNode(0, "root", XmlNodeType.Element, String.Empty, "object", reader, "#1");
reader.Read(); // 123 - element
AssertNode(1, "A", XmlNodeType.Element, String.Empty, "number", reader, "#2");
reader.Read(); // 123 - text
AssertNode(2, String.Empty, XmlNodeType.Text, "123", null, reader, "#3");
reader.Read(); // 123 - endelement
AssertNode(1, "A", XmlNodeType.EndElement, String.Empty, null, reader, "#4");
// string value #1
reader.Read(); // "123" - element
AssertNode(1, "B", XmlNodeType.Element, String.Empty, "string", reader, "#5");
reader.Read(); // "123" - text
AssertNode(2, String.Empty, XmlNodeType.Text, "123", null, reader, "#6");
reader.Read(); // "123" - endelement
AssertNode(1, "B", XmlNodeType.EndElement, String.Empty, null, reader, "#7");
reader.Read(); // true - element
AssertNode(1, "C", XmlNodeType.Element, String.Empty, "boolean", reader, "#8");
reader.Read(); // true - text
AssertNode(2, String.Empty, XmlNodeType.Text, "true", null, reader, "#9");
reader.Read(); // true - endelement
AssertNode(1, "C", XmlNodeType.EndElement, String.Empty, null, reader, "#10");
// string value #2
reader.Read(); // "true" - element
AssertNode(1, "D", XmlNodeType.Element, String.Empty, "string", reader, "#11");
reader.Read(); // "true" - text
AssertNode(2, String.Empty, XmlNodeType.Text, "true", null, reader, "#12");
reader.Read(); // "true" - endelement
AssertNode(1, "D", XmlNodeType.EndElement, String.Empty, null, reader, "#13");
Assert.IsTrue(reader.Read(), "#14"); // }
AssertNode(0, "root", XmlNodeType.EndElement, String.Empty, null, reader, "#15");
Assert.IsFalse(reader.Read(), "#16"); // EOF
}
protected override object DeserializeBody(XmlDictionaryReader reader, MessageVersion version, string action, MessageDescription messageDescription, object[] parameters, bool isRequest)
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("reader"));
}
if (parameters == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("parameters"));
}
MessageInfo messageInfo;
if (isRequest)
{
messageInfo = requestMessageInfo;
}
else
{
messageInfo = replyMessageInfo;
}
if (messageInfo.WrapperName != null)
{
if (!reader.IsStartElement(messageInfo.WrapperName, messageInfo.WrapperNamespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.Format(SR.SFxInvalidMessageBody, messageInfo.WrapperName, messageInfo.WrapperNamespace, reader.NodeType, reader.Name, reader.NamespaceURI)));
}
bool isEmptyElement = reader.IsEmptyElement;
reader.Read();
if (isEmptyElement)
{
return(null);
}
}
object returnValue = null;
if (messageInfo.ReturnPart != null)
{
while (true)
{
PartInfo part = messageInfo.ReturnPart;
if (part.Serializer.IsStartObject(reader))
{
returnValue = DeserializeParameter(reader, part, isRequest);
break;
}
if (!reader.IsStartElement())
{
break;
}
OperationFormatter.TraceAndSkipElement(reader);
}
}
DeserializeParameters(reader, messageInfo.BodyParts, parameters, isRequest);
if (messageInfo.WrapperName != null)
{
reader.ReadEndElement();
}
return(returnValue);
}
// hmm... [ExpectedException (typeof (InvalidOperationException))]
public void CloseAndRead()
{
reader = CreateReader("{}");
reader.Close();
reader.Read();
}
public static void ReaderWriter_C14N_DifferentReadersWriters()
{
int count = 0;
var params1 = TestConfigHelper.GetTest("ReaderWriter_C14N_DifferentReadersWriters_ParamGroup1");
var params2 = TestConfigHelper.GetTest("ReaderWriter_C14N_DifferentReadersWriters_ParamGroup2");
var params3 = TestConfigHelper.GetTest("ReaderWriter_C14N_DifferentReadersWriters_ParamGroup3");
var params4 = TestConfigHelper.GetTest("ReaderWriter_C14N_DifferentReadersWriters_ParamGroup4");
Transform transform;
MemoryStream canonicalStream;
MemoryStream ms;
Stream transformedOutput;
byte[] outputFromSecurity;
byte[] outputFromIndigo;
//TestC14NInMultipleWriters
foreach (var input in params1.Inputs)
{
foreach (var input2 in params2.Inputs)
{
foreach (var input3 in params3.Inputs)
{
count++;
string rwTypeStr = input.Arguments[0].Value;
ReaderWriterFactory.ReaderWriterType rwType = (ReaderWriterFactory.ReaderWriterType)Enum.Parse(typeof(ReaderWriterFactory.ReaderWriterType), rwTypeStr, true);
Encoding encoding = Encoding.GetEncoding((string)input.Arguments[1].Value);
string sampleXmlFileName = Path.Combine("baselines", input2.Arguments[0].Value);
bool mustSupportV14N = input.Arguments[2].Value == "true";
string baselineFileName = Path.Combine("baselines", input2.Arguments[1].Value);
bool testWithComments = input3.Arguments[0].Value == "true";
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.PreserveWhitespace = true;
if (testWithComments)
{
transform = new XmlDsigExcC14NWithCommentsTransform();
}
else
{
transform = new XmlDsigExcC14NTransform();
}
xmlDoc.Load(baselineFileName);
transform.LoadInput(xmlDoc);
transformedOutput = transform.GetOutput(typeof(Stream)) as Stream;
outputFromSecurity = StreamToByteArray(transformedOutput);
byte[] sampleXmlFileBytes = File.ReadAllBytes(sampleXmlFileName);
ms = new MemoryStream();
XmlWriter w = ReaderWriterFactory.CreateXmlWriter(rwType, ms, encoding);
canonicalStream = new MemoryStream();
XmlDictionaryWriter dicWriter = w as XmlDictionaryWriter;
if (dicWriter == null)
{
dicWriter = XmlDictionaryWriter.CreateDictionaryWriter(w);
}
if (!dicWriter.CanCanonicalize)
{
Assert.False(mustSupportV14N, "Error, writer should support C14N, but it doesn't!");
continue;
}
dicWriter.WriteStartElement("MyRoot");
dicWriter.StartCanonicalization(canonicalStream, testWithComments, null);
FileStream fs = File.OpenRead(sampleXmlFileName);
XmlReader webdataReader = XmlReader.Create(fs);
CopyXmlToWriter(webdataReader, dicWriter);
dicWriter.EndCanonicalization();
dicWriter.WriteEndElement();
dicWriter.Flush();
webdataReader.Close();
fs.Close();
outputFromIndigo = canonicalStream.ToArray();
Helper.DumpToFile(outputFromSecurity);
Helper.DumpToFile(outputFromIndigo);
Assert.True(Enumerable.SequenceEqual(outputFromSecurity, outputFromIndigo), $"ReaderWriter_C14N_DifferentReadersWriters test variation #{count} failed");
}
}
}
//TestC14NInReader
foreach (var input in params4.Inputs)
{
count++;
string sampleXmlFileName = Path.Combine("baselines", input.Arguments[3].Value);
string rwTypeStr = input.Arguments[0].Value;
ReaderWriterFactory.ReaderWriterType rwType = (ReaderWriterFactory.ReaderWriterType)Enum.Parse(typeof(ReaderWriterFactory.ReaderWriterType), rwTypeStr, true);
Encoding encoding = Encoding.GetEncoding((string)input.Arguments[1].Value);
bool mustSupportV14N = input.Arguments[2].Value == "true";
string baselineFileName = Path.Combine("baselines", "ReaderWriter_C14N_BaselineXML_OnlyLF.xml");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.PreserveWhitespace = true;
transform = new XmlDsigExcC14NTransform();
xmlDoc.Load(baselineFileName);
transform.LoadInput(xmlDoc);
transformedOutput = transform.GetOutput(typeof(Stream)) as Stream;
outputFromSecurity = StreamToByteArray(transformedOutput);
byte[] sampleXmlFileBytes = File.ReadAllBytes(sampleXmlFileName);
XmlReader r = ReaderWriterFactory.CreateXmlReader(rwType, sampleXmlFileBytes, encoding);
XmlDictionaryReader dicReader = r as XmlDictionaryReader;
if (dicReader == null)
{
dicReader = XmlDictionaryReader.CreateDictionaryReader(r);
}
canonicalStream = new MemoryStream();
if (!dicReader.CanCanonicalize)
{
Assert.False(mustSupportV14N, "Error, reader should support C14N, but it doesn't!");
continue;
}
dicReader.StartCanonicalization(canonicalStream, false, null);
canonicalStream.Position = 0;
string str = new StreamReader(canonicalStream).ReadToEnd();
canonicalStream.Position = 0;
while (dicReader.Read())
{
; // simply read it all into the C14N writer
}
dicReader.EndCanonicalization();
dicReader.Close();
outputFromIndigo = canonicalStream.ToArray();
Helper.DumpToFile(outputFromSecurity);
Helper.DumpToFile(outputFromIndigo);
Assert.True(Enumerable.SequenceEqual(outputFromSecurity, outputFromIndigo), $"ReaderWriter_C14N_DifferentReadersWriters test variation #{count} failed");
}
//TestC14NWriterWithManyAttributes
int numberOfAttributes = 1000;
int seed = (int)DateTime.Now.Ticks;
Random rndGen = new Random(seed);
StringBuilder sb = new StringBuilder();
sb.Append("<Root><Element");
int prefixIndex = 0;
for (int i = 0; i < numberOfAttributes; i++)
{
string namespaceUri = null;
string prefix = null;
if ((rndGen.Next() % 5) == 0)
{
prefix = "p" + (prefixIndex++);
namespaceUri = "http://namespace_" + i;
}
string localName = "attr" + i;
string value = "attrValue" + i;
if (prefix == null)
{
sb.AppendFormat(" {0}=\"{1}\"", localName, value);
}
else
{
sb.AppendFormat(" {0}:{1}=\"{2}\" xmlns:{0}=\"{3}\"",
prefix, localName, value, namespaceUri);
}
}
sb.Append(">Hello world</Element></Root>");
string xmlString = sb.ToString();
XmlDocument doc = new XmlDocument();
doc.LoadXml(xmlString);
ms = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms);
canonicalStream = new MemoryStream();
writer.StartCanonicalization(canonicalStream, false, null);
doc.WriteTo(writer);
writer.Flush();
writer.EndCanonicalization();
outputFromIndigo = canonicalStream.ToArray();
byte[] nonCanonicalOutput = ms.ToArray();
XmlDsigExcC14NTransform transform2 = new XmlDsigExcC14NTransform();
transform2.LoadInput(doc);
transformedOutput = transform2.GetOutput(typeof(Stream)) as Stream;
outputFromSecurity = StreamToByteArray(transformedOutput);
Helper.DumpToFile(outputFromSecurity);
Helper.DumpToFile(outputFromIndigo);
Helper.DumpToFile(nonCanonicalOutput);
Assert.True(Enumerable.SequenceEqual(outputFromSecurity, outputFromIndigo), $"ReaderWriter_C14N_DifferentReadersWriters test variation #{count} failed");
count++;
Assert.Equal(params1.Inputs.Count * params2.Inputs.Count * params3.Inputs.Count + params4.Inputs.Count + 1, count);
}
public object ReadValue(XmlDictionaryReader reader)
{
object obj2;
if (!this.isArray)
{
switch (this.typeCode)
{
case TypeCode.Int32:
return(reader.ReadElementContentAsInt());
case TypeCode.Int64:
return(reader.ReadElementContentAsLong());
case TypeCode.Single:
return(reader.ReadElementContentAsFloat());
case TypeCode.Double:
return(reader.ReadElementContentAsDouble());
case TypeCode.Decimal:
return(reader.ReadElementContentAsDecimal());
case TypeCode.DateTime:
return(reader.ReadElementContentAsDateTime());
case TypeCode.String:
return(reader.ReadElementContentAsString());
case TypeCode.Boolean:
return(reader.ReadElementContentAsBoolean());
}
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxInvalidUseOfPrimitiveOperationFormatter")));
}
switch (this.typeCode)
{
case TypeCode.Boolean:
if (reader.IsEmptyElement)
{
reader.Read();
return(new bool[0]);
}
reader.ReadStartElement();
obj2 = reader.ReadBooleanArray(this.itemName, this.itemNamespace);
reader.ReadEndElement();
return(obj2);
case TypeCode.Byte:
return(reader.ReadElementContentAsBase64());
case TypeCode.Int32:
if (reader.IsEmptyElement)
{
reader.Read();
return(new int[0]);
}
reader.ReadStartElement();
obj2 = reader.ReadInt32Array(this.itemName, this.itemNamespace);
reader.ReadEndElement();
return(obj2);
case TypeCode.Int64:
if (reader.IsEmptyElement)
{
reader.Read();
return(new long[0]);
}
reader.ReadStartElement();
obj2 = reader.ReadInt64Array(this.itemName, this.itemNamespace);
reader.ReadEndElement();
return(obj2);
case TypeCode.Single:
if (reader.IsEmptyElement)
{
reader.Read();
return(new float[0]);
}
reader.ReadStartElement();
obj2 = reader.ReadSingleArray(this.itemName, this.itemNamespace);
reader.ReadEndElement();
return(obj2);
case TypeCode.Double:
if (reader.IsEmptyElement)
{
reader.Read();
return(new double[0]);
}
reader.ReadStartElement();
obj2 = reader.ReadDoubleArray(this.itemName, this.itemNamespace);
reader.ReadEndElement();
return(obj2);
case TypeCode.Decimal:
if (reader.IsEmptyElement)
{
reader.Read();
return(new decimal[0]);
}
reader.ReadStartElement();
obj2 = reader.ReadDecimalArray(this.itemName, this.itemNamespace);
reader.ReadEndElement();
return(obj2);
case TypeCode.DateTime:
if (reader.IsEmptyElement)
{
reader.Read();
return(new DateTime[0]);
}
reader.ReadStartElement();
obj2 = reader.ReadDateTimeArray(this.itemName, this.itemNamespace);
reader.ReadEndElement();
return(obj2);
}
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxInvalidUseOfPrimitiveOperationFormatter")));
}
public static XmlDictionaryReader GetReaderAtDetailContentsFeb2005(string detailName, string detailNamespace,
XmlDictionaryReader headerReader)
{
try
{
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString wsrmNs = wsrmFeb2005Dictionary.Namespace;
XmlBuffer buffer = null;
int index = 0;
int depth = headerReader.Depth;
headerReader.ReadFullStartElement(wsrmFeb2005Dictionary.SequenceFault, wsrmNs);
while (headerReader.Depth > depth)
{
if ((headerReader.NodeType == XmlNodeType.Element) &&
(headerReader.NamespaceURI == detailNamespace) &&
(headerReader.LocalName == detailName))
{
if (buffer != null)
{
return(null);
}
buffer = new XmlBuffer(int.MaxValue);
try
{
index = buffer.SectionCount;
XmlDictionaryWriter writer = buffer.OpenSection(headerReader.Quotas);
// WriteNode moves the reader to the next sibling.
writer.WriteNode(headerReader, false);
}
finally
{
buffer.CloseSection();
}
}
else
{
if (headerReader.Depth == depth)
{
break;
}
headerReader.Read();
}
}
// Ensure at least one detail is found;
if (buffer == null)
{
return(null);
}
// Close causes a state change. It moves the buffer from Created to Reading.
buffer.Close();
XmlDictionaryReader detailReader = buffer.GetReader(index);
return(detailReader);
}
finally
{
headerReader.Close();
}
}
private object[] GetRequestArguments(Message requestMessage, XmlDictionaryReader xmlReader, OperationDescription operation, HttpContext httpContext)
{
var arguments = new object[operation.AllParameters.Length];
IEnumerable <Type> serviceKnownTypes = operation
.GetServiceKnownTypesHierarchy()
.Select(x => x.Type);
if (!operation.IsMessageContractRequest)
{
if (xmlReader != null)
{
xmlReader.ReadStartElement(operation.Name, operation.Contract.Namespace);
while (!xmlReader.EOF)
{
var parameterInfo = operation.InParameters.FirstOrDefault(p => p.Name == xmlReader.LocalName);
if (parameterInfo == null)
{
xmlReader.Skip();
continue;
}
var parameterType = parameterInfo.Parameter.ParameterType;
var argumentValue = _serializerHelper.DeserializeInputParameter(
xmlReader,
parameterType,
parameterInfo.Name,
operation.Contract.Namespace,
parameterInfo.Parameter.Member,
serviceKnownTypes);
//fix https://github.com/DigDes/SoapCore/issues/379 (hack, need research)
if (argumentValue == null)
{
argumentValue = _serializerHelper.DeserializeInputParameter(
xmlReader,
parameterType,
parameterInfo.Name,
parameterInfo.Namespace,
parameterInfo.Parameter.Member,
serviceKnownTypes);
}
arguments[parameterInfo.Index] = argumentValue;
}
var httpContextParameter = operation.InParameters.FirstOrDefault(x => x.Parameter.ParameterType == typeof(HttpContext));
if (httpContextParameter != default)
{
arguments[httpContextParameter.Index] = httpContext;
}
}
else
{
arguments = Array.Empty <object>();
}
}
else
{
// MessageContracts are constrained to having one "InParameter". We can do special logic on
// for this
Debug.Assert(operation.InParameters.Length == 1, "MessageContracts are constrained to having one 'InParameter'");
var parameterInfo = operation.InParameters[0];
var parameterType = parameterInfo.Parameter.ParameterType;
var messageContractAttribute = parameterType.GetCustomAttribute <MessageContractAttribute>();
Debug.Assert(messageContractAttribute != null, "operation.IsMessageContractRequest should be false if this is null");
var @namespace = parameterInfo.Namespace ?? operation.Contract.Namespace;
if (messageContractAttribute.IsWrapped && !parameterType.GetMembersWithAttribute <MessageHeaderAttribute>().Any())
{
//https://github.com/DigDes/SoapCore/issues/385
if (operation.DispatchMethod.GetCustomAttribute <XmlSerializerFormatAttribute>()?.Style == OperationFormatStyle.Rpc)
{
var importer = new SoapReflectionImporter(@namespace);
var map = new XmlReflectionMember
{
IsReturnValue = false,
MemberName = parameterInfo.Name,
MemberType = parameterType
};
var mapping = importer.ImportMembersMapping(parameterInfo.Name, @namespace, new[] { map }, false, true);
var serializer = XmlSerializer.FromMappings(new[] { mapping })[0];
var value = serializer.Deserialize(xmlReader);
if (value is object[] o && o.Length > 0)
{
arguments[parameterInfo.Index] = o[0];
}
}
else
{
// It's wrapped so either the wrapper name or the name of the wrapper type
arguments[parameterInfo.Index] = _serializerHelper.DeserializeInputParameter(
xmlReader,
parameterInfo.Parameter.ParameterType,
messageContractAttribute.WrapperName ?? parameterInfo.Parameter.ParameterType.Name,
messageContractAttribute.WrapperNamespace ?? @namespace,
parameterInfo.Parameter.Member,
serviceKnownTypes);
}
}
else
{
var messageHeadersMembers = parameterType.GetPropertyOrFieldMembers()
.Where(x => x.GetCustomAttribute <MessageHeaderAttribute>() != null)
.Select(mi => new
{
MemberInfo = mi,
MessageHeaderMemberAttribute = mi.GetCustomAttribute <MessageHeaderAttribute>()
}).ToArray();
var wrapperObject = Activator.CreateInstance(parameterInfo.Parameter.ParameterType);
for (var i = 0; i < requestMessage.Headers.Count; i++)
{
var header = requestMessage.Headers[i];
var member = messageHeadersMembers.FirstOrDefault(x => x.MessageHeaderMemberAttribute.Name == header.Name || x.MemberInfo.Name == header.Name);
if (member != null)
{
var reader = requestMessage.Headers.GetReaderAtHeader(i);
var value = _serializerHelper.DeserializeInputParameter(
reader,
member.MemberInfo.GetPropertyOrFieldType(),
member.MessageHeaderMemberAttribute.Name ?? member.MemberInfo.Name,
member.MessageHeaderMemberAttribute.Namespace ?? @namespace,
member.MemberInfo,
serviceKnownTypes);
member.MemberInfo.SetValueToPropertyOrField(wrapperObject, value);
}
}
// This object isn't a wrapper element, so we will hunt for the nested message body
// member inside of it
var messageBodyMembers = parameterType.GetPropertyOrFieldMembers().Where(x => x.GetCustomAttribute <MessageBodyMemberAttribute>() != null).Select(mi => new
{
Member = mi,
MessageBodyMemberAttribute = mi.GetCustomAttribute <MessageBodyMemberAttribute>()
}).OrderBy(x => x.MessageBodyMemberAttribute.Order);
if (messageContractAttribute.IsWrapped)
{
xmlReader.Read();
}
foreach (var messageBodyMember in messageBodyMembers)
{
var messageBodyMemberAttribute = messageBodyMember.MessageBodyMemberAttribute;
var messageBodyMemberInfo = messageBodyMember.Member;
var innerParameterName = messageBodyMemberAttribute.Name ?? messageBodyMemberInfo.Name;
var innerParameterNs = messageBodyMemberAttribute.Namespace ?? @namespace;
var innerParameterType = messageBodyMemberInfo.GetPropertyOrFieldType();
//xmlReader.MoveToStartElement(innerParameterName, innerParameterNs);
var innerParameter = _serializerHelper.DeserializeInputParameter(
xmlReader,
innerParameterType,
innerParameterName,
innerParameterNs,
parameterInfo.Parameter.Member,
serviceKnownTypes);
messageBodyMemberInfo.SetValueToPropertyOrField(wrapperObject, innerParameter);
}
arguments[parameterInfo.Index] = wrapperObject;
}
}
foreach (var parameterInfo in operation.OutParameters)
{
if (arguments[parameterInfo.Index] != null)
{
// do not overwrite input ref parameters
continue;
}
if (parameterInfo.Parameter.ParameterType.Name == "Guid&")
{
arguments[parameterInfo.Index] = Guid.Empty;
}
else if (parameterInfo.Parameter.ParameterType.Name == "String&" || parameterInfo.Parameter.ParameterType.GetElementType().IsArray)
{
arguments[parameterInfo.Index] = null;
}
else
{
var type = parameterInfo.Parameter.ParameterType.GetElementType();
arguments[parameterInfo.Index] = Activator.CreateInstance(type);
}
}
return(arguments);
}
public object ReadValue(XmlDictionaryReader reader)
{
object value;
if (isArray)
{
switch (typeCode)
{
case TypeCode.Byte:
value = reader.ReadElementContentAsBase64();
break;
case TypeCode.Boolean:
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
value = reader.ReadBooleanArray(itemName, itemNamespace);
reader.ReadEndElement();
}
else
{
reader.Read();
value = new bool[0];
}
break;
case TypeCode.DateTime:
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
value = reader.ReadDateTimeArray(itemName, itemNamespace);
reader.ReadEndElement();
}
else
{
reader.Read();
value = new DateTime[0];
}
break;
case TypeCode.Decimal:
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
value = reader.ReadDecimalArray(itemName, itemNamespace);
reader.ReadEndElement();
}
else
{
reader.Read();
value = new decimal[0];
}
break;
case TypeCode.Int32:
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
value = reader.ReadInt32Array(itemName, itemNamespace);
reader.ReadEndElement();
}
else
{
reader.Read();
value = new int[0];
}
break;
case TypeCode.Int64:
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
value = reader.ReadInt64Array(itemName, itemNamespace);
reader.ReadEndElement();
}
else
{
reader.Read();
value = new long[0];
}
break;
case TypeCode.Single:
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
value = reader.ReadSingleArray(itemName, itemNamespace);
reader.ReadEndElement();
}
else
{
reader.Read();
value = new float[0];
}
break;
case TypeCode.Double:
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
value = reader.ReadDoubleArray(itemName, itemNamespace);
reader.ReadEndElement();
}
else
{
reader.Read();
value = new double[0];
}
break;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxInvalidUseOfPrimitiveOperationFormatter));
}
}
else
{
switch (typeCode)
{
case TypeCode.Boolean:
value = reader.ReadElementContentAsBoolean();
break;
case TypeCode.DateTime:
value = reader.ReadElementContentAsDateTime();
break;
case TypeCode.Decimal:
value = reader.ReadElementContentAsDecimal();
break;
case TypeCode.Double:
value = reader.ReadElementContentAsDouble();
break;
case TypeCode.Int32:
value = reader.ReadElementContentAsInt();
break;
case TypeCode.Int64:
value = reader.ReadElementContentAsLong();
break;
case TypeCode.Single:
value = reader.ReadElementContentAsFloat();
break;
case TypeCode.String:
return(reader.ReadElementContentAsString());
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxInvalidUseOfPrimitiveOperationFormatter));
}
}
return(value);
}
public void ReadFrom(XmlDictionaryReader reader, long maxBufferSize)
{
ValidateReadState();
reader.MoveToStartElement(OpeningElementName, NamespaceUri);
this.encoding = reader.GetAttribute(EncodingAttribute, null);
this.id = reader.GetAttribute(XD.XmlEncryptionDictionary.Id, null) ?? SecurityUniqueId.Create().Value;
this.wsuId = reader.GetAttribute(XD.XmlEncryptionDictionary.Id, XD.UtilityDictionary.Namespace) ?? SecurityUniqueId.Create().Value;
this.mimeType = reader.GetAttribute(MimeTypeAttribute, null);
this.type = reader.GetAttribute(TypeAttribute, null);
ReadAdditionalAttributes(reader);
reader.Read();
if (reader.IsStartElement(EncryptionMethodElement.ElementName, NamespaceUri))
{
this.encryptionMethod.ReadFrom(reader);
}
if (this.tokenSerializer.CanReadKeyIdentifier(reader))
{
XmlElement xml = null;
XmlDictionaryReader localReader;
if (this.ShouldReadXmlReferenceKeyInfoClause)
{
// We create the dom only when needed to not affect perf.
XmlDocument doc = new XmlDocument();
xml = (doc.ReadNode(reader) as XmlElement);
localReader = XmlDictionaryReader.CreateDictionaryReader(new XmlNodeReader(xml));
}
else
{
localReader = reader;
}
try
{
this.KeyIdentifier = this.tokenSerializer.ReadKeyIdentifier(localReader);
}
catch (Exception e)
{
// In case when the issued token ( custom token) is used as an initiator token; we will fail
// to read the keyIdentifierClause using the plugged in default serializer. So We need to try to read it as an XmlReferencekeyIdentifierClause
// if it is the client side.
if (Fx.IsFatal(e) || !this.ShouldReadXmlReferenceKeyInfoClause)
{
throw;
}
this.keyIdentifier = ReadGenericXmlSecurityKeyIdentifier(XmlDictionaryReader.CreateDictionaryReader(new XmlNodeReader(xml)), e);
}
}
reader.ReadStartElement(CipherDataElementName, EncryptedType.NamespaceUri);
reader.ReadStartElement(CipherValueElementName, EncryptedType.NamespaceUri);
if (maxBufferSize == 0)
{
ReadCipherData(reader);
}
else
{
ReadCipherData(reader, maxBufferSize);
}
reader.ReadEndElement(); // CipherValue
reader.ReadEndElement(); // CipherData
ReadAdditionalElements(reader);
reader.ReadEndElement(); // OpeningElementName
this.State = EncryptionState.Read;
}
/// <summary>
/// Reads the next node from the stream.
/// </summary>
/// <returns>true if the next node was read successfully.</returns>
public override bool Read()
{
return(_innerReader.Read());
}
private static object ReadFaultDetail(Message reply)
{
const string detailElementName = "Detail";
const string reasonElementName = "Reason";
string reason = null;
using (XmlDictionaryReader reader = reply.GetReaderAtBodyContents())
{
// Find <soap:Reason>
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == reasonElementName)
{
// Find <soap:Text>
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "Text")
{
reader.Read();
reason = reader.Value;
break;
}
}
break;
}
}
// Find <soap:Detail>
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == detailElementName)
{
break;
}
}
// Did we find it?
if (reader.NodeType != XmlNodeType.Element || reader.LocalName != detailElementName)
{
return(null);
}
// Move to the contents of <soap:Detail>
if (!reader.Read())
{
return(null);
}
// Deserialize the fault
var serializer = new NetDataContractSerializer();
try
{
return(serializer.ReadObject(reader, false));
}
catch (SerializationException ex)
{
throw reason != null
? new SerializationException(reason)
: ex;
}
catch (FileNotFoundException)
{
// Serializer was unable to find assembly where exception is defined
return(null);
}
}
}
public virtual void ReadXml(XmlDictionaryReader reader, SamlSerializer samlSerializer, SecurityTokenSerializer keyInfoSerializer, SecurityTokenResolver outOfBandTokenResolver)
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("reader"));
}
if (samlSerializer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("samlSerializer");
}
SamlDictionary samlDictionary = samlSerializer.DictionaryManager.SamlDictionary;
reader.MoveToContent();
reader.Read();
if (reader.IsStartElement(samlDictionary.NameIdentifier, samlDictionary.Namespace))
{
this.nameFormat = reader.GetAttribute(samlDictionary.NameIdentifierFormat, null);
this.nameQualifier = reader.GetAttribute(samlDictionary.NameIdentifierNameQualifier, null);
reader.MoveToContent();
this.name = reader.ReadString();
if (this.name == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(System.IdentityModel.SR.GetString("SAMLNameIdentifierMissingIdentifierValueOnRead")));
}
reader.MoveToContent();
reader.ReadEndElement();
}
if (reader.IsStartElement(samlDictionary.SubjectConfirmation, samlDictionary.Namespace))
{
reader.MoveToContent();
reader.Read();
while (reader.IsStartElement(samlDictionary.SubjectConfirmationMethod, samlDictionary.Namespace))
{
string str = reader.ReadString();
if (string.IsNullOrEmpty(str))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(System.IdentityModel.SR.GetString("SAMLBadSchema", new object[] { samlDictionary.SubjectConfirmationMethod.Value })));
}
this.confirmationMethods.Add(str);
reader.MoveToContent();
reader.ReadEndElement();
}
if (this.confirmationMethods.Count == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(System.IdentityModel.SR.GetString("SAMLSubjectConfirmationClauseMissingConfirmationMethodOnRead")));
}
if (reader.IsStartElement(samlDictionary.SubjectConfirmationData, samlDictionary.Namespace))
{
reader.MoveToContent();
this.confirmationData = reader.ReadString();
reader.MoveToContent();
reader.ReadEndElement();
}
if (reader.IsStartElement(samlSerializer.DictionaryManager.XmlSignatureDictionary.KeyInfo, samlSerializer.DictionaryManager.XmlSignatureDictionary.Namespace))
{
XmlDictionaryReader reader2 = XmlDictionaryReader.CreateDictionaryReader(reader);
this.securityKeyIdentifier = SamlSerializer.ReadSecurityKeyIdentifier(reader2, keyInfoSerializer);
this.crypto = SamlSerializer.ResolveSecurityKey(this.securityKeyIdentifier, outOfBandTokenResolver);
if (this.crypto == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(System.IdentityModel.SR.GetString("SamlUnableToExtractSubjectKey")));
}
this.subjectToken = SamlSerializer.ResolveSecurityToken(this.securityKeyIdentifier, outOfBandTokenResolver);
}
if ((this.confirmationMethods.Count == 0) && string.IsNullOrEmpty(this.name))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(System.IdentityModel.SR.GetString("SAMLSubjectRequiresNameIdentifierOrConfirmationMethodOnRead")));
}
reader.MoveToContent();
reader.ReadEndElement();
}
reader.MoveToContent();
reader.ReadEndElement();
}
