private void AddSchemaType(XmlDictionaryWriter writer, Type type, string name, bool isArray = false, string @namespace = null, bool isAttribute = false, bool isUnqualified = false)
{
AddSchemaType(writer, new TypeToBuild(type), name, isArray, @namespace, isAttribute, isUnqualified: isUnqualified);
}
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", GetOuterInputElementName(operation));
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);
string responseName = operation.Name + "Response";
if (operation.IsMessageContractRequest && operation.InParameters.Length > 0)
{
if (!IsWrappedMessageContractType(operation.InParameters[0].Parameter.ParameterType))
{
responseName = GetMessageContractBodyName(operation.ReturnType);
}
}
writer.WriteAttributeString("name", responseName);
if (operation.DispatchMethod.ReturnType != typeof(void) && operation.DispatchMethod.ReturnType != typeof(Task))
{
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 elementAttribute = operation.DispatchMethod.ReturnType.GetCustomAttribute <XmlElementAttribute>();
bool isUnqualified = elementAttribute?.Form == XmlSchemaForm.Unqualified;
var elementName = string.IsNullOrWhiteSpace(elementAttribute?.ElementName) ? null : elementAttribute.ElementName;
var xmlRootAttr = returnType.GetTypeInfo().GetCustomAttributes <XmlRootAttribute>().FirstOrDefault();
var typeRootName = string.IsNullOrWhiteSpace(xmlRootAttr?.ElementName) ? null : xmlRootAttr.ElementName;
var returnName = elementName
?? operation.DispatchMethod.ReturnParameter.GetCustomAttribute <MessageParameterAttribute>()?.Name
?? typeRootName
?? operation.Name + "Result";
writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD);
writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD);
if (operation.ReturnsChoice)
{
AddChoice(writer, operation.ReturnChoices);
}
else
{
AddSchemaType(writer, returnType, returnName, isUnqualified: isUnqualified);
}
writer.WriteEndElement();
writer.WriteEndElement();
}
else
{
var type = GetMessageContractBodyType(returnType);
if (returnType.IsConstructedGenericType)
{
writer.WriteAttributeString("type", Namespaces.XMLNS_XSD + type.Name);
}
else
{
writer.WriteAttributeString("type", "tns:" + type.Name);
_complexTypeToBuild.Enqueue(new TypeToBuild(type));
}
}
}
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();
AddSchemaComplexType(writer, toBuild);
}
while (_enumToBuild.Count > 0)
{
Type toBuild = _enumToBuild.Dequeue();
if (toBuild.IsByRef)
{
toBuild = toBuild.GetElementType();
}
var typeName = toBuild.GetSerializedTypeName();
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 = toBuild.GetSerializedTypeName();
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, toBuild.GetGenericType(), 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
}
private void AddSchemaComplexType(XmlDictionaryWriter writer, TypeToBuild toBuild)
{
var toBuildType = toBuild.Type;
var toBuildBodyType = GetMessageContractBodyType(toBuildType);
var isWrappedBodyType = IsWrappedMessageContractType(toBuildType);
var toBuildName = toBuild.TypeName;
if (toBuild.IsAnonumous || !_builtComplexTypes.Contains(toBuildName))
{
writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD);
if (!toBuild.IsAnonumous)
{
writer.WriteAttributeString("name", toBuildName);
}
if (toBuildType.IsArray)
{
writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD);
AddSchemaType(writer, toBuildType.GetElementType(), toBuild.ChildElementName, true);
writer.WriteEndElement(); // sequence
}
else if (typeof(IEnumerable).IsAssignableFrom(toBuildType))
{
writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD);
AddSchemaType(writer, toBuildType.GetGenericType(), toBuild.ChildElementName, true);
writer.WriteEndElement(); // sequence
}
else
{
if (!isWrappedBodyType)
{
var propertyOrFieldMembers = toBuildBodyType.GetPropertyOrFieldMembers()
.Where(mi => !mi.IsIgnored()).ToList();
var elements = propertyOrFieldMembers.Where(t => !t.IsAttribute()).ToList();
if (elements.Any())
{
writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD);
foreach (var element in elements)
{
AddSchemaTypePropertyOrField(writer, element, toBuild);
}
writer.WriteEndElement(); // sequence
}
var attributes = propertyOrFieldMembers.Where(t => t.IsAttribute());
foreach (var attribute in attributes)
{
AddSchemaTypePropertyOrField(writer, attribute, toBuild);
}
}
else
{
// TODO: should this also be changed to GetPropertyOrFieldMembers?
var properties = toBuildType.GetProperties().Where(prop => !prop.IsIgnored())
.ToList();
var elements = properties.Where(t => !t.IsAttribute()).ToList();
if (elements.Any())
{
writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD);
foreach (var element in elements)
{
AddSchemaTypePropertyOrField(writer, element, toBuild);
}
writer.WriteEndElement(); // sequence
}
var attributes = properties.Where(t => t.IsAttribute());
foreach (var attribute in attributes)
{
AddSchemaTypePropertyOrField(writer, attribute, toBuild);
}
var messageBodyMemberFields = toBuildType.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(); // 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);
}
}
protected override void WriteRequestedTokenClosed(RequestSecurityTokenResponse rstr, XmlDictionaryWriter writer)
{
if (rstr.IsRequestedTokenClosed)
{
writer.WriteElementString(this.DriverDictionary.RequestedTokenClosed, this.DriverDictionary.Namespace, string.Empty);
}
}
public void WriteTo(
AddressingVersion addressingVersion,
XmlDictionaryWriter writer)
{
WriteTo(addressingVersion, writer, "EndpointReference", addressingVersion.Namespace);
}
public override void WriteStartObject(XmlDictionaryWriter writer, object graph);
public override void WriteStartObject(XmlDictionaryWriter writer, object?graph)
{
// No need to pass in DateTimeFormat to JsonWriterDelegator: no DateTimes will be written in start object
WriteStartObjectHandleExceptions(new JsonWriterDelegator(writer), graph);
}
private void AddTypes(XmlDictionaryWriter writer)
{
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);
writer.WriteStartElement("xs:complexType");
writer.WriteStartElement("xs:sequence");
WriteParameters(writer, operation.InParameters);
writer.WriteEndElement(); // xs:sequence
writer.WriteEndElement(); // xs:complexType
writer.WriteEndElement(); // xs:element
// output parameter / return of operation
writer.WriteStartElement("xs:element");
writer.WriteAttributeString("name", operation.Name + "Response");
writer.WriteStartElement("xs:complexType");
writer.WriteStartElement("xs:sequence");
if (operation.DispatchMethod.ReturnType != typeof(void))
{
var returnType = operation.DispatchMethod.ReturnType;
if (returnType.IsConstructedGenericType && returnType.GetGenericTypeDefinition() == typeof(Task <>))
{
returnType = returnType.GetGenericArguments().First();
}
AddSchemaType(writer, returnType, operation.Name + "Result");
}
WriteParameters(writer, operation.OutParameters);
writer.WriteEndElement(); // xs:sequence
writer.WriteEndElement(); // xs:complexType
writer.WriteEndElement(); // xs:element
}
while (_complexTypeToBuild.Count > 0)
{
var toBuild = _complexTypeToBuild.Dequeue();
var toBuildName = toBuild.IsArray ? "ArrayOf" + toBuild.Name.Replace("[]", string.Empty)
: typeof(IEnumerable).IsAssignableFrom(toBuild) ? "ArrayOf" + GetGenericType(toBuild).Name
: toBuild.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
{
foreach (var property in toBuild.GetProperties())
{
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
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
}
public abstract void WriteTo(XmlDictionaryWriter writer, DictionaryManager dictionaryManager);
internal abstract void WriteTimestamp(XmlDictionaryWriter writer, SecurityTimestamp timestamp);
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)
{
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.Name == "Byte[]")
{
if (string.IsNullOrEmpty(name))
{
name = "base64Binary";
}
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);
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
}
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
writer.WriteStartElement("Binary");
writer.WriteBase64(content, 0, content.Length);
writer.WriteEndElement();
}
void IXmlSerializable.WriteXml(XmlWriter writer)
{
this.address.WriteContentsTo(AddressingVersion.WSAddressing10, XmlDictionaryWriter.CreateDictionaryWriter(writer));
}
protected override void OnWriteStartAddressHeader(XmlDictionaryWriter writer)
{
writer.WriteStartElement(name, ns);
}
public abstract void WriteObjectContent(XmlDictionaryWriter writer, object graph);
public static XmlDictionaryWriter CreateWriter(Stream stream)
{
return(XmlDictionaryWriter.CreateBinaryWriter(stream, new XmlDictionary(), null, true));
}
public override void WriteEndObject(XmlDictionaryWriter writer);
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
Message.WriteBodyContents(writer);
}
internal static void WriteHeaderContents(XmlDictionaryWriter writer, AddressHeader parameter)
{
parameter.WriteAddressHeaderContents(writer);
}
// The demand is not added now (in 4.5), to avoid a breaking change. To be considered in the next version.
/*
* [PermissionSet(SecurityAction.Demand, Unrestricted = true)] // because we call into CoordinationContext, which is defined in a non-APTCA assembly; WSATs are not supported in partial trust, so customers should not be broken by this demand
*/
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
this.context.WriteContent(writer);
}
protected override void WriteReferences(RequestSecurityTokenResponse rstr, XmlDictionaryWriter writer)
{
if (rstr.RequestedAttachedReference != null)
{
writer.WriteStartElement(this.DriverDictionary.Prefix.Value, this.DriverDictionary.RequestedAttachedReference, this.DriverDictionary.Namespace);
this.StandardsManager.SecurityTokenSerializer.WriteKeyIdentifierClause(writer, rstr.RequestedAttachedReference);
writer.WriteEndElement();
}
if (rstr.RequestedUnattachedReference != null)
{
writer.WriteStartElement(this.DriverDictionary.Prefix.Value, this.DriverDictionary.RequestedUnattachedReference, this.DriverDictionary.Namespace);
this.StandardsManager.SecurityTokenSerializer.WriteKeyIdentifierClause(writer, rstr.RequestedUnattachedReference);
writer.WriteEndElement();
}
}
private string GetSignatureStream(MessageHeader header, string headerId, IPrefixGenerator prefixGenerator, XmlDictionaryWriter writer, out Stream stream)
{
stream = new MemoryStream();
XmlDictionaryWriter effectiveWriter;
XmlBuffer canonicalBuffer = null;
if (writer.CanCanonicalize)
{
effectiveWriter = writer;
}
else
{
canonicalBuffer = new XmlBuffer(int.MaxValue);
effectiveWriter = canonicalBuffer.OpenSection(XmlDictionaryReaderQuotas.Max);
}
effectiveWriter.StartCanonicalization(stream, false, null);
header.WriteStartHeader(effectiveWriter, Version);
if (headerId == null)
{
headerId = GenerateId();
StandardsManager.IdManager.WriteIdAttribute(effectiveWriter, headerId);
}
header.WriteHeaderContents(effectiveWriter, Version);
effectiveWriter.WriteEndElement();
effectiveWriter.EndCanonicalization();
effectiveWriter.Flush();
if (!ReferenceEquals(effectiveWriter, writer))
{
Fx.Assert(canonicalBuffer != null, "Canonical buffer cannot be null.");
canonicalBuffer.CloseSection();
canonicalBuffer.Close();
XmlDictionaryReader dicReader = canonicalBuffer.GetReader(0);
writer.WriteNode(dicReader, false);
dicReader.Close();
}
stream.Position = 0;
return(headerId);
}
public void WriteContentsTo(
AddressingVersion addressingVersion,
XmlDictionaryWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
#if MOBILE
if (addressingVersion == AddressingVersion.None)
{
writer.WriteString(Uri.AbsoluteUri);
}
else
{
writer.WriteStartElement("Address", addressingVersion.Namespace);
writer.WriteString(Uri.AbsoluteUri);
writer.WriteEndElement();
}
#else
if (addressingVersion == AddressingVersion.None)
{
writer.WriteString(Uri.AbsoluteUri);
}
else
{
writer.WriteStartElement("Address", addressingVersion.Namespace);
writer.WriteString(Uri.AbsoluteUri);
writer.WriteEndElement();
if (Identity == null)
{
return;
}
if (Headers != null)
{
foreach (AddressHeader ah in Headers)
{
ah.WriteAddressHeader(writer);
}
}
writer.WriteStartElement("Identity", Constants.WsaIdentityUri);
X509CertificateEndpointIdentity x509 =
Identity as X509CertificateEndpointIdentity;
if (x509 != null)
{
KeyInfo ki = new KeyInfo();
KeyInfoX509Data x = new KeyInfoX509Data();
foreach (X509Certificate2 cert in x509.Certificates)
{
x.AddCertificate(cert);
}
ki.AddClause(x);
ki.GetXml().WriteTo(writer);
}
else
{
DataContractSerializer ds = new DataContractSerializer(Identity.IdentityClaim.GetType());
ds.WriteObject(writer, Identity.IdentityClaim);
}
writer.WriteEndElement();
}
#endif
}
private void AddSignatureReference(MessageHeader header, string headerId, IPrefixGenerator prefixGenerator, XmlDictionaryWriter writer)
{
// No transforms added to Reference as the digest value has already been calculated
byte[] hashValue;
headerId = GetSignatureHash(header, headerId, prefixGenerator, writer, out hashValue);
var reference = new System.Security.Cryptography.Xml.Reference();
reference.DigestMethod = AlgorithmSuite.DefaultDigestAlgorithm;
reference.DigestValue = hashValue;
reference.Id = headerId;
_signedXml.AddReference(reference);
}
public void WriteTo(
AddressingVersion addressingVersion, XmlWriter writer)
{
WriteTo(addressingVersion,
XmlDictionaryWriter.CreateDictionaryWriter(writer));
}
private void ApplySecurityAndWriteHeader(MessageHeader header, string headerId, XmlDictionaryWriter writer, IPrefixGenerator prefixGenerator)
{
if (!RequireMessageProtection && ShouldSignToHeader)
{
if ((header.Name == XD.AddressingDictionary.To.Value) &&
(header.Namespace == Message.Version.Addressing.Namespace))
{
if (_toHeaderStream == null)
{
Stream headerStream;
headerId = GetSignatureStream(header, headerId, prefixGenerator, writer, out headerStream);
_toHeaderStream = headerStream;
_toHeaderId = headerId;
}
else
{
// More than one 'To' header is specified in the message.
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.TransportSecuredMessageHasMoreThanOneToHeader));
}
return;
}
}
MessagePartProtectionMode protectionMode = GetProtectionMode(header);
switch (protectionMode)
{
case MessagePartProtectionMode.None:
header.WriteHeader(writer, Version);
return;
case MessagePartProtectionMode.Sign:
AddSignatureReference(header, headerId, prefixGenerator, writer);
return;
case MessagePartProtectionMode.SignThenEncrypt:
case MessagePartProtectionMode.Encrypt:
case MessagePartProtectionMode.EncryptThenSign:
throw new PlatformNotSupportedException();
default:
Fx.Assert("Invalid MessagePartProtectionMode");
return;
}
}
private void AddMessage(XmlDictionaryWriter writer)
{
foreach (var operation in _service.Operations)
{
// input
var hasRequestBody = false;
var requestTypeName = GetOuterInputElementName(operation);
//For document/litteral(WS-I we should point to the element
if (operation.IsMessageContractRequest && operation.InParameters.Length > 0)
{
hasRequestBody = TryGetMessageContractBodyType(operation.InParameters[0].Parameter.ParameterType, out var requestType);
}
writer.WriteStartElement("wsdl", "message", Namespaces.WSDL_NS);
writer.WriteAttributeString("name", $"{BindingType}_{operation.Name}_InputMessage");
if ((operation.IsMessageContractRequest && hasRequestBody) || !operation.IsMessageContractRequest)
{
writer.WriteStartElement("wsdl", "part", Namespaces.WSDL_NS);
writer.WriteAttributeString("name", "parameters");
writer.WriteAttributeString("element", "tns:" + requestTypeName);
writer.WriteEndElement(); // wsdl:part
}
writer.WriteEndElement(); // wsdl:message
var responseTypeName = 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();
}
if (operation.IsMessageContractResponse && !IsWrappedMessageContractType(returnType))
{
responseTypeName = GetMessageContractBodyName(returnType);
}
}
if (operation.IsMessageContractResponse && operation.OutParameters.Length > 0)
{
if (!IsWrappedMessageContractType(operation.OutParameters[0].Parameter.ParameterType))
{
responseTypeName = GetMessageContractBodyType(operation.OutParameters[0].Parameter.ParameterType).Name;
}
}
// output
if (!operation.IsOneWay)
{
writer.WriteStartElement("wsdl", "message", Namespaces.WSDL_NS);
writer.WriteAttributeString("name", $"{BindingType}_{operation.Name}_OutputMessage");
writer.WriteStartElement("wsdl", "part", Namespaces.WSDL_NS);
writer.WriteAttributeString("name", "parameters");
writer.WriteAttributeString("element", "tns:" + responseTypeName);
writer.WriteEndElement(); // wsdl:part
writer.WriteEndElement(); // wsdl:message
}
}
}
public void WriteTo(XmlDictionaryWriter writer, DictionaryManager dictionaryManager)
{
_signature.GetXml().WriteTo(writer);
}
private void AddSchemaTypePropertyOrField(XmlDictionaryWriter writer, MemberInfo member, TypeToBuild parentTypeToBuild)
{
if (member.IsChoice())
{
writer.WriteStartElement("choice", Namespaces.XMLNS_XSD);
if (member.GetPropertyOrFieldType().IsEnumerableType())
{
writer.WriteAttributeString("minOccurs", "0");
writer.WriteAttributeString("maxOccurs", "unbounded");
}
var choiceElements = member.GetCustomAttributes <XmlElementAttribute>();
foreach (var choiceElement in choiceElements)
{
if (choiceElement != null)
{
bool isUnqualifiedChoice = choiceElement?.Form == XmlSchemaForm.Unqualified;
AddSchemaType(writer, choiceElement.Type ?? member.GetPropertyOrFieldType(), choiceElement.ElementName ?? member.Name, isUnqualified: isUnqualifiedChoice);
}
}
writer.WriteEndElement(); // choice
return;
}
var createListWithoutProxyType = false;
var toBuild = new TypeToBuild(member.GetPropertyOrFieldType());
var arrayItem = member.GetCustomAttribute <XmlArrayItemAttribute>();
if (arrayItem != null && !string.IsNullOrWhiteSpace(arrayItem.ElementName))
{
toBuild.ChildElementName = arrayItem.ElementName;
}
var elementItem = member.GetCustomAttribute <XmlElementAttribute>();
bool isUnqualified = elementItem?.Form == XmlSchemaForm.Unqualified;
if (elementItem != null && !string.IsNullOrWhiteSpace(elementItem.ElementName))
{
toBuild.ChildElementName = elementItem.ElementName;
createListWithoutProxyType = toBuild.Type.IsEnumerableType();
}
var attributeItem = member.GetCustomAttribute <XmlAttributeAttribute>();
var messageBodyMemberAttribute = member.GetCustomAttribute <MessageBodyMemberAttribute>();
if (attributeItem != null)
{
var name = attributeItem.AttributeName;
if (string.IsNullOrWhiteSpace(name))
{
name = member.Name;
}
AddSchemaType(writer, toBuild, name, isAttribute: true, isUnqualified: isUnqualified);
}
else if (messageBodyMemberAttribute != null)
{
var name = messageBodyMemberAttribute.Name;
if (string.IsNullOrWhiteSpace(name))
{
name = member.Name;
}
AddSchemaType(writer, toBuild, name, isArray: createListWithoutProxyType, isListWithoutWrapper: createListWithoutProxyType);
}
else
{
AddSchemaType(writer, toBuild, parentTypeToBuild.ChildElementName ?? member.Name, isArray: createListWithoutProxyType, isListWithoutWrapper: createListWithoutProxyType, isUnqualified: isUnqualified);
}
}
protected override void WriteSecurityTokenReferencyEntry(XmlDictionaryWriter writer, SecurityToken securityToken, SecurityTokenParameters securityTokenParameters)
{
return;
}
public virtual void WriteObject(XmlDictionaryWriter writer, object graph);
public abstract void WriteTokenCore(XmlDictionaryWriter writer, SecurityToken token);
public abstract void WriteStartObject(XmlDictionaryWriter writer, object graph);
public override void WriteEndObject(XmlDictionaryWriter writer)
{
// No need to pass in DateTimeFormat to JsonWriterDelegator: no DateTimes will be written in end object
WriteEndObjectHandleExceptions(new JsonWriterDelegator(writer));
}
public override void WriteObjectContent(XmlDictionaryWriter writer, object graph);
public override void WriteObjectContent(XmlDictionaryWriter writer, object?graph)
{
WriteObjectContentHandleExceptions(new JsonWriterDelegator(writer, this.DateTimeFormat), graph);
}
public abstract void WriteEndObject(XmlDictionaryWriter writer);
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();
}
