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(); }