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