private void AddSchemaType(XmlDictionaryWriter writer, Type type, string name, bool isArray = false, string @namespace = null) { var typeInfo = type.GetTypeInfo(); if (typeInfo.IsByRef) { type = typeInfo.GetElementType(); } writer.WriteStartElement("xs:element"); // Check for null, since we may use empty NS if (@namespace != null) { writer.WriteAttributeString("targetNamespace", @namespace); } else if (typeInfo.IsValueType && typeInfo.Namespace.StartsWith("System")) { string xsTypename; if (typeof(DateTimeOffset).IsAssignableFrom(type)) { if (string.IsNullOrEmpty(name)) { name = type.Name; } xsTypename = "nsdto:" + type.Name; writer.WriteAttributeString("xmlns:nsdto", "http://schemas.datacontract.org/2004/07/System"); _buildDateTimeOffset = true; } else if (typeInfo.IsEnum) { xsTypename = "tns:" + type.Name; _enumToBuild.Enqueue(type); } else { var underlyingType = Nullable.GetUnderlyingType(type); if (underlyingType != null) { xsTypename = ResolveType(underlyingType); writer.WriteAttributeString("nillable", "true"); } else { xsTypename = ResolveType(type); } } if (isArray) { writer.WriteAttributeString("minOccurs", "0"); writer.WriteAttributeString("maxOccurs", "unbounded"); writer.WriteAttributeString("nillable", "true"); } else { writer.WriteAttributeString("minOccurs", "1"); writer.WriteAttributeString("maxOccurs", "1"); } if (string.IsNullOrEmpty(name)) { name = xsTypename.Split(':')[1]; } writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", xsTypename); } else { writer.WriteAttributeString("minOccurs", "0"); if (isArray) { writer.WriteAttributeString("maxOccurs", "unbounded"); writer.WriteAttributeString("nillable", "true"); } else { writer.WriteAttributeString("maxOccurs", "1"); } if (type.Name == "String" || type.Name == "String&") { if (string.IsNullOrEmpty(name)) { name = "string"; } writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", "xs:string"); } else if (type == typeof(System.Xml.Linq.XElement)) { writer.WriteAttributeString("name", name); writer.WriteStartElement("xs:complexType"); writer.WriteAttributeString("mixed", "true"); writer.WriteStartElement("xs:sequence"); writer.WriteStartElement("xs:any"); writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteEndElement(); } else if (type.Name == "Byte[]") { if (string.IsNullOrEmpty(name)) { name = "base64Binary"; } writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", "xs:base64Binary"); } else if (type == typeof(Stream) || typeof(Stream).IsAssignableFrom(type)) { name = "StreamBody"; writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", "xs:base64Binary"); } else if (type.IsArray) { if (string.IsNullOrEmpty(name)) { name = type.Name; } writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", "tns:ArrayOf" + type.Name.Replace("[]", string.Empty)); _complexTypeToBuild.Enqueue(type); } else if (typeof(IEnumerable).IsAssignableFrom(type)) { if (GetGenericType(type).Name == "String") { if (string.IsNullOrEmpty(name)) { name = type.Name; } var ns = $"q{_namespaceCounter++}"; writer.WriteAttributeString($"xmlns:{ns}", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"); writer.WriteAttributeString("name", name); writer.WriteAttributeString("nillable", "true"); writer.WriteAttributeString("type", $"{ns}:ArrayOf{GetGenericType(type).Name.ToLower()}"); _arrayToBuild.Enqueue(type); } else { if (string.IsNullOrEmpty(name)) { name = type.Name; } writer.WriteAttributeString("name", name); if (!isArray) { writer.WriteAttributeString("nillable", "true"); } writer.WriteAttributeString("type", "tns:ArrayOf" + GetGenericType(type).Name); _complexTypeToBuild.Enqueue(type); } } else { if (string.IsNullOrEmpty(name)) { name = type.Name; } writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", "tns:" + type.Name); _complexTypeToBuild.Enqueue(type); } } writer.WriteEndElement(); // xs:element }
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 = input2.Arguments[0].Value; bool mustSupportV14N = input.Arguments[2].Value == "true"; string baselineFileName = 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 = 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 = "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); }
/// <summary> /// /// </summary> /// <param name="writer"></param> protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { writer.WriteStartElement(headerElement); writer.WriteBase64(content, 0, content.Length); writer.WriteEndElement(); }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { writer.WriteStartElement("Binary"); writer.WriteBase64(_content, 0, _content.Length); writer.WriteEndElement(); }
private void AddSchemaType(XmlDictionaryWriter writer, Type type, string name, bool isArray = false, string objectNamespace = null) { var typeInfo = type.GetTypeInfo(); if (typeInfo.IsByRef) { type = typeInfo.GetElementType(); } writer.WriteStartElement("xs:element"); if (objectNamespace == null) { objectNamespace = ModelNameSpace; } if (typeInfo.IsEnum) { WriteComplexElementType(writer, type.Name, _schemaNamespace, objectNamespace); _enumToBuild.Enqueue(type); } else if (typeInfo.IsValueType) { string xsTypename; if (typeof(DateTimeOffset).IsAssignableFrom(type)) { if (string.IsNullOrEmpty(name)) { name = type.Name; } var ns = $"q{_namespaceCounter++}"; xsTypename = $"{ns}:{type.Name}"; writer.WriteAttributeString($"xmlns:{ns}", SYSTEM_NS); _buildDateTimeOffset = true; } else { var underlyingType = Nullable.GetUnderlyingType(type); if (underlyingType != null) { var sysType = ResolveSystemType(underlyingType); xsTypename = $"{(sysType.ns == SERIALIZATION_NS ? "ser" : "xs")}:{sysType.name}"; writer.WriteAttributeString("nillable", "true"); } else { var sysType = ResolveSystemType(type); xsTypename = $"{(sysType.ns == SERIALIZATION_NS ? "ser" : "xs")}:{sysType.name}"; } } writer.WriteAttributeString("minOccurs", "0"); if (isArray) { writer.WriteAttributeString("maxOccurs", "unbounded"); } if (string.IsNullOrEmpty(name)) { name = xsTypename.Split(':')[1]; } writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", xsTypename); } else { writer.WriteAttributeString("minOccurs", "0"); if (isArray) { writer.WriteAttributeString("maxOccurs", "unbounded"); } if (type.Name == "String" || type.Name == "String&") { if (string.IsNullOrEmpty(name)) { name = "string"; } writer.WriteAttributeString("name", name); writer.WriteAttributeString("nillable", "true"); writer.WriteAttributeString("type", "xs:string"); } else if (type == typeof(System.Xml.Linq.XElement)) { writer.WriteAttributeString("name", name); writer.WriteAttributeString("nillable", "true"); writer.WriteStartElement("xs:complexType"); writer.WriteStartElement("xs:sequence"); writer.WriteStartElement("xs:any"); writer.WriteAttributeString("minOccurs", "0"); writer.WriteAttributeString("processContents", "lax"); writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteEndElement(); } else if (type.Name == "Byte[]") { if (string.IsNullOrEmpty(name)) { name = "base64Binary"; } writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", "xs:base64Binary"); } else if (typeof(IEnumerable).IsAssignableFrom(type)) { var elType = type.IsArray ? type.GetElementType() : GetGenericType(type); var sysType = ResolveSystemType(elType); if (sysType.name != null) { if (string.IsNullOrEmpty(name)) { name = type.Name; } var ns = $"q{_namespaceCounter++}"; writer.WriteAttributeString($"xmlns:{ns}", ARRAYS_NS); writer.WriteAttributeString("name", name); writer.WriteAttributeString("nillable", "true"); writer.WriteAttributeString("type", $"{ns}:ArrayOf{sysType.name}"); _arrayToBuild.Enqueue(type); } else { if (string.IsNullOrEmpty(name)) { name = type.Name; } writer.WriteAttributeString("name", name); WriteComplexElementType(writer, $"ArrayOf{elType.Name}", _schemaNamespace, objectNamespace); _complexTypeToBuild.Enqueue(type); } } else { if (string.IsNullOrEmpty(name)) { name = type.Name; } writer.WriteAttributeString("name", name); WriteComplexElementType(writer, type.Name, _schemaNamespace, objectNamespace); _complexTypeToBuild.Enqueue(type); } } writer.WriteEndElement(); // xs:element }
static public void WriteElementContentAsInt64(XmlDictionaryWriter writer, XmlDictionaryString localName, XmlDictionaryString ns, Int64 value) { writer.WriteStartElement(localName, ns); writer.WriteValue(value); writer.WriteEndElement(); }
protected override void GetHeadersFromMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest) { try { XmlSerializer serializer; MessageHeaderDescriptionTable headerDescriptionTable; MessageHeaderDescription unknownHeaderDescription; if (isRequest) { serializer = _requestMessageInfo.HeaderSerializer; headerDescriptionTable = _requestMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = _requestMessageInfo.UnknownHeaderDescription; } else { serializer = _replyMessageInfo.HeaderSerializer; headerDescriptionTable = _replyMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = _replyMessageInfo.UnknownHeaderDescription; } MessageHeaders headers = message.Headers; ArrayList unknownHeaders = null; XmlDocument xmlDoc = null; if (unknownHeaderDescription != null) { unknownHeaders = new ArrayList(); xmlDoc = new XmlDocument(); } if (serializer == null) { if (unknownHeaderDescription != null) { for (int headerIndex = 0; headerIndex < headers.Count; headerIndex++) { AddUnknownHeader(unknownHeaderDescription, unknownHeaders, xmlDoc, null /*bufferWriter*/, headers[headerIndex], headers.GetReaderAtHeader(headerIndex)); } parameters[unknownHeaderDescription.Index] = unknownHeaders.ToArray(unknownHeaderDescription.TypedHeader ? typeof(MessageHeader <XmlElement>) : typeof(XmlElement)); } return; } MemoryStream memoryStream = new MemoryStream(); XmlDictionaryWriter bufferWriter = XmlDictionaryWriter.CreateTextWriter(memoryStream); message.WriteStartEnvelope(bufferWriter); message.WriteStartHeaders(bufferWriter); MessageHeaderOfTHelper messageHeaderOfTHelper = null; for (int headerIndex = 0; headerIndex < headers.Count; headerIndex++) { MessageHeaderInfo header = headers[headerIndex]; XmlDictionaryReader headerReader = headers.GetReaderAtHeader(headerIndex); MessageHeaderDescription matchingHeaderDescription = headerDescriptionTable.Get(header.Name, header.Namespace); if (matchingHeaderDescription != null) { if (header.MustUnderstand) { headers.UnderstoodHeaders.Add(header); } if (matchingHeaderDescription.TypedHeader) { if (messageHeaderOfTHelper == null) { messageHeaderOfTHelper = new MessageHeaderOfTHelper(parameters.Length); } messageHeaderOfTHelper.SetHeaderAttributes(matchingHeaderDescription, header.MustUnderstand, header.Relay, header.Actor); } } if (matchingHeaderDescription == null && unknownHeaderDescription != null) { AddUnknownHeader(unknownHeaderDescription, unknownHeaders, xmlDoc, bufferWriter, header, headerReader); } else { bufferWriter.WriteNode(headerReader, false); } headerReader.Dispose(); } bufferWriter.WriteEndElement(); bufferWriter.WriteEndElement(); bufferWriter.Flush(); /* * XmlDocument doc = new XmlDocument(); * memoryStream.Position = 0; * doc.Load(memoryStream); * doc.Save(Console.Out); */ memoryStream.Position = 0; ArraySegment <byte> memoryBuffer; memoryStream.TryGetBuffer(out memoryBuffer); XmlDictionaryReader bufferReader = XmlDictionaryReader.CreateTextReader(memoryBuffer.Array, 0, (int)memoryStream.Length, XmlDictionaryReaderQuotas.Max); bufferReader.ReadStartElement(); bufferReader.MoveToContent(); if (!bufferReader.IsEmptyElement) { bufferReader.ReadStartElement(); object[] headerValues = (object[])serializer.Deserialize(bufferReader); int headerIndex = 0; foreach (MessageHeaderDescription headerDescription in messageDescription.Headers) { if (!headerDescription.IsUnknownHeaderCollection) { object parameterValue = headerValues[headerIndex++]; if (headerDescription.TypedHeader && parameterValue != null) { parameterValue = messageHeaderOfTHelper.CreateMessageHeader(headerDescription, parameterValue); } parameters[headerDescription.Index] = parameterValue; } } bufferReader.Dispose(); } if (unknownHeaderDescription != null) { parameters[unknownHeaderDescription.Index] = unknownHeaders.ToArray(unknownHeaderDescription.TypedHeader ? typeof(MessageHeader <XmlElement>) : typeof(XmlElement)); } } catch (InvalidOperationException e) { // all exceptions from XmlSerializer get wrapped in InvalidOperationException, // so we must be conservative and never turn this into a fault throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException( SR.Format(SR.SFxErrorDeserializingHeader, messageDescription.MessageName), e)); } }
private void AddMSSerialization(XmlDictionaryWriter writer) { writer.WriteStartElement("xs:schema"); writer.WriteAttributeString("attributeFormDefault", "qualified"); writer.WriteAttributeString("elementFormDefault", "qualified"); writer.WriteAttributeString("targetNamespace", SERIALIZATION_NS); writer.WriteAttributeString("xmlns:xs", XMLNS_XS); writer.WriteAttributeString("xmlns:tns", SERIALIZATION_NS); WriteSerializationElement(writer, "anyType", "xs:anyType", true); WriteSerializationElement(writer, "anyURI", "xs:anyURI", true); WriteSerializationElement(writer, "base64Binary", "xs:base64Binary", true); WriteSerializationElement(writer, "boolean", "xs:boolean", true); WriteSerializationElement(writer, "byte", "xs:byte", true); WriteSerializationElement(writer, "dateTime", "xs:dateTime", true); WriteSerializationElement(writer, "decimal", "xs:decimal", true); WriteSerializationElement(writer, "double", "xs:double", true); WriteSerializationElement(writer, "float", "xs:float", true); WriteSerializationElement(writer, "int", "xs:int", true); WriteSerializationElement(writer, "long", "xs:long", true); WriteSerializationElement(writer, "QName", "xs:QName", true); WriteSerializationElement(writer, "short", "xs:short", true); WriteSerializationElement(writer, "string", "xs:string", true); WriteSerializationElement(writer, "unsignedByte", "xs:unsignedByte", true); WriteSerializationElement(writer, "unsignedInt", "xs:unsignedInt", true); WriteSerializationElement(writer, "unsignedLong", "xs:unsignedLong", true); WriteSerializationElement(writer, "unsignedShort", "xs:unsignedShort", true); WriteSerializationElement(writer, "char", "tns:char", true); writer.WriteStartElement("xs:simpleType"); writer.WriteAttributeString("name", "char"); writer.WriteStartElement("xs:restriction"); writer.WriteAttributeString("base", "xs:int"); writer.WriteEndElement(); writer.WriteEndElement(); WriteSerializationElement(writer, "duration", "tns:duration", true); writer.WriteStartElement("xs:simpleType"); writer.WriteAttributeString("name", "duration"); writer.WriteStartElement("xs:restriction"); writer.WriteAttributeString("base", "xs:duration"); writer.WriteStartElement("xs:pattern"); writer.WriteAttributeString("value", @"\-?P(\d*D)?(T(\d*H)?(\d*M)?(\d*(\.\d*)?S)?)?"); writer.WriteEndElement(); writer.WriteStartElement("xs:minInclusive"); writer.WriteAttributeString("value", @"-P10675199DT2H48M5.4775808S"); writer.WriteEndElement(); writer.WriteStartElement("xs:maxInclusive"); writer.WriteAttributeString("value", @"P10675199DT2H48M5.4775807S"); writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteEndElement(); WriteSerializationElement(writer, "guid", "tns:guid", true); writer.WriteStartElement("xs:simpleType"); writer.WriteAttributeString("name", "guid"); writer.WriteStartElement("xs:restriction"); writer.WriteAttributeString("base", "xs:string"); writer.WriteStartElement("xs:pattern"); writer.WriteAttributeString("value", @"[\da-fA-F]{8}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{12}"); writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteStartElement("xs:attribute"); writer.WriteAttributeString("name", "FactoryType"); writer.WriteAttributeString("type", "xs:QName"); writer.WriteEndElement(); writer.WriteStartElement("xs:attribute"); writer.WriteAttributeString("name", "Id"); writer.WriteAttributeString("type", "xs:ID"); writer.WriteEndElement(); writer.WriteStartElement("xs:attribute"); writer.WriteAttributeString("name", "Ref"); writer.WriteAttributeString("type", "xs:IDREF"); writer.WriteEndElement(); writer.WriteEndElement(); //schema }
// Methods of BodyWriter /// <summary> /// Writes out an XML representation of the instance. /// </summary> /// <param name="writer">The writer to be used to write out the XML content</param> protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { // Write out the wst:RequestSecurityToken start tag writer.WriteStartElement(Constants.Trust.Elements.RequestSecurityToken, Constants.Trust.NamespaceUri); // If we have a non-null, non-empty tokenType... if (this.TokenType != null && this.TokenType.Length > 0) { // Write out the wst:TokenType start tag writer.WriteStartElement(Constants.Trust.Elements.TokenType, Constants.Trust.NamespaceUri); // Write out the tokenType string writer.WriteString(this.TokenType); writer.WriteEndElement(); // wst:TokenType } // If we have a non-null, non-empty requestType... if (this.requestType != null && this.requestType.Length > 0) { // Write out the wst:RequestType start tag writer.WriteStartElement(Constants.Trust.Elements.RequestType, Constants.Trust.NamespaceUri); // Write out the requestType string writer.WriteString(this.requestType); writer.WriteEndElement(); // wst:RequestType } // If we have a non-null appliesTo if (this.AppliesTo != null) { // Write out the wsp:AppliesTo start tag writer.WriteStartElement(Constants.Policy.Elements.AppliesTo, Constants.Policy.NamespaceUri); // Write the appliesTo in WS-Addressing 1.0 format this.AppliesTo.WriteTo(AddressingVersion.WSAddressing10, writer); writer.WriteEndElement(); // wsp:AppliesTo } if (this.requestorEntropy != null) { writer.WriteStartElement(Constants.Trust.Elements.Entropy, Constants.Trust.NamespaceUri); BinarySecretSecurityToken bsst = this.requestorEntropy as BinarySecretSecurityToken; if (bsst != null) { writer.WriteStartElement(Constants.Trust.Elements.BinarySecret, Constants.Trust.NamespaceUri); byte[] key = bsst.GetKeyBytes(); writer.WriteBase64(key, 0, key.Length); writer.WriteEndElement(); // wst:BinarySecret } writer.WriteEndElement(); // wst:Entropy } if (this.keyType != null && this.keyType.Length > 0) { writer.WriteStartElement(Constants.Trust.Elements.KeyType, Constants.Trust.NamespaceUri); writer.WriteString(this.keyType); writer.WriteEndElement(); // wst:KeyType } if (this.KeySize > 0) { writer.WriteStartElement(Constants.Trust.Elements.KeySize, Constants.Trust.NamespaceUri); writer.WriteValue(this.KeySize); writer.WriteEndElement(); // wst:KeySize } writer.WriteEndElement(); // wst:RequestSecurityToken }
private void WriteInnerMessageWithId(XmlDictionaryWriter writer) { WriteStartInnerMessageWithId(writer); InnerMessage.WriteBodyContents(writer); writer.WriteEndElement(); }
private void WriteElementStringAsUniqueId(XmlDictionaryWriter writer, String localName, String ns, string id) { writer.WriteStartElement(localName, ns); writer.WriteValue(id); writer.WriteEndElement(); }
private void WriteElementContentAsInt64(XmlDictionaryWriter writer, String localName, String ns, long value) { writer.WriteStartElement(localName, ns); writer.WriteValue(value); writer.WriteEndElement(); }
private void AddSchemaType(XmlDictionaryWriter writer, Type type, string name, bool isArray = false, string @namespace = null, bool isRequired = false) { var typeInfo = type.GetTypeInfo(); if (typeInfo.IsByRef) { type = typeInfo.GetElementType(); } var typeName = GetSerialsedTypeName(type, true); if (writer.TryAddSchemaTypeFromXmlSchemaProviderAttribute(type, name, SoapSerializer.XmlSerializer, _xmlNamespaceManager)) { return; } writer.WriteStartElement("element", Namespaces.XMLNS_XSD); // Check for null, since we may use empty NS if (@namespace != null) { writer.WriteAttributeString("targetNamespace", @namespace); } else if (typeInfo.IsEnum || (typeInfo.IsValueType && typeInfo.Namespace != null && typeInfo.Namespace.StartsWith("System")) || (type.Name == "String") || (type.Name == "Byte[]") ) { XmlQualifiedName xsTypename; if (typeof(DateTimeOffset).IsAssignableFrom(type)) { if (string.IsNullOrEmpty(name)) { name = typeName; } Namespaces.AddNamespaceIfNotAlreadyPresentAndGetPrefix(_xmlNamespaceManager, "nsdto", Namespaces.SYSTEM_NS); xsTypename = new XmlQualifiedName(typeName, Namespaces.SYSTEM_NS); _buildDateTimeOffset = true; } else if (typeInfo.IsEnum) { xsTypename = new XmlQualifiedName(typeName, _xmlNamespaceManager.LookupNamespace("tns")); _enumToBuild.Enqueue(type); } else { var underlyingType = Nullable.GetUnderlyingType(type); if (underlyingType != null) { xsTypename = ResolveType(underlyingType); writer.WriteAttributeString("nillable", "true"); } else { xsTypename = ResolveType(type); } } if (isArray) { writer.WriteAttributeString("minOccurs", "0"); writer.WriteAttributeString("maxOccurs", "unbounded"); writer.WriteAttributeString("nillable", "true"); } else { writer.WriteAttributeString("minOccurs", type.IsValueType ? "1" : "0"); writer.WriteAttributeString("maxOccurs", "1"); } if (string.IsNullOrEmpty(name)) { name = xsTypename.Name; } writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", $"{_xmlNamespaceManager.LookupPrefix(xsTypename.Namespace)}:{xsTypename.Name}"); } else { writer.WriteAttributeString("minOccurs", isRequired ? "1" : "0"); if (isArray) { writer.WriteAttributeString("maxOccurs", "unbounded"); writer.WriteAttributeString("nillable", "true"); } else { writer.WriteAttributeString("maxOccurs", "1"); } if (type == typeof(Stream) || typeof(Stream).IsAssignableFrom(type)) { name = "StreamBody"; writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", $"{_xmlNamespaceManager.LookupPrefix(Namespaces.XMLNS_XSD)}:base64Binary"); } else if (type.IsArray) { if (string.IsNullOrEmpty(name)) { name = typeName; } writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", "tns:" + typeName); _complexTypeToBuild.Enqueue(type); } else if (typeof(IEnumerable).IsAssignableFrom(type)) { if (GetGenericType(type).Name == "String") { if (string.IsNullOrEmpty(name)) { name = typeName; } var ns = $"q{_namespaceCounter++}"; writer.WriteXmlnsAttribute(ns, Namespaces.ARRAYS_NS); writer.WriteAttributeString("name", name); writer.WriteAttributeString("nillable", "true"); writer.WriteAttributeString("type", $"{ns}:{typeName.ToLower()}"); _arrayToBuild.Enqueue(type); } else { if (string.IsNullOrEmpty(name)) { name = typeName; } writer.WriteAttributeString("name", name); if (!isArray) { writer.WriteAttributeString("nillable", "true"); } writer.WriteAttributeString("type", "tns:" + typeName); _complexTypeToBuild.Enqueue(type); } } else { if (string.IsNullOrEmpty(name)) { name = typeName; } writer.WriteAttributeString("name", name); writer.WriteAttributeString("type", "tns:" + typeName); _complexTypeToBuild.Enqueue(type); } } writer.WriteEndElement(); // element }
private void AddTypes(XmlDictionaryWriter writer) { writer.WriteStartElement("wsdl", "types", Namespaces.WSDL_NS); writer.WriteStartElement("schema", Namespaces.XMLNS_XSD); writer.WriteAttributeString("elementFormDefault", "qualified"); writer.WriteAttributeString("targetNamespace", TargetNameSpace); writer.WriteStartElement("import", Namespaces.XMLNS_XSD); writer.WriteAttributeString("namespace", Namespaces.ARRAYS_NS); writer.WriteEndElement(); writer.WriteStartElement("import", Namespaces.XMLNS_XSD); writer.WriteAttributeString("namespace", Namespaces.SYSTEM_NS); writer.WriteEndElement(); foreach (var operation in _service.Operations) { // input parameters of operation writer.WriteStartElement("element", Namespaces.XMLNS_XSD); writer.WriteAttributeString("name", operation.Name); if (!operation.IsMessageContractRequest && operation.InParameters.Length == 0) { writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD); writer.WriteEndElement(); } else { WriteParameters(writer, operation.InParameters, operation.IsMessageContractRequest); } writer.WriteEndElement(); // element // output parameter / return of operation writer.WriteStartElement("element", Namespaces.XMLNS_XSD); writer.WriteAttributeString("name", operation.Name + "Response"); if (operation.DispatchMethod.ReturnType != typeof(void)) { var returnType = operation.DispatchMethod.ReturnType; if (returnType.IsConstructedGenericType && returnType.GetGenericTypeDefinition() == typeof(Task <>)) { returnType = returnType.GetGenericArguments().First(); } var doWriteInlineType = true; if (operation.IsMessageContractResponse) { doWriteInlineType = IsWrappedMessageContractType(returnType); } if (doWriteInlineType) { var returnName = operation.DispatchMethod.ReturnParameter.GetCustomAttribute <MessageParameterAttribute>()?.Name ?? operation.Name + "Result"; writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD); writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD); AddSchemaType(writer, returnType, returnName); writer.WriteEndElement(); writer.WriteEndElement(); } else { var type = GetMessageContractBodyType(returnType); writer.WriteAttributeString("type", "tns:" + type.Name); _complexTypeToBuild.Enqueue(returnType); } } else { if (!operation.IsMessageContractResponse) { writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD); writer.WriteEndElement(); } } WriteParameters(writer, operation.OutParameters, operation.IsMessageContractResponse); writer.WriteEndElement(); // element } while (_complexTypeToBuild.Count > 0) { var toBuild = _complexTypeToBuild.Dequeue(); var toBuildBodyType = GetMessageContractBodyType(toBuild); var isWrappedBodyType = IsWrappedMessageContractType(toBuild); var toBuildName = GetSerialsedTypeName(toBuild); if (!_builtComplexTypes.Contains(toBuildName)) { writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD); writer.WriteAttributeString("name", toBuildName); writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD); if (toBuild.IsArray) { AddSchemaType(writer, toBuild.GetElementType(), null, true); } else if (typeof(IEnumerable).IsAssignableFrom(toBuild)) { AddSchemaType(writer, GetGenericType(toBuild), null, true); } else { if (!isWrappedBodyType) { foreach (var property in toBuildBodyType.GetProperties().Where(prop => !prop.CustomAttributes.Any(attr => attr.AttributeType == typeof(IgnoreDataMemberAttribute)))) { AddSchemaType(writer, property.PropertyType, property.Name, isRequired: property.GetCustomAttribute <DataMemberAttribute>()?.IsRequired ?? false); } } else { foreach (var property in toBuild.GetProperties().Where(prop => !prop.CustomAttributes.Any(attr => attr.AttributeType == typeof(IgnoreDataMemberAttribute)))) { AddSchemaType(writer, property.PropertyType, property.Name); } var messageBodyMemberFields = toBuild.GetFields() .Where(field => field.CustomAttributes.Any(attr => attr.AttributeType == typeof(MessageBodyMemberAttribute))) .OrderBy(field => field.GetCustomAttribute <MessageBodyMemberAttribute>().Order); foreach (var field in messageBodyMemberFields) { var messageBodyMember = field.GetCustomAttribute <MessageBodyMemberAttribute>(); var fieldName = messageBodyMember.Name ?? field.Name; AddSchemaType(writer, field.FieldType, fieldName); } } } writer.WriteEndElement(); // sequence writer.WriteEndElement(); // complexType if (isWrappedBodyType) { writer.WriteStartElement("element", Namespaces.XMLNS_XSD); writer.WriteAttributeString("name", toBuildName); writer.WriteAttributeString("nillable", "true"); writer.WriteAttributeString("type", "tns:" + toBuildName); writer.WriteEndElement(); // element } _builtComplexTypes.Add(toBuildName); } } while (_enumToBuild.Count > 0) { Type toBuild = _enumToBuild.Dequeue(); if (toBuild.IsByRef) { toBuild = toBuild.GetElementType(); } var typeName = GetSerialsedTypeName(toBuild); if (!_builtEnumTypes.Contains(toBuild.Name)) { writer.WriteStartElement("simpleType", Namespaces.XMLNS_XSD); writer.WriteAttributeString("name", typeName); writer.WriteStartElement("restriction", Namespaces.XMLNS_XSD); writer.WriteAttributeString("base", $"{_xmlNamespaceManager.LookupPrefix(Namespaces.XMLNS_XSD)}:string"); foreach (var value in Enum.GetValues(toBuild)) { writer.WriteStartElement("enumeration", Namespaces.XMLNS_XSD); writer.WriteAttributeString("value", value.ToString()); writer.WriteEndElement(); // enumeration } writer.WriteEndElement(); // restriction writer.WriteEndElement(); // simpleType _builtEnumTypes.Add(toBuild.Name); } } writer.WriteEndElement(); // schema while (_arrayToBuild.Count > 0) { var toBuild = _arrayToBuild.Dequeue(); var toBuildName = GetSerialsedTypeName(toBuild); if (!_buildArrayTypes.Contains(toBuildName)) { writer.WriteStartElement("schema", Namespaces.XMLNS_XSD); writer.WriteXmlnsAttribute("tns", Namespaces.ARRAYS_NS); writer.WriteAttributeString("elementFormDefault", "qualified"); writer.WriteAttributeString("targetNamespace", Namespaces.ARRAYS_NS); writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD); writer.WriteAttributeString("name", toBuildName); writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD); AddSchemaType(writer, GetGenericType(toBuild), null, true); writer.WriteEndElement(); // sequence writer.WriteEndElement(); // complexType writer.WriteStartElement("element", Namespaces.XMLNS_XSD); writer.WriteAttributeString("name", toBuildName); writer.WriteAttributeString("nillable", "true"); writer.WriteAttributeString("type", "tns:" + toBuildName); writer.WriteEndElement(); // element writer.WriteEndElement(); // schema _buildArrayTypes.Add(toBuildName); } } if (_buildDateTimeOffset) { writer.WriteStartElement("schema", Namespaces.XMLNS_XSD); writer.WriteXmlnsAttribute("tns", Namespaces.SYSTEM_NS); writer.WriteAttributeString("elementFormDefault", "qualified"); writer.WriteAttributeString("targetNamespace", Namespaces.SYSTEM_NS); writer.WriteStartElement("import", Namespaces.XMLNS_XSD); writer.WriteAttributeString("namespace", Namespaces.SERIALIZATION_NS); writer.WriteEndElement(); writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD); writer.WriteAttributeString("name", "DateTimeOffset"); writer.WriteStartElement("annotation", Namespaces.XMLNS_XSD); writer.WriteStartElement("appinfo", Namespaces.XMLNS_XSD); writer.WriteElementString("IsValueType", Namespaces.SERIALIZATION_NS, "true"); writer.WriteEndElement(); // appinfo writer.WriteEndElement(); // annotation writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD); AddSchemaType(writer, typeof(DateTime), "DateTime", false); AddSchemaType(writer, typeof(short), "OffsetMinutes", false); writer.WriteEndElement(); // sequence writer.WriteEndElement(); // complexType writer.WriteStartElement("element", Namespaces.XMLNS_XSD); writer.WriteAttributeString("name", "DateTimeOffset"); writer.WriteAttributeString("nillable", "true"); writer.WriteAttributeString("type", "tns:DateTimeOffset"); writer.WriteEndElement(); writer.WriteEndElement(); // schema } writer.WriteEndElement(); // wsdl:types }
protected override void AddHeadersToMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest) { XmlSerializer serializer; MessageHeaderDescriptionTable headerDescriptionTable; MessageHeaderDescription unknownHeaderDescription; bool mustUnderstand; bool relay; string actor; try { if (isRequest) { serializer = _requestMessageInfo.HeaderSerializer; headerDescriptionTable = _requestMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = _requestMessageInfo.UnknownHeaderDescription; } else { serializer = _replyMessageInfo.HeaderSerializer; headerDescriptionTable = _replyMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = _replyMessageInfo.UnknownHeaderDescription; } if (serializer != null) { object[] headerValues = new object[headerDescriptionTable.Count]; MessageHeaderOfTHelper messageHeaderOfTHelper = null; int headerIndex = 0; foreach (MessageHeaderDescription headerDescription in messageDescription.Headers) { object parameterValue = parameters[headerDescription.Index]; if (!headerDescription.IsUnknownHeaderCollection) { if (headerDescription.TypedHeader) { if (messageHeaderOfTHelper == null) { messageHeaderOfTHelper = new MessageHeaderOfTHelper(parameters.Length); } headerValues[headerIndex++] = messageHeaderOfTHelper.GetContentAndSaveHeaderAttributes(parameters[headerDescription.Index], headerDescription); } else { headerValues[headerIndex++] = parameterValue; } } } MemoryStream memoryStream = new MemoryStream(); XmlDictionaryWriter bufferWriter = XmlDictionaryWriter.CreateTextWriter(memoryStream); bufferWriter.WriteStartElement("root"); serializer.Serialize(bufferWriter, headerValues, null); bufferWriter.WriteEndElement(); bufferWriter.Flush(); XmlDocument doc = new XmlDocument(); memoryStream.Position = 0; doc.Load(memoryStream); //doc.Save(Console.Out); foreach (XmlElement element in doc.DocumentElement.ChildNodes) { MessageHeaderDescription matchingHeaderDescription = headerDescriptionTable.Get(element.LocalName, element.NamespaceURI); if (matchingHeaderDescription == null) { message.Headers.Add(new XmlElementMessageHeader(this, message.Version, element.LocalName, element.NamespaceURI, false /*mustUnderstand*/, null /*actor*/, false /*relay*/, element)); } else { if (matchingHeaderDescription.TypedHeader) { messageHeaderOfTHelper.GetHeaderAttributes(matchingHeaderDescription, out mustUnderstand, out relay, out actor); } else { mustUnderstand = matchingHeaderDescription.MustUnderstand; relay = matchingHeaderDescription.Relay; actor = matchingHeaderDescription.Actor; } message.Headers.Add(new XmlElementMessageHeader(this, message.Version, element.LocalName, element.NamespaceURI, mustUnderstand, actor, relay, element)); } } } if (unknownHeaderDescription != null && parameters[unknownHeaderDescription.Index] != null) { foreach (object unknownHeader in (IEnumerable)parameters[unknownHeaderDescription.Index]) { XmlElement element = (XmlElement)GetContentOfMessageHeaderOfT(unknownHeaderDescription, unknownHeader, out mustUnderstand, out relay, out actor); if (element != null) { message.Headers.Add(new XmlElementMessageHeader(this, message.Version, element.LocalName, element.NamespaceURI, mustUnderstand, actor, relay, element)); } } } } catch (InvalidOperationException e) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException( SR.Format(SR.SFxErrorSerializingHeader, messageDescription.MessageName, e.Message), e)); } }
public static void WriteIdentifier(XmlDictionaryWriter writer, ReliableMessagingVersion reliableMessagingVersion, UniqueId sequenceId) { writer.WriteStartElement("r", XD.WsrmFeb2005Dictionary.Identifier, WsrmIndex.GetNamespace(reliableMessagingVersion)); writer.WriteValue(sequenceId); writer.WriteEndElement(); }
private void writeValue(XmlDictionaryWriter writer, Param param) { string valueType; object value = param.Value; if (param.Value.GetType().IsArray) { valueType = "array"; } else if (param.Value.GetType().Name.ToLower() == "xmlrpcstruct") { valueType = "struct"; } else { valueType = param.Value.GetType().Name.ToLower(); } switch (valueType) { case "string": valueType = "string"; break; case "bool": case "boolean": valueType = "boolean"; bool temp = (bool)value; if (temp == true) { value = 1; } else { value = 0; } break; case "int16": case "int32": case "int64": case "int": case "short": case "long": valueType = "i4"; break; case "float": case "double": valueType = "double"; break; case "array": valueType = "array"; writer.WriteStartElement(valueType); writer.WriteStartElement("data"); Array arrayParam = (Array)value; foreach (object element in arrayParam) { Param newParam = new Param() { Value = element }; writer.WriteStartElement("value"); writeValue(writer, newParam); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteEndElement(); return; case "struct": case "xmlrpcstruct": valueType = "struct"; writer.WriteStartElement(valueType); XmlRpcStruct structParam = (XmlRpcStruct)value; foreach (StructMember member in structParam.Member) { writer.WriteStartElement("member"); Param memberName = new Param() { Value = member.Name }; Param memberValue = new Param() { Value = member.Value }; writer.WriteStartElement("name"); writeValue(writer, memberName); writer.WriteEndElement(); writer.WriteStartElement("value"); writeValue(writer, memberValue); writer.WriteEndElement(); writer.WriteEndElement(); } writer.WriteEndElement(); return; case "datetime": valueType = "dateTime.iso8601"; DateTime dt = new DateTime(); dt = (DateTime)value; value = dt.ToString("o"); break; default: throw new NotSupportedException("Unsupported type!"); } writer.WriteStartElement(valueType); writer.WriteValue(value); writer.WriteEndElement(); }
private void AddComplexTypes(XmlDictionaryWriter writer) { writer.WriteStartElement("xs:schema"); writer.WriteAttributeString("elementFormDefault", "qualified"); writer.WriteAttributeString("targetNamespace", ModelNameSpace); writer.WriteAttributeString("xmlns:xs", XMLNS_XS); writer.WriteAttributeString("xmlns:tns", ModelNameSpace); _namespaceCounter = 1; _schemaNamespace = ModelNameSpace; writer.WriteStartElement("xs:import"); writer.WriteAttributeString("namespace", SYSTEM_NS); writer.WriteEndElement(); writer.WriteStartElement("xs:import"); writer.WriteAttributeString("namespace", ARRAYS_NS); writer.WriteEndElement(); while (_complexTypeToBuild.Count > 0) { var toBuild = _complexTypeToBuild.Dequeue(); var toBuildName = toBuild.IsArray ? "ArrayOf" + toBuild.GetElementType().Name : typeof(IEnumerable).IsAssignableFrom(toBuild) ? "ArrayOf" + GetGenericType(toBuild).Name : toBuild.Name; if (!_builtComplexTypes.Contains(toBuildName)) { writer.WriteStartElement("xs:complexType"); writer.WriteAttributeString("name", toBuildName); writer.WriteStartElement("xs:sequence"); if (toBuild.IsArray || typeof(IEnumerable).IsAssignableFrom(toBuild)) { var elementType = toBuild.IsArray ? toBuild.GetElementType() : GetGenericType(toBuild); AddSchemaType(writer, elementType, null, true); } else { var properties = toBuild.GetProperties().Where(prop => !prop.CustomAttributes.Any(attr => attr.AttributeType.Name == "IgnoreDataMemberAttribute")); //TODO: base type properties //TODO: enforce order attribute parameters foreach (var property in properties.OrderBy(p => p.Name)) { AddSchemaType(writer, property.PropertyType, property.Name); } } writer.WriteEndElement(); // xs:sequence writer.WriteEndElement(); // xs:complexType writer.WriteStartElement("xs:element"); writer.WriteAttributeString("name", toBuildName); writer.WriteAttributeString("nillable", "true"); writer.WriteAttributeString("type", "tns:" + toBuildName); writer.WriteEndElement(); // xs:element _builtComplexTypes.Add(toBuildName); } } while (_enumToBuild.Count > 0) { Type toBuild = _enumToBuild.Dequeue(); if (toBuild.IsByRef) { toBuild = toBuild.GetElementType(); } if (!_builtEnumTypes.Contains(toBuild.Name)) { writer.WriteStartElement("xs:simpleType"); writer.WriteAttributeString("name", toBuild.Name); writer.WriteStartElement("xs:restriction "); writer.WriteAttributeString("base", "xs:string"); foreach (var value in Enum.GetValues(toBuild)) { writer.WriteStartElement("xs:enumeration "); writer.WriteAttributeString("value", value.ToString()); writer.WriteEndElement(); // xs:enumeration } writer.WriteEndElement(); // xs:restriction writer.WriteEndElement(); // xs:simpleType _builtEnumTypes.Add(toBuild.Name); } } writer.WriteEndElement(); // xs:schema }
public override void WriteEndObject(XmlDictionaryWriter writer) { writer.WriteEndElement(); }
static public void WriteElementStringAsUniqueId(XmlDictionaryWriter writer, XmlDictionaryString localName, XmlDictionaryString ns, UniqueId id) { writer.WriteStartElement(localName, ns); writer.WriteValue(id); writer.WriteEndElement(); }
// XmlDictionaryWriter.WriteAsync isn't supported for the type of writer returned by XmlDictionaryWriter.CreateBinaryWriter // as that writer isn't Async. We still want to read from the reader async so this is a hybrid implementation of WriteNodeAsync. // It uses synchronous api's when using the writer and async api's when using the reader. public static async Task InternalWriteNodeAsync(this XmlDictionaryWriter writer, XmlReader reader, bool defattr) { char[] writeNodeBuffer = null; const int WriteNodeBufferSize = 1024; if (null == reader) { throw new ArgumentNullException(nameof(reader)); } bool canReadChunk = reader.CanReadValueChunk; int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth; do { switch (reader.NodeType) { case XmlNodeType.Element: writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); writer.WriteAttributes(reader, defattr); if (reader.IsEmptyElement) { writer.WriteEndElement(); } break; case XmlNodeType.Text: if (canReadChunk) { if (writeNodeBuffer == null) { writeNodeBuffer = new char[WriteNodeBufferSize]; } int read; while ((read = await reader.ReadValueChunkAsync(writeNodeBuffer, 0, WriteNodeBufferSize)) > 0) { writer.WriteChars(writeNodeBuffer, 0, read); } } else { writer.WriteString(await reader.GetValueAsync()); } break; case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: writer.WriteWhitespace(await reader.GetValueAsync()); break; case XmlNodeType.CDATA: writer.WriteCData(await reader.GetValueAsync()); break; case XmlNodeType.EntityReference: writer.WriteEntityRef(reader.Name); break; case XmlNodeType.XmlDeclaration: case XmlNodeType.ProcessingInstruction: writer.WriteProcessingInstruction(reader.Name, await reader.GetValueAsync()); break; case XmlNodeType.DocumentType: writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), await reader.GetValueAsync()); break; case XmlNodeType.Comment: writer.WriteComment(await reader.GetValueAsync()); break; case XmlNodeType.EndElement: writer.WriteFullEndElement(); break; } } while (await reader.ReadAsync() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement))); }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { writer.WriteStartElement(_envelopeName, _serviceNamespace); if (_outResults != null) { foreach (var outResult in _outResults) { string value; if (outResult.Value is Guid) { value = outResult.Value.ToString(); } else if (outResult.Value is bool) { value = outResult.Value.ToString().ToLower(); } else if (outResult.Value is string) { value = SecurityElement.Escape(outResult.Value.ToString()); } else if (outResult.Value is Enum) { value = outResult.Value.ToString(); } else if (outResult.Value == null) { value = null; } else //for complex types { using (var ms = new MemoryStream()) using (var stream = new BufferedStream(ms)) { switch (_serializer) { case SoapSerializer.XmlSerializer: new XmlSerializer(outResult.Value.GetType()).Serialize(ms, outResult.Value); break; case SoapSerializer.DataContractSerializer: new DataContractSerializer(outResult.Value.GetType()).WriteObject(ms, outResult.Value); break; default: throw new NotImplementedException(); } stream.Position = 0; using (var reader = XmlReader.Create(stream)) { reader.MoveToContent(); value = reader.ReadInnerXml(); } } } if (value != null) { writer.WriteRaw(string.Format("<{0}>{1}</{0}>", outResult.Key, value)); } } } if (_result != null) { switch (_serializer) { case SoapSerializer.XmlSerializer: { // see https://referencesource.microsoft.com/System.Xml/System/Xml/Serialization/XmlSerializer.cs.html#c97688a6c07294d5 var serializer = CachedXmlSerializer.GetXmlSerializer(_result.GetType(), _resultName, _serviceNamespace); lock (serializer) serializer.Serialize(writer, _result); } break; case SoapSerializer.DataContractSerializer: { var serializer = new DataContractSerializer(_result.GetType(), _resultName, _serviceNamespace); serializer.WriteObject(writer, _result); } break; default: throw new NotImplementedException(); } } writer.WriteEndElement(); }
public byte[] CreateCookieFromSecurityContext(UniqueId contextId, string id, byte[] key, DateTime tokenEffectiveTime, DateTime tokenExpirationTime, UniqueId keyGeneration, DateTime keyEffectiveTime, DateTime keyExpirationTime, ReadOnlyCollection <IAuthorizationPolicy> authorizationPolicies) { if (contextId == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contextId"); } if (key == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("key"); } MemoryStream stream = new MemoryStream(); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(stream, SctClaimDictionary.Instance, null); SctClaimDictionary dictionary = SctClaimDictionary.Instance; writer.WriteStartElement(dictionary.SecurityContextSecurityToken, dictionary.EmptyString); writer.WriteStartElement(dictionary.Version, dictionary.EmptyString); writer.WriteValue(SupportedPersistanceVersion); writer.WriteEndElement(); if (id != null) { writer.WriteElementString(dictionary.Id, dictionary.EmptyString, id); } XmlHelper.WriteElementStringAsUniqueId(writer, dictionary.ContextId, dictionary.EmptyString, contextId); writer.WriteStartElement(dictionary.Key, dictionary.EmptyString); writer.WriteBase64(key, 0, key.Length); writer.WriteEndElement(); if (keyGeneration != null) { XmlHelper.WriteElementStringAsUniqueId(writer, dictionary.KeyGeneration, dictionary.EmptyString, keyGeneration); } XmlHelper.WriteElementContentAsInt64(writer, dictionary.EffectiveTime, dictionary.EmptyString, tokenEffectiveTime.ToUniversalTime().Ticks); XmlHelper.WriteElementContentAsInt64(writer, dictionary.ExpiryTime, dictionary.EmptyString, tokenExpirationTime.ToUniversalTime().Ticks); XmlHelper.WriteElementContentAsInt64(writer, dictionary.KeyEffectiveTime, dictionary.EmptyString, keyEffectiveTime.ToUniversalTime().Ticks); XmlHelper.WriteElementContentAsInt64(writer, dictionary.KeyExpiryTime, dictionary.EmptyString, keyExpirationTime.ToUniversalTime().Ticks); AuthorizationContext authContext = null; if (authorizationPolicies != null) { authContext = AuthorizationContext.CreateDefaultAuthorizationContext(authorizationPolicies); } if (authContext != null && authContext.ClaimSets.Count != 0) { DataContractSerializer identitySerializer = DataContractSerializerDefaults.CreateSerializer(typeof(IIdentity), this.knownTypes, int.MaxValue); DataContractSerializer claimSetSerializer = DataContractSerializerDefaults.CreateSerializer(typeof(ClaimSet), this.knownTypes, int.MaxValue); DataContractSerializer claimSerializer = DataContractSerializerDefaults.CreateSerializer(typeof(Claim), this.knownTypes, int.MaxValue); SctClaimSerializer.SerializeIdentities(authContext, dictionary, writer, identitySerializer); writer.WriteStartElement(dictionary.ClaimSets, dictionary.EmptyString); for (int i = 0; i < authContext.ClaimSets.Count; i++) { SctClaimSerializer.SerializeClaimSet(authContext.ClaimSets[i], dictionary, writer, claimSetSerializer, claimSerializer); } writer.WriteEndElement(); } writer.WriteEndElement(); writer.Flush(); byte[] serializedContext = stream.ToArray(); return(this.securityStateEncoder.EncodeSecurityState(serializedContext)); }
protected virtual void ComputeHash(HashStream hashStream) { if (this.sendSide) { XmlDictionaryWriter writer = this.ResourcePool.TakeUtf8Writer(); writer.StartCanonicalization(hashStream, false, null); this.WriteTo(writer, this.dictionaryManager); writer.EndCanonicalization(); } else if (this.canonicalStream != null) { this.canonicalStream.WriteTo(hashStream); } else { if (this.readerProvider == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CryptographicException(System.IdentityModel.SR.GetString("InclusiveNamespacePrefixRequiresSignatureReader"))); } XmlDictionaryReader reader = this.readerProvider.GetReader(this.signatureReaderProviderCallbackContext); if (!reader.CanCanonicalize) { MemoryStream stream = new MemoryStream(); XmlDictionaryWriter writer2 = XmlDictionaryWriter.CreateBinaryWriter(stream, this.DictionaryManager.ParentDictionary); string[] inclusivePrefixes = this.GetInclusivePrefixes(); if (inclusivePrefixes != null) { writer2.WriteStartElement("a"); for (int i = 0; i < inclusivePrefixes.Length; i++) { string namespaceForInclusivePrefix = this.GetNamespaceForInclusivePrefix(inclusivePrefixes[i]); if (namespaceForInclusivePrefix != null) { writer2.WriteXmlnsAttribute(inclusivePrefixes[i], namespaceForInclusivePrefix); } } } reader.MoveToContent(); writer2.WriteNode(reader, false); if (inclusivePrefixes != null) { writer2.WriteEndElement(); } writer2.Flush(); byte[] buffer = stream.ToArray(); int length = (int)stream.Length; writer2.Close(); reader.Close(); reader = XmlDictionaryReader.CreateBinaryReader(buffer, 0, length, this.DictionaryManager.ParentDictionary, XmlDictionaryReaderQuotas.Max); if (inclusivePrefixes != null) { reader.ReadStartElement("a"); } } reader.ReadStartElement(this.dictionaryManager.XmlSignatureDictionary.Signature, this.dictionaryManager.XmlSignatureDictionary.Namespace); reader.MoveToStartElement(this.dictionaryManager.XmlSignatureDictionary.SignedInfo, this.dictionaryManager.XmlSignatureDictionary.Namespace); reader.StartCanonicalization(hashStream, false, this.GetInclusivePrefixes()); reader.Skip(); reader.EndCanonicalization(); reader.Close(); } }
private void WriteTo11(XmlDictionaryWriter writer) { writer.WriteStartElement(XD.MessageDictionary.Fault, XD.Message11Dictionary.Namespace); writer.WriteStartElement(XD.Message11Dictionary.FaultCode, XD.Message11Dictionary.FaultNamespace); FaultCode faultCode = Code; if (faultCode.SubCode != null) { faultCode = faultCode.SubCode; } string name; if (faultCode.IsSenderFault) { name = "Client"; } else if (faultCode.IsReceiverFault) { name = "Server"; } else { name = faultCode.Name; } string ns; if (faultCode.IsPredefinedFault) { ns = Message11Strings.Namespace; } else { ns = faultCode.Namespace; } string prefix = writer.LookupPrefix(ns); if (prefix == null) { writer.WriteAttributeString("xmlns", "a", XmlUtil.XmlNsNs, ns); } writer.WriteQualifiedName(name, ns); writer.WriteEndElement(); FaultReasonText translation = Reason.Translations[0]; writer.WriteStartElement(XD.Message11Dictionary.FaultString, XD.Message11Dictionary.FaultNamespace); if (translation.XmlLang.Length > 0) { writer.WriteAttributeString("xml", "lang", XmlUtil.XmlNs, translation.XmlLang); } writer.WriteString(translation.Text); writer.WriteEndElement(); if (Actor.Length > 0) { writer.WriteElementString(XD.Message11Dictionary.FaultActor, XD.Message11Dictionary.FaultNamespace, Actor); } if (HasDetail) { OnWriteDetail(writer, EnvelopeVersion.Soap11); } writer.WriteEndElement(); }
private void AddTypes(XmlDictionaryWriter writer) { writer.WriteStartElement("wsdl:types"); writer.WriteStartElement("xs:schema"); writer.WriteAttributeString("xmlns:xs", XMLNS_XS); writer.WriteAttributeString("elementFormDefault", "qualified"); writer.WriteAttributeString("targetNamespace", TargetNameSpace); writer.WriteStartElement("xs:import"); writer.WriteAttributeString("namespace", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"); writer.WriteEndElement(); writer.WriteStartElement("xs:import"); writer.WriteAttributeString("namespace", "http://schemas.datacontract.org/2004/07/System"); writer.WriteEndElement(); foreach (var operation in _service.Operations) { // input parameters of operation writer.WriteStartElement("xs:element"); writer.WriteAttributeString("name", operation.Name); WriteParameters(writer, operation.InParameters, operation.IsMessageContractRequest); writer.WriteEndElement(); // xs:element // output parameter / return of operation writer.WriteStartElement("xs:element"); writer.WriteAttributeString("name", operation.Name + "Response"); if (operation.DispatchMethod.ReturnType != typeof(void)) { var returnType = operation.DispatchMethod.ReturnType; if (returnType.IsConstructedGenericType && returnType.GetGenericTypeDefinition() == typeof(Task <>)) { returnType = returnType.GetGenericArguments().First(); } var doWriteInlineType = true; if (operation.IsMessageContractResponse) { doWriteInlineType = IsWrappedMessageContractType(returnType); } if (doWriteInlineType) { var returnName = operation.DispatchMethod.ReturnParameter.GetCustomAttribute <MessageParameterAttribute>()?.Name ?? operation.Name + "Result"; AddSchemaType(writer, returnType, returnName); } else { var type = GetMessageContractBodyType(returnType); writer.WriteAttributeString("type", "tns:" + type.Name); _complexTypeToBuild.Enqueue(returnType); } } WriteParameters(writer, operation.OutParameters, operation.IsMessageContractResponse); writer.WriteEndElement(); // xs:element } while (_complexTypeToBuild.Count > 0) { var toBuild = _complexTypeToBuild.Dequeue(); var toBuildBodyType = GetMessageContractBodyType(toBuild); var isWrappedBodyType = IsWrappedMessageContractType(toBuild); var toBuildName = toBuildBodyType.IsArray ? "ArrayOf" + toBuildBodyType.Name.Replace("[]", string.Empty) : typeof(IEnumerable).IsAssignableFrom(toBuildBodyType) ? "ArrayOf" + GetGenericType(toBuildBodyType).Name : toBuildBodyType.Name; if (!_builtComplexTypes.Contains(toBuildName)) { writer.WriteStartElement("xs:complexType"); if (toBuild.IsArray) { writer.WriteAttributeString("name", toBuildName); } else if (typeof(IEnumerable).IsAssignableFrom(toBuild)) { writer.WriteAttributeString("name", toBuildName); } else { writer.WriteAttributeString("name", toBuildName); } writer.WriteStartElement("xs:sequence"); if (toBuild.IsArray) { AddSchemaType(writer, toBuild.GetElementType(), null, true); } else if (typeof(IEnumerable).IsAssignableFrom(toBuild)) { AddSchemaType(writer, GetGenericType(toBuild), null, true); } else { if (!isWrappedBodyType) { foreach (var property in toBuildBodyType.GetProperties().Where(prop => !prop.CustomAttributes.Any(attr => attr.AttributeType == typeof(IgnoreDataMemberAttribute)))) { AddSchemaType(writer, property.PropertyType, property.Name); } } else { foreach (var property in toBuild.GetProperties().Where(prop => !prop.CustomAttributes.Any(attr => attr.AttributeType == typeof(IgnoreDataMemberAttribute)))) { AddSchemaType(writer, property.PropertyType, property.Name); } var messageBodyMemberFields = toBuild.GetFields() .Where(field => field.CustomAttributes.Any(attr => attr.AttributeType == typeof(MessageBodyMemberAttribute))) .OrderBy(field => field.GetCustomAttribute <MessageBodyMemberAttribute>().Order); foreach (var field in messageBodyMemberFields) { var messageBodyMember = field.GetCustomAttribute <MessageBodyMemberAttribute>(); var fieldName = messageBodyMember.Name ?? field.Name; AddSchemaType(writer, field.FieldType, fieldName); } } } writer.WriteEndElement(); // xs:sequence writer.WriteEndElement(); // xs:complexType if (isWrappedBodyType) { writer.WriteStartElement("xs:element"); writer.WriteAttributeString("name", toBuildName); writer.WriteAttributeString("nillable", "true"); writer.WriteAttributeString("type", "tns:" + toBuildName); writer.WriteEndElement(); // xs:element } _builtComplexTypes.Add(toBuildName); } } while (_enumToBuild.Count > 0) { Type toBuild = _enumToBuild.Dequeue(); if (toBuild.IsByRef) { toBuild = toBuild.GetElementType(); } if (!_builtEnumTypes.Contains(toBuild.Name)) { writer.WriteStartElement("xs:simpleType"); writer.WriteAttributeString("name", toBuild.Name); writer.WriteStartElement("xs:restriction "); writer.WriteAttributeString("base", "xs:string"); foreach (var value in Enum.GetValues(toBuild)) { writer.WriteStartElement("xs:enumeration "); writer.WriteAttributeString("value", value.ToString()); writer.WriteEndElement(); // xs:enumeration } writer.WriteEndElement(); // xs:restriction writer.WriteEndElement(); // xs:simpleType _builtEnumTypes.Add(toBuild.Name); } } writer.WriteEndElement(); // xs:schema while (_arrayToBuild.Count > 0) { var toBuild = _arrayToBuild.Dequeue(); var toBuildName = toBuild.IsArray ? "ArrayOf" + toBuild.Name.Replace("[]", string.Empty) : typeof(IEnumerable).IsAssignableFrom(toBuild) ? "ArrayOf" + GetGenericType(toBuild).Name.ToLower() : toBuild.Name; if (!_buildArrayTypes.Contains(toBuildName)) { writer.WriteStartElement("xs:schema"); writer.WriteAttributeString("xmlns:xs", XMLNS_XS); writer.WriteAttributeString("xmlns:tns", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"); writer.WriteAttributeString("elementFormDefault", "qualified"); writer.WriteAttributeString("targetNamespace", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"); writer.WriteStartElement("xs:complexType"); writer.WriteAttributeString("name", toBuildName); writer.WriteStartElement("xs:sequence"); AddSchemaType(writer, GetGenericType(toBuild), null, true); writer.WriteEndElement(); // xs:sequence writer.WriteEndElement(); // xs:complexType writer.WriteStartElement("xs:element"); writer.WriteAttributeString("name", toBuildName); writer.WriteAttributeString("nillable", "true"); writer.WriteAttributeString("type", "tns:" + toBuildName); writer.WriteEndElement(); // xs:element writer.WriteEndElement(); // xs:schema _buildArrayTypes.Add(toBuildName); } } if (_buildDateTimeOffset) { writer.WriteStartElement("xs:schema"); writer.WriteAttributeString("xmlns:xs", XMLNS_XS); writer.WriteAttributeString("xmlns:tns", "http://schemas.datacontract.org/2004/07/System"); writer.WriteAttributeString("elementFormDefault", "qualified"); writer.WriteAttributeString("targetNamespace", "http://schemas.datacontract.org/2004/07/System"); writer.WriteStartElement("xs:import"); writer.WriteAttributeString("namespace", "http://schemas.microsoft.com/2003/10/Serialization/"); writer.WriteEndElement(); writer.WriteStartElement("xs:complexType"); writer.WriteAttributeString("name", "DateTimeOffset"); writer.WriteStartElement("xs:annotation"); writer.WriteStartElement("xs:appinfo"); writer.WriteElementString("IsValueType", "http://schemas.microsoft.com/2003/10/Serialization/", "true"); writer.WriteEndElement(); // xs:appinfo writer.WriteEndElement(); // xs:annotation writer.WriteStartElement("xs:sequence"); AddSchemaType(writer, typeof(DateTime), "DateTime", false); AddSchemaType(writer, typeof(short), "OffsetMinutes", false); writer.WriteEndElement(); // xs:sequence writer.WriteEndElement(); // xs:complexType writer.WriteStartElement("xs:element"); writer.WriteAttributeString("name", "DateTimeOffset"); writer.WriteAttributeString("nillable", "true"); writer.WriteAttributeString("type", "tns:DateTimeOffset"); writer.WriteEndElement(); writer.WriteEndElement(); // xs:schema } writer.WriteEndElement(); // wsdl:types }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { writer.WriteStartElement("Binary"); writer.WriteValue(new Microsoft.ServiceBus.Web.StreamBodyWriter.StreamProvider(this.stream)); writer.WriteEndElement(); }
protected virtual void OnWriteDetail(XmlDictionaryWriter writer, EnvelopeVersion version) { OnWriteStartDetail(writer, version); OnWriteDetailContents(writer); writer.WriteEndElement(); }
protected override void OnWriteBodyContents(XmlDictionaryWriter w) { w.WriteStartElement("RequestSecurityToken", Constants.WstNamespace); w.WriteEndElement(); }
public static void TestC14NInclusivePrefixes() { TestCase tc = TestConfigHelper.GetTest("TestC14NInclusivePrefixes"); int count = 0; foreach (var input in tc.Inputs) { count++; string rwTypeStr = input.Arguments[0].Value; ReaderWriterFactory.ReaderWriterType rwType = (ReaderWriterFactory.ReaderWriterType)Enum.Parse(typeof(ReaderWriterFactory.ReaderWriterType), rwTypeStr, true); Encoding encoding = Encoding.GetEncoding(input.Arguments[1].Value); bool mustSupportV14N = input.Arguments[2].Value.ToLower() == "true"; MemoryStream ms = new MemoryStream(); XmlWriter w = ReaderWriterFactory.CreateXmlWriter(rwType, ms, encoding); XmlDictionaryWriter writer = w as XmlDictionaryWriter; if (writer == null) { writer = XmlDictionaryWriter.CreateDictionaryWriter(w); } if (!writer.CanCanonicalize) { Assert.False(mustSupportV14N, string.Format("Error, writer {0},{1} should support C14N, but it doesn't!", rwTypeStr, encoding.ToString())); continue; } string myDefaultNamespace = "http://mynamespace"; string myNamespace1 = "http://mynamespace1"; string myNamespace2 = "http://mynamespace2"; string myNamespace3 = "http://mynamespace3"; string myNamespace4 = "http://mynamespace4"; writer.WriteStartElement("Root"); writer.WriteXmlnsAttribute("p1", myNamespace1); writer.WriteAttributeString("p1", "a", null, "b"); writer.WriteStartElement("", "Element1", myDefaultNamespace); writer.WriteAttributeString("p3", "c", myNamespace3, "d"); writer.WriteStartElement("Element2"); MemoryStream canonicalStream = new MemoryStream(); writer.StartCanonicalization(canonicalStream, false, new string[] { "p3", "p2", "p1", "" }); writer.WriteStartElement("pre", "Element3", myNamespace2); writer.WriteAttributeString("pre2", "attrName", myNamespace4, "attrValue"); writer.WriteStartElement("Element4", ""); writer.WriteStartAttribute("attr1"); writer.WriteQualifiedName("foo", myNamespace1); writer.WriteEndAttribute(); writer.WriteStartAttribute("attr2"); writer.WriteQualifiedName("bar", myNamespace3); writer.WriteEndAttribute(); writer.WriteString("Hello world"); writer.WriteEndElement(); // Element4 writer.WriteEndElement(); // pre:Element3 writer.EndCanonicalization(); writer.WriteEndElement(); // Element2 writer.WriteEndElement(); // Element1 writer.WriteEndElement(); // Root writer.Flush(); byte[] canonicalDoc = canonicalStream.ToArray(); byte[] fullDoc = ms.ToArray(); writer.Close(); // Finished creating the document XmlDsigExcC14NTransform transform = new XmlDsigExcC14NTransform(); transform.InclusiveNamespacesPrefixList = "p3 p2 p1 #default"; transform.LoadInput(new MemoryStream(canonicalDoc)); Stream transformedOutput = transform.GetOutput(typeof(Stream)) as Stream; byte[] outputFromSecurity = StreamToByteArray(transformedOutput); //Finished creating the doc from the security class Helper.DumpToFile(fullDoc); Helper.DumpToFile(canonicalDoc); Helper.DumpToFile(outputFromSecurity); Assert.True(Enumerable.SequenceEqual(outputFromSecurity, canonicalDoc), $"TestC14NInclusivePrefixes test variation #{count} failed"); } }
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion) { writer.WriteRaw(GetToken().OuterXml); writer.WriteStartElement("Timestamp"); writer.WriteXmlnsAttribute("", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"); writer.WriteAttributeString("Id", "Timestamp-79"); //Created writer.WriteStartElement("Created"); writer.WriteString(this.token.ValidFrom.ToString("yyyy-MM-ddTHH:mm:ssZ")); writer.WriteEndElement(); //Expires writer.WriteStartElement("Expires"); writer.WriteString(this.token.ValidTo.ToString("yyyy-MM-ddTHH:mm:ssZ")); writer.WriteEndElement(); writer.WriteEndElement(); }