/// <summary>
/// Establishes Connection Level Security Session and gather their output into specified stream.
/// </summary>
/// <param name="senderInput">The input stream.</param>
/// <param name="listenerInput">The input stream.</param>
/// <param name="output">The output stream.</param>
/// <param name="sender">The sender's Security Session.</param>
/// <param name="listener">The listener's Security Session.</param>
/// <returns>True if at least one Security Session requested sending of data.</returns>
public bool GatherContentOfConnectionLevelSecuritySessions(Stream senderInput, Stream listenerInput, GenuineChunkedStream output, SecuritySession sender, SecuritySession listener)
{
bool clssDataPresents = false;
Stream clsseStream;
// CLSSE info
using (new GenuineChunkedStreamSizeLabel(output))
{
if (sender != null && !sender.IsEstablished)
{
clsseStream = sender.EstablishSession(senderInput, true);
if (clsseStream != null)
{
clssDataPresents = true;
GenuineUtility.CopyStreamToStream(clsseStream, output);
}
}
}
// CLSSE info
using (new GenuineChunkedStreamSizeLabel(output))
{
if (listener != null && !listener.IsEstablished)
{
clsseStream = listener.EstablishSession(listenerInput, true);
if (clsseStream != null)
{
clssDataPresents = true;
GenuineUtility.CopyStreamToStream(clsseStream, output);
}
}
}
return(clssDataPresents);
}
/// <summary>
/// Accepts an incoming connection.
/// </summary>
/// <param name="url">The name of the share.</param>
/// <param name="localUri">URI of the local host.</param>
/// <param name="protocolVersion">The version of the protocol supported by the remote host.</param>
/// <param name="remoteUri">Uri of the remote host.</param>
/// <param name="remoteHostUniqueIdentifier">The unique identifier of the HostInformation used by the remote host.</param>
/// <returns>The established connection.</returns>
private SharedMemoryConnection LowLevel_AcceptConnection_1(string url, string localUri, byte protocolVersion, out string remoteUri, out int remoteHostUniqueIdentifier)
{
BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter;
using (new ReaderAutoLocker(this._disposeLock))
{
if (this._disposed)
{
throw OperationException.WrapException(this._disposeReason);
}
}
remoteUri = null;
Stream inputStream = null;
Stream outputStream = null;
remoteHostUniqueIdentifier = 0;
// the maximum time during which the connection must be established
int timeout = GenuineUtility.GetTimeout((TimeSpan)this.ITransportContext.IParameterProvider[GenuineParameter.ConnectTimeout]);
// open the client's share
SharedMemoryConnection sharedMemoryConnection = new SharedMemoryConnection(this.ITransportContext, url, false, true);
// LOG:
if (binaryLogWriter != null && binaryLogWriter[LogCategory.Connection] > 0)
{
binaryLogWriter.WriteConnectionParameterEvent(LogCategory.Connection, "SharedMemoryConnectionManager.LowLevel_AcceptConnection",
LogMessageType.ConnectionParameters, null, null, this.ITransportContext.IParameterProvider,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, sharedMemoryConnection.DbgConnectionId,
"The connection is being established to \"{0}\".", url);
}
// get the connection-level Security Session
string connectionLevelSSName = this.ITransportContext.IParameterProvider[GenuineParameter.SecuritySessionForPersistentConnections] as string;
SecuritySession securitySession = null;
if (connectionLevelSSName != null)
{
securitySession = this.ITransportContext.IKeyStore.GetKey(connectionLevelSSName).CreateSecuritySession(connectionLevelSSName, null);
}
// establish it
if (securitySession != null && !securitySession.IsEstablished)
{
for ( ; ;)
{
inputStream = Stream.Null;
try
{
// prepare streams
inputStream = sharedMemoryConnection.LowLevel_ReadSync(timeout);
outputStream = securitySession.EstablishSession(inputStream, true);
if (outputStream == null)
{
break;
}
// send a packet to the remote host
sharedMemoryConnection.LowLevel_SendSync(outputStream, timeout);
if (securitySession.IsEstablished)
{
break;
}
}
finally
{
if (inputStream != null)
{
inputStream.Close();
}
if (outputStream != null)
{
outputStream.Close();
}
}
}
}
sharedMemoryConnection.ConnectionLevelSecurity = securitySession;
HostInformation remote = null;
// read remote info
using (Stream remoteUriStream = sharedMemoryConnection.LowLevel_ReadSync(timeout))
{
BinaryReader binaryReader = new BinaryReader(remoteUriStream);
remoteUri = binaryReader.ReadString();
remote = this.ITransportContext.KnownHosts[remoteUri];
if (protocolVersion > 0)
{
remoteHostUniqueIdentifier = binaryReader.ReadInt32();
}
}
// now send connection info through the established connection
using (GenuineChunkedStream serializedLocalInfo = new GenuineChunkedStream(false))
{
// serialize local info
BinaryWriter binaryWriter = new BinaryWriter(serializedLocalInfo);
binaryWriter.Write((string)localUri);
if (protocolVersion > 0)
{
binaryWriter.Write((int)remote.LocalHostUniqueIdentifier);
}
// and send it
sharedMemoryConnection.LowLevel_SendSync(serializedLocalInfo, timeout);
}
// LOG:
if (binaryLogWriter != null && binaryLogWriter[LogCategory.Connection] > 0)
{
binaryLogWriter.WriteEvent(LogCategory.Connection, "SharedMemoryConnectionManager.LowLevel_AcceptConnection_1",
LogMessageType.ConnectionEstablished, null, null, remote, null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
securitySession, connectionLevelSSName,
sharedMemoryConnection.DbgConnectionId, (int)GenuineConnectionType.Persistent, 0, 0, this.GetType().Name, null, null, null,
"The connection to the remote host has been established.");
}
return(sharedMemoryConnection);
}
/// <summary>
/// Opens a connection to the host specified by the url.
/// </summary>
/// <param name="remote">The HostInformation of the Remote Host.</param>
/// <param name="localUri">The uri of the local host.</param>
/// <param name="remoteUri">The uri of the remote host.</param>
/// <param name="remoteHostUniqueIdentifier">The unique identifier of the HostInformation used by the remote host.</param>
/// <returns>The established connection.</returns>
private SharedMemoryConnection LowLevel_OpenConnection(HostInformation remote, string localUri, out string remoteUri, out int remoteHostUniqueIdentifier)
{
using (new ReaderAutoLocker(this._disposeLock))
{
if (this._disposed)
{
throw OperationException.WrapException(this._disposeReason);
}
}
remoteUri = null;
Stream inputStream = null;
Stream outputStream = null;
string url = remote.Url;
// the maximum time during which the connection must be established
int timeout = GenuineUtility.GetTimeout((TimeSpan)this.ITransportContext.IParameterProvider[GenuineParameter.ConnectTimeout]);
IParameterProvider parameters = this.ITransportContext.IParameterProvider;
string mutexName = GenuineSharedMemoryChannel.ConstructSharedObjectName(
"MUTEX" + url, parameters);
string clientConnected = GenuineSharedMemoryChannel.ConstructSharedObjectName(
"CC" + url, parameters);
string clientAccepted = GenuineSharedMemoryChannel.ConstructSharedObjectName(
"CA" + url, parameters);
// open the server share
SharedMemoryConnection serverSharedMemoryConnection = new SharedMemoryConnection(this.ITransportContext, url, false, false);
// LOG:
BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter;
if (binaryLogWriter != null && binaryLogWriter[LogCategory.Connection] > 0)
{
binaryLogWriter.WriteConnectionParameterEvent(LogCategory.Connection, "SharedMemoryConnectionManager.LowLevel_OpenConnection",
LogMessageType.ConnectionParameters, null, remote, this.ITransportContext.IParameterProvider,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, serverSharedMemoryConnection.DbgConnectionId,
"A Shared Memory connection is being established.");
}
// and create the local share
string shareName = "gshmem://" + Guid.NewGuid().ToString("N");
SharedMemoryConnection sharedMemoryConnection = new SharedMemoryConnection(this.ITransportContext, shareName, true, true);
BinaryWriter connectionInformation = MessageCoder.SerializeConnectionHeader(MessageCoder.PROTOCOL_VERSION, GenuineConnectionType.Persistent, "Default");
connectionInformation.Write(shareName);
// let the server know that a client's share is ready
Mutex mutex = null;
try
{
mutex = WindowsAPI.OpenMutex(mutexName);
NamedEvent _clientConnected = NamedEvent.OpenNamedEvent(clientConnected);
NamedEvent _clientAccepted = NamedEvent.OpenNamedEvent(clientAccepted);
if (!GenuineUtility.WaitOne(mutex, GenuineUtility.GetMillisecondsLeft(timeout)))
{
throw GenuineExceptions.Get_Connect_CanNotConnectToRemoteHost(url, "Can not acquire the lock for the global mutex.");
}
// wait until server accepts this client
_clientAccepted.ManualResetEvent.Reset();
_clientConnected.ManualResetEvent.Set();
// copy client's name
serverSharedMemoryConnection.LowLevel_SendSync(connectionInformation.BaseStream, timeout);
if (!GenuineUtility.WaitOne(_clientAccepted.ManualResetEvent, GenuineUtility.GetMillisecondsLeft(timeout)))
{
throw GenuineExceptions.Get_Connect_CanNotConnectToRemoteHost(url, "Remote server did not accept a request within the specified time span.");
}
}
finally
{
if (mutex != null)
{
try
{
mutex.ReleaseMutex();
}
catch
{
}
try
{
mutex.Close();
}
catch
{
}
}
}
// get the connection-level Security Session
string connectionLevelSSName = this.ITransportContext.IParameterProvider[GenuineParameter.SecuritySessionForPersistentConnections] as string;
SecuritySession securitySession = null;
if (connectionLevelSSName != null)
{
securitySession = this.ITransportContext.IKeyStore.GetKey(connectionLevelSSName).CreateSecuritySession(connectionLevelSSName, null);
}
// establish it
if (securitySession != null && !securitySession.IsEstablished)
{
bool firstPass = true;
for ( ; ;)
{
inputStream = Stream.Null;
try
{
// prepare streams
if (!firstPass)
{
inputStream = sharedMemoryConnection.LowLevel_ReadSync(timeout);
}
else
{
firstPass = false;
}
outputStream = securitySession.EstablishSession(inputStream, true);
if (outputStream == null)
{
break;
}
// send a packet to the remote host
sharedMemoryConnection.LowLevel_SendSync(outputStream, timeout);
if (securitySession.IsEstablished)
{
break;
}
}
finally
{
if (inputStream != null)
{
inputStream.Close();
}
if (outputStream != null)
{
outputStream.Close();
}
}
}
}
sharedMemoryConnection.ConnectionLevelSecurity = securitySession;
// now send connection info through the established connection
using (GenuineChunkedStream serializedLocalInfo = new GenuineChunkedStream(false))
{
// serialize local info
BinaryWriter binaryWriter = new BinaryWriter(serializedLocalInfo);
binaryWriter.Write((string)localUri);
binaryWriter.Write((int)remote.LocalHostUniqueIdentifier);
// and send it
sharedMemoryConnection.LowLevel_SendSync(serializedLocalInfo, timeout);
// read remote info
using (Stream remoteUriStream = sharedMemoryConnection.LowLevel_ReadSync(timeout))
{
BinaryReader binaryReader = new BinaryReader(remoteUriStream);
remoteUri = binaryReader.ReadString();
remoteHostUniqueIdentifier = binaryReader.ReadInt32();
}
}
sharedMemoryConnection.Remote = remote;
sharedMemoryConnection.Remote.UpdateUri(remoteUri, remoteHostUniqueIdentifier);
sharedMemoryConnection.Remote.GenuinePersistentConnectionState = GenuinePersistentConnectionState.Opened;
// LOG:
if (binaryLogWriter != null && binaryLogWriter[LogCategory.HostInformation] > 0)
{
binaryLogWriter.WriteHostInformationEvent("SharedMemoryConnectionManager.LowLevel_OpenConnection",
LogMessageType.HostInformationCreated, null, remote,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null,
sharedMemoryConnection.DbgConnectionId,
"HostInformation is ready for actions.");
}
// LOG:
if (binaryLogWriter != null && binaryLogWriter[LogCategory.Connection] > 0)
{
binaryLogWriter.WriteEvent(LogCategory.Connection, "SharedMemoryConnectionManager.LowLevel_OpenConnection",
LogMessageType.ConnectionEstablished, null, null, remote, null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
securitySession, connectionLevelSSName,
sharedMemoryConnection.DbgConnectionId, (int)GenuineConnectionType.Persistent, 0, 0, this.GetType().Name, null, null, null,
"The connection to the remote host is established.");
}
return(sharedMemoryConnection);
}