Samuele Locatelli
1833 lines
64 KiB
C#
1833 lines
64 KiB
C#
/* ========================================================================
|
|
* Copyright (c) 2005-2020 The OPC Foundation, Inc. All rights reserved.
|
|
*
|
|
* OPC Foundation MIT License 1.00
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following
|
|
* conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* The complete license agreement can be found here:
|
|
* http://opcfoundation.org/License/MIT/1.00/
|
|
* ======================================================================*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.Reflection;
|
|
using System.Threading;
|
|
using System.Security.Cryptography.X509Certificates;
|
|
using Opc.Ua.Security.Certificates;
|
|
|
|
namespace Opc.Ua.Client.Controls
|
|
{
|
|
/// <summary>
|
|
/// Prompts the user to edit a ComPseudoServerDlg.
|
|
/// </summary>
|
|
public partial class ConfiguredServerDlg : Form
|
|
{
|
|
#region Constructors
|
|
/// <summary>
|
|
/// Initializes the dialog.
|
|
/// </summary>
|
|
public ConfiguredServerDlg()
|
|
{
|
|
InitializeComponent();
|
|
this.Icon = ClientUtils.GetAppIcon();
|
|
|
|
m_userIdentities = new Dictionary<string, UserIdentityToken>();
|
|
m_statusObject = new StatusObject((int)StatusChannel.MaxStatusChannels);
|
|
}
|
|
#endregion
|
|
|
|
#region Private Fields
|
|
/// <summary>
|
|
/// The possible encodings.
|
|
/// </summary>
|
|
private enum Encoding
|
|
{
|
|
Default,
|
|
Xml,
|
|
Binary
|
|
}
|
|
|
|
/// <summary>
|
|
/// The type of status (for coloring the status textbox).
|
|
/// </summary>
|
|
private enum StatusType
|
|
{
|
|
Ok = 0,
|
|
Warning = 1,
|
|
Error = 2
|
|
}
|
|
|
|
/// <summary>
|
|
/// The status channel inside the StatusObject.
|
|
/// </summary>
|
|
private enum StatusChannel
|
|
{
|
|
Discovery = 0,
|
|
SelectedSecurityMode = 1,
|
|
ApplicationType = 2,
|
|
SelectedProtocol = 3,
|
|
ApplicationUri = 4,
|
|
DiscoveryURLs = 5,
|
|
Server = 6,
|
|
DifferentCertificate = 7,
|
|
SecurityPolicyUri = 8,
|
|
TransportProfileUri = 9,
|
|
SelectedSecurityPolicy = 10,
|
|
MaxStatusChannels = 11
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether to override limits
|
|
/// </summary>
|
|
private enum UseDefaultLimits
|
|
{
|
|
Yes,
|
|
No
|
|
}
|
|
|
|
/// <summary>
|
|
/// This class merges multiple error/warning/status codes from multiple sources.
|
|
/// Initialize it with the number of status channels and update "StatusChannel" accordingly.
|
|
/// Provides a general view of all the statuses (joined texts, worst status).
|
|
/// </summary>
|
|
private class StatusObject
|
|
{
|
|
public StatusObject(int maxChannels)
|
|
{
|
|
m_maxChannels = maxChannels;
|
|
m_statusTexts = new string[maxChannels];
|
|
m_statusTypes = new StatusType[maxChannels];
|
|
|
|
for (int i = 0; i < m_maxChannels; ++i)
|
|
{
|
|
m_statusTexts[i] = String.Empty;
|
|
m_statusTypes[i] = StatusType.Ok;
|
|
}
|
|
}
|
|
|
|
public String StatusString
|
|
{
|
|
get
|
|
{
|
|
String status = String.Empty;
|
|
|
|
for (int i = 0; i < m_maxChannels; ++i)
|
|
{
|
|
if (!String.IsNullOrEmpty(m_statusTexts[i]))
|
|
{
|
|
if (!String.IsNullOrEmpty(status))
|
|
{
|
|
status += " | ";
|
|
}
|
|
|
|
status += m_statusTexts[i];
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
}
|
|
|
|
public StatusType StatusType
|
|
{
|
|
get
|
|
{
|
|
StatusType type = StatusType.Ok;
|
|
|
|
for (int i = 0; i < m_maxChannels; ++i)
|
|
{
|
|
if (m_statusTypes[i] > type)
|
|
{
|
|
type = m_statusTypes[i];
|
|
}
|
|
}
|
|
|
|
return type;
|
|
}
|
|
}
|
|
|
|
public void SetStatus(StatusChannel channel, String text, StatusType type)
|
|
{
|
|
int intChannel = (int)channel;
|
|
|
|
if ((intChannel >= 0) && (intChannel < m_maxChannels))
|
|
{
|
|
m_statusTexts[intChannel] = text;
|
|
m_statusTypes[intChannel] = type;
|
|
}
|
|
}
|
|
|
|
public void ClearStatus(StatusChannel channel)
|
|
{
|
|
int intChannel = (int)channel;
|
|
|
|
if ((intChannel >= 0) && (intChannel < m_maxChannels))
|
|
{
|
|
m_statusTexts[intChannel] = String.Empty;
|
|
m_statusTypes[intChannel] = StatusType.Ok;
|
|
}
|
|
}
|
|
|
|
private int m_maxChannels;
|
|
private String[] m_statusTexts;
|
|
private StatusType[] m_statusTypes;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This class is used by the EndopintListLB (list box).
|
|
/// Holds references to the received EndpointDescription and its MessageSecurityMode, SecurityPolicyUri, MessageSecurityMode and EncodingSupport.
|
|
/// Also prepares a user-friendly text representation of all the endpoint-rellevant characteristics.
|
|
/// The extracted EndpointDescription properties are used in selecting the right combo-box values when user clicks in the endpoint list box.
|
|
/// </summary>
|
|
private class EndpointDescriptionString
|
|
{
|
|
public EndpointDescriptionString(EndpointDescription endpointDescription)
|
|
{
|
|
m_endpointDescription = endpointDescription;
|
|
m_protocol = new Protocol(endpointDescription);
|
|
m_currentPolicy = SecurityPolicies.GetDisplayName(endpointDescription.SecurityPolicyUri);
|
|
m_messageSecurityMode = endpointDescription.SecurityMode;
|
|
|
|
switch (m_endpointDescription.EncodingSupport)
|
|
{
|
|
case BinaryEncodingSupport.None:
|
|
{
|
|
m_encoding = Encoding.Xml;
|
|
break;
|
|
}
|
|
|
|
case BinaryEncodingSupport.Optional:
|
|
case BinaryEncodingSupport.Required:
|
|
{
|
|
m_encoding = Encoding.Binary;
|
|
break;
|
|
}
|
|
}
|
|
|
|
BuildEndpointDescription();
|
|
}
|
|
|
|
public EndpointDescription EndpointDescription
|
|
{
|
|
get
|
|
{
|
|
return m_endpointDescription;
|
|
}
|
|
}
|
|
|
|
public Protocol Protocol
|
|
{
|
|
get
|
|
{
|
|
return m_protocol;
|
|
}
|
|
}
|
|
|
|
public string CurrentPolicy
|
|
{
|
|
get
|
|
{
|
|
return m_currentPolicy;
|
|
}
|
|
}
|
|
|
|
public MessageSecurityMode MessageSecurityMode
|
|
{
|
|
get
|
|
{
|
|
return m_messageSecurityMode;
|
|
}
|
|
}
|
|
|
|
public Encoding Encoding
|
|
{
|
|
get
|
|
{
|
|
return m_encoding;
|
|
}
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return m_stringRepresentation;
|
|
}
|
|
|
|
private void BuildEndpointDescription()
|
|
{
|
|
m_stringRepresentation = m_protocol.ToString() + " - ";
|
|
m_stringRepresentation += m_endpointDescription.SecurityMode + " - ";
|
|
m_stringRepresentation += SecurityPolicies.GetDisplayName(m_endpointDescription.SecurityPolicyUri) + " - ";
|
|
|
|
switch (m_endpointDescription.EncodingSupport)
|
|
{
|
|
case BinaryEncodingSupport.None:
|
|
{
|
|
m_stringRepresentation += Encoding.Xml;
|
|
break;
|
|
}
|
|
|
|
case BinaryEncodingSupport.Required:
|
|
{
|
|
m_stringRepresentation += Encoding.Binary;
|
|
break;
|
|
}
|
|
|
|
case BinaryEncodingSupport.Optional:
|
|
{
|
|
m_stringRepresentation += Encoding.Binary + "/" + Encoding.Xml;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private Protocol m_protocol;
|
|
private EndpointDescription m_endpointDescription;
|
|
private MessageSecurityMode m_messageSecurityMode;
|
|
private string m_currentPolicy;
|
|
private Encoding m_encoding;
|
|
private string m_stringRepresentation;
|
|
}
|
|
|
|
private ConfiguredEndpoint m_endpoint;
|
|
private EndpointDescription m_currentDescription;
|
|
private EndpointDescriptionCollection m_availableEndpoints;
|
|
private List<EndpointDescriptionString> m_availableEndpointsDescriptions;
|
|
private int m_discoveryTimeout;
|
|
private int m_discoverCount;
|
|
private ApplicationConfiguration m_configuration;
|
|
private bool m_updating;
|
|
private bool m_selecting;
|
|
private Dictionary<string, UserIdentityToken> m_userIdentities;
|
|
private EndpointConfiguration m_endpointConfiguration;
|
|
private bool m_discoverySucceeded;
|
|
private Uri m_discoveryUrl;
|
|
private bool m_showAllOptions;
|
|
private StatusObject m_statusObject;
|
|
#endregion
|
|
|
|
#region Public Interface
|
|
public EndpointDescriptionCollection AvailableEnpoints
|
|
{
|
|
get { return m_availableEndpoints; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The timeout in milliseconds to use when discovering servers.
|
|
/// </summary>
|
|
[System.ComponentModel.DefaultValue(20000)]
|
|
public int DiscoveryTimeout
|
|
{
|
|
get { return m_discoveryTimeout; }
|
|
set { Interlocked.Exchange(ref m_discoveryTimeout, value); }
|
|
}
|
|
/// <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;
|
|
}
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
|
|
/// <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>
|
|
/// 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;
|
|
}
|
|
|
|
/// <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;
|
|
}
|
|
|
|
private class Protocol
|
|
{
|
|
public Uri Url;
|
|
public string Profile;
|
|
|
|
public Protocol(string url)
|
|
{
|
|
Url = Utils.ParseUri(url);
|
|
}
|
|
|
|
public Protocol(EndpointDescription url)
|
|
{
|
|
Url = null;
|
|
|
|
if (url != null)
|
|
{
|
|
Url = Utils.ParseUri(url.EndpointUrl);
|
|
|
|
if ((Url != null) && (Url.Scheme == Utils.UriSchemeHttps))
|
|
{
|
|
switch (url.TransportProfileUri)
|
|
{
|
|
case Profiles.HttpsBinaryTransport:
|
|
{
|
|
Profile = "REST";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool Matches(Uri url)
|
|
{
|
|
if (url == null || Url == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (url.Scheme != Url.Scheme)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (url.DnsSafeHost != Url.DnsSafeHost)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (url.Port != Url.Port)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
if (Url == null)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
|
|
StringBuilder builder = new StringBuilder();
|
|
builder.Append(Url.Scheme);
|
|
|
|
if (!String.IsNullOrEmpty(Profile))
|
|
{
|
|
builder.Append(" ");
|
|
builder.Append(Profile);
|
|
}
|
|
|
|
builder.Append(" [");
|
|
builder.Append(Url.DnsSafeHost);
|
|
|
|
if (Url.Port != -1)
|
|
{
|
|
builder.Append(":");
|
|
builder.Append(Url.Port);
|
|
}
|
|
|
|
builder.Append("]");
|
|
|
|
return builder.ToString();
|
|
}
|
|
}
|
|
|
|
/// <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>
|
|
/// 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>
|
|
/// 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)
|
|
{
|
|
var securityPolicies = SecurityPolicies.GetDisplayNames();
|
|
foreach (var policy in securityPolicies)
|
|
{
|
|
SecurityPolicyCB.Items.Add(policy);
|
|
}
|
|
}
|
|
|
|
// 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>
|
|
/// 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;
|
|
}
|
|
|
|
private class UserTokenItem
|
|
{
|
|
public UserTokenPolicy Policy;
|
|
|
|
public UserTokenItem(UserTokenPolicy policy)
|
|
{
|
|
Policy = policy;
|
|
}
|
|
|
|
public UserTokenItem(UserTokenType tokenType)
|
|
{
|
|
Policy = new UserTokenPolicy(tokenType);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
if (Policy != null)
|
|
{
|
|
if (String.IsNullOrEmpty(Policy.PolicyId))
|
|
{
|
|
return Policy.TokenType.ToString();
|
|
}
|
|
|
|
return Utils.Format("{0} [{1}]", Policy.TokenType, Policy.PolicyId);
|
|
}
|
|
|
|
return UserTokenType.Anonymous.ToString();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes the endpoint list control.
|
|
/// </summary>
|
|
private void InitializeEndpointList(List<EndpointDescriptionString> endpoints)
|
|
{
|
|
EndpointListLB.Items.Clear();
|
|
|
|
foreach (EndpointDescriptionString endpointString in endpoints)
|
|
{
|
|
EndpointListLB.Items.Add(endpointString);
|
|
}
|
|
}
|
|
|
|
private void SelectCorrespondingEndpointFromList(EndpointDescription endpoint)
|
|
{
|
|
if (!m_selecting)
|
|
{
|
|
int index = -1;
|
|
|
|
// try to match endpoint description id
|
|
if (endpoint != null)
|
|
{
|
|
for (int ii = 0; ii < EndpointListLB.Items.Count; ii++)
|
|
{
|
|
if (endpoint == ((EndpointDescriptionString)EndpointListLB.Items[ii]).EndpointDescription)
|
|
{
|
|
index = ii;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
EndpointListLB.SelectedIndex = index;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Attempts fetch the list of servers from the discovery server.
|
|
/// </summary>
|
|
private void OnDiscoverEndpoints(object state)
|
|
{
|
|
int discoverCount = m_discoverCount;
|
|
|
|
// do nothing if a valid list is not provided.
|
|
ApplicationDescription server = state as ApplicationDescription;
|
|
|
|
if (server == null)
|
|
{
|
|
return;
|
|
|
|
}
|
|
|
|
OnUpdateStatus(new Tuple<String, StatusType>("Attempting to read latest configuration options from server.", StatusType.Ok));
|
|
|
|
String discoveryMessage = String.Empty;
|
|
|
|
// process each url.
|
|
foreach (string discoveryUrl in server.DiscoveryUrls)
|
|
{
|
|
Uri url = Utils.ParseUri(discoveryUrl);
|
|
|
|
if (url != null)
|
|
{
|
|
if (DiscoverEndpoints(url, out discoveryMessage))
|
|
{
|
|
m_discoverySucceeded = true;
|
|
m_discoveryUrl = url;
|
|
OnUpdateStatus(new Tuple<String, StatusType>("Configuration options are up to date.", StatusType.Ok));
|
|
return;
|
|
}
|
|
|
|
// check if another discover operation has started.
|
|
if (discoverCount != m_discoverCount)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
OnUpdateEndpoints(m_availableEndpoints);
|
|
OnUpdateStatus(new Tuple<String, StatusType>("Warning: Configuration options may not be correct because the server is not available (" + discoveryMessage + ").", StatusType.Warning));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches the servers from the discovery server.
|
|
/// </summary>
|
|
private bool DiscoverEndpoints(Uri discoveryUrl, out String message)
|
|
{
|
|
// use a short timeout.
|
|
EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(m_configuration);
|
|
endpointConfiguration.OperationTimeout = m_discoveryTimeout;
|
|
|
|
DiscoveryClient client = DiscoveryClient.Create(
|
|
discoveryUrl,
|
|
EndpointConfiguration.Create(m_configuration),
|
|
m_configuration);
|
|
|
|
try
|
|
{
|
|
EndpointDescriptionCollection endpoints = client.GetEndpoints(null);
|
|
OnUpdateEndpoints(endpoints);
|
|
message = String.Empty;
|
|
return true;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Utils.Trace("Could not fetch endpoints from url: {0}. Reason={1}", discoveryUrl, e.Message);
|
|
message = e.Message;
|
|
return false;
|
|
}
|
|
finally
|
|
{
|
|
client.Close();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the status displayed in the dialog.
|
|
/// </summary>
|
|
private void OnUpdateStatus(object status)
|
|
{
|
|
if (this.InvokeRequired)
|
|
{
|
|
this.BeginInvoke(new WaitCallback(OnUpdateStatus), status);
|
|
return;
|
|
}
|
|
|
|
Tuple<String, StatusType> statusTuple = status as Tuple<String, StatusType>;
|
|
m_statusObject.SetStatus(StatusChannel.Discovery, statusTuple.Item1, statusTuple.Item2);
|
|
UpdateStatus();
|
|
}
|
|
|
|
/// <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.");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates the endpoint description from current selections.
|
|
/// </summary>
|
|
private EndpointDescription CreateDescriptionFromSelections()
|
|
{
|
|
Protocol currentProtocol = (Protocol)ProtocolCB.SelectedItem;
|
|
|
|
EndpointDescription endpoint = null;
|
|
|
|
for (int ii = 0; ii < m_availableEndpoints.Count; ii++)
|
|
{
|
|
Uri url = Utils.ParseUri(m_availableEndpoints[ii].EndpointUrl);
|
|
|
|
if (url == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (endpoint == null)
|
|
{
|
|
endpoint = m_availableEndpoints[ii];
|
|
}
|
|
|
|
if (currentProtocol.Matches(url))
|
|
{
|
|
endpoint = m_availableEndpoints[ii];
|
|
break;
|
|
}
|
|
}
|
|
|
|
UriBuilder builder = null;
|
|
string scheme = Utils.UriSchemeOpcTcp;
|
|
|
|
if (currentProtocol != null && currentProtocol.Url != null)
|
|
{
|
|
scheme = currentProtocol.Url.Scheme;
|
|
}
|
|
|
|
if (endpoint == null)
|
|
{
|
|
builder = new UriBuilder();
|
|
builder.Host = "localhost";
|
|
|
|
if (scheme == Utils.UriSchemeOpcTcp)
|
|
{
|
|
builder.Port = Utils.UaTcpDefaultPort;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
builder = new UriBuilder(endpoint.EndpointUrl);
|
|
}
|
|
|
|
builder.Scheme = scheme;
|
|
|
|
endpoint = new EndpointDescription();
|
|
endpoint.EndpointUrl = builder.ToString();
|
|
endpoint.SecurityMode = (MessageSecurityMode)SecurityModeCB.SelectedItem;
|
|
endpoint.SecurityPolicyUri = SecurityPolicies.GetUri((string)SecurityPolicyCB.SelectedItem);
|
|
endpoint.Server.ApplicationName = endpoint.EndpointUrl;
|
|
endpoint.Server.ApplicationType = ApplicationType.Server;
|
|
endpoint.Server.ApplicationUri = endpoint.EndpointUrl;
|
|
|
|
return endpoint;
|
|
}
|
|
#endregion
|
|
|
|
#region Event Handlers
|
|
private void OkBTN_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
// check that discover has completed.
|
|
if (!m_discoverySucceeded)
|
|
{
|
|
DialogResult result = MessageBox.Show(
|
|
"Endpoint information may be out of date because the discovery process has not completed. Continue anyways?",
|
|
this.Text,
|
|
MessageBoxButtons.YesNo,
|
|
MessageBoxIcon.Warning);
|
|
|
|
if (result != DialogResult.Yes)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
EndpointConfiguration configuration = m_endpointConfiguration;
|
|
|
|
if (configuration == null)
|
|
{
|
|
configuration = EndpointConfiguration.Create(m_configuration);
|
|
}
|
|
|
|
if (m_currentDescription == null)
|
|
{
|
|
m_currentDescription = CreateDescriptionFromSelections();
|
|
}
|
|
|
|
// the discovery endpoint should always be on the same machine as the server.
|
|
// if there is a mismatch it is likely because the server has multiple addresses
|
|
// and was not configured to return the current address to the client.
|
|
// The code automatically updates the domain in the url.
|
|
Uri endpointUrl = Utils.ParseUri(m_currentDescription.EndpointUrl);
|
|
|
|
if (m_discoverySucceeded)
|
|
{
|
|
if (!Utils.AreDomainsEqual(endpointUrl, m_discoveryUrl))
|
|
{
|
|
UriBuilder url = new UriBuilder(endpointUrl);
|
|
|
|
url.Host = m_discoveryUrl.DnsSafeHost;
|
|
|
|
if (url.Scheme == m_discoveryUrl.Scheme)
|
|
{
|
|
url.Port = m_discoveryUrl.Port;
|
|
}
|
|
|
|
endpointUrl = url.Uri;
|
|
|
|
m_currentDescription.EndpointUrl = endpointUrl.ToString();
|
|
}
|
|
}
|
|
|
|
// set the encoding.
|
|
Encoding encoding = (Encoding)EncodingCB.SelectedItem;
|
|
configuration.UseBinaryEncoding = encoding != Encoding.Xml;
|
|
|
|
if (m_endpoint == null)
|
|
{
|
|
m_endpoint = new ConfiguredEndpoint(null, m_currentDescription, configuration);
|
|
}
|
|
else
|
|
{
|
|
m_endpoint.Update(m_currentDescription);
|
|
m_endpoint.Update(configuration);
|
|
}
|
|
|
|
DialogResult = DialogResult.OK;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
|
|
}
|
|
}
|
|
|
|
private void ProtocolCB_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
InitializeSecurityModes(m_availableEndpoints);
|
|
|
|
if (!m_updating)
|
|
{
|
|
try
|
|
{
|
|
m_updating = true;
|
|
|
|
// update current description.
|
|
m_currentDescription = FindBestEndpointDescription(m_availableEndpoints);
|
|
|
|
InitializeEncodings(m_availableEndpoints, m_currentDescription);
|
|
SelectCorrespondingEndpointFromList(m_currentDescription);
|
|
}
|
|
finally
|
|
{
|
|
m_updating = false;
|
|
}
|
|
}
|
|
|
|
if (ProtocolCB.SelectedItem != null)
|
|
{
|
|
if (((Protocol)ProtocolCB.SelectedItem).Url.DnsSafeHost != m_endpoint.EndpointUrl.DnsSafeHost)
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.SelectedProtocol, "Warning: Selected Endpoint hostname is different than initial hostname.", StatusType.Warning);
|
|
}
|
|
else
|
|
{
|
|
m_statusObject.ClearStatus(StatusChannel.SelectedProtocol);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.SelectedProtocol, "Error: Selected Protocol is invalid.", StatusType.Warning);
|
|
}
|
|
|
|
UpdateStatus();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
|
|
}
|
|
}
|
|
|
|
private void SecurityModeCB_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
InitializeSecurityPolicies(m_availableEndpoints);
|
|
|
|
if (!m_updating)
|
|
{
|
|
try
|
|
{
|
|
m_updating = true;
|
|
|
|
// update current description.
|
|
m_currentDescription = FindBestEndpointDescription(m_availableEndpoints);
|
|
|
|
InitializeEncodings(m_availableEndpoints, m_currentDescription);
|
|
SelectCorrespondingEndpointFromList(m_currentDescription);
|
|
}
|
|
finally
|
|
{
|
|
m_updating = false;
|
|
}
|
|
}
|
|
|
|
if (SecurityModeCB.SelectedItem != null)
|
|
{
|
|
if ((((MessageSecurityMode)SecurityModeCB.SelectedItem) == MessageSecurityMode.None) &&
|
|
(ProtocolCB.SelectedItem != null) && (((Protocol)ProtocolCB.SelectedItem).ToString().IndexOf("https") != 0))
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.SelectedSecurityMode, "Warning: Selected Endpoint has no security.", StatusType.Warning);
|
|
}
|
|
else if (((MessageSecurityMode)SecurityModeCB.SelectedItem) == MessageSecurityMode.Invalid)
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.SelectedSecurityMode, "Error: Selected Endpoint Security Mode is unsupported.", StatusType.Warning);
|
|
}
|
|
else
|
|
{
|
|
m_statusObject.ClearStatus(StatusChannel.SelectedSecurityMode);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.SelectedSecurityMode, "Error: Selected Endpoint Security Mode is invalid.", StatusType.Warning);
|
|
}
|
|
|
|
UpdateStatus();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
|
|
}
|
|
}
|
|
|
|
private void SecurityPolicyCB_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (!m_updating)
|
|
{
|
|
try
|
|
{
|
|
m_updating = true;
|
|
|
|
// update current description.
|
|
m_currentDescription = FindBestEndpointDescription(m_availableEndpoints);
|
|
|
|
InitializeEncodings(m_availableEndpoints, m_currentDescription);
|
|
SelectCorrespondingEndpointFromList(m_currentDescription);
|
|
}
|
|
finally
|
|
{
|
|
m_updating = false;
|
|
}
|
|
}
|
|
|
|
if (SecurityPolicyCB.SelectedItem != null)
|
|
{
|
|
m_statusObject.ClearStatus(StatusChannel.SelectedSecurityPolicy);
|
|
}
|
|
else
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.SelectedSecurityPolicy, "Error: Selected Security Policy is invalid.", StatusType.Warning);
|
|
}
|
|
|
|
UpdateStatus();
|
|
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
|
|
}
|
|
}
|
|
|
|
private void EndpointListLB_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if (!m_updating)
|
|
{
|
|
try
|
|
{
|
|
m_updating = true;
|
|
m_selecting = true;
|
|
|
|
int selectedIndex = EndpointListLB.SelectedIndex;
|
|
|
|
if (selectedIndex != -1)
|
|
{
|
|
EndpointDescriptionString selection = (EndpointDescriptionString)EndpointListLB.SelectedItem;
|
|
|
|
int index = -1;
|
|
|
|
for (int i = 0; i < ProtocolCB.Items.Count; ++i)
|
|
{
|
|
if (((Protocol)ProtocolCB.Items[i]).ToString() == selection.Protocol.ToString())
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ProtocolCB.SelectedIndex = index;
|
|
|
|
InitializeSecurityModes(m_availableEndpoints);
|
|
|
|
m_currentDescription = m_availableEndpoints[selectedIndex];
|
|
|
|
InitializeEncodings(m_availableEndpoints, m_currentDescription);
|
|
|
|
index = -1;
|
|
|
|
for (int i = 0; i < SecurityModeCB.Items.Count; ++i)
|
|
{
|
|
if ((MessageSecurityMode)SecurityModeCB.Items[i] == selection.MessageSecurityMode)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
SecurityModeCB.SelectedIndex = index;
|
|
|
|
index = -1;
|
|
|
|
for (int i = 0; i < SecurityPolicyCB.Items.Count; ++i)
|
|
{
|
|
if ((string)SecurityPolicyCB.Items[i] == selection.CurrentPolicy)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
SecurityPolicyCB.SelectedIndex = index;
|
|
|
|
index = -1;
|
|
|
|
for (int i = 0; i < EncodingCB.Items.Count; ++i)
|
|
{
|
|
if ((Encoding)EncodingCB.Items[i] == selection.Encoding)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
EncodingCB.SelectedIndex = index;
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
|
|
}
|
|
finally
|
|
{
|
|
m_updating = false;
|
|
m_selecting = false;
|
|
}
|
|
}
|
|
|
|
UpdateAdvancedEndpointInformation();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates advanced endpoint information.
|
|
/// </summary>
|
|
private void UpdateAdvancedEndpointInformation()
|
|
{
|
|
try
|
|
{
|
|
ApplicationNameTB.Text = String.Empty;
|
|
ApplicationTypeTB.Text = String.Empty;
|
|
ApplicationUriTB.Text = String.Empty;
|
|
ProductUriTB.Text = String.Empty;
|
|
GatewayServerUriTB.Text = String.Empty;
|
|
DiscoveryProfileUriTB.Text = String.Empty;
|
|
TransportProfileUriTB.Text = String.Empty;
|
|
UserSecurityPoliciesTB.Text = String.Empty;
|
|
SecurityLevelTB.Text = String.Empty;
|
|
|
|
if (m_currentDescription != null)
|
|
{
|
|
UserSecurityPoliciesTB.Text = "Anonymous";
|
|
|
|
if (m_currentDescription.Server != null)
|
|
{
|
|
if (m_currentDescription.Server.ApplicationName != null)
|
|
{
|
|
ApplicationNameTB.Text = m_currentDescription.Server.ApplicationName.ToString();
|
|
}
|
|
|
|
ApplicationTypeTB.Text = m_currentDescription.Server.ApplicationType.ToString();
|
|
ApplicationUriTB.Text = m_currentDescription.Server.ApplicationUri;
|
|
ProductUriTB.Text = m_currentDescription.Server.ProductUri;
|
|
GatewayServerUriTB.Text = m_currentDescription.Server.GatewayServerUri;
|
|
DiscoveryProfileUriTB.Text = m_currentDescription.Server.DiscoveryProfileUri;
|
|
}
|
|
|
|
SecurityLevelTB.Text = m_currentDescription.SecurityLevel.ToString();
|
|
TransportProfileUriTB.Text = m_currentDescription.TransportProfileUri;
|
|
|
|
if (m_currentDescription.UserIdentityTokens.Count > 0)
|
|
{
|
|
UserSecurityPoliciesTB.Text = String.Join(", ", m_currentDescription.UserIdentityTokens);
|
|
}
|
|
}
|
|
|
|
UpdateStatus();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the StatusTB text and color.
|
|
/// Also enables/disables the OK button, should any error occurr (unsupported stuff etc).
|
|
/// </summary>
|
|
private void UpdateStatus()
|
|
{
|
|
try
|
|
{
|
|
if ((m_currentDescription != null) && (m_currentDescription.Server != null))
|
|
{
|
|
m_statusObject.ClearStatus(StatusChannel.Server);
|
|
|
|
if (m_currentDescription.Server.ApplicationType == ApplicationType.Client)
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.ApplicationType, "Warning: Application type is unsupported.", StatusType.Warning);
|
|
}
|
|
else
|
|
{
|
|
m_statusObject.ClearStatus(StatusChannel.ApplicationType);
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(m_currentDescription.Server.ApplicationUri))
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.ApplicationUri, "Warning: Application URI is missing.", StatusType.Warning);
|
|
}
|
|
else
|
|
{
|
|
m_statusObject.ClearStatus(StatusChannel.ApplicationUri);
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(m_currentDescription.TransportProfileUri))
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.TransportProfileUri, "Warning: Transport Profile URI is missing.", StatusType.Warning);
|
|
}
|
|
else if (Utils.ParseUri(m_currentDescription.TransportProfileUri) == null)
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.TransportProfileUri, "Warning: Transport Profile URI is invalid.", StatusType.Warning);
|
|
}
|
|
|
|
if ((m_currentDescription.Server.DiscoveryUrls == null) || (m_currentDescription.Server.DiscoveryUrls.Count == 0))
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.DiscoveryURLs, "Warning: Discovery URLs are missing.", StatusType.Warning);
|
|
}
|
|
else
|
|
{
|
|
m_statusObject.ClearStatus(StatusChannel.DiscoveryURLs);
|
|
}
|
|
|
|
if ((m_currentDescription.ServerCertificate != null) && (m_currentDescription.ServerCertificate.Length > 0))
|
|
{
|
|
X509Certificate2 serverCertificate = new X509Certificate2(m_currentDescription.ServerCertificate);
|
|
String certificateApplicationUri = X509Utils.GetApplicationUriFromCertificate(serverCertificate);
|
|
|
|
if (certificateApplicationUri != m_currentDescription.Server.ApplicationUri)
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.DifferentCertificate, "Warning: Application URI host different than the certificate host.", StatusType.Warning);
|
|
}
|
|
else
|
|
{
|
|
m_statusObject.ClearStatus(StatusChannel.DifferentCertificate);
|
|
}
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(m_currentDescription.SecurityPolicyUri))
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.SecurityPolicyUri, "Error: Security Policy URI is missing.", StatusType.Warning);
|
|
}
|
|
else if (string.IsNullOrEmpty(SecurityPolicies.GetDisplayName(m_currentDescription.SecurityPolicyUri)))
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.SecurityPolicyUri, "Error: Security Policy URI is invalid.", StatusType.Warning);
|
|
}
|
|
else
|
|
{
|
|
m_statusObject.ClearStatus(StatusChannel.SecurityPolicyUri);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_statusObject.SetStatus(StatusChannel.Server, "Warning: Server endpoint is invalid.", StatusType.Warning);
|
|
}
|
|
|
|
|
|
OkBTN.Enabled = true;
|
|
StatusTB.ForeColor = SystemColors.WindowText;
|
|
StatusTB.Text = m_statusObject.StatusString;
|
|
|
|
if (m_statusObject.StatusType == StatusType.Error)
|
|
{
|
|
OkBTN.Enabled = false;
|
|
StatusTB.ForeColor = Color.Red;
|
|
}
|
|
else if (m_statusObject.StatusType == StatusType.Warning)
|
|
{
|
|
StatusTB.ForeColor = Color.DarkOrange;
|
|
}
|
|
|
|
// hack for WinForms to update color
|
|
StatusTB.BackColor = StatusTB.BackColor;
|
|
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|