public static List <List <string> > GetEndpoints(Uri uri)
{
using (DiscoveryClient client = DiscoveryClient.Create(uri))
{
var lst = new List <List <string> >();
EndpointDescriptionCollection endpoints = client.GetEndpoints(null);
if (endpoints.Count > 0)
{
StringBuilder[] arrStrBuilder = new StringBuilder[endpoints.Count];
List <string>[] arrList = new List <string> [endpoints.Count];
for (int ii = 0; ii < endpoints.Count; ii++)
{
arrList[ii] = new List <string>();
arrList[ii].Add(endpoints[ii].EndpointUrl);
arrList[ii].Add(endpoints[ii].SecurityPolicyUri.Substring(
endpoints[ii].SecurityPolicyUri.LastIndexOf('#') + 1));
arrList[ii].Add(endpoints[ii].SecurityMode.ToString()); // [None, Sign, SignAndEncrypt]
lst.Add(arrList[ii]);
}
}
return(lst);
}
}
/// <summary>
/// Creates the endpoints and creates the hosts.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="bindingFactory">The binding factory.</param>
/// <param name="serverDescription">The server description.</param>
/// <param name="endpoints">The endpoints.</param>
/// <returns>
/// Returns IList of a host for a UA service which type is <seealso cref="ServiceHost"/>.
/// </returns>
protected override IList <Task> InitializeServiceHosts(
ApplicationConfiguration configuration,
out ApplicationDescription serverDescription,
out EndpointDescriptionCollection endpoints)
{
serverDescription = null;
endpoints = null;
Dictionary <string, Task> hosts = new Dictionary <string, Task>();
// ensure at least one security policy exists.
if (configuration.ServerConfiguration.SecurityPolicies.Count == 0)
{
configuration.ServerConfiguration.SecurityPolicies.Add(new ServerSecurityPolicy());
}
// ensure at least one user token policy exists.
if (configuration.ServerConfiguration.UserTokenPolicies.Count == 0)
{
UserTokenPolicy userTokenPolicy = new UserTokenPolicy();
userTokenPolicy.TokenType = UserTokenType.Anonymous;
userTokenPolicy.PolicyId = userTokenPolicy.TokenType.ToString();
configuration.ServerConfiguration.UserTokenPolicies.Add(userTokenPolicy);
}
// set server description.
serverDescription = new ApplicationDescription();
serverDescription.ApplicationUri = configuration.ApplicationUri;
serverDescription.ApplicationName = new LocalizedText("en-US", configuration.ApplicationName);
serverDescription.ApplicationType = configuration.ApplicationType;
serverDescription.ProductUri = configuration.ProductUri;
serverDescription.DiscoveryUrls = GetDiscoveryUrls();
endpoints = new EndpointDescriptionCollection();
IList <EndpointDescription> endpointsForHost = null;
// create UA TCP host.
endpointsForHost = CreateUaTcpServiceHost(
hosts,
configuration,
configuration.ServerConfiguration.BaseAddresses,
serverDescription,
configuration.ServerConfiguration.SecurityPolicies);
endpoints.InsertRange(0, endpointsForHost);
// create HTTPS host.
endpointsForHost = CreateHttpsServiceHost(
hosts,
configuration,
configuration.ServerConfiguration.BaseAddresses,
serverDescription,
configuration.ServerConfiguration.SecurityPolicies);
endpoints.AddRange(endpointsForHost);
return(new List <Task>(hosts.Values));
}
public List <EndpointDes> FindServer(string serverUrl)
{
List <EndpointDes> endpointListView = new List <EndpointDes>();
_EndpointDescriptions.Clear();
ApplicationDescriptionCollection servers = uAClient.FindServers(serverUrl);
foreach (ApplicationDescription ad in servers)
{
foreach (string url in ad.DiscoveryUrls)
{
EndpointDescriptionCollection endpoints = uAClient.GetEndpoints(url);
foreach (EndpointDescription ep in endpoints)
{
string securityPolicy = ep.SecurityPolicyUri.Remove(0, 42);
EndpointDes endpointDes = new EndpointDes()
{
ID = Guid.NewGuid().ToString(),
Description = "[" + ad.ApplicationName + "] " + " [" + ep.SecurityMode + "] " + " [" + securityPolicy + "] " + " [" + ep.EndpointUrl + "]",
OpcEndpointDescription = ep
};
endpointListView.Add(endpointDes);
_EndpointDescriptions.Add(endpointDes.ID, endpointDes);
}
}
}
return(endpointListView);
}
private List <EndpointDescription> ListEndpoints(string serverUrl)
{
List <EndpointDescription> endPointsList = new List <EndpointDescription>();
try
{
ApplicationDescriptionCollection servers = FindServers(serverUrl);
foreach (ApplicationDescription ad in servers)
{
foreach (string url in ad.DiscoveryUrls)
{
EndpointDescriptionCollection endpoints = GetEndpoints(url);
foreach (EndpointDescription ep in endpoints)
{
endPointsList.Add(ep);
}
}
}
}
catch (Exception ex)
{
endPointsList?.Clear();
endPointsList = null;
System.Diagnostics.Debug.WriteLine("OpcUaClient::ListEndpoints" + ex.Message);
}
return(endPointsList);
}
/// <summary>
/// Fetches the servers from the discovery server.
/// </summary>
private bool DiscoverEndpoints(Uri discoveryUrl)
{
// use a short timeout.
EndpointConfiguration configuration = EndpointConfiguration.Create(m_configuration);
configuration.OperationTimeout = m_discoveryTimeout;
DiscoveryClient client = DiscoveryClient.Create(
discoveryUrl,
BindingFactory.Create(m_configuration, m_configuration.CreateMessageContext()),
EndpointConfiguration.Create(m_configuration));
try
{
EndpointDescriptionCollection endpoints = client.GetEndpoints(null);
OnUpdateEndpoints(endpoints);
return(true);
}
catch (Exception e)
{
Utils.Trace("Could not fetch endpoints from url: {0}. Reason={1}", discoveryUrl, e.Message);
return(false);
}
finally
{
client.Close();
}
}
/// <summary>
/// Starts OPC UA server.
/// </summary>
private async Task StartOpcServer()
{
await opcApp.Start(opcServer);
StringBuilder sbStartInfo = new StringBuilder("OPC UA server started");
EndpointDescriptionCollection endpoints = opcServer.GetEndpoints();
if (endpoints.Count > 0)
{
// print endpoint info
foreach (string endpointUrl in endpoints.Select(e => e.EndpointUrl).Distinct())
{
sbStartInfo.AppendLine().Append(" ").Append(endpointUrl);
}
}
else
{
sbStartInfo.AppendLine().Append(" No endpoints");
}
dsLog.WriteAction(sbStartInfo.ToString());
// add event handlers
ISessionManager sessionManager = opcServer.CurrentInstance.SessionManager;
sessionManager.SessionActivated += SessionManager_SessionEvent;
sessionManager.SessionClosing += SessionManager_SessionEvent;
sessionManager.SessionCreated += SessionManager_SessionEvent;
ISubscriptionManager subscriptionManager = opcServer.CurrentInstance.SubscriptionManager;
subscriptionManager.SubscriptionCreated += SubscriptionManager_SubscriptionEvent;
subscriptionManager.SubscriptionDeleted += SubscriptionManager_SubscriptionEvent;
}
private EndpointDescriptionCollection Discover(string discoveryURL, int operationTimeout)
{
Uri uri = new Uri(discoveryURL);
EndpointConfiguration configuration = EndpointConfiguration.Create();
if (operationTimeout > 0)
{
configuration.OperationTimeout = operationTimeout;
}
var endpoints = new EndpointDescriptionCollection();
using (DiscoveryClient client = DiscoveryClient.Create(uri, configuration))
{
foreach (var got in client.GetEndpoints(null))
{
if (got.EndpointUrl.StartsWith(uri.Scheme))
{
endpoints.Add(got);
}
}
}
return(endpoints);
}
private void EndpointButton_Click(object sender, EventArgs e)
{
endpointListView.Items.Clear();
//The local discovery URL for the discovery server
string discoveryUrl = discoveryTextBox.Text;
try
{
ApplicationDescriptionCollection servers = myClientHelperAPI.FindServers(discoveryUrl);
foreach (ApplicationDescription ad in servers)
{
foreach (string url in ad.DiscoveryUrls)
{
EndpointDescriptionCollection endpoints = myClientHelperAPI.GetEndpoints(url);
foreach (EndpointDescription ep in endpoints)
{
string securityPolicy = ep.SecurityPolicyUri.Remove(0, 42);
endpointListView.Items.Add("[" + ad.ApplicationName + "] " + " [" + ep.SecurityMode + "] " + " [" + securityPolicy + "] " + " [" + ep.EndpointUrl + "]").Tag = ep;
}
}
}
}
catch (Exception ex)
{
if (BGW_OPCUA.IsBusy)
{
BGW_OPCUA.CancelAsync();
}
MessageBox.Show(ex.Message, "Error");
}
}
/// <summary>
/// Patch returned endpoints urls with url used to reached the endpoint.
/// </summary>
private EndpointDescriptionCollection PatchEndpointUrls(EndpointDescriptionCollection endpoints)
{
// if a server is behind a firewall, can only be accessed with a FQDN or IP address
// it may return URLs that are not accessible to the client. This problem can be avoided
// by assuming that the domain in the URL used to call GetEndpoints can be used to
// access any of the endpoints. This code patches the returned endpoints accordingly.
Uri endpointUrl = Utils.ParseUri(this.Endpoint.EndpointUrl);
if (endpointUrl != null)
{
// patch discovery Url to endpoint Url used for service call
foreach (EndpointDescription discoveryEndPoint in endpoints)
{
Uri discoveryEndPointUri = Utils.ParseUri(discoveryEndPoint.EndpointUrl);
if (endpointUrl.Scheme == discoveryEndPointUri.Scheme)
{
UriBuilder builder = new UriBuilder(discoveryEndPointUri);
builder.Host = endpointUrl.DnsSafeHost;
builder.Port = endpointUrl.Port;
discoveryEndPoint.EndpointUrl = builder.ToString();
}
if (discoveryEndPoint.Server != null &&
discoveryEndPoint.Server.DiscoveryUrls != null)
{
discoveryEndPoint.Server.DiscoveryUrls.Clear();
discoveryEndPoint.Server.DiscoveryUrls.Add(this.Endpoint.EndpointUrl.ToString());
}
}
}
return(endpoints);
}
private EndpointDescriptionCollection DiscoverEndpoints(ApplicationConfiguration config, Uri discoveryUrl, int timeout)
{
// use a short timeout.
EndpointConfiguration configuration = EndpointConfiguration.Create(config);
configuration.OperationTimeout = timeout;
using (DiscoveryClient client = DiscoveryClient.Create(
discoveryUrl,
EndpointConfiguration.Create(config)))
{
try
{
EndpointDescriptionCollection endpoints = client.GetEndpoints(null);
ReplaceLocalHostWithRemoteHost(endpoints, discoveryUrl);
return(endpoints);
}
catch (Exception e)
{
Console.WriteLine($"Не удалось найти OPC-сервер по адресу: {discoveryUrl}");
Console.WriteLine($"Ошибка = {e.Message}");
throw e;
}
}
}
/// <summary>
/// Displays the dialog.
/// </summary>
public 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.SelectedItem = UseDefaultLimits.Yes;
// discover endpoints in the background.
m_discoverySucceeded = false;
Interlocked.Increment(ref m_discoverCount);
ThreadPool.QueueUserWorkItem(new WaitCallback(OnDiscoverEndpoints), server);
if (ShowDialog() != DialogResult.OK)
{
return(null);
}
return(m_endpoint);
}
private static EndpointDescriptionCollection DiscoverEndpoints(ApplicationConfiguration config, Uri discoveryUrl, int timeout)
{
// use a short timeout.
EndpointConfiguration configuration = EndpointConfiguration.Create(config);
configuration.OperationTimeout = timeout;
using (DiscoveryClient client = DiscoveryClient.Create(
discoveryUrl,
EndpointConfiguration.Create(config)))
{
try
{
EndpointDescriptionCollection endpoints = client.GetEndpoints(null);
ReplaceLocalHostWithRemoteHost(endpoints, discoveryUrl);
return(endpoints);
}
catch (Exception e)
{
Console.WriteLine("Could not fetch endpoints from url: {0}", discoveryUrl);
Console.WriteLine("Reason = {0}", e.Message);
throw e;
}
}
}
private void DiscoveryB_Click(object sender, EventArgs e)
{
bool foundEndpoints = false;
DiscoveredServersLV.Items.Clear();
//Create discovery URL for the discovery client
string serverUrl = null;
if (!String.IsNullOrEmpty(DiscoveryUrlTB.Text) & !String.IsNullOrEmpty(DiscoveryPortTB.Text))
{
serverUrl = "opc.tcp://" + DiscoveryUrlTB.Text + ":" + DiscoveryPortTB.Text;
}
else if (String.IsNullOrEmpty(DiscoveryUrlTB.Text) & !String.IsNullOrEmpty(DiscoveryPortTB.Text))
{
serverUrl = "opc.tcp://localhost:" + DiscoveryPortTB.Text;
}
else if (!String.IsNullOrEmpty(DiscoveryUrlTB.Text) & String.IsNullOrEmpty(DiscoveryPortTB.Text))
{
serverUrl = "opc.tcp://" + DiscoveryUrlTB.Text + ":" + "4840";
}
else
{
serverUrl = "opc.tcp://localhost:4840";
}
//Get the endpoints
try
{
ApplicationDescriptionCollection servers = myHelperApi.FindServers(serverUrl);
foreach (ApplicationDescription ad in servers)
{
foreach (string url in ad.DiscoveryUrls)
{
EndpointDescriptionCollection endpoints = myHelperApi.GetEndpoints(url);
foundEndpoints = foundEndpoints || endpoints.Count > 0;
foreach (EndpointDescription ep in endpoints)
{
string securityPolicy = ep.SecurityPolicyUri.Remove(0, 43);
if (!DiscoveredServersLV.Items.ContainsKey(ep.Server.ApplicationName.Text))
{
string[] row = { ep.Server.ApplicationName.Text, ep.EndpointUrl, ep.SecurityMode + "-" + securityPolicy };
ListViewItem listViewItem = new ListViewItem(row);
DiscoveredServersLV.Items.Add(listViewItem).Tag = ep;
DiscoveredServersLV.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
}
}
}
if (!foundEndpoints)
{
MessageBox.Show("Could not get any Endpoints", "Error");
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error");
}
}
/// <summary>
/// Initializes the protocol dropdown.
/// </summary>
private void InitializeProtocols(EndpointDescriptionCollection endpoints)
{
// preserve the existing value.
string currentProtocol = (string)ProtocolCB.SelectedItem;
ProtocolCB.Items.Clear();
// set all available protocols.
if (m_showAllOptions)
{
ProtocolCB.Items.Add(Utils.UriSchemeHttp);
ProtocolCB.Items.Add(Utils.UriSchemeOpcTcp);
}
// find all unique protocols.
else
{
if (endpoints != null)
{
foreach (EndpointDescription endpoint in endpoints)
{
Uri url = Utils.ParseUri(endpoint.EndpointUrl);
if (url != null)
{
int existingIndex = ProtocolCB.FindStringExact(url.Scheme);
if (existingIndex == -1)
{
ProtocolCB.Items.Add(url.Scheme);
}
}
}
}
// add at least one protocol.
if (ProtocolCB.Items.Count == 0)
{
ProtocolCB.Items.Add(Utils.UriSchemeHttp);
}
}
// set the current value.
int index = 0;
if (!String.IsNullOrEmpty(currentProtocol))
{
index = ProtocolCB.FindStringExact(currentProtocol);
if (index == -1)
{
index = 0;
}
}
ProtocolCB.SelectedIndex = index;
}
/// <summary>
/// Creates the endpoints and creates the hosts.
/// </summary>
/// <param name="configuration">The object that stores the configurable configuration information for a UA application.</param>
/// <param name="serverDescription">The object of the class that contains a description for the ApplicationDescription DataType.</param>
/// <param name="endpoints">The collection of <see cref="EndpointDescription"/> objects.</param>
/// <returns>Returns list of hosts for a UA service.</returns>
protected virtual IList <Task> InitializeServiceHosts(
ApplicationConfiguration configuration,
out ApplicationDescription serverDescription,
out EndpointDescriptionCollection endpoints)
{
serverDescription = null;
endpoints = null;
return(new List <Task>());
}
/// <summary>
/// Create channel
/// </summary>
/// <param name="contextId"></param>
/// <param name="listener"></param>
/// <param name="bufferManager"></param>
/// <param name="quotas"></param>
/// <param name="serverCertificate"></param>
/// <param name="serverCertificateChain"></param>
/// <param name="endpoints"></param>
public SecureChannel(string contextId, ITcpChannelListener listener,
BufferManager bufferManager, ChannelQuotas quotas,
X509Certificate2 serverCertificate,
X509Certificate2Collection serverCertificateChain,
EndpointDescriptionCollection endpoints) :
base(contextId, listener, bufferManager, quotas, serverCertificate,
serverCertificateChain, endpoints)
{
_endpoints = endpoints;
}
/// <summary>
/// Attaches the object to an existing socket.
/// </summary>
public TcpReverseConnectChannel(
string contextId,
ITcpChannelListener listener,
BufferManager bufferManager,
ChannelQuotas quotas,
EndpointDescriptionCollection endpoints)
:
base(contextId, listener, bufferManager, quotas, null, null, endpoints)
{
}
/// <summary>
/// Attaches the object to an existing socket.
/// </summary>
public TcpListenerChannel(
string contextId,
ITcpChannelListener listener,
BufferManager bufferManager,
ChannelQuotas quotas,
X509Certificate2 serverCertificate,
EndpointDescriptionCollection endpoints)
:
this(contextId, listener, bufferManager, quotas, serverCertificate, null, endpoints)
{
}
/// <summary>
/// Starts the server (called from a IIS host process).
/// </summary>
/// <param name="configuration">The object that stores the configurable configuration information
/// for a UA application</param>
/// <param name="baseAddresses">The array of Uri elements which contains base addresses.</param>
/// <returns>Returns a host for a UA service.</returns>
public Task Start(ApplicationConfiguration configuration, params Uri[] baseAddresses)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
// do any pre-startup processing
OnServerStarting(configuration);
// intialize the request queue from the configuration.
InitializeRequestQueue(configuration);
// initialize the server capabilities
ServerCapabilities = configuration.ServerConfiguration.ServerCapabilities;
// initialize the base addresses.
InitializeBaseAddresses(configuration);
// initialize the hosts.
ApplicationDescription serverDescription = null;
EndpointDescriptionCollection endpoints = null;
IList <Task> hosts = InitializeServiceHosts(
configuration,
out serverDescription,
out endpoints);
// save discovery information.
ServerDescription = serverDescription;
m_endpoints = new ReadOnlyList <EndpointDescription>(endpoints);
// start the application.
StartApplication(configuration);
// the configuration file may specify multiple security policies or non-HTTP protocols
// which will require multiple service hosts. the default host will be opened by WCF when
// it is returned from this function. The others must be opened here.
if (hosts == null || hosts.Count == 0)
{
throw ServiceResultException.Create(StatusCodes.BadConfigurationError, "The UA server does not have a default host.");
}
lock (m_hosts)
{
for (int ii = 1; ii < hosts.Count; ii++)
{
m_hosts.Add(hosts[ii]);
}
}
return(hosts[0]);
}
public int Connect()
{
try
{
List <object> Listtmp = new List <object>();
ApplicationDescriptionCollection servers = null;
servers = m_Server.FindServers(discoveryUrl.ToString());
//for (int i = 0; i < servers.Count; i++)
//{
// // Create discovery client and get the available endpoints.
EndpointDescriptionCollection endpoints = null;
// string sUrl;
// sUrl = servers[i].DiscoveryUrls[0];
// discoveryUrl = new Uri(sUrl);
endpoints = m_Server.GetEndpoints(discoveryUrl.ToString());
// Create wrapper and fill the combobox.
for (int j = 0; j < endpoints.Count; j++)
{
// Create endpoint wrapper.
EndpointWrapper wrapper = new EndpointWrapper(endpoints[j]);
Listtmp.Add(wrapper);
// Add it to the combobox.
// UrlCB.Items.Add(wrapper);
}
if (Listtmp != null)
{
// Call connect with URL
//m_Server.Connect(Listtmp[0].ToString(), "none", MessageSecurityMode.None, false, "", "");
m_Server.Connect(((EndpointWrapper)Listtmp[0]).Endpoint, false, "", "");
}
else
{
m_Connected = false;
return(-1);
}
//}
//servers[i].ApplicationName;
m_Connected = true;
return(0);
}
catch
{
//MessageBox.Show(ex.Message);
if (m_Connected)
{
// Disconnect from server.
Disconnect();
}
m_Connected = false;
return(-1);
}
}
//private EndpointDescription CreateEndpointDescription(string url, string secPolicy, MessageSecurityMode msgSecMode)
//{
// // create the endpoint description.
// EndpointDescription endpointDescription = new EndpointDescription();
// // submit the url of the endopoint
// endpointDescription.EndpointUrl = url;
// // specify the security policy to use.
// endpointDescription.SecurityPolicyUri = secPolicy;
// endpointDescription.SecurityMode = msgSecMode;
// // specify the transport profile.
// endpointDescription.TransportProfileUri = Profiles.UaTcpTransport;
// return endpointDescription;
//}
//url="opc.tcp://192.168.0.15:4840"
private EndpointDescription getEndpointDescription(string url)
{
EndpointDescription ret = null;
EndpointDescriptionCollection endpoints = myClientHelperAPI.GetEndpoints(url);
if (endpoints != null && endpoints.Count > 0)
{
ret = endpoints[0];
}
return(ret);
}
public async Task GetEndpoints()
{
var endpointConfiguration = EndpointConfiguration.Create();
endpointConfiguration.OperationTimeout = 10000;
using (var client = DiscoveryClient.Create(m_url, endpointConfiguration))
{
m_endpoints = await client.GetEndpointsAsync(null).ConfigureAwait(false);
}
}
/// <summary>
/// Attaches the object to an existing socket.
/// </summary>
public UaSCUaBinaryChannel(
string contextId,
BufferManager bufferManager,
ChannelQuotas quotas,
X509Certificate2 serverCertificate,
EndpointDescriptionCollection endpoints,
MessageSecurityMode securityMode,
string securityPolicyUri)
:
this(contextId, bufferManager, quotas, serverCertificate, null, endpoints, securityMode, securityPolicyUri)
{
}
protected void GetEnpoints_Click(object sender, EventArgs e)
{
if (discoveryTextBox.Text != "")
{
bool foundEndpoints = false;
endpointListView.Items.Clear();
Session["Urltext"] = discoveryTextBox.Text;
//The local discovery URL for the discovery server
string discoveryUrl = discoveryTextBox.Text;
try
{
ApplicationDescriptionCollection servers = myClientHelperAPI.FindServers(discoveryUrl);
foreach (ApplicationDescription ad in servers)
{
foreach (string url in ad.DiscoveryUrls)
{
try
{
EndpointDescriptionCollection endpoints = myClientHelperAPI.GetEndpoints(url);
foundEndpoints = foundEndpoints || endpoints.Count > 0;
List <string> enps = new List <string>();
foreach (EndpointDescription ep in endpoints)
{
string securityPolicy = ep.SecurityPolicyUri.Remove(0, 42);
string key = "[" + ad.ApplicationName + "] " + " [" + ep.SecurityMode + "] " + " [" + securityPolicy + "] " + " [" + ep.EndpointUrl + "]";
enps.Add(key);
endpointListView.Items.Add(key);
}
Session["endpointlist"] = enps;
}
catch (ServiceResultException sre)
{
//If an url in ad.DiscoveryUrls can not be reached, myClientHelperAPI will throw an Exception
ClientScript.RegisterStartupScript(this.GetType(), "Alert", "mess('error','Oops...'," + sre.ToString() + ")", true);
}
}
if (!foundEndpoints)
{
ClientScript.RegisterStartupScript(this.GetType(), "Alert", "mess('warning','Oops...','Could not get any Endpoints!')", true);
}
}
}
catch (Exception ex)
{
ClientScript.RegisterStartupScript(this.GetType(), "Alert", "mess('error','Oops...'," + ex.ToString() + ")", true);
}
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "Alert", "mess('warning','Warning...','You forget write endpoint Url!')", true);
}
}
/// <summary>
/// Attaches the object to an existing socket.
/// </summary>
public TcpServerChannel(
string contextId,
UaTcpChannelListener listener,
BufferManager bufferManager,
TcpChannelQuotas quotas,
X509Certificate2 serverCertificate,
EndpointDescriptionCollection endpoints)
:
base(contextId, bufferManager, quotas, serverCertificate, endpoints, MessageSecurityMode.None, SecurityPolicies.None)
{
m_listener = listener;
m_queuedResponses = new SortedDictionary<uint,IServiceResponse>();
}
private static void ReplaceLocalHostWithRemoteHost(EndpointDescriptionCollection endpoints, Uri discoveryUrl)
{
foreach (EndpointDescription endpoint in endpoints)
{
endpoint.EndpointUrl = Utils.ReplaceLocalhost(endpoint.EndpointUrl, discoveryUrl.DnsSafeHost);
StringCollection updatedDiscoveryUrls = new StringCollection();
foreach (string url in endpoint.Server.DiscoveryUrls)
{
updatedDiscoveryUrls.Add(Utils.ReplaceLocalhost(url, discoveryUrl.DnsSafeHost));
}
endpoint.Server.DiscoveryUrls = updatedDiscoveryUrls;
}
}
/// <summary>
/// Attaches the object to an existing socket.
/// </summary>
public TcpServerChannel(
string contextId,
UaTcpChannelListener listener,
BufferManager bufferManager,
TcpChannelQuotas quotas,
X509Certificate2 serverCertificate,
EndpointDescriptionCollection endpoints)
:
base(contextId, bufferManager, quotas, serverCertificate, endpoints, MessageSecurityMode.None, SecurityPolicies.None)
{
m_listener = listener;
m_queuedResponses = new SortedDictionary <uint, IServiceResponse>();
}
/// <summary>
/// Invokes the GetEndpoints service.
/// </summary>
/// <param name="profileUris">The collection of profile URIs.</param>
/// <returns></returns>
public virtual EndpointDescriptionCollection GetEndpoints(StringCollection profileUris)
{
EndpointDescriptionCollection endpoints = null;
GetEndpoints(
null,
this.Endpoint.EndpointUrl,
null,
profileUris,
out endpoints);
return(PatchEndpointUrls(endpoints));
}
private async Task MainTask()
{
ApplicationInstance application = new ApplicationInstance
{
ApplicationName = "UA Console Client",
ApplicationType = ApplicationType.Client,
ConfigSectionName = "UaConsoleClient"
};
// load the application configuration.
ApplicationConfiguration config = await application.LoadApplicationConfiguration(false);
// check the application certificate.
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, 0);
if (!haveAppCertificate)
{
throw new Exception("Application instance certificate invalid!");
}
if (haveAppCertificate)
{
config.ApplicationUri = Utils.GetApplicationUriFromCertificate(config.SecurityConfiguration.ApplicationCertificate.Certificate);
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
autoAccept = true;
}
config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
else
{
Console.WriteLine(" WARN: missing application certificate, using unsecure connection.");
}
using (DiscoveryClient client = DiscoveryClient.Create(new Uri("opc.tcp://localhost:4840")))
{
EndpointDescriptionCollection endpoints = client.GetEndpoints(null);
for (int ii = 0; ii < endpoints.Count; ii++)
{
Console.WriteLine("Endpoint #{0}:", ii);
Console.WriteLine(endpoints[ii].EndpointUrl);
Console.WriteLine(endpoints[ii].SecurityPolicyUri.Substring(
endpoints[ii].SecurityPolicyUri.LastIndexOf('#') + 1));
Console.WriteLine(endpoints[ii].SecurityMode.ToString()); // [None, Sign, SignAndEncrypt]
}
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
/// <summary>
/// Reads the endpoints for a server.
/// </summary>
private ConfiguredEndpointCollection GetEndpoints(ConfiguredEndpoint endpoint)
{
// some protocols will require a seperate endpoint for the discovery endpoints.
List <Uri> urlsToTry = new List <Uri>();
foreach (string discoveryUrl in endpoint.Description.Server.DiscoveryUrls)
{
urlsToTry.Add(new Uri(discoveryUrl));
}
urlsToTry.Add(endpoint.EndpointUrl);
// servers that do not support using the same endpoint for discovery and sessions should
// use the convention where the discovery endpoint is constructed by appending "/discovery";
if (endpoint.EndpointUrl.Scheme != Utils.UriSchemeOpcTcp)
{
urlsToTry.Add(new Uri(endpoint.EndpointUrl.ToString() + "/discovery"));
}
for (int ii = 0; ii < urlsToTry.Count; ii++)
{
// the discovery client provides a programmer's interace to a discovery server.
DiscoveryClient client = DiscoveryClient.Create(urlsToTry[ii], m_bindingFactory, null);
try {
// fetch the endpoints from the server.
EndpointDescriptionCollection endpoints = client.GetEndpoints(null);
// add endpoints to cache.
ConfiguredEndpointCollection endpointCache = new ConfiguredEndpointCollection();
foreach (EndpointDescription description in endpoints)
{
endpointCache.Add(description, endpoint.Configuration);
}
return(endpointCache);
} catch (Exception) {
Report("No discovery endpoint found at: {0}", urlsToTry[ii]);
} finally {
// must always close the channel to free resources.
client.Close();
}
}
// nothing found.
throw ServiceResultException.Create(
StatusCodes.BadUnexpectedError,
"Could not find discovery endpoint for server at: {0}",
endpoint);
}
public void RetrieveEndpointsAndPopulateLV()
{
EndpointDescriptionCollection endpointDescCol = new EndpointDescriptionCollection();
XmlNodeList endpointNodes = myDoc.SelectSingleNode("//Endpoints").SelectNodes("//Endpoint");
XmlNodeList ipConfig = myDoc.SelectSingleNode("//Endpoints").SelectNodes("//IpConfig");
foreach (XmlNode node in endpointNodes)
{
EndpointDescription epDesc = new EndpointDescription();
epDesc.EndpointUrl = node.SelectSingleNode("url").InnerText;
epDesc.Server.ApplicationName = node.SelectSingleNode("serverName").InnerText;
string[] secMode = node.SelectSingleNode("securityMode").InnerText.Split('-');
epDesc.SecurityPolicyUri = "http://opcfoundation.org/UA/SecurityPolicy#" + secMode[0];
if (secMode[1].Equals("SignAndEncrypt"))
{
epDesc.SecurityMode = MessageSecurityMode.SignAndEncrypt;
}
else if (secMode[1].Equals("Sign"))
{
epDesc.SecurityMode = MessageSecurityMode.Sign;
}
else if (secMode[1].Equals("None"))
{
epDesc.SecurityMode = MessageSecurityMode.None;
}
else
{
epDesc.SecurityMode = MessageSecurityMode.Invalid;
}
endpointDescCol.Add(epDesc);
}
RecentEndpointsLV.Items.Clear();
foreach (EndpointDescription ep in endpointDescCol)
{
string securityPolicy = ep.SecurityPolicyUri.Remove(0, 43);
string[] row = { ep.Server.ApplicationName.Text, ep.EndpointUrl, ep.SecurityMode + "-" + securityPolicy };
ListViewItem listViewItem = new ListViewItem(row);
RecentEndpointsLV.Items.Add(listViewItem).Tag = ep;
RecentEndpointsLV.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
}
if (ipConfig[0].ChildNodes.Count > 0)
{
DiscoveryUrlTB.Text = ipConfig[0].SelectSingleNode("IP").InnerText;
DiscoveryPortTB.Text = ipConfig[0].SelectSingleNode("Port").InnerText;
}
}
/// <summary>
/// Displays the dialog.
/// </summary>
public ITransportChannel ShowDialog(
ApplicationConfiguration configuration,
EndpointDescriptionCollection endpoints)
{
if (endpoints == null) throw new ArgumentNullException("endpoints");
if (configuration == null) throw new ArgumentNullException("configuration");
m_endpoints = endpoints;
m_configuration = configuration;
m_messageContext = configuration.CreateMessageContext();
EndpointCB.Items.Clear();
foreach (EndpointDescription endpoint in endpoints)
{
EndpointCB.Items.Add(endpoint.EndpointUrl);
}
if (EndpointCB.Items.Count > 0)
{
EndpointCB.SelectedIndex = 0;
}
OperationTimeoutNC.Value = configuration.TransportQuotas.OperationTimeout;
MaxMessageSizeNC.Value = configuration.TransportQuotas.MaxMessageSize;
MaxArrayLengthNC.Value = configuration.TransportQuotas.MaxArrayLength;
MaxStringLengthNC.Value = configuration.TransportQuotas.MaxStringLength;
MaxByteStringLengthNC.Value = configuration.TransportQuotas.MaxByteStringLength;
if (ShowDialog() != DialogResult.OK)
{
return null;
}
// return the channel.
return m_channel;
}
/// <summary>
/// Creates the endpoints and creates the hosts.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="bindingFactory">The binding factory.</param>
/// <param name="serverDescription">The server description.</param>
/// <param name="endpoints">The endpoints.</param>
/// <returns>
/// Returns IList of a host for a UA service which type is <seealso cref="ServiceHost"/>.
/// </returns>
protected override IList<Task> InitializeServiceHosts(
ApplicationConfiguration configuration,
out ApplicationDescription serverDescription,
out EndpointDescriptionCollection endpoints)
{
serverDescription = null;
endpoints = null;
Dictionary<string, Task> hosts = new Dictionary<string, Task>();
// ensure at least one security policy exists.
if (configuration.ServerConfiguration.SecurityPolicies.Count == 0)
{
configuration.ServerConfiguration.SecurityPolicies.Add(new ServerSecurityPolicy());
}
// ensure at least one user token policy exists.
if (configuration.ServerConfiguration.UserTokenPolicies.Count == 0)
{
UserTokenPolicy userTokenPolicy = new UserTokenPolicy();
userTokenPolicy.TokenType = UserTokenType.Anonymous;
userTokenPolicy.PolicyId = userTokenPolicy.TokenType.ToString();
configuration.ServerConfiguration.UserTokenPolicies.Add(userTokenPolicy);
}
// set server description.
serverDescription = new ApplicationDescription();
serverDescription.ApplicationUri = configuration.ApplicationUri;
serverDescription.ApplicationName = configuration.ApplicationName;
serverDescription.ApplicationType = configuration.ApplicationType;
serverDescription.ProductUri = configuration.ProductUri;
serverDescription.DiscoveryUrls = GetDiscoveryUrls();
endpoints = new EndpointDescriptionCollection();
IList<EndpointDescription> endpointsForHost = null;
// create UA TCP host.
endpointsForHost = CreateUaTcpServiceHost(
hosts,
configuration,
configuration.ServerConfiguration.BaseAddresses,
serverDescription,
configuration.ServerConfiguration.SecurityPolicies);
endpoints.InsertRange(0, endpointsForHost);
// create HTTPS host.
#if !NO_HTTPS
endpointsForHost = CreateHttpsServiceHost(
hosts,
configuration,
configuration.ServerConfiguration.BaseAddresses,
serverDescription,
configuration.ServerConfiguration.SecurityPolicies);
endpoints.AddRange(endpointsForHost);
#endif
return new List<Task>(hosts.Values);
}
/// <summary>
/// Initializes the protocol dropdown.
/// </summary>
private void InitializeProtocols(EndpointDescriptionCollection endpoints)
{
// preserve the existing value.
Protocol currentProtocol = (Protocol)ProtocolCB.SelectedItem;
ProtocolCB.Items.Clear();
// set all available protocols.
if (m_showAllOptions)
{
ProtocolCB.Items.Add(new Protocol("http://localhost"));
ProtocolCB.Items.Add(new Protocol("https://localhost"));
ProtocolCB.Items.Add(new Protocol("opc.tcp://localhost"));
}
// find all unique protocols.
else
{
if (endpoints != null)
{
foreach (EndpointDescription endpoint in endpoints)
{
Uri url = Utils.ParseUri(endpoint.EndpointUrl);
if (url != null)
{
bool found = false;
for (int ii = 0; ii < ProtocolCB.Items.Count; ii++)
{
if (((Protocol)ProtocolCB.Items[ii]).Matches(url))
{
found = true;
break;
}
}
if (!found)
{
ProtocolCB.Items.Add(new Protocol(endpoint));
}
}
}
}
// add at least one protocol.
if (ProtocolCB.Items.Count == 0)
{
ProtocolCB.Items.Add(new Protocol("opc.tcp://localhost"));
}
}
// set the current value.
int index = 0;
if (currentProtocol != null)
{
index = 0;
for (int ii = 0; ii < ProtocolCB.Items.Count; ii++)
{
if (((Protocol)ProtocolCB.Items[ii]).Matches(currentProtocol.Url))
{
index = ii;
break;
}
}
}
ProtocolCB.SelectedIndex = index;
}
/// <summary>
/// Replace localhost in returned discovery url with remote host name.
/// </summary>
private void ReplaceLocalHostWithRemoteHost(EndpointDescriptionCollection endpoints, Uri discoveryUrl)
{
foreach (EndpointDescription endpoint in endpoints)
{
endpoint.EndpointUrl = Utils.ReplaceLocalhost(endpoint.EndpointUrl, discoveryUrl.DnsSafeHost);
StringCollection updatedDiscoveryUrls = new StringCollection();
foreach (string url in endpoint.Server.DiscoveryUrls)
{
updatedDiscoveryUrls.Add(Utils.ReplaceLocalhost(url, discoveryUrl.DnsSafeHost));
}
endpoint.Server.DiscoveryUrls = updatedDiscoveryUrls;
}
}
/// <summary>
/// Create a new service host for UA TCP.
/// </summary>
protected List<EndpointDescription> CreateUaTcpServiceHost(
IDictionary<string, ServiceHost> hosts,
ApplicationConfiguration configuration,
BindingFactory bindingFactory,
IList<string> baseAddresses,
ApplicationDescription serverDescription,
List<ServerSecurityPolicy> securityPolicies)
{
// generate a unique host name.
string hostName = String.Empty;
if (hosts.ContainsKey(hostName))
{
hostName = "/Tcp";
}
if (hosts.ContainsKey(hostName))
{
hostName += Utils.Format("/{0}", hosts.Count);
}
// check if the server if configured to use the ANSI C stack.
bool useAnsiCStack = configuration.UseNativeStack;
// build list of uris.
List<Uri> uris = new List<Uri>();
EndpointDescriptionCollection endpoints = new EndpointDescriptionCollection();
// create the endpoint configuration to use.
EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(configuration);
string computerName = System.Net.Dns.GetHostName();
for (int ii = 0; ii < baseAddresses.Count; ii++)
{
// UA TCP and HTTPS endpoints support multiple policies.
if (!baseAddresses[ii].StartsWith(Utils.UriSchemeOpcTcp, StringComparison.Ordinal))
{
continue;
}
UriBuilder uri = new UriBuilder(baseAddresses[ii]);
if (String.Compare(uri.Host, "localhost", StringComparison.OrdinalIgnoreCase) == 0)
{
uri.Host = computerName;
}
uris.Add(uri.Uri);
foreach (ServerSecurityPolicy policy in securityPolicies)
{
// create the endpoint description.
EndpointDescription description = new EndpointDescription();
description.EndpointUrl = uri.ToString();
description.Server = serverDescription;
description.SecurityMode = policy.SecurityMode;
description.SecurityPolicyUri = policy.SecurityPolicyUri;
description.SecurityLevel = policy.SecurityLevel;
description.UserIdentityTokens = GetUserTokenPolicies( configuration, description );
description.TransportProfileUri = Profiles.UaTcpTransport;
bool requireEncryption = RequireEncryption(description);
if (!requireEncryption)
{
foreach (UserTokenPolicy userTokenPolicy in description.UserIdentityTokens)
{
if (userTokenPolicy.SecurityPolicyUri != SecurityPolicies.None)
{
requireEncryption = true;
break;
}
}
}
if (requireEncryption)
{
description.ServerCertificate = InstanceCertificate.RawData;
//if (InstanceCertificateChain != null)
//{
// List<byte> certificateChainList = new List<byte>();
// for (int i = 0; i < InstanceCertificateChain.Count; i++)
// {
// certificateChainList.AddRange(InstanceCertificateChain[i].RawData);
// }
// description.ServerCertificate = certificateChainList.ToArray();
//}
}
endpoints.Add( description );
}
// create the UA-TCP stack listener.
try
{
TransportListenerSettings settings = new TransportListenerSettings();
settings.Descriptions = endpoints;
settings.Configuration = endpointConfiguration;
settings.ServerCertificate = this.InstanceCertificate;
//settings.ServerCertificateChain = this.InstanceCertificateChain;
settings.CertificateValidator = configuration.CertificateValidator.GetChannelValidator();
settings.NamespaceUris = this.MessageContext.NamespaceUris;
settings.Factory = this.MessageContext.Factory;
ITransportListener listener = null;
Type type = null;
if (useAnsiCStack)
{
type = Type.GetType("Opc.Ua.NativeStack.NativeStackListener,Opc.Ua.NativeStackWrapper");
}
if (useAnsiCStack && type != null)
{
listener = (ITransportListener)Activator.CreateInstance(type);
}
else
{
listener = new Opc.Ua.Bindings.UaTcpChannelListener();
}
listener.Open(
uri.Uri,
settings,
GetEndpointInstance(this));
TransportListeners.Add(listener);
}
catch (Exception e)
{
Utils.Trace(e, "Could not load UA-TCP Stack Listener.");
throw;
}
}
return endpoints;
}
/// <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>
/// Invokes the CreateSession service.
/// </summary>
public virtual ResponseHeader CreateSession(
RequestHeader requestHeader,
ApplicationDescription clientDescription,
string serverUri,
string endpointUrl,
string sessionName,
byte[] clientNonce,
byte[] clientCertificate,
double requestedSessionTimeout,
uint maxResponseMessageSize,
out NodeId sessionId,
out NodeId authenticationToken,
out double revisedSessionTimeout,
out byte[] serverNonce,
out byte[] serverCertificate,
out EndpointDescriptionCollection serverEndpoints,
out SignedSoftwareCertificateCollection serverSoftwareCertificates,
out SignatureData serverSignature,
out uint maxRequestMessageSize)
{
CreateSessionRequest request = new CreateSessionRequest();
CreateSessionResponse response = null;
request.RequestHeader = requestHeader;
request.ClientDescription = clientDescription;
request.ServerUri = serverUri;
request.EndpointUrl = endpointUrl;
request.SessionName = sessionName;
request.ClientNonce = clientNonce;
request.ClientCertificate = clientCertificate;
request.RequestedSessionTimeout = requestedSessionTimeout;
request.MaxResponseMessageSize = maxResponseMessageSize;
UpdateRequestHeader(request, requestHeader == null, "CreateSession");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (CreateSessionResponse)genericResponse;
}
else
{
CreateSessionResponseMessage responseMessage = InnerChannel.CreateSession(new CreateSessionMessage(request));
if (responseMessage == null || responseMessage.CreateSessionResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.CreateSessionResponse;
ValidateResponse(response.ResponseHeader);
}
sessionId = response.SessionId;
authenticationToken = response.AuthenticationToken;
revisedSessionTimeout = response.RevisedSessionTimeout;
serverNonce = response.ServerNonce;
serverCertificate = response.ServerCertificate;
serverEndpoints = response.ServerEndpoints;
serverSoftwareCertificates = response.ServerSoftwareCertificates;
serverSignature = response.ServerSignature;
maxRequestMessageSize = response.MaxRequestMessageSize;
}
finally
{
RequestCompleted(request, response, "CreateSession");
}
return response.ResponseHeader;
}
/// <summary>
/// Invokes the GetEndpoints service.
/// </summary>
public virtual ResponseHeader GetEndpoints(
RequestHeader requestHeader,
string endpointUrl,
StringCollection localeIds,
StringCollection profileUris,
out EndpointDescriptionCollection endpoints)
{
GetEndpointsRequest request = new GetEndpointsRequest();
GetEndpointsResponse response = null;
request.RequestHeader = requestHeader;
request.EndpointUrl = endpointUrl;
request.LocaleIds = localeIds;
request.ProfileUris = profileUris;
UpdateRequestHeader(request, requestHeader == null, "GetEndpoints");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (GetEndpointsResponse)genericResponse;
}
else
{
GetEndpointsResponseMessage responseMessage = InnerChannel.GetEndpoints(new GetEndpointsMessage(request));
if (responseMessage == null || responseMessage.GetEndpointsResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.GetEndpointsResponse;
ValidateResponse(response.ResponseHeader);
}
endpoints = response.Endpoints;
}
finally
{
RequestCompleted(request, response, "GetEndpoints");
}
return response.ResponseHeader;
}
/// <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;
}
/// <summary>
/// Invokes the GetEndpoints service.
/// </summary>
/// <param name="requestHeader">The request header.</param>
/// <param name="endpointUrl">The endpoint URL.</param>
/// <param name="localeIds">The locale ids.</param>
/// <param name="profileUris">The profile uris.</param>
/// <param name="endpoints">The endpoints supported by the server.</param>
/// <returns>
/// Returns a <see cref="ResponseHeader"/> object
/// </returns>
public override ResponseHeader GetEndpoints(
RequestHeader requestHeader,
string endpointUrl,
StringCollection localeIds,
StringCollection profileUris,
out EndpointDescriptionCollection endpoints)
{
endpoints = null;
ValidateRequest(requestHeader);
lock (m_lock)
{
// filter by profile.
IList<BaseAddress> baseAddresses = FilterByProfile(profileUris, BaseAddresses);
// get the descriptions.
endpoints = GetEndpointDescriptions(
endpointUrl,
baseAddresses,
localeIds);
}
return CreateResponse(requestHeader, StatusCodes.Good);
}
/// <summary>
/// Updates the list of servers displayed in the control.
/// </summary>
private void OnUpdateEndpoints(object state)
{
if (this.InvokeRequired)
{
this.BeginInvoke(new WaitCallback(OnUpdateEndpoints), state);
return;
}
try
{
// get the updated descriptions.
EndpointDescriptionCollection endpoints = state as EndpointDescriptionCollection;
if (endpoints == null)
{
m_showAllOptions = true;
InitializeProtocols(m_availableEndpoints);
}
else
{
m_showAllOptions = false;
m_availableEndpoints = endpoints;
BuildEndpointDescriptionStrings(m_availableEndpoints);
if (endpoints.Count > 0)
{
m_currentDescription = endpoints[0];
}
// initializing the protocol will trigger an update to all other controls.
InitializeProtocols(m_availableEndpoints);
// select the best security mode.
MessageSecurityMode bestMode = MessageSecurityMode.Invalid;
foreach (MessageSecurityMode securityMode in SecurityModeCB.Items)
{
if (securityMode > bestMode)
{
bestMode = securityMode;
}
}
SecurityModeCB.SelectedItem = bestMode;
// select the best encoding.
Encoding bestEncoding = Encoding.Default;
foreach (Encoding encoding in EncodingCB.Items)
{
if (encoding > bestEncoding)
{
bestEncoding = encoding;
}
}
EncodingCB.SelectedItem = bestEncoding;
}
if (m_endpoint != null)
{
Uri url = m_endpoint.EndpointUrl;
foreach (Protocol protocol in ProtocolCB.Items)
{
if (protocol.Matches(url))
{
ProtocolCB.SelectedItem = protocol;
break;
}
}
foreach (MessageSecurityMode securityMode in SecurityModeCB.Items)
{
if (securityMode == m_endpoint.Description.SecurityMode)
{
SecurityModeCB.SelectedItem = securityMode;
break;
}
}
foreach (string securityPolicy in SecurityPolicyCB.Items)
{
if (securityPolicy == m_endpoint.Description.SecurityPolicyUri)
{
SecurityPolicyCB.SelectedItem = securityPolicy;
break;
}
}
foreach (Encoding encoding in EncodingCB.Items)
{
if (encoding == Encoding.Binary && m_endpoint.Configuration.UseBinaryEncoding)
{
EncodingCB.SelectedItem = encoding;
break;
}
if (encoding == Encoding.Xml && !m_endpoint.Configuration.UseBinaryEncoding)
{
EncodingCB.SelectedItem = encoding;
break;
}
}
}
}
catch (Exception e)
{
Utils.Trace(e, "Unexpected error updating endpoints.");
}
}
public Session(
ITransportChannel channel,
ApplicationConfiguration configuration,
ConfiguredEndpoint endpoint,
X509Certificate2 clientCertificate,
EndpointDescriptionCollection availableEndpoints)
:
base(channel)
{
Initialize(channel, configuration, endpoint, clientCertificate);
m_expectedServerEndpoints = availableEndpoints;
}
/// <summary>
/// Displays the dialog.
/// </summary>
public 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_availableEndpointsDescriptions = new List<EndpointDescriptionString>();
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);
BuildEndpointDescriptionStrings(m_availableEndpoints);
// discover endpoints in the background.
m_discoverySucceeded = false;
Interlocked.Increment(ref m_discoverCount);
ThreadPool.QueueUserWorkItem(new WaitCallback(OnDiscoverEndpoints), server);
if (ShowDialog() != DialogResult.OK)
{
return null;
}
return m_endpoint;
}
/// <summary>
/// Displays the dialog.
/// </summary>
public 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_availableEndpointsDescriptions = new List<EndpointDescriptionString>();
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);
}
}
}
BuildEndpointDescriptionStrings(m_availableEndpoints);
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;
}
}
// 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);
// discover endpoints in the background.
Interlocked.Increment(ref m_discoverCount);
ThreadPool.QueueUserWorkItem(new WaitCallback(OnDiscoverEndpoints), m_endpoint.Description.Server);
if (ShowDialog() != DialogResult.OK)
{
return null;
}
return m_endpoint;
}
/// <summary>
/// Creates the string representation of each EndpointDescription - to be used in the Endpoint Description List
/// </summary>
private void BuildEndpointDescriptionStrings(EndpointDescriptionCollection endpoints)
{
lock (m_availableEndpointsDescriptions)
{
m_availableEndpointsDescriptions.Clear();
foreach (EndpointDescription endpoint in endpoints)
{
m_availableEndpointsDescriptions.Add(new EndpointDescriptionString(endpoint));
}
InitializeEndpointList(m_availableEndpointsDescriptions);
}
}
/// <summary>
/// Initializes the security modes dropdown.
/// </summary>
private void InitializeSecurityModes(EndpointDescriptionCollection endpoints)
{
// filter by the current protocol.
Protocol currentProtocol = (Protocol)ProtocolCB.SelectedItem;
// preserve the existing value.
MessageSecurityMode currentMode = MessageSecurityMode.None;
if (SecurityModeCB.SelectedIndex != -1)
{
currentMode = (MessageSecurityMode)SecurityModeCB.SelectedItem;
}
SecurityModeCB.Items.Clear();
// set all available security modes.
if (m_showAllOptions)
{
SecurityModeCB.Items.Add(MessageSecurityMode.None);
SecurityModeCB.Items.Add(MessageSecurityMode.Sign);
SecurityModeCB.Items.Add(MessageSecurityMode.SignAndEncrypt);
}
// find all unique security modes.
else
{
if (endpoints != null)
{
foreach (EndpointDescription endpoint in endpoints)
{
Uri url = Utils.ParseUri(endpoint.EndpointUrl);
if ((url != null) && (currentProtocol != null))
{
if (!currentProtocol.Matches(url))
{
continue;
}
if (!SecurityModeCB.Items.Contains(endpoint.SecurityMode))
{
SecurityModeCB.Items.Add(endpoint.SecurityMode);
}
}
}
}
// add at least one policy.
if (SecurityModeCB.Items.Count == 0)
{
SecurityModeCB.Items.Add(MessageSecurityMode.None);
}
}
// set the current value.
int index = SecurityModeCB.Items.IndexOf(currentMode);
if (index == -1)
{
index = 0;
}
SecurityModeCB.SelectedIndex = index;
}
/// <summary>
/// Invokes the CreateSession service.
/// </summary>
/// <param name="requestHeader">The request header.</param>
/// <param name="clientDescription">Application description for the client application.</param>
/// <param name="serverUri">The server URI.</param>
/// <param name="endpointUrl">The endpoint URL.</param>
/// <param name="sessionName">Name for the Session assigned by the client.</param>
/// <param name="clientNonce">The client nonce.</param>
/// <param name="clientCertificate">The client certificate.</param>
/// <param name="requestedSessionTimeout">The requested session timeout.</param>
/// <param name="maxResponseMessageSize">Size of the max response message.</param>
/// <param name="sessionId">The unique public identifier assigned by the Server to the Session.</param>
/// <param name="authenticationToken">The unique private identifier assigned by the Server to the Session.</param>
/// <param name="revisedSessionTimeout">The revised session timeout.</param>
/// <param name="serverNonce">The server nonce.</param>
/// <param name="serverCertificate">The server certificate.</param>
/// <param name="serverEndpoints">The server endpoints.</param>
/// <param name="serverSoftwareCertificates">The server software certificates.</param>
/// <param name="serverSignature">The server signature.</param>
/// <param name="maxRequestMessageSize">Size of the max request message.</param>
/// <returns>
/// Returns a <see cref="ResponseHeader"/> object
/// </returns>
public override ResponseHeader CreateSession(
RequestHeader requestHeader,
ApplicationDescription clientDescription,
string serverUri,
string endpointUrl,
string sessionName,
byte[] clientNonce,
byte[] clientCertificate,
double requestedSessionTimeout,
uint maxResponseMessageSize,
out NodeId sessionId,
out NodeId authenticationToken,
out double revisedSessionTimeout,
out byte[] serverNonce,
out byte[] serverCertificate,
out EndpointDescriptionCollection serverEndpoints,
out SignedSoftwareCertificateCollection serverSoftwareCertificates,
out SignatureData serverSignature,
out uint maxRequestMessageSize)
{
sessionId = 0;
revisedSessionTimeout = 0;
serverNonce = null;
serverCertificate = null;
serverSoftwareCertificates = null;
serverSignature = null;
maxRequestMessageSize = (uint)MessageContext.MaxMessageSize;
OperationContext context = ValidateRequest(requestHeader, RequestType.CreateSession);
try
{
// check the server uri.
if (!String.IsNullOrEmpty(serverUri))
{
if (serverUri != this.Configuration.ApplicationUri)
{
throw new ServiceResultException(StatusCodes.BadServerUriInvalid);
}
}
bool requireEncryption = ServerBase.RequireEncryption(context.ChannelContext.EndpointDescription);
if (!requireEncryption && clientCertificate != null)
{
requireEncryption = true;
}
// validate client application instance certificate.
X509Certificate2 parsedClientCertificate = null;
if (requireEncryption && clientCertificate != null && clientCertificate.Length > 0)
{
try
{
parsedClientCertificate = CertificateFactory.Create(clientCertificate, true);
if (context.SecurityPolicyUri != SecurityPolicies.None)
{
string certificateApplicationUri = Utils.GetApplicationUriFromCertficate(parsedClientCertificate);
// verify if applicationUri from ApplicationDescription matches the applicationUri in the client certificate.
if (!String.IsNullOrEmpty(certificateApplicationUri) &&
!String.IsNullOrEmpty(clientDescription.ApplicationUri) &&
certificateApplicationUri != clientDescription.ApplicationUri)
{
throw ServiceResultException.Create(
StatusCodes.BadCertificateUriInvalid,
"The URI specified in the ApplicationDescription does not match the URI in the Certificate.");
}
CertificateValidator.Validate(parsedClientCertificate);
}
}
catch (Exception e)
{
OnApplicationCertificateError(clientCertificate, new ServiceResult(e));
}
}
// verify the nonce provided by the client.
if (clientNonce != null)
{
if (clientNonce.Length < m_minNonceLength)
{
throw new ServiceResultException(StatusCodes.BadNonceInvalid);
}
}
// create the session.
Session session = ServerInternal.SessionManager.CreateSession(
context,
requireEncryption ? InstanceCertificate : null,
sessionName,
clientNonce,
clientDescription,
endpointUrl,
parsedClientCertificate,
requestedSessionTimeout,
maxResponseMessageSize,
out sessionId,
out authenticationToken,
out serverNonce,
out revisedSessionTimeout);
lock (m_lock)
{
// return the application instance certificate for the server.
if (requireEncryption)
{
serverCertificate = InstanceCertificate.RawData;
}
// return the endpoints supported by the server.
serverEndpoints = GetEndpointDescriptions(endpointUrl, BaseAddresses, null);
// return the software certificates assigned to the server.
serverSoftwareCertificates = new SignedSoftwareCertificateCollection(ServerProperties.SoftwareCertificates);
// sign the nonce provided by the client.
serverSignature = null;
// sign the client nonce (if provided).
if (parsedClientCertificate != null && clientNonce != null)
{
byte[] dataToSign = Utils.Append(clientCertificate, clientNonce);
serverSignature = SecurityPolicies.Sign(InstanceCertificate, context.SecurityPolicyUri, dataToSign);
}
}
lock (ServerInternal.DiagnosticsLock)
{
ServerInternal.ServerDiagnostics.CurrentSessionCount++;
ServerInternal.ServerDiagnostics.CumulatedSessionCount++;
}
Utils.Trace("Server - SESSION CREATED. SessionId={0}", sessionId);
return CreateResponse(requestHeader, StatusCodes.Good);
}
catch (ServiceResultException e)
{
Utils.Trace("Server - SESSION CREATE failed. {0}", e.Message);
lock (ServerInternal.DiagnosticsLock)
{
ServerInternal.ServerDiagnostics.RejectedSessionCount++;
ServerInternal.ServerDiagnostics.RejectedRequestsCount++;
if (IsSecurityError(e.StatusCode))
{
ServerInternal.ServerDiagnostics.SecurityRejectedSessionCount++;
ServerInternal.ServerDiagnostics.SecurityRejectedRequestsCount++;
}
}
throw TranslateException((DiagnosticsMasks)requestHeader.ReturnDiagnostics, new StringCollection(), e);
}
finally
{
OnRequestComplete(context);
}
}
/// <summary>
/// Invokes the CreateSession service.
/// </summary>
public virtual ResponseHeader CreateSession(
RequestHeader requestHeader,
ApplicationDescription clientDescription,
string serverUri,
string endpointUrl,
string sessionName,
byte[] clientNonce,
byte[] clientCertificate,
double requestedSessionTimeout,
uint maxResponseMessageSize,
out NodeId sessionId,
out NodeId authenticationToken,
out double revisedSessionTimeout,
out byte[] serverNonce,
out byte[] serverCertificate,
out EndpointDescriptionCollection serverEndpoints,
out SignedSoftwareCertificateCollection serverSoftwareCertificates,
out SignatureData serverSignature,
out uint maxRequestMessageSize)
{
sessionId = null;
authenticationToken = null;
revisedSessionTimeout = 0;
serverNonce = null;
serverCertificate = null;
serverEndpoints = null;
serverSoftwareCertificates = null;
serverSignature = null;
maxRequestMessageSize = 0;
ValidateRequest(requestHeader);
// Insert implementation.
return CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported);
}
/// <summary>
/// Finishes an asynchronous invocation of the GetEndpoints service.
/// </summary>
public ResponseHeader EndGetEndpoints(
IAsyncResult result,
out EndpointDescriptionCollection endpoints)
{
GetEndpointsResponse response = null;
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.EndSendRequest(result);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (GetEndpointsResponse)genericResponse;
}
else
{
GetEndpointsResponseMessage responseMessage = InnerChannel.EndGetEndpoints(result);
if (responseMessage == null || responseMessage.GetEndpointsResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.GetEndpointsResponse;
ValidateResponse(response.ResponseHeader);
}
endpoints = response.Endpoints;
}
finally
{
RequestCompleted(null, response, "GetEndpoints");
}
return response.ResponseHeader;
}
/// <summary>
/// Creates the endpoints and creates the hosts.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="bindingFactory">The binding factory.</param>
/// <param name="serverDescription">The server description.</param>
/// <param name="endpoints">The endpoints.</param>
/// <returns>
/// Returns IList of a host for a UA service which type is <seealso cref="ServiceHost"/>.
/// </returns>
protected override IList<IBackgroundTask> InitializeServiceHosts(
ApplicationConfiguration configuration,
BindingFactory bindingFactory,
out ApplicationDescription serverDescription,
out EndpointDescriptionCollection endpoints)
{
serverDescription = null;
endpoints = null;
Dictionary<string, IBackgroundTask> hosts = new Dictionary<string, IBackgroundTask>();
// ensure at least one security policy exists.
if (configuration.ServerConfiguration.SecurityPolicies.Count == 0)
{
configuration.ServerConfiguration.SecurityPolicies.Add(new ServerSecurityPolicy());
}
// ensure at least one user token policy exists.
if (configuration.ServerConfiguration.UserTokenPolicies.Count == 0)
{
UserTokenPolicy userTokenPolicy = new UserTokenPolicy();
userTokenPolicy.TokenType = UserTokenType.Anonymous;
userTokenPolicy.PolicyId = userTokenPolicy.TokenType.ToString();
configuration.ServerConfiguration.UserTokenPolicies.Add(userTokenPolicy);
}
// set server description.
serverDescription = new ApplicationDescription();
serverDescription.ApplicationUri = configuration.ApplicationUri;
serverDescription.ApplicationName = configuration.ApplicationName;
serverDescription.ApplicationType = configuration.ApplicationType;
serverDescription.ProductUri = configuration.ProductUri;
serverDescription.DiscoveryUrls = GetDiscoveryUrls();
endpoints = new EndpointDescriptionCollection();
IList<EndpointDescription> endpointsForHost = null;
// create hosts for protocols that require one endpoints per security policy
foreach (ServerSecurityPolicy securityPolicy in configuration.ServerConfiguration.SecurityPolicies)
{
endpointsForHost = CreateSinglePolicyServiceHost(
hosts,
configuration,
bindingFactory,
configuration.ServerConfiguration.BaseAddresses,
serverDescription,
securityPolicy.SecurityMode,
securityPolicy.SecurityPolicyUri,
String.Empty);
for (int ii = 0; ii < endpointsForHost.Count; ii++)
{
endpointsForHost[ii].SecurityLevel = securityPolicy.SecurityLevel;
}
endpoints.AddRange(endpointsForHost);
}
// create UA TCP host.
endpointsForHost = CreateUaTcpServiceHost(
hosts,
configuration,
bindingFactory,
configuration.ServerConfiguration.BaseAddresses,
serverDescription,
configuration.ServerConfiguration.SecurityPolicies);
endpoints.InsertRange(0, endpointsForHost);
// create HTTPS host.
endpointsForHost = CreateHttpsServiceHost(
hosts,
configuration,
bindingFactory,
configuration.ServerConfiguration.BaseAddresses,
serverDescription,
configuration.ServerConfiguration.SecurityPolicies);
endpoints.AddRange(endpointsForHost);
return new List<IBackgroundTask>(hosts.Values);
}
/// <summary>
/// Initializes the message encodings dropdown.
/// </summary>
private void InitializeEncodings(EndpointDescriptionCollection endpoints, EndpointDescription endpoint)
{
// preserve the existing value.
Encoding currentEncoding = Encoding.Default;
if (EncodingCB.SelectedIndex != -1)
{
currentEncoding = (Encoding)EncodingCB.SelectedItem;
}
EncodingCB.Items.Clear();
if (endpoint != null)
{
Protocol protocol = new Protocol(endpoint);
String securityPolicy = SecurityPolicies.GetDisplayName(endpoint.SecurityPolicyUri);
foreach (EndpointDescription endpointDescription in endpoints)
{
if ((protocol.Matches(Utils.ParseUri(endpointDescription.EndpointUrl))) &&
(endpoint.SecurityMode == endpointDescription.SecurityMode) &&
(securityPolicy == SecurityPolicies.GetDisplayName(endpointDescription.SecurityPolicyUri)))
{
switch (endpointDescription.EncodingSupport)
{
case BinaryEncodingSupport.None:
{
if (!EncodingCB.Items.Contains(Encoding.Xml))
{
EncodingCB.Items.Add(Encoding.Xml);
}
break;
}
case BinaryEncodingSupport.Required:
{
if (!EncodingCB.Items.Contains(Encoding.Binary))
{
EncodingCB.Items.Add(Encoding.Binary);
}
break;
}
case BinaryEncodingSupport.Optional:
{
if (!EncodingCB.Items.Contains(Encoding.Binary))
{
EncodingCB.Items.Add(Encoding.Binary);
}
if (!EncodingCB.Items.Contains(Encoding.Xml))
{
EncodingCB.Items.Add(Encoding.Xml);
}
break;
}
}
}
}
}
// add at least one encoding.
if (EncodingCB.Items.Count == 0)
{
EncodingCB.Items.Add(Encoding.Default);
}
// set the current value.
int index = EncodingCB.Items.IndexOf(currentEncoding);
if (index == -1)
{
index = 0;
}
EncodingCB.SelectedIndex = index;
}
/// <summary>
/// Create a new service host for UA HTTPS.
/// </summary>
protected List<EndpointDescription> CreateHttpsServiceHost(
IDictionary<string, ServiceHost> hosts,
ApplicationConfiguration configuration,
BindingFactory bindingFactory,
IList<string> baseAddresses,
ApplicationDescription serverDescription,
List<ServerSecurityPolicy> securityPolicies)
{
// generate a unique host name.
string hostName = String.Empty;
if (hosts.ContainsKey(hostName))
{
hostName = "/Https";
}
if (hosts.ContainsKey(hostName))
{
hostName += Utils.Format("/{0}", hosts.Count);
}
// build list of uris.
List<Uri> uris = new List<Uri>();
EndpointDescriptionCollection endpoints = new EndpointDescriptionCollection();
// create the endpoint configuration to use.
EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(configuration);
string computerName = System.Net.Dns.GetHostName();
for (int ii = 0; ii < baseAddresses.Count; ii++)
{
if (!baseAddresses[ii].StartsWith(Utils.UriSchemeHttps, StringComparison.Ordinal) &&
!baseAddresses[ii].StartsWith(Utils.UriSchemeNoSecurityHttp, StringComparison.Ordinal))
{
continue;
}
UriBuilder uri = new UriBuilder(baseAddresses[ii]);
if (uri.Scheme == Utils.UriSchemeNoSecurityHttp)
{
uri.Scheme = Utils.UriSchemeHttp;
}
if (uri.Path[uri.Path.Length-1] != '/')
{
uri.Path += "/";
}
if (String.Compare(uri.Host, "localhost", StringComparison.OrdinalIgnoreCase) == 0)
{
uri.Host = computerName;
}
uris.Add(uri.Uri);
if (uri.Scheme == Utils.UriSchemeHttps)
{
// can only support one policy with HTTPS so pick the best one.
ServerSecurityPolicy bestPolicy = null;
foreach (ServerSecurityPolicy policy in securityPolicies)
{
if (bestPolicy == null)
{
bestPolicy = policy;
continue;
}
if (bestPolicy.SecurityLevel > policy.SecurityLevel)
{
bestPolicy = policy;
continue;
}
}
EndpointDescription description = new EndpointDescription();
description.EndpointUrl = uri.ToString();
description.Server = serverDescription;
description.ServerCertificate = InstanceCertificate.RawData;
//if (InstanceCertificateChain != null)
//{
// List<byte> certificateChainList = new List<byte>();
// for (int i = 0; i < InstanceCertificateChain.Count; i++)
// {
// certificateChainList.AddRange(InstanceCertificateChain[i].RawData);
// }
// description.ServerCertificate = certificateChainList.ToArray();
//}
description.SecurityMode = bestPolicy.SecurityMode;
description.SecurityPolicyUri = bestPolicy.SecurityPolicyUri;
description.SecurityLevel = bestPolicy.SecurityLevel;
description.UserIdentityTokens = GetUserTokenPolicies(configuration, description);
description.TransportProfileUri = Profiles.HttpsBinaryTransport;
endpoints.Add(description);
// create the endpoint description.
description = new EndpointDescription();
description.EndpointUrl = uri.ToString();
description.Server = serverDescription;
description.ServerCertificate = InstanceCertificate.RawData;
//if (InstanceCertificateChain != null)
//{
// List<byte> certificateChainList = new List<byte>();
// for (int i = 0; i < InstanceCertificateChain.Count; i++)
// {
// certificateChainList.AddRange(InstanceCertificateChain[i].RawData);
// }
// description.ServerCertificate = certificateChainList.ToArray();
//}
description.SecurityMode = MessageSecurityMode.None;
description.SecurityPolicyUri = SecurityPolicies.None;
description.SecurityLevel = 0;
description.UserIdentityTokens = GetUserTokenPolicies(configuration, description);
description.TransportProfileUri = Profiles.HttpsXmlTransport;
endpoints.Add(description);
}
// create the stack listener.
try
{
TransportListenerSettings settings = new TransportListenerSettings();
settings.Descriptions = endpoints;
settings.Configuration = endpointConfiguration;
settings.ServerCertificate = this.InstanceCertificate;
//settings.ServerCertificateChain = this.InstanceCertificateChain;
settings.CertificateValidator = configuration.CertificateValidator.GetChannelValidator();
settings.NamespaceUris = this.MessageContext.NamespaceUris;
settings.Factory = this.MessageContext.Factory;
ITransportListener listener = new Opc.Ua.Bindings.UaHttpsChannelListener();
listener.Open(
uri.Uri,
settings,
GetEndpointInstance(this));
TransportListeners.Add(listener);
}
catch (Exception e)
{
Utils.Trace(e, "Could not load HTTPS Stack Listener.");
throw;
}
}
return endpoints;
}
/// <summary>
/// Finds the best match for the current protocol and security selections.
/// </summary>
private EndpointDescription FindBestEndpointDescription(EndpointDescriptionCollection endpoints)
{
// filter by the current protocol.
Protocol currentProtocol = (Protocol)ProtocolCB.SelectedItem;
// filter by the current security mode.
MessageSecurityMode currentMode = MessageSecurityMode.None;
if (SecurityModeCB.SelectedIndex != -1)
{
currentMode = (MessageSecurityMode)SecurityModeCB.SelectedItem;
}
// filter by the current security policy.
string currentPolicy = (string)SecurityPolicyCB.SelectedItem;
// find all matching descriptions.
EndpointDescriptionCollection matches = new EndpointDescriptionCollection();
if (endpoints != null)
{
foreach (EndpointDescription endpoint in endpoints)
{
Uri url = Utils.ParseUri(endpoint.EndpointUrl);
if (url == null)
{
continue;
}
if ((currentProtocol != null) && (!currentProtocol.Matches(url)))
{
continue;
}
if (currentMode != endpoint.SecurityMode)
{
continue;
}
if (currentPolicy != SecurityPolicies.GetDisplayName(endpoint.SecurityPolicyUri))
{
continue;
}
matches.Add(endpoint);
}
}
// check for no matches.
if (matches.Count == 0)
{
return null;
}
// check for single match.
if (matches.Count == 1)
{
return matches[0];
}
// choose highest priority.
EndpointDescription bestMatch = matches[0];
for (int ii = 1; ii < matches.Count; ii++)
{
if (bestMatch.SecurityLevel < matches[ii].SecurityLevel)
{
bestMatch = matches[ii];
}
}
return bestMatch;
}
/// <summary>
/// Invokes the GetEndpoints service.
/// </summary>
public virtual ResponseHeader GetEndpoints(
RequestHeader requestHeader,
string endpointUrl,
StringCollection localeIds,
StringCollection profileUris,
out EndpointDescriptionCollection endpoints)
{
endpoints = null;
ValidateRequest(requestHeader);
// Insert implementation.
return CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported);
}
/// <summary>
/// Translates the endpoint descriptions based on the client url and profiles provided.
/// </summary>
/// <param name="clientUrl">The client URL.</param>
/// <param name="baseAddresses">The base addresses.</param>
/// <param name="endpoints">The endpoints.</param>
/// <param name="application">The application to use with the endpoints.</param>
/// <returns>The translated list of endpoints.</returns>
protected EndpointDescriptionCollection TranslateEndpointDescriptions(
Uri clientUrl,
IList<BaseAddress> baseAddresses,
IList<EndpointDescription> endpoints,
ApplicationDescription application)
{
EndpointDescriptionCollection translations = new EndpointDescriptionCollection();
// process endpoints
foreach (EndpointDescription endpoint in endpoints)
{
UriBuilder endpointUrl = new UriBuilder(endpoint.EndpointUrl);
// find matching base address.
foreach (BaseAddress baseAddress in baseAddresses)
{
bool translateHttpsEndpoint = false;
if ((endpoint.TransportProfileUri == Profiles.HttpsBinaryTransport && baseAddress.ProfileUri == Profiles.HttpsXmlOrBinaryTransport)
|| endpoint.TransportProfileUri == Profiles.HttpsBinaryTransport && baseAddress.ProfileUri == Profiles.HttpsBinaryTransport)
{
translateHttpsEndpoint = true;
}
if ((endpoint.TransportProfileUri == Profiles.HttpsXmlTransport && baseAddress.ProfileUri == Profiles.HttpsXmlOrBinaryTransport)
|| endpoint.TransportProfileUri == Profiles.HttpsXmlTransport && baseAddress.ProfileUri == Profiles.HttpsXmlTransport)
{
translateHttpsEndpoint = true;
}
if (endpoint.TransportProfileUri != baseAddress.ProfileUri && !translateHttpsEndpoint)
{
continue;
}
if (endpointUrl.Scheme != baseAddress.Url.Scheme)
{
continue;
}
EndpointDescription translation = new EndpointDescription();
translation.EndpointUrl = baseAddress.Url.ToString();
if (endpointUrl.Path.StartsWith(baseAddress.Url.PathAndQuery) && endpointUrl.Path.Length > baseAddress.Url.PathAndQuery.Length)
{
string suffix = endpointUrl.Path.Substring(baseAddress.Url.PathAndQuery.Length);
translation.EndpointUrl += suffix;
}
translation.ProxyUrl = endpoint.ProxyUrl;
translation.SecurityLevel = endpoint.SecurityLevel;
translation.SecurityMode = endpoint.SecurityMode;
translation.SecurityPolicyUri = endpoint.SecurityPolicyUri;
translation.ServerCertificate = endpoint.ServerCertificate;
translation.TransportProfileUri = endpoint.TransportProfileUri;
translation.UserIdentityTokens = endpoint.UserIdentityTokens;
translation.Server = application;
translations.Add(translation);
}
}
return translations;
}
/// <summary>
/// Creates the endpoints and creates the hosts.
/// </summary>
/// <param name="configuration">The object that stores the configurable configuration information for a UA application.</param>
/// <param name="bindingFactory">The object of a class that manages a mapping between a URL scheme and a binding.</param>
/// <param name="serverDescription">The object of the class that contains a description for the ApplicationDescription DataType.</param>
/// <param name="endpoints">The collection of <see cref="EndpointDescription"/> objects.</param>
/// <returns>Returns list of hosts for a UA service.</returns>
protected virtual IList<ServiceHost> InitializeServiceHosts(
ApplicationConfiguration configuration,
BindingFactory bindingFactory,
out ApplicationDescription serverDescription,
out EndpointDescriptionCollection endpoints)
{
serverDescription = null;
endpoints = null;
return new List<ServiceHost>();
}
/// <summary>
/// Initializes the security policies dropdown.
/// </summary>
private void InitializeSecurityPolicies(EndpointDescriptionCollection endpoints)
{
// filter by the current protocol.
Protocol currentProtocol = (Protocol)ProtocolCB.SelectedItem;
// filter by the current security mode.
MessageSecurityMode currentMode = MessageSecurityMode.None;
if (SecurityModeCB.SelectedIndex != -1)
{
currentMode = (MessageSecurityMode)SecurityModeCB.SelectedItem;
}
// preserve the existing value.
string currentPolicy = (string)SecurityPolicyCB.SelectedItem;
SecurityPolicyCB.Items.Clear();
// set all available security policies.
if (m_showAllOptions)
{
SecurityPolicyCB.Items.Add(SecurityPolicies.GetDisplayName(SecurityPolicies.None));
SecurityPolicyCB.Items.Add(SecurityPolicies.GetDisplayName(SecurityPolicies.Basic128Rsa15));
SecurityPolicyCB.Items.Add(SecurityPolicies.GetDisplayName(SecurityPolicies.Basic256));
}
// find all unique security policies.
else
{
if (endpoints != null)
{
foreach (EndpointDescription endpoint in endpoints)
{
Uri url = Utils.ParseUri(endpoint.EndpointUrl);
if ((url != null) && (currentProtocol != null))
{
if (!currentProtocol.Matches(url))
{
continue;
}
if (currentMode != endpoint.SecurityMode)
{
continue;
}
string policyName = SecurityPolicies.GetDisplayName(endpoint.SecurityPolicyUri);
if (policyName != null)
{
int existingIndex = SecurityPolicyCB.FindStringExact(policyName);
if (existingIndex == -1)
{
SecurityPolicyCB.Items.Add(policyName);
}
}
}
}
}
}
// add at least one policy.
if (SecurityPolicyCB.Items.Count == 0)
{
SecurityPolicyCB.Items.Add(SecurityPolicies.GetDisplayName(SecurityPolicies.None));
}
// set the current value.
int index = 0;
if (!String.IsNullOrEmpty(currentPolicy))
{
index = SecurityPolicyCB.FindStringExact(currentPolicy);
if (index == -1)
{
index = 0;
}
}
SecurityPolicyCB.SelectedIndex = index;
}
/// <summary>
/// Finishes an asynchronous invocation of the CreateSession service.
/// </summary>
public ResponseHeader EndCreateSession(
IAsyncResult result,
out NodeId sessionId,
out NodeId authenticationToken,
out double revisedSessionTimeout,
out byte[] serverNonce,
out byte[] serverCertificate,
out EndpointDescriptionCollection serverEndpoints,
out SignedSoftwareCertificateCollection serverSoftwareCertificates,
out SignatureData serverSignature,
out uint maxRequestMessageSize)
{
CreateSessionResponse response = null;
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.EndSendRequest(result);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (CreateSessionResponse)genericResponse;
}
else
{
CreateSessionResponseMessage responseMessage = InnerChannel.EndCreateSession(result);
if (responseMessage == null || responseMessage.CreateSessionResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.CreateSessionResponse;
ValidateResponse(response.ResponseHeader);
}
sessionId = response.SessionId;
authenticationToken = response.AuthenticationToken;
revisedSessionTimeout = response.RevisedSessionTimeout;
serverNonce = response.ServerNonce;
serverCertificate = response.ServerCertificate;
serverEndpoints = response.ServerEndpoints;
serverSoftwareCertificates = response.ServerSoftwareCertificates;
serverSignature = response.ServerSignature;
maxRequestMessageSize = response.MaxRequestMessageSize;
}
finally
{
RequestCompleted(null, response, "CreateSession");
}
return response.ResponseHeader;
}
private static EndpointDescription SelectUaTcpEndpoint(EndpointDescriptionCollection endpointCollection, bool haveCert)
{
EndpointDescription bestEndpoint = null;
foreach (EndpointDescription endpoint in endpointCollection)
{
if (endpoint.TransportProfileUri == Profiles.UaTcpTransport)
{
if (bestEndpoint == null ||
haveCert && (endpoint.SecurityLevel > bestEndpoint.SecurityLevel) ||
!haveCert && (endpoint.SecurityLevel < bestEndpoint.SecurityLevel))
{
bestEndpoint = endpoint;
}
}
}
return bestEndpoint;
}
