mxaccess/analysis/decompiled/aaServicesProxyIData/ArchestrAServices.Proxy/ASBDataProxy.cs

#define TRACE
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Security.Cryptography.X509Certificates;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Discovery;
using System.ServiceModel.Security;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using ArchestrAServices.ASBContract;
using ArchestrAServices.ASBIDataContract;
using ArchestrAServices.Common;
using ArchestrAServices.Contract;

namespace ArchestrAServices.Proxy;

public class ASBDataProxy : IData, IDisposable
{
	public class ConnectionDelegate
	{
		private readonly IASBIData dataClientField;

		public ConnectionDelegate(IASBIData dataClient)
		{
			dataClientField = dataClient;
		}

		private ConnectionDelegate()
		{
			dataClientField = null;
		}

		public ConnectResponse CallConnect(ConnectRequest request)
		{
			if (dataClientField != null)
			{
				return dataClientField.Connect(request);
			}
			return new ConnectResponse
			{
				Result = ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0)
			};
		}

		public void CallAuthenticateMe(AuthenticateMe request)
		{
			if (dataClientField != null)
			{
				dataClientField.AuthenticateMe(request);
			}
		}

		public void CallDisconnect(Disconnect request)
		{
			if (dataClientField != null)
			{
				dataClientField.Disconnect(request);
			}
		}
	}

	public static TraceSource ASBDataProxyCustom = new TraceSource("ASBDataProxyLogs");

	private static readonly XmlQualifiedName qualifiedName = new XmlQualifiedName("IASBIData", "http://ArchestrAServices.Contract");

	private static readonly XmlQualifiedName securedQualifiedName = new XmlQualifiedName("IASBIDataS", "http://ArchestrAServices.Contract");

	public Guid m_ConnectionId = Guid.Empty;

	private readonly string m_AccessName;

	private ChannelFactory<IASBIData> m_DataProviderFactory;

	private IASBIData IDataClient;

	private readonly object connectionLock;

	private ManualResetEvent connectionEstablishedEvent;

	private List<string> accumulatedErrorMsg;

	private object errorMsgLock;

	private readonly string customSerializerSearchString = "/binding/customserializer/version1";

	private readonly ConfiguredLogger aaLoggerConfig;

	public bool Connected
	{
		get
		{
			if (IDataClient != null)
			{
				return ((IClientChannel)IDataClient).State != CommunicationState.Faulted;
			}
			return false;
		}
	}

	public CommunicationState ChannelState
	{
		get
		{
			if (IDataClient == null)
			{
				return CommunicationState.Faulted;
			}
			return ((IClientChannel)IDataClient).State;
		}
	}

	public SecureCommunicationModes SecureCommunicationMode { get; set; }

	public ASBDataProxy(string AccessName)
	{
		m_AccessName = AccessName;
		connectionLock = new object();
		Process currentProcess = Process.GetCurrentProcess();
		if (currentProcess != null)
		{
			aaLoggerConfig = new ConfiguredLogger(currentProcess.ProcessName);
			aaLoggerConfig.ChangeSourceLevel("DataFlowLogs", SourceLevels.All);
			aaLoggerConfig.ChangeSourceLevel("ControlFlowLogs", SourceLevels.All);
			aaLoggerConfig.ChangeSourceLevel("CommandLogs", SourceLevels.All);
			aaLoggerConfig.ChangeSourceLevel("ExceptionLogs", SourceLevels.All);
			aaLoggerConfig.ChangeSourceLevel("DiagnosticsLogs", SourceLevels.All);
			aaLoggerConfig.AddCustomTraceSource("ASBDataProxyLogs", ASBDataProxyCustom, "ASBDataProxy");
			aaLoggerConfig.ChangeSourceLevel("ASBDataProxyLogs", SourceLevels.All);
		}
		SecureCommunicationMode = RegistryHandler.SecureCommunicationMode;
	}

	public static FindResponse FindIDataEndpoint(string AccessName)
	{
		return FindIDataEndpoint(AccessName, SecureCommunicationModes.Never);
	}

	public static FindResponse FindIDataEndpoint(string AccessName, SecureCommunicationModes secureCommunicationMode)
	{
		if (secureCommunicationMode == SecureCommunicationModes.Preferred || secureCommunicationMode == SecureCommunicationModes.Required)
		{
			FindResponse findResponse = DiscoverEndpointsInternal(AccessName, securedQualifiedName);
			if (findResponse != null && findResponse.Endpoints.Any())
			{
				return findResponse;
			}
		}
		if (secureCommunicationMode != SecureCommunicationModes.Required)
		{
			return DiscoverEndpointsInternal(AccessName, qualifiedName);
		}
		return null;
	}

	public bool Connect(out string errorMessage)
	{
		errorMessage = string.Empty;
		switch (SecureCommunicationMode)
		{
		case SecureCommunicationModes.Required:
			return ConnectInternal(secured: true, out errorMessage);
		case SecureCommunicationModes.Preferred:
		{
			bool flag = ConnectInternal(secured: true, out errorMessage);
			if (!flag)
			{
				SvcTrace.DiagControl.TraceEvent(TraceEventType.Information, 0, "Attempting the fallback connection - reason {0}", errorMessage);
				flag = ConnectInternal(secured: false, out errorMessage);
			}
			return flag;
		}
		default:
			return ConnectInternal(secured: false, out errorMessage);
		}
	}

	private bool ConnectInternal(bool secured, out string errorMessage)
	{
		try
		{
			Reset();
		}
		catch (Exception ex)
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Warning, 0, "Connection reset failed : {0} \n Stack: {1}", ex.Message, ex.StackTrace);
		}
		errorMessage = string.Empty;
		bool result = false;
		bool useCustomSerializer = false;
		string SolutionName = string.Empty;
		EndpointDiscoveryMetadata endpointDiscoveryMetadata = null;
		string accessName = m_AccessName;
		int secureCommunicationMode;
		if (!secured)
		{
			secureCommunicationMode = 0;
		}
		else
		{
			SecureCommunicationModes secureCommunicationModes = (SecureCommunicationMode = SecureCommunicationModes.Required);
			secureCommunicationMode = (int)secureCommunicationModes;
		}
		FindResponse findResponse = FindIDataEndpoint(accessName, (SecureCommunicationModes)secureCommunicationMode);
		if (findResponse != null && findResponse.Endpoints != null && findResponse.Endpoints.Count != 0)
		{
			endpointDiscoveryMetadata = SelectEndpointToConnectTo(findResponse, ref useCustomSerializer);
			if (endpointDiscoveryMetadata != null)
			{
				ASBSolutionManager aSBSolutionManager = new ASBSolutionManager();
				SolutionName = aSBSolutionManager.GetASBSolutionName(endpointDiscoveryMetadata, out errorMessage);
				if (string.IsNullOrEmpty(errorMessage))
				{
					aSBSolutionManager.GetASBSolutionPassphrase(SolutionName, out errorMessage);
				}
			}
			else
			{
				SvcTrace.DiagException.TraceEvent(TraceEventType.Warning, 0, "Connect found no endpoints for access name {0} that were configured correctly", m_AccessName);
			}
		}
		else if (findResponse != null)
		{
			if (findResponse.Endpoints != null)
			{
				if (findResponse.Endpoints.Count == 0)
				{
					SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "Connect found no endpoints for IData with access name {0}", m_AccessName);
				}
			}
			else
			{
				SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "Connect FindResponse has a null Endpoints member finding IData with access name {0}", m_AccessName);
			}
		}
		else
		{
			SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "Connect null FindResponse finding IData with access name {0}", m_AccessName);
		}
		if (string.IsNullOrEmpty(errorMessage))
		{
			if (endpointDiscoveryMetadata != null)
			{
				bool useSecureConnection = endpointDiscoveryMetadata.ContractTypeNames[0] == securedQualifiedName;
				lock (connectionLock)
				{
					m_DataProviderFactory = null;
					IDataClient = null;
					m_ConnectionId = Guid.Empty;
				}
				connectionEstablishedEvent = new ManualResetEvent(initialState: false);
				accumulatedErrorMsg = new List<string>();
				errorMsgLock = new object();
				foreach (Uri endpointUri in endpointDiscoveryMetadata.ListenUris)
				{
					string SelectedEndpointUri = endpointUri.ToString();
					Task.Factory.StartNew(delegate
					{
						NetTcpBindingSecurityMode securityMode;
						EndpointAddress iDataProviderEndpoint;
						if (useSecureConnection)
						{
							securityMode = NetTcpBindingSecurityMode.CertificateEncryption;
							IPHostEntry hostEntry = Dns.GetHostEntry(endpointUri.Host);
							iDataProviderEndpoint = new EndpointAddress(endpointUri, EndpointIdentity.CreateDnsIdentity(hostEntry.HostName));
						}
						else
						{
							securityMode = NetTcpBindingSecurityMode.None;
							iDataProviderEndpoint = new EndpointAddress(SelectedEndpointUri);
						}
						Binding binding = SvcUtilities.GetBinding(SelectedEndpointUri, securityMode);
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Information, 0, "Try connecting with endpoint {0}", SelectedEndpointUri);
						if (InternalConnect(iDataProviderEndpoint, binding, SolutionName, out var errorMessage2, useCustomSerializer))
						{
							SvcTrace.DiagControl.TraceEvent(TraceEventType.Information, 0, "Connected to IData endpoint {0}", SelectedEndpointUri);
						}
						else if (errorMessage2 != null)
						{
							lock (errorMsgLock)
							{
								accumulatedErrorMsg.Add(errorMessage2);
							}
						}
					});
				}
				connectionEstablishedEvent.WaitOne(20000);
				connectionEstablishedEvent.Close();
				connectionEstablishedEvent = null;
				lock (connectionLock)
				{
					result = true;
					if (m_DataProviderFactory == null)
					{
						foreach (string item in accumulatedErrorMsg)
						{
							SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, item);
						}
						result = false;
					}
				}
			}
			else
			{
				string text = $"There are no endpoints selected for the namespace: '{m_AccessName}'. Confirm that \r";
				string text2 = $"a) local galaxy and remote galaxy {m_AccessName} specify the same UDS \r";
				string text3 = $"b) local galaxy has been paired with remote galaxy {m_AccessName} \r";
				string text4 = $"c) MxDataProvider service has been deployed on galaxy {m_AccessName}.";
				errorMessage = $"{text}{text2}{text3}{text4}";
			}
		}
		return result;
	}

	public EndpointDiscoveryMetadata SelectEndpointToConnectTo(FindResponse findResponse, ref bool useCustomSerializer)
	{
		EndpointDiscoveryMetadata result = null;
		List<EndpointDiscoveryMetadata> list = new List<EndpointDiscoveryMetadata>();
		List<EndpointDiscoveryMetadata> list2 = new List<EndpointDiscoveryMetadata>();
		bool flag = false;
		foreach (EndpointDiscoveryMetadata endpoint in findResponse.Endpoints)
		{
			foreach (Uri scope in endpoint.Scopes)
			{
				if (scope.AbsolutePath.Contains(customSerializerSearchString))
				{
					ASBDataProxyCustom.TraceEvent(TraceEventType.Information, 0, "ASBIData custom-serialization scope is found.");
					flag = true;
					break;
				}
			}
			if (flag)
			{
				list2.Add(endpoint);
			}
			else
			{
				list.Add(endpoint);
			}
			flag = false;
		}
		Random random = new Random(DateTime.Now.Millisecond);
		if (list2.Count != 0)
		{
			useCustomSerializer = true;
			result = list2[random.Next(list2.Count)];
		}
		else if (list.Count != 0)
		{
			useCustomSerializer = false;
			result = list[random.Next(list.Count)];
		}
		return result;
	}

	public bool Connect(EndpointDiscoveryMetadata SelectedMetadata, out string errorMessage)
	{
		errorMessage = string.Empty;
		bool useCustomSerializer = false;
		foreach (Uri scope in SelectedMetadata.Scopes)
		{
			if (scope.AbsolutePath.Contains(customSerializerSearchString))
			{
				useCustomSerializer = true;
				break;
			}
		}
		bool num = SelectedMetadata.ContractTypeNames[0] == securedQualifiedName;
		string text = SelectedMetadata.Address.Uri.ToString();
		NetTcpBindingSecurityMode securityMode;
		EndpointAddress iDataProviderEndpoint;
		if (num)
		{
			securityMode = NetTcpBindingSecurityMode.CertificateEncryption;
			IPHostEntry hostEntry = Dns.GetHostEntry(SelectedMetadata.Address.Uri.Host);
			iDataProviderEndpoint = new EndpointAddress(SelectedMetadata.Address.Uri, EndpointIdentity.CreateDnsIdentity(hostEntry.HostName));
		}
		else
		{
			securityMode = NetTcpBindingSecurityMode.None;
			iDataProviderEndpoint = new EndpointAddress(text);
		}
		Binding binding = SvcUtilities.GetBinding(text, securityMode);
		ASBSolutionManager aSBSolutionManager = new ASBSolutionManager();
		string aSBSolutionName = aSBSolutionManager.GetASBSolutionName(SelectedMetadata, out errorMessage);
		if (string.IsNullOrEmpty(errorMessage))
		{
			aSBSolutionManager.GetASBSolutionPassphrase(aSBSolutionName, out errorMessage);
		}
		if (string.IsNullOrEmpty(errorMessage))
		{
			bool num2 = InternalConnect(iDataProviderEndpoint, binding, aSBSolutionName, out errorMessage, useCustomSerializer);
			if (!num2 && errorMessage != null)
			{
				SvcTrace.DiagControl.TraceEvent(TraceEventType.Error, 0, errorMessage);
			}
			return num2;
		}
		return false;
	}

	public void Disconnect()
	{
		SysAuthClientAuthentication.DisconnectSecureSession(m_ConnectionId, CallDisconnect);
	}

	public void Abort()
	{
		Reset();
	}

	public ArchestrAServices.ASBContract.ArchestrAResult KeepAlive(ArchestrAServices.ASBContract.ConnectionId Id)
	{
		return KeepAlive();
	}

	public ArchestrAServices.ASBContract.ArchestrAResult KeepAlive()
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				KeepAlive keepAlive = new KeepAlive();
				keepAlive.ConnectionValidator.ConnectionId = m_ConnectionId;
				clientAuthenticator.Sign(keepAlive);
				IDataClient.KeepAlive(keepAlive);
				return ArchestrAServices.ASBContract.ResultFactory.MakeGoodResult();
			}
		}
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Read(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.RuntimeValue[] Values, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items)
	{
		return Read(out Status, out Values, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Read(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.RuntimeValue[] Values, ArchestrAServices.ASBContract.ItemIdentity[] Items)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				ReadRequest readRequest = new ReadRequest();
				readRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				readRequest.Items = Items;
				clientAuthenticator.Sign(readRequest);
				ReadResponse readResponse = IDataClient.Read(readRequest);
				if (readResponse != null)
				{
					Status = readResponse.Status;
					Values = readResponse.Values;
					return readResponse.Result;
				}
			}
		}
		Status = null;
		Values = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Write(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items, ArchestrAServices.ASBContract.WriteValue[] Values, uint WriteHandle)
	{
		return Write(out Status, Items, Values, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Write(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ItemIdentity[] Items, ArchestrAServices.ASBContract.WriteValue[] Values, uint WriteHandle)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				WriteBasicRequest writeBasicRequest = new WriteBasicRequest();
				writeBasicRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				writeBasicRequest.Items = Items;
				writeBasicRequest.Values = Values;
				writeBasicRequest.WriteHandle = WriteHandle;
				clientAuthenticator.Sign(writeBasicRequest);
				WriteResponse writeResponse = IDataClient.Write(writeBasicRequest);
				if (writeResponse != null)
				{
					Status = writeResponse.Status;
					return writeResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteUser(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items, ArchestrAServices.ASBContract.WriteValue[] Values, ArchestrAServices.ASBContract.UserToken User, uint WriteHandle)
	{
		return WriteUser(out Status, Items, Values, User, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteUser(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ItemIdentity[] Items, ArchestrAServices.ASBContract.WriteValue[] Values, ArchestrAServices.ASBContract.UserToken User, uint WriteHandle)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				WriteUserRequest writeUserRequest = new WriteUserRequest();
				writeUserRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				writeUserRequest.Items = Items;
				writeUserRequest.Values = Values;
				writeUserRequest.User = User;
				writeUserRequest.WriteHandle = WriteHandle;
				clientAuthenticator.Sign(writeUserRequest);
				WriteUserResponse writeUserResponse = IDataClient.WriteUser(writeUserRequest);
				if (writeUserResponse != null)
				{
					Status = writeUserResponse.Status;
					return writeUserResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteVerified(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items, ArchestrAServices.ASBContract.WriteValue[] Values, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor, uint WriteHandle)
	{
		return WriteVerified(out Status, Items, Values, User, Supervisor, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteVerified(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ItemIdentity[] Items, ArchestrAServices.ASBContract.WriteValue[] Values, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor, uint WriteHandle)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				WriteVerifiedRequest writeVerifiedRequest = new WriteVerifiedRequest();
				writeVerifiedRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				writeVerifiedRequest.Items = Items;
				writeVerifiedRequest.Values = Values;
				writeVerifiedRequest.User = User;
				writeVerifiedRequest.Supervisor = Supervisor;
				writeVerifiedRequest.WriteHandle = WriteHandle;
				clientAuthenticator.Sign(writeVerifiedRequest);
				WriteVerifiedResponse writeVerifiedResponse = IDataClient.WriteVerified(writeVerifiedRequest);
				if (writeVerifiedResponse != null)
				{
					Status = writeVerifiedResponse.Status;
					return writeVerifiedResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteSecured(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items, ArchestrAServices.ASBContract.WriteValue[] Values, ArchestrAServices.ASBContract.UserToken User, uint WriteHandle)
	{
		return WriteSecured(out Status, Items, Values, User, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteSecured(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ItemIdentity[] Items, ArchestrAServices.ASBContract.WriteValue[] Values, ArchestrAServices.ASBContract.UserToken User, uint WriteHandle)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				WriteSecuredRequest writeSecuredRequest = new WriteSecuredRequest();
				writeSecuredRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				writeSecuredRequest.Items = Items;
				writeSecuredRequest.Values = Values;
				writeSecuredRequest.User = User;
				writeSecuredRequest.WriteHandle = WriteHandle;
				clientAuthenticator.Sign(writeSecuredRequest);
				WriteSecuredResponse writeSecuredResponse = IDataClient.WriteSecured(writeSecuredRequest);
				if (writeSecuredResponse != null)
				{
					Status = writeSecuredResponse.Status;
					return writeSecuredResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteConfirmed(out ArchestrAServices.ASBContract.WriteValue ValueReceived, out long WriteToken, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity Item, ArchestrAServices.ASBContract.WriteValue Value, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor)
	{
		return WriteConfirmed(out ValueReceived, out WriteToken, Item, Value, User, Supervisor);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteConfirmed(out ArchestrAServices.ASBContract.WriteValue ValueReceived, out long WriteToken, ArchestrAServices.ASBContract.ItemIdentity Item, ArchestrAServices.ASBContract.WriteValue Value, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				WriteConfirmedRequest writeConfirmedRequest = new WriteConfirmedRequest();
				writeConfirmedRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				writeConfirmedRequest.Item = Item;
				writeConfirmedRequest.Value = Value;
				writeConfirmedRequest.User = User;
				writeConfirmedRequest.Supervisor = Supervisor;
				clientAuthenticator.Sign(writeConfirmedRequest);
				WriteConfirmedResponse writeConfirmedResponse = IDataClient.WriteConfirmed(writeConfirmedRequest);
				if (writeConfirmedResponse != null)
				{
					ValueReceived = writeConfirmedResponse.ValueReceived;
					WriteToken = writeConfirmedResponse.WriteToken;
					return writeConfirmedResponse.Result;
				}
			}
		}
		ValueReceived = default(ArchestrAServices.ASBContract.WriteValue);
		WriteToken = long.MaxValue;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult ConfirmWrite(ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity Item, long WriteToken, ArchestrAServices.ASBContract.WriteValue Value, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor, uint WriteHandle)
	{
		return ConfirmWrite(Item, WriteToken, Value, User, Supervisor, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult ConfirmWrite(ArchestrAServices.ASBContract.ItemIdentity Item, long WriteToken, ArchestrAServices.ASBContract.WriteValue Value, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor, uint WriteHandle)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				ConfirmWriteRequest confirmWriteRequest = new ConfirmWriteRequest();
				confirmWriteRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				confirmWriteRequest.Item = Item;
				confirmWriteRequest.WriteToken = WriteToken;
				confirmWriteRequest.Value = Value;
				confirmWriteRequest.User = User;
				confirmWriteRequest.Supervisor = Supervisor;
				confirmWriteRequest.WriteHandle = WriteHandle;
				clientAuthenticator.Sign(confirmWriteRequest);
				ConfirmWriteResponse confirmWriteResponse = IDataClient.ConfirmWrite(confirmWriteRequest);
				if (confirmWriteResponse != null)
				{
					return confirmWriteResponse.Result;
				}
			}
		}
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult PublishWriteComplete(out ArchestrAServices.ASBContract.ItemWriteComplete[] CompleteWrites, ArchestrAServices.ASBContract.ConnectionId Id)
	{
		return PublishWriteComplete(out CompleteWrites);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult PublishWriteComplete(out ArchestrAServices.ASBContract.ItemWriteComplete[] CompleteWrites)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				PublishWriteCompleteRequest publishWriteCompleteRequest = new PublishWriteCompleteRequest();
				publishWriteCompleteRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				clientAuthenticator.Sign(publishWriteCompleteRequest);
				PublishWriteCompleteResponse publishWriteCompleteResponse = IDataClient.PublishWriteComplete(publishWriteCompleteRequest);
				if (publishWriteCompleteResponse != null)
				{
					CompleteWrites = publishWriteCompleteResponse.CompleteWrites;
					return publishWriteCompleteResponse.Result;
				}
			}
		}
		CompleteWrites = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult CreateSubscription(out long SubscriptionId, ArchestrAServices.ASBContract.ConnectionId Id, long MaxQueueSize, ulong SampleInterval)
	{
		return CreateSubscription(out SubscriptionId, MaxQueueSize, SampleInterval);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult CreateSubscription(out long SubscriptionId, long MaxQueueSize, ulong SampleInterval)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				CreateSubscriptionRequest createSubscriptionRequest = new CreateSubscriptionRequest();
				createSubscriptionRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				createSubscriptionRequest.MaxQueueSize = MaxQueueSize;
				createSubscriptionRequest.SampleInterval = SampleInterval;
				clientAuthenticator.Sign(createSubscriptionRequest);
				CreateSubscriptionResponse createSubscriptionResponse = IDataClient.CreateSubscription(createSubscriptionRequest);
				if (createSubscriptionResponse != null)
				{
					SubscriptionId = createSubscriptionResponse.SubscriptionId;
					return createSubscriptionResponse.Result;
				}
			}
		}
		SubscriptionId = long.MaxValue;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult SetSubscriptionState(ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId, ArchestrAServices.ASBIDataContract.Variant NewState, ushort StateToChange)
	{
		return SetSubscriptionState(SubscriptionId, NewState, StateToChange);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult SetSubscriptionState(long SubscriptionId, ArchestrAServices.ASBIDataContract.Variant NewState, ushort StateToChange)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				SetSubscriptionStateRequest setSubscriptionStateRequest = new SetSubscriptionStateRequest();
				setSubscriptionStateRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				setSubscriptionStateRequest.SubscriptionId = SubscriptionId;
				setSubscriptionStateRequest.NewStateProperty = NewState;
				setSubscriptionStateRequest.StateToChange = StateToChange;
				clientAuthenticator.Sign(setSubscriptionStateRequest);
				SetSubscriptionStateResponse setSubscriptionStateResponse = IDataClient.SetSubscriptionState(setSubscriptionStateRequest);
				if (setSubscriptionStateResponse != null)
				{
					return setSubscriptionStateResponse.Result;
				}
			}
		}
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult GetSubscriptionState(out ArchestrAServices.ASBIDataContract.Variant State, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId, ushort StateToGet)
	{
		return GetSubscriptionState(out State, SubscriptionId, StateToGet);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult GetSubscriptionState(out ArchestrAServices.ASBIDataContract.Variant State, long SubscriptionId, ushort StateToGet)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				GetSubscriptionStateRequest getSubscriptionStateRequest = new GetSubscriptionStateRequest();
				getSubscriptionStateRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				getSubscriptionStateRequest.SubscriptionId = SubscriptionId;
				getSubscriptionStateRequest.StateToGet = StateToGet;
				clientAuthenticator.Sign(getSubscriptionStateRequest);
				GetSubscriptionStateResponse subscriptionState = IDataClient.GetSubscriptionState(getSubscriptionStateRequest);
				if (subscriptionState != null)
				{
					State = subscriptionState.StateProperty;
					return subscriptionState.Result;
				}
			}
		}
		State = default(ArchestrAServices.ASBIDataContract.Variant);
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult DeleteSubscription(ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId)
	{
		return DeleteSubscription(SubscriptionId);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult DeleteSubscription(long SubscriptionId)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				DeleteSubscriptionRequest deleteSubscriptionRequest = new DeleteSubscriptionRequest();
				deleteSubscriptionRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				deleteSubscriptionRequest.SubscriptionId = SubscriptionId;
				clientAuthenticator.Sign(deleteSubscriptionRequest);
				DeleteSubscriptionResponse deleteSubscriptionResponse = IDataClient.DeleteSubscription(deleteSubscriptionRequest);
				if (deleteSubscriptionResponse != null)
				{
					return deleteSubscriptionResponse.Result;
				}
			}
		}
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult AddMonitoredItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId, ArchestrAServices.ASBContract.MonitoredItem[] Items, byte RequireId)
	{
		return AddMonitoredItems(out Status, out ItemCapabilities, SubscriptionId, RequireId != 0, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult AddMonitoredItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, long SubscriptionId, ArchestrAServices.ASBContract.MonitoredItem[] Items, byte RequireId)
	{
		return AddMonitoredItems(out Status, out ItemCapabilities, SubscriptionId, RequireId != 0, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult AddMonitoredItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, long SubscriptionId, bool RequireId, ArchestrAServices.ASBContract.MonitoredItem[] Items)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				AddMonitoredItemsRequest addMonitoredItemsRequest = new AddMonitoredItemsRequest();
				addMonitoredItemsRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				addMonitoredItemsRequest.SubscriptionId = SubscriptionId;
				addMonitoredItemsRequest.Items = Items;
				addMonitoredItemsRequest.RequireId = RequireId;
				clientAuthenticator.Sign(addMonitoredItemsRequest);
				AddMonitoredItemsResponse addMonitoredItemsResponse = IDataClient.AddMonitoredItems(addMonitoredItemsRequest);
				if (addMonitoredItemsResponse != null)
				{
					Status = addMonitoredItemsResponse.Status;
					ItemCapabilities = addMonitoredItemsResponse.ItemCapabilities;
					return addMonitoredItemsResponse.Result;
				}
			}
		}
		Status = null;
		ItemCapabilities = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult DeleteMonitoredItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId, ArchestrAServices.ASBContract.MonitoredItem[] Items)
	{
		return DeleteMonitoredItems(out Status, SubscriptionId, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult DeleteMonitoredItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, long SubscriptionId, ArchestrAServices.ASBContract.MonitoredItem[] Items)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				DeleteMonitoredItemsRequest deleteMonitoredItemsRequest = new DeleteMonitoredItemsRequest();
				deleteMonitoredItemsRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				deleteMonitoredItemsRequest.SubscriptionId = SubscriptionId;
				deleteMonitoredItemsRequest.Items = Items;
				clientAuthenticator.Sign(deleteMonitoredItemsRequest);
				DeleteMonitoredItemsResponse deleteMonitoredItemsResponse = IDataClient.DeleteMonitoredItems(deleteMonitoredItemsRequest);
				if (deleteMonitoredItemsResponse != null)
				{
					Status = deleteMonitoredItemsResponse.Status;
					return deleteMonitoredItemsResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult GetMonitoredItems(out ArchestrAServices.ASBContract.MonitoredItem[] Items, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId)
	{
		return GetMonitoredItems(out Items, SubscriptionId);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult GetMonitoredItems(out ArchestrAServices.ASBContract.MonitoredItem[] Items, long SubscriptionId)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				GetMonitoredItemsRequest getMonitoredItemsRequest = new GetMonitoredItemsRequest();
				getMonitoredItemsRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				getMonitoredItemsRequest.SubscriptionId = SubscriptionId;
				clientAuthenticator.Sign(getMonitoredItemsRequest);
				GetMonitoredItemsResponse monitoredItems = IDataClient.GetMonitoredItems(getMonitoredItemsRequest);
				if (monitoredItems != null)
				{
					Items = monitoredItems.Items;
					return monitoredItems.Result;
				}
			}
		}
		Items = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Publish(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.MonitoredItemValue[] Values, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId)
	{
		return Publish(out Status, out Values, SubscriptionId);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Publish(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.MonitoredItemValue[] Values, long SubscriptionId)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				PublishRequest publishRequest = new PublishRequest();
				publishRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				publishRequest.SubscriptionId = SubscriptionId;
				clientAuthenticator.Sign(publishRequest);
				PublishResponse publishResponse = IDataClient.Publish(publishRequest);
				if (publishResponse != null)
				{
					Status = publishResponse.Status;
					Values = publishResponse.Values;
					return publishResponse.Result;
				}
			}
		}
		Status = null;
		Values = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult RegisterItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items, byte RequireId, byte RegisterOnly)
	{
		return RegisterItems(out Status, out ItemCapabilities, RequireId != 0, RegisterOnly != 0, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult RegisterItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, ArchestrAServices.ASBContract.ItemIdentity[] Items, byte RequireId, byte RegisterOnly)
	{
		return RegisterItems(out Status, out ItemCapabilities, RequireId != 0, RegisterOnly != 0, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult RegisterItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, bool RequireId, bool RegisterOnly, ArchestrAServices.ASBContract.ItemIdentity[] Items)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				RegisterItemsRequest registerItemsRequest = new RegisterItemsRequest();
				registerItemsRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				registerItemsRequest.Items = Items;
				registerItemsRequest.RequireId = RequireId;
				registerItemsRequest.RegisterOnly = RegisterOnly;
				clientAuthenticator.Sign(registerItemsRequest);
				RegisterItemsResponse registerItemsResponse = IDataClient.RegisterItems(registerItemsRequest);
				if (registerItemsResponse != null)
				{
					Status = registerItemsResponse.Status;
					ItemCapabilities = registerItemsResponse.ItemCapabilities;
					return registerItemsResponse.Result;
				}
			}
		}
		Status = null;
		ItemCapabilities = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult UnregisterItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items)
	{
		return UnregisterItems(out Status, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult UnregisterItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ItemIdentity[] Items)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				UnregisterItemsRequest unregisterItemsRequest = new UnregisterItemsRequest();
				unregisterItemsRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				unregisterItemsRequest.Items = Items;
				clientAuthenticator.Sign(unregisterItemsRequest);
				UnregisterItemsResponse unregisterItemsResponse = IDataClient.UnregisterItems(unregisterItemsRequest);
				if (unregisterItemsResponse != null)
				{
					Status = unregisterItemsResponse.Status;
					return unregisterItemsResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public void OnConnect(ArchestrAServices.ASBContract.ConnectionId ConnectionId, ulong Timeout)
	{
	}

	public void OnDisconnect(ArchestrAServices.ASBContract.ConnectionId Id)
	{
	}

	public void Dispose()
	{
		Dispose(disposing: true);
		GC.SuppressFinalize(this);
	}

	protected virtual void Dispose(bool disposing)
	{
		if (!disposing)
		{
			return;
		}
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null && clientAuthenticator.SecureSessionEstablished)
			{
				Disconnect();
			}
			IClientChannel obj = IDataClient as IClientChannel;
			obj?.Close();
			obj?.Dispose();
		}
		connectionEstablishedEvent?.Close();
		connectionEstablishedEvent = null;
	}

	private static FindResponse DiscoverEndpointsInternal(string AccessName, XmlQualifiedName qualifiedName)
	{
		FindResponse result = null;
		try
		{
			Uri uri = RegistryHandler.MakeLDSProbeEndpointAddress(Environment.MachineName);
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "FindIDataEndpoint generated LDS endpoint for SR Node localhost: {0}", uri.AbsoluteUri);
			using DiscoveryClient discoveryClient = new DiscoveryClient(new DiscoveryEndpoint(SvcUtilities.GetBinding(uri.AbsoluteUri), new EndpointAddress(uri)));
			FindCriteria findCriteria = new FindCriteria();
			if (!string.IsNullOrEmpty(qualifiedName.Name))
			{
				findCriteria.ContractTypeNames.Add(qualifiedName);
			}
			List<string> list = new List<string>();
			list.Add("domainname/" + AccessName + "/global");
			Collection<Uri> collection = SvcUtilities.CreateFindScopes(string.Empty, string.Empty, string.Empty, list);
			findCriteria.Scopes.Clear();
			foreach (Uri item in collection)
			{
				findCriteria.Scopes.Add(item);
			}
			result = discoveryClient.Find(findCriteria);
		}
		catch (TargetInvocationException ex)
		{
			SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "FindIDataEndpoint({0}) TargetInvocationException: {1}", AccessName, ex.Message);
			if (ex.InnerException != null)
			{
				SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "   {0}", ex.InnerException.Message);
			}
			result = null;
		}
		catch (ObjectDisposedException ex2)
		{
			SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "FindIDataEndpoint({0}) ObjectDisposedException: {1}", AccessName, ex2.Message);
			if (ex2.InnerException != null)
			{
				SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "   {0}", ex2.InnerException.Message);
			}
			result = null;
		}
		catch (Exception ex3)
		{
			SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "FindIDataEndpoint({0}) Exception: {1}", AccessName, ex3.Message);
			if (ex3.InnerException != null)
			{
				SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "   {0}", ex3.InnerException.Message);
			}
			result = null;
		}
		return result;
	}

	private void Reset()
	{
		if (IDataClient != null)
		{
			((IClientChannel)IDataClient).Abort();
		}
		m_DataProviderFactory = null;
		IDataClient = null;
		m_ConnectionId = Guid.Empty;
	}

	private bool InternalConnect(EndpointAddress IDataProviderEndpoint, Binding binding, string SolutionName, out string errorMessage, bool useCustomSerializer)
	{
		bool flag = false;
		errorMessage = string.Empty;
		if (IDataProviderEndpoint != null && binding != null)
		{
			try
			{
				ChannelFactory<IASBIData> channelFactory = new ChannelFactory<IASBIData>(binding, IDataProviderEndpoint);
				if (channelFactory != null)
				{
					if (binding is NetTcpBinding netTcpBinding && netTcpBinding.Security.Mode == SecurityMode.Transport && channelFactory.Credentials != null)
					{
						channelFactory.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.ChainTrust;
						channelFactory.Credentials.ServiceCertificate.Authentication.RevocationMode = X509RevocationMode.NoCheck;
					}
					if (useCustomSerializer)
					{
						IContractBehavior contractBehavior = new ASBCustomSerializerContractBehavior<ASBIDataCustomSerializerOperationBehavior>();
						if (contractBehavior != null)
						{
							SvcTrace.DiagControl.TraceEvent(TraceEventType.Information, 0, "ASB-IData optimized serialization is enabled.");
							channelFactory.Endpoint.Contract.Behaviors.Add(contractBehavior);
						}
					}
					foreach (OperationDescription operation in channelFactory.Endpoint.Contract.Operations)
					{
						DataContractSerializerOperationBehavior dataContractSerializerOperationBehavior = operation.Behaviors.Find<DataContractSerializerOperationBehavior>();
						if (dataContractSerializerOperationBehavior != null)
						{
							dataContractSerializerOperationBehavior.MaxItemsInObjectGraph = int.MaxValue;
						}
					}
					channelFactory.Open();
					IASBIData iASBIData = channelFactory.CreateChannel();
					Guid connectionId = Guid.Empty;
					if (iASBIData != null)
					{
						((IClientChannel)iASBIData).Open();
						if (iASBIData != null && ((IClientChannel)iASBIData).State != CommunicationState.Faulted)
						{
							ConnectionDelegate connectionDelegate = new ConnectionDelegate(iASBIData);
							flag = SysAuthClientAuthentication.EstablishSecureSession(Process.GetCurrentProcess().ProcessName, "localdomain", Environment.MachineName, SolutionName, new WeakReference(this), connectionDelegate.CallConnect, connectionDelegate.CallAuthenticateMe, out connectionId, out errorMessage);
							Thread.Sleep(250);
							if (flag)
							{
								Stopwatch stopwatch = new Stopwatch();
								stopwatch.Start();
								bool flag2;
								do
								{
									flag2 = PublishWriteComplete(out var _).ErrorCode != ArchestrAServices.ASBContract.EnumASBFactory.ArchestrAErrorToInt(ArchestrAServices.ASBContract.ArchestrAError.InvalidConnectionId);
									if (flag2)
									{
										SvcTrace.DiagControl.TraceEvent(TraceEventType.Information, 0, "Ping PublishWriteComplete() successful with service using ConnectionId {0}", connectionId);
									}
									if (!flag2)
									{
										Thread.Sleep(250);
									}
								}
								while (!flag2 && stopwatch.ElapsedMilliseconds < 2500);
								flag = flag2;
							}
							if (flag)
							{
								bool flag3 = false;
								lock (connectionLock)
								{
									if (m_DataProviderFactory == null)
									{
										flag3 = true;
										m_DataProviderFactory = channelFactory;
										IDataClient = iASBIData;
										m_ConnectionId = connectionId;
										if (connectionEstablishedEvent != null)
										{
											connectionEstablishedEvent.Set();
										}
									}
								}
								if (!flag3)
								{
									SysAuthClientAuthentication.DisconnectSecureSession(connectionId, connectionDelegate.CallDisconnect);
									if (iASBIData != null)
									{
										((IClientChannel)iASBIData).Close();
										((IClientChannel)iASBIData).Dispose();
									}
								}
							}
							else
							{
								if (iASBIData != null)
								{
									((IClientChannel)iASBIData).Abort();
									((IClientChannel)iASBIData).Dispose();
								}
								if (string.IsNullOrEmpty(errorMessage))
								{
									errorMessage = "ASBDataProxy could not connect with service: EstablishSecureSession failed";
								}
							}
						}
						else
						{
							errorMessage = "ASBDataProxy could not connect with service: communicaton channel in faulted state";
							flag = false;
						}
					}
					else
					{
						errorMessage = $"ASBDataProxy not able to create a channel for the endpoint {IDataProviderEndpoint.Uri}";
					}
				}
				else
				{
					errorMessage = $"ASBDataProxy not able to connect it to endpoint {IDataProviderEndpoint.Uri}";
				}
			}
			catch (CommunicationException ex)
			{
				errorMessage = "ASBDataProxy caught CommunicationException opening channel: " + ex.Message;
				if (ex.InnerException != null)
				{
					errorMessage += ex.InnerException.Message;
				}
			}
			catch (TimeoutException ex2)
			{
				errorMessage = "ASBDataProxy caught TimeoutException opening channel: " + ex2.Message;
				if (ex2.InnerException != null)
				{
					errorMessage += ex2.InnerException.Message;
				}
			}
			catch (Exception ex3)
			{
				errorMessage = "ASBDataProxy caught exception opening channel: " + ex3.Message;
				flag = false;
			}
		}
		else
		{
			if (IDataProviderEndpoint == null)
			{
				errorMessage += "ASBDataProxy cannot proceed to connect: No provider endpoint provided by caller";
				flag = false;
			}
			if (binding == null)
			{
				errorMessage += "ASBDataProxy cannot proceed to connect: No binding provided by caller";
				flag = false;
			}
		}
		return flag;
	}

	private void CallDisconnect(Disconnect request)
	{
		if (IDataClient != null)
		{
			IDataClient.Disconnect(request);
		}
	}
}