void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
var mebe = new TextMessageEncodingBindingElement();
mebe.MessageVersion = this.MessageVersion;
((IWsdlExportExtension)mebe).ExportEndpoint(exporter, context);
}
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext endpointContext)
{
bool createdNew;
MessageEncodingBindingElement encodingBindingElement = FindMessageEncodingBindingElement(endpointContext, out createdNew);
TransportBindingElement.ExportWsdlEndpoint(exporter, endpointContext, this.WsdlTransportUri, encodingBindingElement.MessageVersion.Addressing);
}
private static SoapBinding GetSoapBinding(WsdlEndpointConversionContext endpointContext, WsdlExporter exporter)
{
EnvelopeVersion item = null;
SoapBinding soapBinding = null;
object obj = null;
object obj1 = new object();
if (exporter.State.TryGetValue(obj1, out obj))
{
Dictionary <System.Web.Services.Description.Binding, EnvelopeVersion> bindings = obj as Dictionary <System.Web.Services.Description.Binding, EnvelopeVersion>;
if (bindings != null && bindings.ContainsKey(endpointContext.WsdlBinding))
{
item = bindings[endpointContext.WsdlBinding];
}
}
if (item == EnvelopeVersion.None)
{
return(null);
}
foreach (object extension in endpointContext.WsdlBinding.Extensions)
{
SoapBinding soapBinding1 = extension as SoapBinding;
if (soapBinding1 == null)
{
continue;
}
soapBinding = soapBinding1;
}
return(soapBinding);
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
#pragma warning suppress 56506 // Microsoft, these properties cannot be null in this context
if (context.Endpoint.Binding == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context.Endpoint.Binding");
}
#pragma warning suppress 56506 // Microsoft, CustomBinding.Elements never be null
TransportBindingElement transportBindingElement = GetBindingElements(context).Find <TransportBindingElement>();
bool transportHandledExternaly = (transportBindingElement != null) && !StateHelper.IsRegisteredTransportBindingElement(importer, context);
if (transportHandledExternaly)
{
return;
}
#pragma warning suppress 56506 // Microsoft, these properties cannot be null in this context
WsdlNS.SoapBinding soapBinding = (WsdlNS.SoapBinding)context.WsdlBinding.Extensions.Find(typeof(WsdlNS.SoapBinding));
if (soapBinding != null && transportBindingElement == null)
{
CreateLegacyTransportBindingElement(importer, soapBinding, context);
}
// Try to import WS-Addressing address from the port
if (context.WsdlPort != null)
{
ImportAddress(context, transportBindingElement);
}
}
bool ImportBasicHttpEndpoint(WsdlEndpointConversionContext context)
{
var http = context.Endpoint.Binding as BasicHttpBinding;
if (http == null)
{
return(false);
}
WS.SoapAddressBinding address = null;
foreach (var extension in context.WsdlPort.Extensions)
{
var check = extension as WS.SoapAddressBinding;
if (check != null)
{
address = check;
break;
}
}
if (address == null)
{
return(false);
}
context.Endpoint.Address = new EndpointAddress(address.Location);
context.Endpoint.ListenUri = new Uri(address.Location);
context.Endpoint.ListenUriMode = ListenUriMode.Explicit;
return(true);
}
/// <summary>
/// When ExportEndpoint is called, the XML schemas have been generated. Now we can manipulate to
/// our heart's content.
/// </summary>
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
foreach (var p in _requiredParameter)
{
var schemas = exporter.GeneratedXmlSchemas.Schemas(p.Namespace);
foreach (XmlSchema schema in schemas)
{
var message = (XmlSchemaElement)schema.Elements[p.XmlQualifiedName];
var complexType = message.ElementSchemaType as XmlSchemaComplexType;
Debug.Assert(complexType != null, "Expected input message to be complex type.");
var sequence = complexType.Particle as XmlSchemaSequence;
Debug.Assert(sequence != null, "Expected a sequence.");
foreach (XmlSchemaElement item in sequence.Items)
{
if (item.Name == p.Name)
{
item.MinOccurs = 1;
item.MinOccursString = "1";
break;
}
}
}
}
// Throw away the temporary list we generated
_requiredParameter = null;
}
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
if (context.Endpoint != null && context.Endpoint.Address.Uri.Scheme.Equals("net.tcp"))
{
context.WsdlPort.Service.Ports.Remove(context.WsdlPort);
}
}
static BindingElementCollection GetBindingElements(WsdlEndpointConversionContext context)
{
Binding binding = context.Endpoint.Binding;
BindingElementCollection elements = binding is CustomBinding ? ((CustomBinding)binding).Elements : binding.CreateBindingElements();
return(elements);
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext context)
{
if (context != null && context.WsdlBinding != null && ContainsHttpBindingExtension(context.WsdlBinding))
{
httpBindingContracts.Add(context.ContractConversionContext.Contract);
}
}
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
BindingElementCollection bindingElements = context.Endpoint.Binding.CreateBindingElements();
MessageEncodingBindingElement encodingBindingElement = bindingElements.Find <MessageEncodingBindingElement>();
if (encodingBindingElement == null)
{
encodingBindingElement = new TextMessageEncodingBindingElement();
}
// Set SoapBinding Transport URI
if (UdpPolicyStrings.UdpNamespace != null)
{
WsdlNS.SoapBinding soapBinding = GetSoapBinding(context, exporter);
if (soapBinding != null)
{
soapBinding.Transport = UdpPolicyStrings.UdpNamespace;
}
}
if (context.WsdlPort != null)
{
AddAddressToWsdlPort(context.WsdlPort, context.Endpoint.Address, encodingBindingElement.MessageVersion.Addressing);
}
}
internal static void ExportWsdlEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext endpointContext,
string wsdlTransportUri, EndpointAddress address, AddressingVersion addressingVersion)
{
if (exporter == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
if (endpointContext == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointContext");
}
// Set SoapBinding Transport URI
#pragma warning suppress 56506 // [....], these properties cannot be null in this context
BindingElementCollection bindingElements = endpointContext.Endpoint.Binding.CreateBindingElements();
if (wsdlTransportUri != null)
{
WsdlNS.SoapBinding soapBinding = SoapHelper.GetOrCreateSoapBinding(endpointContext, exporter);
if (soapBinding != null)
{
soapBinding.Transport = wsdlTransportUri;
}
}
if (endpointContext.WsdlPort != null)
{
WsdlExporter.WSAddressingHelper.AddAddressToWsdlPort(endpointContext.WsdlPort, address, addressingVersion);
}
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
if (context.Endpoint.Binding == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context.Endpoint.Binding");
}
TransportBindingElement transportBindingElement = GetBindingElements(context).Find <TransportBindingElement>();
if ((transportBindingElement == null) || StateHelper.IsRegisteredTransportBindingElement(importer, context))
{
SoapBinding soapBinding = (SoapBinding)context.WsdlBinding.Extensions.Find(typeof(SoapBinding));
if ((soapBinding != null) && (transportBindingElement == null))
{
CreateLegacyTransportBindingElement(importer, soapBinding, context);
}
if (context.WsdlPort != null)
{
ImportAddress(context, transportBindingElement);
}
}
}
private static void ImportAddress(WsdlEndpointConversionContext context)
{
EndpointAddress endpointAddress = null;
if (context.WsdlPort != null)
{
XmlElement xmlElement = context.WsdlPort.Extensions.Find("EndpointReference", "http://www.w3.org/2005/08/addressing");
XmlElement xmlElement1 = context.WsdlPort.Extensions.Find("EndpointReference", "http://schemas.xmlsoap.org/ws/2004/08/addressing");
SoapAddressBinding soapAddressBinding = (SoapAddressBinding)context.WsdlPort.Extensions.Find(typeof(SoapAddressBinding));
if (xmlElement != null)
{
endpointAddress = EndpointAddress.ReadFrom(AddressingVersion.WSAddressing10, new XmlNodeReader(xmlElement));
}
if (xmlElement1 != null)
{
endpointAddress = EndpointAddress.ReadFrom(AddressingVersion.WSAddressingAugust2004, new XmlNodeReader(xmlElement1));
}
else if (soapAddressBinding != null)
{
endpointAddress = new EndpointAddress(soapAddressBinding.Location);
}
}
if (endpointAddress != null)
{
context.Endpoint.Address = endpointAddress;
}
}
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
((IWsdlExportExtension) new TextMessageEncodingBindingElement
{
MessageVersion = this.msgVersion
}).ExportEndpoint(exporter, context);
}
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext endpointContext)
{
bool flag;
MessageEncodingBindingElement element = this.FindMessageEncodingBindingElement(endpointContext, out flag);
TransportBindingElement.ExportWsdlEndpoint(exporter, endpointContext, "http://schemas.microsoft.com/soap/peer", element.MessageVersion.Addressing);
}
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter,
WsdlEndpointConversionContext context)
{
var soap_binding = new WS.Soap12Binding();
soap_binding.Transport = "http://schemas.microsoft.com/soap/tcp";
soap_binding.Style = WS.SoapBindingStyle.Document;
context.WsdlBinding.Extensions.Add(soap_binding);
var address = context.Endpoint.Address;
var uri = address.Uri.AbsoluteUri;
var soap_address = new WS.Soap12AddressBinding();
soap_address.Location = uri;
context.WsdlPort.Extensions.Add(soap_address);
var doc = new XmlDocument();
var endpoint_ref = doc.CreateElement(
"EndpointReference", AddressingVersion.WSAddressing10.Namespace);
var endpoint_addr = doc.CreateElement(
"Address", AddressingVersion.WSAddressing10.Namespace);
endpoint_addr.InnerText = uri;
endpoint_ref.AppendChild(endpoint_addr);
context.WsdlPort.Extensions.Add(endpoint_ref);
}
private void ImportXRoadPort(WsdlEndpointConversionContext context)
{
if (context.WsdlPort == null)
{
return;
}
var addressNode = context.WsdlPort.Extensions.Find("address", NamespaceConstants.XROAD31);
if (addressNode != null)
{
context.WsdlPort.Extensions.Remove(addressNode);
}
var titleExtensions = context.WsdlPort.Extensions.FindAll("title", NamespaceConstants.XROAD31).ToList();
if (!titleExtensions.Any())
{
return;
}
var documentationContractBehavior = new DocumentationContractBehavior();
foreach (var node in titleExtensions)
{
var languageAttribute = node.GetAttribute("lang", NamespaceConstants.XML);
documentationContractBehavior.AddComment(languageAttribute ?? "", node.InnerText);
context.WsdlPort.Extensions.Remove(node);
}
context.ContractConversionContext.Contract.Behaviors.Add(documentationContractBehavior);
}
public void ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext endpointContext)
{
System.ServiceModel.Channels.Binding binding;
if (endpointContext == null)
{
throw new ArgumentNullException("endpointContext");
}
if (endpointContext.Endpoint.Binding == null)
{
throw new ArgumentNullException("endpointContext.Binding");
}
if (endpointContext.Endpoint.Binding is CustomBinding)
{
BindingElementCollection elements = ((CustomBinding)endpointContext.Endpoint.Binding).Elements;
if (elements.Find <HttpRelayTransportBindingElement>() != null)
{
elements.Remove <HttpsTransportBindingElement>();
if (WSHttpRelayBindingBase.TryCreate(elements, out binding))
{
StandardRelayBindingImporter.SetBinding(endpointContext.Endpoint, binding);
return;
}
if (BasicHttpRelayBinding.TryCreate(elements, out binding))
{
StandardRelayBindingImporter.SetBinding(endpointContext.Endpoint, binding);
return;
}
}
else if (elements.Find <TcpRelayTransportBindingElement>() != null && NetTcpRelayBinding.TryCreate(elements, out binding))
{
StandardRelayBindingImporter.SetBinding(endpointContext.Endpoint, binding);
}
}
}
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
var scheme = HttpContext.Current.Request.Headers["X-Forwarded-Proto"] ?? HttpContext.Current.Request.Url.Scheme;
var host = HttpContext.Current.Request.Url.Host;
_location = new Uri($"{scheme}://{host}");
foreach (object extension in context.WsdlPort.Extensions)
{
SoapAddressBinding addr = (extension as SoapAddressBinding);
if (addr != null)
{
addr.Location = Rewrite(addr.Location).ToString();
}
}
EnumerateWsdlsAndSchemas(exporter.GeneratedWsdlDocuments, exporter.GeneratedXmlSchemas);
foreach (ServiceDescription description in exporter.GeneratedWsdlDocuments)
{
FixImportAddresses(exporter.GeneratedWsdlDocuments, description, exporter.GeneratedXmlSchemas);
}
foreach (XmlSchema schema in exporter.GeneratedXmlSchemas.Schemas())
{
FixImportAddresses(exporter.GeneratedXmlSchemas, schema);
}
}
private static WsdlNS.SoapBinding GetSoapBinding(WsdlEndpointConversionContext endpointContext, WsdlExporter exporter)
{
EnvelopeVersion envelopeVersion = null;
WsdlNS.SoapBinding existingSoapBinding = null;
object versions = null;
object SoapVersionStateKey = new object();
//get the soap version state
if (exporter.State.TryGetValue(SoapVersionStateKey, out versions))
{
if (versions != null && ((Dictionary <WsdlNS.Binding, EnvelopeVersion>)versions).ContainsKey(endpointContext.WsdlBinding))
{
envelopeVersion = ((Dictionary <WsdlNS.Binding, EnvelopeVersion>)versions)[endpointContext.WsdlBinding];
}
}
if (envelopeVersion == EnvelopeVersion.None)
{
return(null);
}
//get existing soap binding
foreach (object o in endpointContext.WsdlBinding.Extensions)
{
if (o is WsdlNS.SoapBinding)
{
existingSoapBinding = (WsdlNS.SoapBinding)o;
}
}
return(existingSoapBinding);
}
public void ExportEndpoint(
WsdlExporter exporter,
WsdlEndpointConversionContext context)
{
var wsdl = exporter.GeneratedWsdlDocuments[0];
var schemas = exporter.GeneratedXmlSchemas;
// In order to make generated WSDL more readable, common SOAP + SAML
// namespaces are added to the head of the WSDL file
var namespaces =
Utils.Namespaces.Merge(
wsdl.Namespaces.ToArray(),
Utils.Namespaces.Required
);
var mainPolicy = new List <Element>();
var mainPolicyName = context.WsdlBinding.Name + "_policy";
if (wsdl.Extensions[0] is XmlElement policy)
{
mainPolicy.Add(Utils.Parse.Extension.Policy(policy));
}
// In order to ensure we always get the same WSDL even if we choose
// ?singleWsdl or ?wsdl which limits the possibilities of errors.
ClearTypes(wsdl);
ClearMainPolicy(wsdl, mainPolicyName);
AddNamespaces(wsdl, namespaces);
AddTypes(wsdl, schemas);
AddPoliciesMain(wsdl, mainPolicyName, mainPolicy, token);
}
public void ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext context)
{
var custom = context.Endpoint.Binding as CustomBinding;
if (custom == null)
{
return;
}
var soapHttp = GetHttpSoapBinding(context.WsdlBinding);
if (soapHttp != null)
{
ImportBasicHttpBinding(importer, context, custom, soapHttp);
return;
}
var soapTcp = GetTcpSoapBinding(context.WsdlBinding);
if (soapTcp != null)
{
ImportNetTcpBinding(importer, context, custom, soapTcp);
return;
}
}
static void EnsureMessageEncoding(WsdlEndpointConversionContext context, MessageEncodingBindingElement encodingBindingElement)
{
EnvelopeVersion soapVersion = SoapHelper.GetSoapVersion(context.WsdlBinding);
AddressingVersion addressingVersion;
if (encodingBindingElement == null)
{
encodingBindingElement = new TextMessageEncodingBindingElement();
ConvertToCustomBinding(context).Elements.Add(encodingBindingElement);
addressingVersion = AddressingVersion.None;
}
else
{
if (soapVersion == EnvelopeVersion.None)
{
addressingVersion = AddressingVersion.None;
}
else
{
addressingVersion = encodingBindingElement.MessageVersion.Addressing;
}
}
MessageVersion newMessageVersion = MessageVersion.CreateVersion(soapVersion, addressingVersion);
if (!encodingBindingElement.MessageVersion.IsMatch(newMessageVersion))
{
ConvertToCustomBinding(context).Elements.Find <MessageEncodingBindingElement>().MessageVersion
= MessageVersion.CreateVersion(soapVersion, addressingVersion);
}
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext endpointContext)
{
if (endpointContext == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointContext");
}
#pragma warning suppress 56506 // [....], endpointContext.Endpoint is never null
if (endpointContext.Endpoint.Binding == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointContext.Binding");
}
if (endpointContext.Endpoint.Binding is CustomBinding)
{
BindingElementCollection elements = ((CustomBinding)endpointContext.Endpoint.Binding).Elements;
Binding binding;
TransportBindingElement transport = elements.Find <TransportBindingElement>();
if (transport is HttpTransportBindingElement)
{
if (WSHttpBindingBase.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
else if (WSDualHttpBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
else if (BasicHttpBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
else if (NetHttpBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
}
else if (transport is MsmqTransportBindingElement && NetMsmqBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
else if (transport is NamedPipeTransportBindingElement && NetNamedPipeBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
#pragma warning disable 0618
else if (transport is PeerTransportBindingElement && NetPeerTcpBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
#pragma warning restore 0618
else if (transport is TcpTransportBindingElement && NetTcpBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
}
}
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
SoapHelper.SetSoapVersion(context, exporter, System.ServiceModel.Channels.MessageVersion.Soap12WSAddressing10.Envelope);
}
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
SoapHelper.SetSoapVersion(context, exporter, this.messageVersion.Envelope);
}
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
// The MessageEncodingBindingElement is responsible for ensuring that the WSDL has the correct
// SOAP version. We can delegate to the WCF implementation of TextMessageEncodingBindingElement for this.
TextMessageEncodingBindingElement mebe = new TextMessageEncodingBindingElement();
mebe.MessageVersion = this.msgVersion;
((IWsdlExportExtension)mebe).ExportEndpoint(exporter, context);
}
/// <summary>
/// Writes custom Web Services Description Language (WSDL) elements into the generated WSDL for an endpoint.
/// </summary>
/// <param name="exporter">The <see cref="T:System.ServiceModel.Description.WsdlExporter" /> that exports the endpoint information.</param>
/// <param name="context">Provides mappings from exported WSDL elements to the endpoint description.</param>
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
BindingElementCollection bindingElements = context.Endpoint.Binding.CreateBindingElements();
MessageEncodingBindingElement encodingBindingElement = bindingElements.Find <MessageEncodingBindingElement>() ?? new TextMessageEncodingBindingElement();
if (context.WsdlPort != null)
{
AddAddressToWsdlPort(context.WsdlPort, context.Endpoint.Address, encodingBindingElement.MessageVersion.Addressing);
}
}
public void ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext context)
{
// Only import the binding, not the endpoint.
if (context.WsdlPort == null)
{
return;
}
DoImportEndpoint(context);
}
static CustomBinding ConvertToCustomBinding(WsdlEndpointConversionContext context)
{
CustomBinding customBinding = context.Endpoint.Binding as CustomBinding;
if (customBinding == null)
{
customBinding = new CustomBinding(context.Endpoint.Binding);
context.Endpoint.Binding = customBinding;
}
return(customBinding);
}
