mxaccess/analysis/decompiled/aaServicesProxyIDataV2/ArchestrAServices.Proxy/ASBDataV2Proxy.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.V2;
using ArchestrAServices.ASBIDataV2Contract;
using ArchestrAServices.Common;
using ArchestrAServices.Contract;

namespace ArchestrAServices.Proxy;

public class ASBDataV2Proxy : IDataV2, IDisposable
{
	public class ConnectionDelegate
	{
		private readonly IASBIDataV2 dataClientField;

		public ConnectionDelegate(IASBIDataV2 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("IASBIDataV2", "http://ASB.IDataV2");

	private static readonly XmlQualifiedName securedQualifiedName = new XmlQualifiedName("IASBIDataV2S", "http://ASB.IDataV2");

	public Guid m_ConnectionId = Guid.Empty;

	private readonly DiscoveryScope scopeRule;

	private readonly string m_AccessName;

	private ChannelFactory<IASBIDataV2> m_DataProviderFactory;

	private IASBIDataV2 IDataClient;

	private readonly object connectionLock;

	private ManualResetEvent connectionEstablishedEvent;

	private List<string> accumulatedErrorMsg;

	private object errorMsgLock;

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

	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 IAsbInterfaceSettings Settings { get; private set; }

	public ASBDataV2Proxy(string accessName, IAsbInterfaceSettings settings)
		: this(accessName, DiscoveryScope.Global, settings)
	{
	}

	public ASBDataV2Proxy(string accessName, DiscoveryScope scopeRule, IAsbInterfaceSettings settings)
	{
		this.scopeRule = scopeRule;
		m_AccessName = accessName;
		this.scopeRule = DiscoveryScope.Global;
		Settings = settings;
		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, "ASBDataV2Proxy");
			aaLoggerConfig.ChangeSourceLevel("ASBDataProxyLogs", SourceLevels.All);
		}
		SecureCommunicationMode = RegistryHandler.SecureCommunicationMode;
	}

	public static ReadOnlyCollection<EndpointDiscoveryMetadata> DiscoverEndpoints(string scope, DiscoveryScope scopeRule)
	{
		return DiscoverEndpoints(scope, scopeRule, SecureCommunicationModes.Never);
	}

	public static ReadOnlyCollection<EndpointDiscoveryMetadata> DiscoverEndpoints(string scope, DiscoveryScope scopeRule, SecureCommunicationModes secureCommunicationMode)
	{
		ServiceTrace.LogCsv("DiscoverEndpoints entry [Contract scopeRule],IASBIDataV2", scopeRule);
		ServiceTrace.LogResume("DiscoverEndpointsForContract entry, contract IASBIDataV2, scope {0}, scopeRule {1}", scope, scopeRule);
		if (string.IsNullOrWhiteSpace(scope))
		{
			throw new ArgumentNullException("scope");
		}
		return DiscoverEndpoints(scope + "/" + scopeRule.ToString().ToLowerInvariant(), secureCommunicationMode);
	}

	public static ReadOnlyCollection<EndpointDiscoveryMetadata> DiscoverEndpoints(string scope)
	{
		return DiscoverEndpoints(scope, SecureCommunicationModes.Never);
	}

	public static ReadOnlyCollection<EndpointDiscoveryMetadata> DiscoverEndpoints(string scope, SecureCommunicationModes secureCommunicationMode)
	{
		ServiceTrace.LogCsv("DiscoverEndpoints entry [Contract scopeRule],IASBIDataV2", scope);
		ServiceTrace.LogResume("DiscoverEndpointsForContract entry, contract IASBIDataV2, scopeToFind {0}, scopeRule {1}", scope, scope);
		if (string.IsNullOrWhiteSpace(scope))
		{
			throw new ArgumentNullException("scope");
		}
		FindResponse findResponse = null;
		if (secureCommunicationMode == SecureCommunicationModes.Preferred || secureCommunicationMode == SecureCommunicationModes.Required)
		{
			findResponse = DiscoverEndpointsInternal(scope, securedQualifiedName);
		}
		if ((findResponse == null || !findResponse.Endpoints.Any()) && secureCommunicationMode != SecureCommunicationModes.Required)
		{
			findResponse = DiscoverEndpointsInternal(scope, qualifiedName);
		}
		ServiceTrace.LogSuspend("DiscoverEndpoints exit, contract IASBIDataV2, scopeRule {0}", scope);
		ServiceTrace.LogCsv("DiscoverEndpointsForContract exit [Contract scopeRule],IASBIDataV2", scope);
		if (findResponse == null)
		{
			return new ReadOnlyCollection<EndpointDiscoveryMetadata>(new List<EndpointDiscoveryMetadata>());
		}
		return new ReadOnlyCollection<EndpointDiscoveryMetadata>(findResponse.Endpoints.ToList());
	}

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

