/// <summary>
/// Creates a new transport channel that supports the IRegistrationChannel service contract.
/// </summary>
/// <param name="configuration">The application configuration.</param>
/// <param name="description">The description for the endpoint.</param>
/// <param name="endpointConfiguration">The configuration to use with the endpoint.</param>
/// <param name="clientCertificate">The client certificate.</param>
/// <param name="messageContext">The message context to use when serializing the messages.</param>
/// <returns></returns>
public static ITransportChannel Create(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
X509Certificate2 clientCertificate,
ServiceMessageContext messageContext)
{
// create a UA binary channel.
ITransportChannel channel = CreateUaBinaryChannel(
configuration,
description,
endpointConfiguration,
clientCertificate,
messageContext);
// create a WCF XML channel.
if (channel == null)
{
Uri endpointUrl = new Uri(description.EndpointUrl);
channel = new RegistrationChannel();
TransportChannelSettings settings = new TransportChannelSettings();
settings.Configuration = endpointConfiguration;
settings.Description = description;
settings.ClientCertificate = clientCertificate;
channel.Initialize(endpointUrl, settings);
}
return channel;
}
/// <summary>
/// Creates a binding for to use for discovering servers.
/// </summary>
/// <param name="discoveryUrl">The discovery URL.</param>
/// <param name="configuration">The configuration.</param>
/// <returns></returns>
public static DiscoveryClient Create(Uri discoveryUrl, EndpointConfiguration configuration)
{
if (configuration == null)
{
configuration = EndpointConfiguration.Create();
}
ITransportChannel channel = DiscoveryChannel.Create(discoveryUrl, configuration, new ServiceMessageContext());
return new DiscoveryClient(channel);
}
/// <summary>
/// Creates an instance of a configuration with reasonable default values.
/// </summary>
public static EndpointConfiguration Create()
{
EndpointConfiguration configuration = new EndpointConfiguration();
configuration.OperationTimeout = 120000;
configuration.UseBinaryEncoding = true;
configuration.MaxArrayLength = UInt16.MaxValue;
configuration.MaxByteStringLength = UInt16.MaxValue*16;
configuration.MaxMessageSize = UInt16.MaxValue*64;
configuration.MaxStringLength = UInt16.MaxValue;
configuration.MaxBufferSize = UInt16.MaxValue;
configuration.ChannelLifetime = 120000;
configuration.SecurityTokenLifetime = 3600000;
return configuration;
}
/// <summary>
/// Creates a binding for to use for discovering servers.
/// </summary>
/// <param name="discoveryUrl">The discovery URL.</param>
/// <param name="bindingFactory">The binding factory.</param>
/// <param name="configuration">The configuration.</param>
/// <returns></returns>
public static DiscoveryClient Create(Uri discoveryUrl, BindingFactory bindingFactory, EndpointConfiguration configuration)
{
if (discoveryUrl == null) throw new ArgumentNullException("discoveryUrl");
if (bindingFactory == null)
{
bindingFactory = BindingFactory.Default;
}
if (configuration == null)
{
configuration = EndpointConfiguration.Create();
}
ITransportChannel channel = DiscoveryChannel.Create(discoveryUrl, bindingFactory, configuration, new ServiceMessageContext());
return new DiscoveryClient(channel);
}
/// <summary>
/// Creates a new transport channel that supports the ISessionChannel service contract.
/// </summary>
/// <param name="configuration">The application configuration.</param>
/// <param name="description">The description for the endpoint.</param>
/// <param name="endpointConfiguration">The configuration to use with the endpoint.</param>
/// <param name="clientCertificate">The client certificate.</param>
/// <param name="messageContext">The message context to use when serializing the messages.</param>
/// <returns></returns>
public static ITransportChannel Create(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
X509Certificate2 clientCertificate,
ServiceMessageContext messageContext)
{
// create a UA binary channel.
ITransportChannel channel = CreateUaBinaryChannel(
configuration,
description,
endpointConfiguration,
clientCertificate,
messageContext);
return channel;
}
/// <summary>
/// Creates a binding for to use for discovering servers.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="description">The description.</param>
/// <param name="endpointConfiguration">The endpoint configuration.</param>
/// <param name="instanceCertificate">The instance certificate.</param>
/// <returns></returns>
public static RegistrationClient Create(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
X509Certificate2 instanceCertificate)
{
if (configuration == null) throw new ArgumentNullException("configuration");
if (description == null) throw new ArgumentNullException("description");
ITransportChannel channel = RegistrationChannel.Create(
configuration,
description,
endpointConfiguration,
instanceCertificate,
new ServiceMessageContext());
return new RegistrationClient(channel);
}
/// <summary>
/// Creates an instance of a configuration with reasonable default values.
/// </summary>
public static EndpointConfiguration Create(ApplicationConfiguration applicationConfiguration)
{
if (applicationConfiguration == null || applicationConfiguration.TransportQuotas == null)
{
return Create();
}
EndpointConfiguration configuration = new EndpointConfiguration();
configuration.OperationTimeout = applicationConfiguration.TransportQuotas.OperationTimeout;
configuration.UseBinaryEncoding = true;
configuration.MaxArrayLength = applicationConfiguration.TransportQuotas.MaxArrayLength;
configuration.MaxByteStringLength = applicationConfiguration.TransportQuotas.MaxByteStringLength;
configuration.MaxMessageSize = applicationConfiguration.TransportQuotas.MaxMessageSize;
configuration.MaxStringLength = applicationConfiguration.TransportQuotas.MaxStringLength;
configuration.MaxBufferSize = applicationConfiguration.TransportQuotas.MaxBufferSize;
configuration.ChannelLifetime = applicationConfiguration.TransportQuotas.ChannelLifetime;
configuration.SecurityTokenLifetime = applicationConfiguration.TransportQuotas.SecurityTokenLifetime;
return configuration;
}
/// <summary>
/// Creates a new transport channel that supports the ISessionChannel service contract.
/// </summary>
/// <param name="configuration">The application configuration.</param>
/// <param name="description">The description for the endpoint.</param>
/// <param name="endpointConfiguration">The configuration to use with the endpoint.</param>
/// <param name="clientCertificate">The client certificate.</param>
/// <param name="messageContext">The message context to use when serializing the messages.</param>
/// <returns></returns>
public static ITransportChannel Create(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
X509Certificate2 clientCertificate,
ServiceMessageContext messageContext)
{
// create a UA binary channel.
ITransportChannel channel = CreateUaBinaryChannel(
configuration,
description,
endpointConfiguration,
clientCertificate,
messageContext);
#if !SILVERLIGHT
// create a WCF XML channel.
if (channel == null)
{
Uri endpointUrl = new Uri(description.EndpointUrl);
BindingFactory bindingFactory = BindingFactory.Create(configuration, messageContext);
Binding binding = bindingFactory.Create(endpointUrl.Scheme, description, endpointConfiguration);
SessionChannel wcfXmlChannel = new SessionChannel();
wcfXmlChannel.Initialize(
configuration,
description,
endpointConfiguration,
binding,
clientCertificate,
null);
channel = wcfXmlChannel;
}
#endif
return channel;
}
public static RegistrationChannel Create(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
Binding binding,
X509Certificate2 clientCertificate,
string configurationName)
{
RegistrationChannel channel = new RegistrationChannel();
channel.Initialize(
configuration,
description,
endpointConfiguration,
binding,
clientCertificate,
configurationName);
return channel;
}
public static SessionChannel Create(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
BindingFactory bindingFactory,
X509Certificate2 clientCertificate,
string configurationName)
{
if (description == null) throw new ArgumentNullException("description");
if (configuration == null) throw new ArgumentNullException("configuration");
if (bindingFactory == null) throw new ArgumentNullException("bindingFactory");
Uri uri = new Uri(description.EndpointUrl);
Binding binding = bindingFactory.Create(uri.Scheme, description, endpointConfiguration);
return Create(configuration, description, endpointConfiguration, binding, clientCertificate, configurationName);
}
public static DiscoveryChannel Create(
Uri discoveryUrl,
EndpointConfiguration configuration,
BindingFactory bindingFactory,
string configurationName)
{
return Create(discoveryUrl, configuration, bindingFactory.Create(discoveryUrl.Scheme, configuration), configurationName);
}
/// <summary>
/// Creates a new UA-binary transport channel if requested. Null otherwise.
/// </summary>
/// <param name="configuration">The application configuration.</param>
/// <param name="description">The description for the endpoint.</param>
/// <param name="endpointConfiguration">The configuration to use with the endpoint.</param>
/// <param name="clientCertificate">The client certificate.</param>
/// <param name="messageContext">The message context to use when serializing the messages.</param>
/// <returns></returns>
public static ITransportChannel CreateUaBinaryChannel(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
X509Certificate2 clientCertificate,
ServiceMessageContext messageContext)
{
// check if the server if configured to use the ANSI C stack.
bool useUaTcp = description.EndpointUrl.StartsWith(Utils.UriSchemeOpcTcp);
bool useHttps = description.EndpointUrl.StartsWith(Utils.UriSchemeHttps);
#if !SILVERLIGHT
bool useAnsiCStack = false;
#else
useHttps = description.EndpointUrl.StartsWith(Utils.UriSchemeHttp);
#endif
switch (description.TransportProfileUri)
{
case Profiles.UaTcpTransport:
{
useUaTcp = true;
#if !SILVERLIGHT
if (configuration != null)
{
useAnsiCStack = configuration.UseNativeStack;
}
#endif
break;
}
case Profiles.HttpsXmlTransport:
case Profiles.HttpsBinaryTransport:
case Profiles.HttpsXmlOrBinaryTransport:
{
useHttps = true;
break;
}
}
#if !SILVERLIGHT
// check for a WCF channel.
if (!useUaTcp && !useHttps)
{
// binary channels only need the base class.
if (endpointConfiguration.UseBinaryEncoding)
{
Uri endpointUrl = new Uri(description.EndpointUrl);
BindingFactory bindingFactory = BindingFactory.Create(configuration, messageContext);
Binding binding = bindingFactory.Create(endpointUrl.Scheme, description, endpointConfiguration);
WcfChannelBase<IChannelBase> wcfChannel = new WcfChannelBase<IChannelBase>();
// create regular binding.
if (configuration != null)
{
wcfChannel.Initialize(
configuration,
description,
endpointConfiguration,
binding,
clientCertificate,
null);
}
// create no-security discovery binding.
else
{
wcfChannel.Initialize(
description,
endpointConfiguration,
binding,
null);
}
return wcfChannel;
}
return null;
}
#endif
// initialize the channel which will be created with the server.
ITransportChannel channel = null;
// create a UA-TCP channel.
TransportChannelSettings settings = new TransportChannelSettings();
settings.Description = description;
settings.Configuration = endpointConfiguration;
settings.ClientCertificate = clientCertificate;
if (description.ServerCertificate != null && description.ServerCertificate.Length > 0)
{
settings.ServerCertificate = Utils.ParseCertificateBlob(description.ServerCertificate);
}
#if !SILVERLIGHT
if (configuration != null)
{
settings.CertificateValidator = configuration.CertificateValidator.GetChannelValidator();
}
#endif
settings.NamespaceUris = messageContext.NamespaceUris;
settings.Factory = messageContext.Factory;
if (useUaTcp)
{
#if !SILVERLIGHT
Type type = null;
if (useAnsiCStack)
{
type = Type.GetType("Opc.Ua.NativeStack.NativeStackChannel,Opc.Ua.NativeStackWrapper");
}
if (useAnsiCStack && type != null)
{
channel = (ITransportChannel)Activator.CreateInstance(type);
}
else
{
channel = new Opc.Ua.Bindings.TcpTransportChannel();
}
#endif
}
else if (useHttps)
{
channel = new Opc.Ua.Bindings.HttpsTransportChannel();
}
channel.Initialize(new Uri(description.EndpointUrl), settings);
channel.Open();
return channel;
}
/// <summary>
/// Displays the dialog.
/// </summary>
public async Task<ConfiguredEndpoint> ShowDialog(ApplicationDescription server, ApplicationConfiguration configuration)
{
if (server == null) throw new ArgumentNullException("server");
m_configuration = configuration;
// construct a list of available endpoint descriptions for the application.
m_availableEndpoints = new EndpointDescriptionCollection();
m_endpointConfiguration = EndpointConfiguration.Create(configuration);
// create a default endpoint description.
m_endpoint = null;
m_currentDescription = null;
// initializing the protocol will trigger an update to all other controls.
InitializeProtocols(m_availableEndpoints);
UseDefaultLimitsCB.SelectedIndex = (int)UseDefaultLimits.Yes;
// discover endpoints in the background.
m_discoverySucceeded = false;
Interlocked.Increment(ref m_discoverCount);
OnDiscoverEndpoints(server);
TaskCompletionSource<ConfiguredEndpoint> tcs = new TaskCompletionSource<ConfiguredEndpoint>();
// display dialog
dialogPopup.Child = this;
dialogPopup.IsOpen = true;
dialogPopup.Closed += (o, e) =>
{
tcs.SetResult(m_endpoint);
};
return await tcs.Task;
}
/// <summary>
/// Displays the dialog.
/// </summary>
public async Task<ConfiguredEndpoint> ShowDialog(ConfiguredEndpoint endpoint, ApplicationConfiguration configuration)
{
if (endpoint == null) throw new ArgumentNullException("endpoint");
m_endpoint = endpoint;
m_configuration = configuration;
// construct a list of available endpoint descriptions for the application.
m_availableEndpoints = new EndpointDescriptionCollection();
m_availableEndpoints.Add(endpoint.Description);
m_currentDescription = endpoint.Description;
m_endpointConfiguration = endpoint.Configuration;
if (m_endpointConfiguration == null)
{
m_endpointConfiguration = EndpointConfiguration.Create(configuration);
}
if (endpoint.Collection != null)
{
foreach (ConfiguredEndpoint existingEndpoint in endpoint.Collection.Endpoints)
{
if (existingEndpoint.Description.Server.ApplicationUri == endpoint.Description.Server.ApplicationUri)
{
m_availableEndpoints.Add(existingEndpoint.Description);
}
}
}
UserTokenPolicy policy = m_endpoint.SelectedUserTokenPolicy;
if (policy == null)
{
if (m_endpoint.Description.UserIdentityTokens.Count > 0)
{
policy = m_endpoint.Description.UserIdentityTokens[0];
}
}
if (policy != null)
{
UserTokenItem userTokenItem = new UserTokenItem(policy);
if (policy.TokenType == UserTokenType.UserName && m_endpoint.UserIdentity is UserNameIdentityToken)
{
m_userIdentities[userTokenItem.ToString()] = m_endpoint.UserIdentity;
}
if (policy.TokenType == UserTokenType.Certificate && m_endpoint.UserIdentity is X509IdentityToken)
{
m_userIdentities[userTokenItem.ToString()] = m_endpoint.UserIdentity;
}
if (policy.TokenType == UserTokenType.IssuedToken && m_endpoint.UserIdentity is IssuedIdentityToken)
{
m_userIdentities[userTokenItem.ToString()] = m_endpoint.UserIdentity;
}
UserTokenTypeCB.Items.Add(userTokenItem);
UserTokenTypeCB.SelectedIndex = UserTokenTypeCB.Items.IndexOf(userTokenItem);
}
// copy com identity.
m_comIdentity = endpoint.ComIdentity;
// initializing the protocol will trigger an update to all other controls.
InitializeProtocols(m_availableEndpoints);
// check if the current settings match the defaults.
EndpointConfiguration defaultConfiguration = EndpointConfiguration.Create(configuration);
if (SameAsDefaults(defaultConfiguration, m_endpoint.Configuration))
{
UseDefaultLimitsCB.SelectedIndex = (int)UseDefaultLimits.Yes;
}
else
{
UseDefaultLimitsCB.SelectedIndex = (int)UseDefaultLimits.No;
}
// discover endpoints in the background.
Interlocked.Increment(ref m_discoverCount);
OnDiscoverEndpoints(m_endpoint.Description.Server);
TaskCompletionSource<ConfiguredEndpoint> tcs = new TaskCompletionSource<ConfiguredEndpoint>();
// display dialog
dialogPopup.Child = this;
dialogPopup.IsOpen = true;
dialogPopup.Closed += (o, e) =>
{
tcs.SetResult(m_endpoint);
};
return await tcs.Task;
}
public void InitializeSinglePolicy(
Type contractType,
ApplicationConfiguration configuration,
BindingFactory bindingFactory,
EndpointConfiguration endpointConfiguration,
List<EndpointDescription> endpoints,
MessageSecurityMode securityMode,
string securityPolicyUri)
{
// allow any url to match.
System.ServiceModel.ServiceBehaviorAttribute behavoir = this.Description.Behaviors.Find<System.ServiceModel.ServiceBehaviorAttribute>();
behavoir.AddressFilterMode = System.ServiceModel.AddressFilterMode.Any;
// specify service credentials
ServiceCredentials credentials = new ServiceCredentials();
credentials.ClientCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.Custom;
credentials.ClientCertificate.Authentication.TrustedStoreLocation = StoreLocation.LocalMachine;
credentials.ClientCertificate.Authentication.RevocationMode = X509RevocationMode.NoCheck;
credentials.ClientCertificate.Authentication.CustomCertificateValidator = configuration.CertificateValidator.GetChannelValidator();
if (configuration.SecurityConfiguration.ApplicationCertificate != null)
{
X509Certificate2 certificate = configuration.SecurityConfiguration.ApplicationCertificate.Find(true);
if (certificate != null)
{
credentials.ServiceCertificate.Certificate = CertificateFactory.Load(certificate, true);
}
}
this.Description.Behaviors.Add(credentials);
// check if explicitly specified.
ServiceThrottlingBehavior throttle = this.Description.Behaviors.Find<ServiceThrottlingBehavior>();
if (throttle == null)
{
throttle = new ServiceThrottlingBehavior();
throttle.MaxConcurrentCalls = 1000;
throttle.MaxConcurrentInstances = 100;
throttle.MaxConcurrentSessions = 100;
this.Description.Behaviors.Add(throttle);
}
// add the endpoints for each base address.
foreach (Uri baseAddress in this.BaseAddresses)
{
ServiceEndpoint endpoint = null;
// find endpoint configuration.
EndpointDescription description = null;
foreach (EndpointDescription current in endpoints)
{
if (new Uri(current.EndpointUrl) == baseAddress)
{
description = current;
break;
}
}
// skip endpoints without a matching base address.
if (description == null)
{
continue;
}
// set the supported profiles.
description.TransportProfileUri = Profiles.WsHttpXmlOrBinaryTransport;
// create the SOAP XML binding
Binding binding = bindingFactory.Create(baseAddress.Scheme, description, endpointConfiguration);
// add the session endpoint.
endpoint = this.AddServiceEndpoint(contractType, binding, baseAddress, baseAddress);
// set the protection level
if (securityMode == MessageSecurityMode.Sign)
{
endpoint.Contract.ProtectionLevel = System.Net.Security.ProtectionLevel.Sign;
}
// update the max items in graph (set to an low value by default).
foreach (OperationDescription operation in endpoint.Contract.Operations)
{
operation.Behaviors.Find<DataContractSerializerOperationBehavior>().MaxItemsInObjectGraph = Int32.MaxValue;
}
}
}
/// <summary>
/// Creates a new UA-binary transport channel if requested. Null otherwise.
/// </summary>
/// <param name="configuration">The application configuration.</param>
/// <param name="description">The description for the endpoint.</param>
/// <param name="endpointConfiguration">The configuration to use with the endpoint.</param>
/// <param name="clientCertificate">The client certificate.</param>
/// <param name="messageContext">The message context to use when serializing the messages.</param>
/// <returns></returns>
public static ITransportChannel CreateUaBinaryChannel(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
X509Certificate2 clientCertificate,
ServiceMessageContext messageContext)
{
bool useUaTcp = description.EndpointUrl.StartsWith(Utils.UriSchemeOpcTcp);
bool useHttps = description.EndpointUrl.StartsWith(Utils.UriSchemeHttps);
switch (description.TransportProfileUri)
{
case Profiles.UaTcpTransport:
{
useUaTcp = true;
break;
}
case Profiles.HttpsBinaryTransport:
{
useHttps = true;
break;
}
}
// note: WCF channels are not supported
if (!useUaTcp && !useHttps)
{
throw ServiceResultException.Create(
StatusCodes.BadServiceUnsupported,
"Unsupported transport profile\r\n");
}
// initialize the channel which will be created with the server.
ITransportChannel channel = null;
// create a UA-TCP channel.
TransportChannelSettings settings = new TransportChannelSettings();
settings.Description = description;
settings.Configuration = endpointConfiguration;
settings.ClientCertificate = clientCertificate;
if (description.ServerCertificate != null && description.ServerCertificate.Length > 0)
{
settings.ServerCertificate = Utils.ParseCertificateBlob(description.ServerCertificate);
}
if (configuration != null)
{
settings.CertificateValidator = configuration.CertificateValidator.GetChannelValidator();
}
settings.NamespaceUris = messageContext.NamespaceUris;
settings.Factory = messageContext.Factory;
if (useUaTcp)
{
if (g_CustomTransportChannel != null)
{
channel = g_CustomTransportChannel.Create();
}
else
{
channel = new TcpTransportChannel();
}
}
else if (useHttps)
{
channel = new HttpsTransportChannel();
}
channel.Initialize(new Uri(description.EndpointUrl), settings);
channel.Open();
return channel;
}
/// <summary>
/// Initializes the object with its default endpoint configuration.
/// </summary>
public ConfiguredEndpointCollection(EndpointConfiguration configuration)
{
Initialize();
m_defaultConfiguration = (EndpointConfiguration)configuration.MemberwiseClone();
}
/// <summary>
/// Creates a binding for to use for discovering servers.
/// </summary>
/// <param name="discoveryUrl">The discovery URL.</param>
/// <param name="configuration">The configuration.</param>
/// <returns></returns>
public static DiscoveryClient Create(
Uri discoveryUrl,
EndpointConfiguration configuration)
{
return(DiscoveryClient.Create(discoveryUrl, configuration, null));
}
/// <summary>
/// Creates a new transport channel that supports the IDiscoveryChannel service contract.
/// </summary>
/// <param name="discoveryUrl">The discovery URL.</param>
/// <param name="bindingFactory">The binding factory.</param>
/// <param name="endpointConfiguration">The endpoint configuration.</param>
/// <param name="messageContext">The message context.</param>
/// <returns></returns>
public static ITransportChannel Create(
Uri discoveryUrl,
BindingFactory bindingFactory,
EndpointConfiguration endpointConfiguration,
ServiceMessageContext messageContext)
{
// create a dummy description.
EndpointDescription endpoint = new EndpointDescription();
endpoint.EndpointUrl = discoveryUrl.ToString();
endpoint.SecurityMode = MessageSecurityMode.None;
endpoint.SecurityPolicyUri = SecurityPolicies.None;
endpoint.Server.ApplicationUri = endpoint.EndpointUrl;
endpoint.Server.ApplicationType = ApplicationType.DiscoveryServer;
ITransportChannel channel = CreateUaBinaryChannel(
null,
endpoint,
endpointConfiguration,
(System.Security.Cryptography.X509Certificates.X509Certificate2)null,
messageContext);
// create a WCF XML channel.
if (channel == null)
{
Binding binding = bindingFactory.Create(discoveryUrl.Scheme, endpointConfiguration);
DiscoveryChannel wcfXmlChannel = new DiscoveryChannel();
wcfXmlChannel.Initialize(
endpoint,
endpointConfiguration,
binding,
null);
channel = wcfXmlChannel;
}
return channel;
}
public static DiscoveryChannel Create(
Uri discoveryUrl,
EndpointConfiguration configuration,
Binding binding,
string configurationName)
{
// create a dummy description.
EndpointDescription endpoint = new EndpointDescription();
endpoint.EndpointUrl = discoveryUrl.ToString();
endpoint.SecurityMode = MessageSecurityMode.None;
endpoint.SecurityPolicyUri = SecurityPolicies.None;
endpoint.Server.ApplicationUri = endpoint.EndpointUrl;
endpoint.Server.ApplicationType = ApplicationType.DiscoveryServer;
DiscoveryChannel channel = new DiscoveryChannel();
channel.Initialize(
endpoint,
configuration,
binding,
configurationName);
return channel;
}
/// <summary>
/// Creates a new UA-binary transport channel if requested. Null otherwise.
/// </summary>
/// <param name="configuration">The application configuration.</param>
/// <param name="description">The description for the endpoint.</param>
/// <param name="endpointConfiguration">The configuration to use with the endpoint.</param>
/// <param name="clientCertificate">The client certificate.</param>
/// <param name="messageContext">The message context to use when serializing the messages.</param>
/// <returns></returns>
public static ITransportChannel CreateUaBinaryChannel(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
X509Certificate2 clientCertificate,
ServiceMessageContext messageContext)
{
// check if the server if configured to use the ANSI C stack.
bool useUaTcp = description.EndpointUrl.StartsWith(Utils.UriSchemeOpcTcp);
bool useHttps = description.EndpointUrl.StartsWith(Utils.UriSchemeHttps);
bool useAnsiCStack = false;
switch (description.TransportProfileUri)
{
case Profiles.UaTcpTransport:
{
useUaTcp = true;
if (configuration != null)
{
useAnsiCStack = configuration.UseNativeStack;
}
break;
}
case Profiles.HttpsXmlTransport:
case Profiles.HttpsBinaryTransport:
case Profiles.HttpsXmlOrBinaryTransport:
{
useHttps = true;
break;
}
}
// note: WCF channels are not supported
if (!useUaTcp && !useHttps)
{
throw ServiceResultException.Create(
StatusCodes.BadServiceUnsupported,
"Unsupported transport profile\r\n");
}
// initialize the channel which will be created with the server.
ITransportChannel channel = null;
// create a UA-TCP channel.
TransportChannelSettings settings = new TransportChannelSettings();
settings.Description = description;
settings.Configuration = endpointConfiguration;
settings.ClientCertificate = clientCertificate;
if (description.ServerCertificate != null && description.ServerCertificate.Length > 0)
{
settings.ServerCertificate = Utils.ParseCertificateBlob(description.ServerCertificate);
}
if (configuration != null)
{
settings.CertificateValidator = configuration.CertificateValidator.GetChannelValidator();
}
settings.NamespaceUris = messageContext.NamespaceUris;
settings.Factory = messageContext.Factory;
if (useUaTcp)
{
Type type = null;
if (useAnsiCStack)
{
type = Type.GetType("Opc.Ua.NativeStack.NativeStackChannel,Opc.Ua.NativeStackWrapper");
}
if (useAnsiCStack && type != null)
{
channel = (ITransportChannel)Activator.CreateInstance(type);
}
else
{
channel = new Opc.Ua.Bindings.TcpTransportChannel();
}
}
else if (useHttps)
{
channel = new Opc.Ua.Bindings.HttpsTransportChannel();
}
channel.Initialize(new Uri(description.EndpointUrl), settings);
channel.Open();
return channel;
}
/// <summary>
/// Creates a new transport channel that supports the ISessionChannel service contract.
/// </summary>
/// <param name="discoveryUrl">The discovery url.</param>
/// <param name="endpointConfiguration">The configuration to use with the endpoint.</param>
/// <param name="messageContext">The message context to use when serializing the messages.</param>
/// <returns></returns>
public static ITransportChannel Create(
Uri discoveryUrl,
EndpointConfiguration endpointConfiguration,
ServiceMessageContext messageContext)
{
// create a dummy description.
EndpointDescription endpoint = new EndpointDescription();
endpoint.EndpointUrl = discoveryUrl.ToString();
endpoint.SecurityMode = MessageSecurityMode.None;
endpoint.SecurityPolicyUri = SecurityPolicies.None;
endpoint.Server.ApplicationUri = endpoint.EndpointUrl;
endpoint.Server.ApplicationType = ApplicationType.DiscoveryServer;
ITransportChannel channel = CreateUaBinaryChannel(
null,
endpoint,
endpointConfiguration,
(System.Security.Cryptography.X509Certificates.X509Certificate2)null,
messageContext);
return channel;
}
/// <summary>
/// Creates a new UA-binary transport channel if requested. Null otherwise.
/// </summary>
/// <param name="configuration">The application configuration.</param>
/// <param name="description">The description for the endpoint.</param>
/// <param name="endpointConfiguration">The configuration to use with the endpoint.</param>
/// <param name="clientCertificate">The client certificate.</param>
/// <param name="messageContext">The message context to use when serializing the messages.</param>
/// <returns></returns>
public static ITransportChannel CreateUaBinaryChannel(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
X509Certificate2 clientCertificate,
ServiceMessageContext messageContext)
{
// check if the server if configured to use the ANSI C stack.
bool useUaTcp = description.EndpointUrl.StartsWith(Utils.UriSchemeOpcTcp);
bool useHttps = description.EndpointUrl.StartsWith(Utils.UriSchemeHttps);
bool useAnsiCStack = false;
switch (description.TransportProfileUri)
{
case Profiles.UaTcpTransport:
{
useUaTcp = true;
if (configuration != null)
{
useAnsiCStack = configuration.UseNativeStack;
}
break;
}
case Profiles.HttpsXmlTransport:
case Profiles.HttpsBinaryTransport:
case Profiles.HttpsXmlOrBinaryTransport:
{
useHttps = true;
break;
}
}
// note: WCF channels are not supported
if (!useUaTcp && !useHttps)
{
throw ServiceResultException.Create(
StatusCodes.BadServiceUnsupported,
"Unsupported transport profile\r\n");
}
// initialize the channel which will be created with the server.
ITransportChannel channel = null;
// create a UA-TCP channel.
TransportChannelSettings settings = new TransportChannelSettings();
settings.Description = description;
settings.Configuration = endpointConfiguration;
settings.ClientCertificate = clientCertificate;
if (description.ServerCertificate != null && description.ServerCertificate.Length > 0)
{
settings.ServerCertificate = Utils.ParseCertificateBlob(description.ServerCertificate);
}
if (configuration != null)
{
settings.CertificateValidator = configuration.CertificateValidator.GetChannelValidator();
}
settings.NamespaceUris = messageContext.NamespaceUris;
settings.Factory = messageContext.Factory;
if (useUaTcp)
{
Type type = null;
if (useAnsiCStack)
{
type = Type.GetType("Opc.Ua.NativeStack.NativeStackChannel,Opc.Ua.NativeStackWrapper");
}
if (useAnsiCStack && type != null)
{
channel = (ITransportChannel)Activator.CreateInstance(type);
}
else
{
channel = new Opc.Ua.Bindings.TcpTransportChannel();
}
}
else if (useHttps)
{
channel = new Opc.Ua.Bindings.HttpsTransportChannel();
}
channel.Initialize(new Uri(description.EndpointUrl), settings);
channel.Open();
return(channel);
}
/// <summary>
/// Creates a session binding for the specified URI scheme.
/// </summary>
/// <param name="uriScheme">The URI scheme.</param>
/// <param name="description">The description.</param>
/// <param name="configuration">The configuration.</param>
/// <returns></returns>
public virtual Binding Create(
string uriScheme,
EndpointDescription description,
EndpointConfiguration configuration)
{
if (uriScheme == null) throw new ArgumentNullException("uriScheme");
Type bindingType = null;
if (!m_bindings.TryGetValue(uriScheme, out bindingType))
{
throw ServiceResultException.Create(StatusCodes.BadInvalidArgument, "Could not find binding type for scheme: '{0}'.", uriScheme);
}
try
{
return (Binding)Activator.CreateInstance(bindingType, m_namespaceUris, m_factory, configuration, description);
}
catch (Exception e)
{
throw ServiceResultException.Create(StatusCodes.BadInvalidArgument, e, "An session binding for type '{0}' could not be created from the EndpointDescription and the EndpointConfiguration.", bindingType.FullName);
}
}
/// <summary>
/// Returns true if the configuration is the same as the default.
/// </summary>
private bool SameAsDefaults(EndpointConfiguration defaultConfiguration, EndpointConfiguration currentConfiguration)
{
if (defaultConfiguration.ChannelLifetime != currentConfiguration.ChannelLifetime)
{
return false;
}
if (defaultConfiguration.MaxArrayLength != currentConfiguration.MaxArrayLength)
{
return false;
}
if (defaultConfiguration.MaxBufferSize != currentConfiguration.MaxBufferSize)
{
return false;
}
if (defaultConfiguration.MaxByteStringLength != currentConfiguration.MaxByteStringLength)
{
return false;
}
if (defaultConfiguration.MaxMessageSize != currentConfiguration.MaxMessageSize)
{
return false;
}
if (defaultConfiguration.MaxStringLength != currentConfiguration.MaxStringLength)
{
return false;
}
if (defaultConfiguration.OperationTimeout != currentConfiguration.OperationTimeout)
{
return false;
}
if (defaultConfiguration.SecurityTokenLifetime != currentConfiguration.SecurityTokenLifetime)
{
return false;
}
if (defaultConfiguration.UseBinaryEncoding != currentConfiguration.UseBinaryEncoding)
{
return false;
}
return true;
}
public static SessionChannel Create(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
string configurationName)
{
return Create(configuration, description, endpointConfiguration, BindingFactory.Default, null, configurationName);
}
public static SessionChannel Create(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
X509Certificate2 clientCertificate)
{
return Create(configuration, description, endpointConfiguration, BindingFactory.Default, clientCertificate, null);
}
/// <summary>
/// Creates a new UA-binary transport channel if requested. Null otherwise.
/// </summary>
/// <param name="configuration">The application configuration.</param>
/// <param name="description">The description for the endpoint.</param>
/// <param name="endpointConfiguration">The configuration to use with the endpoint.</param>
/// <param name="clientCertificate">The client certificate.</param>
/// <param name="clientCertificateChain">The client certificate chain.</param>
/// <param name="messageContext">The message context to use when serializing the messages.</param>
/// <returns></returns>
public static ITransportChannel CreateUaBinaryChannel(
ApplicationConfiguration configuration,
EndpointDescription description,
EndpointConfiguration endpointConfiguration,
X509Certificate2 clientCertificate,
X509Certificate2Collection clientCertificateChain,
ServiceMessageContext messageContext)
{
string uriScheme = new Uri(description.EndpointUrl).Scheme;
switch (description.TransportProfileUri)
{
case Profiles.UaTcpTransport:
{
uriScheme = Utils.UriSchemeOpcTcp;
break;
}
case Profiles.HttpsBinaryTransport:
{
uriScheme = Utils.UriSchemeHttps;
break;
}
case Profiles.UaWssTransport:
{
uriScheme = Utils.UriSchemeOpcWss;
break;
}
}
// initialize the channel which will be created with the server.
ITransportChannel channel = TransportBindings.Channels.GetChannel(uriScheme);
if (channel == null)
{
throw ServiceResultException.Create(
StatusCodes.BadProtocolVersionUnsupported,
"Unsupported transport profile for scheme {0}.", uriScheme);
}
// create a UA-TCP channel.
TransportChannelSettings settings = new TransportChannelSettings {
Description = description,
Configuration = endpointConfiguration,
ClientCertificate = clientCertificate,
ClientCertificateChain = clientCertificateChain
};
if (description.ServerCertificate != null && description.ServerCertificate.Length > 0)
{
settings.ServerCertificate = Utils.ParseCertificateBlob(description.ServerCertificate);
}
if (configuration != null)
{
settings.CertificateValidator = configuration.CertificateValidator.GetChannelValidator();
}
settings.NamespaceUris = messageContext.NamespaceUris;
settings.Factory = messageContext.Factory;
channel.Initialize(new Uri(description.EndpointUrl), settings);
channel.Open();
return(channel);
}
public static DiscoveryChannel Create(Uri discoveryUrl, EndpointConfiguration configuration)
{
return Create(discoveryUrl, configuration, BindingFactory.Default, null);
}