	public static FindResponse FindIDataEndpoint(string accessName, SecureCommunicationModes secureCommunicationMode)
	{
		return FindIDataEndpoint(accessName, DiscoveryScope.Global, secureCommunicationMode);
	}

	public static FindResponse FindIDataEndpoint(string accessName, DiscoveryScope scopeRule)
	{
		return FindIDataEndpoint(accessName, scopeRule, SecureCommunicationModes.Never);
	}

	public static FindResponse FindIDataEndpoint(string accessName, DiscoveryScope scopeRule, SecureCommunicationModes secureCommunicationMode)
	{
		if (secureCommunicationMode == SecureCommunicationModes.Preferred || secureCommunicationMode == SecureCommunicationModes.Required)
		{
			FindResponse findResponse = DiscoverEndpointsInternal("domainname/" + accessName + "/" + scopeRule.ToString().ToLowerInvariant(), securedQualifiedName);
			if (findResponse != null && findResponse.Endpoints.Any())
			{
				return findResponse;
			}
		}
		if (secureCommunicationMode != SecureCommunicationModes.Required)
		{
			return DiscoverEndpointsInternal("domainname/" + accessName + "/" + scopeRule.ToString().ToLowerInvariant(), 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);
		}
		bool result = false;
		bool useCustomSerializer = false;
		string solutionName;
		EndpointDiscoveryMetadata endpointDiscoveryMetadata = FindEndpointForConnect(secured, ref useCustomSerializer, out solutionName, out errorMessage);
		bool useSecureConnection = endpointDiscoveryMetadata.ContractTypeNames[0] == securedQualifiedName;
		if (endpointDiscoveryMetadata != null)
		{
			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.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "Try connecting with endpoint {0}", SelectedEndpointUri);
					if (InternalConnect(iDataProviderEndpoint, binding, solutionName, out var errorMessage2, useCustomSerializer))
					{
						SvcTrace.DiagDiagnostics.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;
				}
			}
		}
		return result;
	}

	public EndpointDiscoveryMetadata SelectEndpointToConnectTo(FindResponse findResponse, ref bool useCustomSerializer)
	{
		if (findResponse == null)
		{
			return null;
		}
		return SelectEndpointToConnectTo(new ReadOnlyCollection<EndpointDiscoveryMetadata>(findResponse.Endpoints), ref useCustomSerializer);
	}

	public EndpointDiscoveryMetadata SelectEndpointToConnectTo(ReadOnlyCollection<EndpointDiscoveryMetadata> findResponse, ref bool useCustomSerializer)
	{
		if (findResponse == null)
		{
			return null;
		}
		EndpointDiscoveryMetadata result = null;
		List<EndpointDiscoveryMetadata> list = new List<EndpointDiscoveryMetadata>();
		List<EndpointDiscoveryMetadata> list2 = new List<EndpointDiscoveryMetadata>();
		bool flag = true;
		foreach (EndpointDiscoveryMetadata item in findResponse)
		{
			if (flag)
			{
				list2.Add(item);
			}
			else
			{
				list.Add(item);
			}
			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 ActivateUser(ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBIDataV2Contract.UserToken UserToken)
	{
		return ActivateUser(UserToken);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult ActivateUser(ArchestrAServices.ASBIDataV2Contract.UserToken UserToken)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				ActivateUserRequest activateUserRequest = new ActivateUserRequest();
				activateUserRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				activateUserRequest.UserToken = UserToken;
				clientAuthenticator.Sign(activateUserRequest);
				ActivateUserResponse activateUserResponse = IDataClient.ActivateUser(activateUserRequest);
				if (activateUserResponse != null)
				{
					return activateUserResponse.Result;
				}
			}
		}
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult ExchangeCapabilities(out string ServiceCapabilities, ArchestrAServices.ASBContract.ConnectionId Id, string ClientCapabilities)
	{
		return ExchangeCapabilities(out ServiceCapabilities, ClientCapabilities);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult ExchangeCapabilities(out string ServiceCapabilities, string ClientCapabilities)
	{
		if (IDataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(m_ConnectionId);
			if (clientAuthenticator != null)
			{
				ExchangeCapabilitiesRequest exchangeCapabilitiesRequest = new ExchangeCapabilitiesRequest();
				exchangeCapabilitiesRequest.ConnectionValidator.ConnectionId = m_ConnectionId;
				exchangeCapabilitiesRequest.ClientCapabilities = ClientCapabilities;
				clientAuthenticator.Sign(exchangeCapabilitiesRequest);
				ExchangeCapabilitiesResponse exchangeCapabilitiesResponse = IDataClient.ExchangeCapabilities(exchangeCapabilitiesRequest);
				if (exchangeCapabilitiesResponse != null)
				{
					ServiceCapabilities = exchangeCapabilitiesResponse.ServiceCapabilities;
					return exchangeCapabilitiesResponse.Result;
				}
			}
		}
		ServiceCapabilities = string.Empty;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

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

	public ArchestrAServices.ASBContract.ArchestrAResult Read(out ArchestrAServices.ASBIDataV2Contract.ItemStatus[] Status, out ArchestrAServices.ASBIDataV2Contract.RuntimeValue[] Values, ArchestrAServices.ASBIDataV2Contract.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.ASBIDataV2Contract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBIDataV2Contract.ItemIdentity[] Items, ArchestrAServices.ASBIDataV2Contract.WriteValue[] Values, uint WriteHandle)
	{
		return Write(out Status, Items, Values, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Write(out ArchestrAServices.ASBIDataV2Contract.ItemStatus[] Status, ArchestrAServices.ASBIDataV2Contract.ItemIdentity[] Items, ArchestrAServices.ASBIDataV2Contract.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;
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0)
					{
						for (int i = 0; i < Values.Length; i++)
						{
							if (Values[i].ArrayElementIndexSpecified)
							{
								Values[i].ArrayElementIndex -= setting;
							}
						}
					}
				}
				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.ASBIDataV2Contract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBIDataV2Contract.ItemIdentity[] Items, ArchestrAServices.ASBIDataV2Contract.WriteValue[] Values, ArchestrAServices.ASBIDataV2Contract.UserToken User, uint WriteHandle)
	{
		return WriteUser(out Status, Items, Values, User, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteUser(out ArchestrAServices.ASBIDataV2Contract.ItemStatus[] Status, ArchestrAServices.ASBIDataV2Contract.ItemIdentity[] Items, ArchestrAServices.ASBIDataV2Contract.WriteValue[] Values, ArchestrAServices.ASBIDataV2Contract.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;
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0)
					{
						for (int i = 0; i < Values.Length; i++)
						{
							if (Values[i].ArrayElementIndexSpecified)
							{
								Values[i].ArrayElementIndex -= setting;
							}
						}
					}
				}
				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.ASBIDataV2Contract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBIDataV2Contract.ItemIdentity[] Items, ArchestrAServices.ASBIDataV2Contract.WriteValue[] Values, ArchestrAServices.ASBIDataV2Contract.UserToken User, ArchestrAServices.ASBIDataV2Contract.UserToken Supervisor, uint WriteHandle)
	{
		return WriteVerified(out Status, Items, Values, User, Supervisor, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteVerified(out ArchestrAServices.ASBIDataV2Contract.ItemStatus[] Status, ArchestrAServices.ASBIDataV2Contract.ItemIdentity[] Items, ArchestrAServices.ASBIDataV2Contract.WriteValue[] Values, ArchestrAServices.ASBIDataV2Contract.UserToken User, ArchestrAServices.ASBIDataV2Contract.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;
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0)
					{
						for (int i = 0; i < Values.Length; i++)
						{
							if (Values[i].ArrayElementIndexSpecified)
							{
								Values[i].ArrayElementIndex -= setting;
							}
						}
					}
				}
				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.ASBIDataV2Contract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBIDataV2Contract.ItemIdentity[] Items, ArchestrAServices.ASBIDataV2Contract.WriteValue[] Values, ArchestrAServices.ASBIDataV2Contract.UserToken User, uint WriteHandle)
	{
		return WriteSecured(out Status, Items, Values, User, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteSecured(out ArchestrAServices.ASBIDataV2Contract.ItemStatus[] Status, ArchestrAServices.ASBIDataV2Contract.ItemIdentity[] Items, ArchestrAServices.ASBIDataV2Contract.WriteValue[] Values, ArchestrAServices.ASBIDataV2Contract.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;
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0)
					{
						for (int i = 0; i < Values.Length; i++)
						{
							if (Values[i].ArrayElementIndexSpecified)
							{
								Values[i].ArrayElementIndex -= setting;
							}
						}
					}
				}
				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.ASBIDataV2Contract.WriteValue ValueReceived, out long WriteToken, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBIDataV2Contract.ItemIdentity Item, ArchestrAServices.ASBIDataV2Contract.WriteValue Value, ArchestrAServices.ASBIDataV2Contract.UserToken User, ArchestrAServices.ASBIDataV2Contract.UserToken Supervisor)
	{
		return WriteConfirmed(out ValueReceived, out WriteToken, Item, Value, User, Supervisor);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteConfirmed(out ArchestrAServices.ASBIDataV2Contract.WriteValue ValueReceived, out long WriteToken, ArchestrAServices.ASBIDataV2Contract.ItemIdentity Item, ArchestrAServices.ASBIDataV2Contract.WriteValue Value, ArchestrAServices.ASBIDataV2Contract.UserToken User, ArchestrAServices.ASBIDataV2Contract.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;
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0 && Value.ArrayElementIndexSpecified)
					{
						Value.ArrayElementIndex -= setting;
					}
				}
				writeConfirmedRequest.Value = Value;
				writeConfirmedRequest.User = User;
				writeConfirmedRequest.Supervisor = Supervisor;
				clientAuthenticator.Sign(writeConfirmedRequest);
				WriteConfirmedResponse writeConfirmedResponse = IDataClient.WriteConfirmed(writeConfirmedRequest);
				if (writeConfirmedResponse != null)
				{
					if (Settings != null)
					{
						int setting2 = Settings.GetSetting("ArrayBase", 0);
						if (setting2 != 0 && writeConfirmedResponse.ValueReceived.ArrayElementIndexSpecified)
						{
							writeConfirmedResponse.ValueReceived.ArrayElementIndex += setting2;
						}
					}
					ValueReceived = writeConfirmedResponse.ValueReceived;
					WriteToken = writeConfirmedResponse.WriteToken;
					return writeConfirmedResponse.Result;
				}
			}
		}
		ValueReceived = default(ArchestrAServices.ASBIDataV2Contract.WriteValue);
		WriteToken = long.MaxValue;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

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

	public ArchestrAServices.ASBContract.ArchestrAResult ConfirmWrite(ArchestrAServices.ASBIDataV2Contract.ItemIdentity Item, long WriteToken, ArchestrAServices.ASBIDataV2Contract.WriteValue Value, ArchestrAServices.ASBIDataV2Contract.UserToken User, ArchestrAServices.ASBIDataV2Contract.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;
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0 && Value.ArrayElementIndexSpecified)
					{
						Value.ArrayElementIndex -= setting;
					}
				}
				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.ASBIDataV2Contract.ItemWriteComplete[] CompleteWrites, ArchestrAServices.ASBContract.ConnectionId Id)
	{
		return PublishWriteComplete(out CompleteWrites);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult PublishWriteComplete(out ArchestrAServices.ASBIDataV2Contract.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.V2.Variant NewState, ushort StateToChange)
	{
		return SetSubscriptionState(SubscriptionId, NewState, StateToChange);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult SetSubscriptionState(long SubscriptionId, ArchestrAServices.ASBIDataContract.V2.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.V2.Variant State, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId, ushort StateToGet)
	{
		return GetSubscriptionState(out State, SubscriptionId, StateToGet);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult GetSubscriptionState(out ArchestrAServices.ASBIDataContract.V2.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.V2.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.ASBIDataV2Contract.ItemStatus[] Status, out ArchestrAServices.ASBIDataV2Contract.ItemRegistration[] ItemCapabilities, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId, ArchestrAServices.ASBIDataV2Contract.MonitoredItem[] Items, byte RequireId)
	{
		return AddMonitoredItems(out Status, out ItemCapabilities, SubscriptionId, RequireId != 0, Items);
	}

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

	public ArchestrAServices.ASBContract.ArchestrAResult AddMonitoredItems(out ArchestrAServices.ASBIDataV2Contract.ItemStatus[] Status, out ArchestrAServices.ASBIDataV2Contract.ItemRegistration[] ItemCapabilities, long SubscriptionId, bool RequireId, ArchestrAServices.ASBIDataV2Contract.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.ASBIDataV2Contract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId, ArchestrAServices.ASBIDataV2Contract.MonitoredItem[] Items)
	{
		return DeleteMonitoredItems(out Status, SubscriptionId, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult DeleteMonitoredItems(out ArchestrAServices.ASBIDataV2Contract.ItemStatus[] Status, long SubscriptionId, ArchestrAServices.ASBIDataV2Contract.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.ASBIDataV2Contract.MonitoredItem[] Items, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId)
	{
		return GetMonitoredItems(out Items, SubscriptionId);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult GetMonitoredItems(out ArchestrAServices.ASBIDataV2Contract.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.ASBIDataV2Contract.ItemStatus[] Status, out ArchestrAServices.ASBIDataV2Contract.MonitoredItemValue[] Values, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId)
	{
		return Publish(out Status, out Values, SubscriptionId);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Publish(out ArchestrAServices.ASBIDataV2Contract.ItemStatus[] Status, out ArchestrAServices.ASBIDataV2Contract.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.ASBIDataV2Contract.ItemStatus[] Status, out ArchestrAServices.ASBIDataV2Contract.ItemRegistration[] ItemCapabilities, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBIDataV2Contract.ItemIdentity[] Items, byte RequireId, byte RegisterOnly)
	{
		return RegisterItems(out Status, out ItemCapabilities, RequireId != 0, RegisterOnly != 0, Items);
	}

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

	public ArchestrAServices.ASBContract.ArchestrAResult RegisterItems(out ArchestrAServices.ASBIDataV2Contract.ItemStatus[] Status, out ArchestrAServices.ASBIDataV2Contract.ItemRegistration[] ItemCapabilities, bool RequireId, bool RegisterOnly, ArchestrAServices.ASBIDataV2Contract.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.ASBIDataV2Contract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBIDataV2Contract.ItemIdentity[] Items)
	{
		return UnregisterItems(out Status, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult UnregisterItems(out ArchestrAServices.ASBIDataV2Contract.ItemStatus[] Status, ArchestrAServices.ASBIDataV2Contract.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 scopeToFind, 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();
			findCriteria.ContractTypeNames.Add(qualifiedName);
			List<string> extraScopes = new List<string> { scopeToFind };
			Collection<Uri> collection = SvcUtilities.CreateFindScopes(string.Empty, string.Empty, string.Empty, extraScopes);
			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}", scopeToFind, 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}", scopeToFind, 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}", scopeToFind, 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 EndpointDiscoveryMetadata FindEndpointForConnect(bool secured, ref bool useCustomSerializer, out string solutionName, out string errorMessage)
	{
		solutionName = string.Empty;
		string accessName = m_AccessName;
		DiscoveryScope num = scopeRule;
		int secureCommunicationMode;
		if (!secured)
		{
			SecureCommunicationModes secureCommunicationModes = (SecureCommunicationMode = SecureCommunicationModes.Never);
			secureCommunicationMode = (int)secureCommunicationModes;
		}
		else
		{
			secureCommunicationMode = 2;
		}
		FindResponse findResponse = FindIDataEndpoint(accessName, num, (SecureCommunicationModes)secureCommunicationMode);
		EndpointDiscoveryMetadata 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);
			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 endpointDiscoveryMetadata;
	}

	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<IASBIDataV2> channelFactory = new ChannelFactory<IASBIDataV2>(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 && binding is NetTcpBinding)
					{
						IContractBehavior contractBehavior = new ASBCustomSerializerContractBehavior<ASBIDataCustomSerializerOperationBehavior>();
						if (contractBehavior != null)
						{
							SvcTrace.DiagDiagnostics.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();
					IASBIDataV2 iASBIDataV = channelFactory.CreateChannel();
					Guid connectionId = Guid.Empty;
					if (iASBIDataV != null)
					{
						((IClientChannel)iASBIDataV).Open();
						if (iASBIDataV != null && ((IClientChannel)iASBIDataV).State != CommunicationState.Faulted)
						{
							ConnectionDelegate connectionDelegate = new ConnectionDelegate(iASBIDataV);
							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.DiagDiagnostics.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 = iASBIDataV;
										m_ConnectionId = connectionId;
										if (connectionEstablishedEvent != null)
										{
											connectionEstablishedEvent.Set();
										}
									}
								}
								if (!flag3)
								{
									SysAuthClientAuthentication.DisconnectSecureSession(connectionId, connectionDelegate.CallDisconnect);
									if (iASBIDataV != null)
									{
										((IClientChannel)iASBIDataV).Close();
										((IClientChannel)iASBIDataV).Dispose();
									}
								}
							}
							else
							{
								if (iASBIDataV != null)
								{
									((IClientChannel)iASBIDataV).Abort();
									((IClientChannel)iASBIDataV).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);
		}
	}
}