/// <summary>
/// Initializes an instance of this exception with the given named pipe endpoint and inner exception
/// that caused this exception.
/// </summary>
/// <param name="endPoint"></param>
/// <param name="timeout">The amount of time that passed until the connection-establishment was dropped</param>
/// <param name="innerException"></param>
public NoSuchNamedPipeEndPointException(NamedPipeEndPoint endPoint, TimeSpan timeout, Exception innerException = null)
: base(
string.Format("Unable to establish a connection with the given endpoint after {0}: {1}",
Format(timeout),
endPoint),
innerException)
{
EndPoint = endPoint;
}
/// <summary>
/// Deserialization ctor.
/// </summary>
/// <param name="info"></param>
/// <param name="context"></param>
public NoSuchNamedPipeEndPointException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
var type = (NamedPipeEndPoint.PipeType)info.GetByte("Type");
if (type != NamedPipeEndPoint.PipeType.None)
{
EndPoint = new NamedPipeEndPoint(info.GetString("EndPoint"), type);
}
EndPointName = info.GetString("EndPointName");
}
public bool Equals(NamedPipeEndPoint other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(string.Equals(_pipeName, other._pipeName) && _type == other._type);
}
/// <summary>
///
/// </summary>
/// <param name="endPoint"></param>
/// <param name="timeout"></param>
public ConnectionId Connect(NamedPipeEndPoint endPoint, TimeSpan timeout)
{
Exception exception;
ConnectionId connectionId;
if (!TryConnect(endPoint, timeout, out exception, out connectionId))
{
throw exception;
}
return(connectionId);
}
/// <summary>
/// Binds this endpoint to the given name.
/// Once bound, incoming connections may be accepted.
/// </summary>
/// <param name="endPoint"></param>
public void Bind(NamedPipeEndPoint endPoint)
{
if (endPoint == null)
{
throw new ArgumentNullException(nameof(endPoint));
}
if (LocalEndPoint != null)
{
throw new InvalidOperationException("This endpoint is already bound");
}
LocalEndPoint = endPoint;
_pipe = new NamedPipeServerStream(endPoint.PipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
_pipe.BeginWaitForConnection(OnIncomingConnection, null);
}
/// <summary>
/// Initializes an instance of this exception with the given named pipe endpoint and inner exception
/// that caused this exception.
/// </summary>
/// <param name="endPoint"></param>
/// <param name="innerException"></param>
public NoSuchNamedPipeEndPointException(NamedPipeEndPoint endPoint, Exception innerException = null)
: base(string.Format("Unable to establish a connection with the given endpoint: {0}", endPoint), innerException)
{
EndPoint = endPoint;
}
private void OnIncomingConnection(IAsyncResult ar)
{
lock (SyncRoot)
{
if (IsDisposed)
{
return;
}
}
NamedPipeServerStream socket = null;
bool success = false;
try
{
_pipe.EndWaitForConnection(ar);
socket = _pipe;
bool isAlreadyConnected;
lock (SyncRoot)
{
isAlreadyConnected = InternalRemoteEndPoint != null ||
_isConnecting;
_isConnecting = true;
}
if (isAlreadyConnected)
{
Log.InfoFormat("Blocking incoming connection from '', we're already connected to another endpoint");
}
else
{
Log.DebugFormat("Incoming connection from '', starting handshake...");
var remoteEndPoint = NamedPipeEndPoint.FromClient(Name);
var connectionId = PerformIncomingHandshake(_pipe, remoteEndPoint);
FireOnConnected(remoteEndPoint, connectionId);
success = true;
}
}
catch (AuthenticationException e)
{
Log.WarnFormat("Closing connection: {0}", e);
Disconnect();
}
catch (Exception e)
{
Log.ErrorFormat("Caught exception while accepting incoming connection - disconnecting again: {0}", e);
Disconnect();
}
finally
{
if (!success)
{
if (socket != null)
{
try
{
socket.Disconnect();
}
catch (Exception e)
{
Log.WarnFormat("Ignoring exception caught while disconnecting & disposing of socket: {0}", e);
}
}
lock (SyncRoot)
{
if (!IsDisposed)
{
_pipe.BeginWaitForConnection(OnIncomingConnection, null);
}
}
}
_isConnecting = false;
}
}
/// <summary>
///
/// </summary>
/// <param name="endPoint"></param>
/// <param name="timeout"></param>
/// <param name="exception"></param>
/// <param name="connectionId"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
/// <exception cref="ArgumentOutOfRangeException"></exception>
/// <exception cref="InvalidOperationException"></exception>
public bool TryConnect(NamedPipeEndPoint endPoint, TimeSpan timeout, out Exception exception, out ConnectionId connectionId)
{
if (endPoint == null)
{
throw new ArgumentNullException(nameof(endPoint));
}
if (Equals(endPoint, LocalEndPoint))
{
throw new ArgumentException("An endPoint cannot be connected to itself", nameof(endPoint));
}
if (endPoint.Type != NamedPipeEndPoint.PipeType.Server)
{
throw new ArgumentException("An endpoint can only establish a connection with a server-side enpoint", nameof(endPoint));
}
if (timeout <= TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(timeout));
}
if (IsConnected)
{
throw new InvalidOperationException(
"This endPoint is already connected to another endPoint and cannot establish any more connections");
}
bool success = false;
NamedPipeClientStream pipe = null;
try
{
var started = DateTime.Now;
pipe = new NamedPipeClientStream(Localhost, endPoint.PipeName);
try
{
var totalMilliseconds = (int)Math.Min(int.MaxValue, timeout.TotalMilliseconds);
pipe.Connect(totalMilliseconds);
}
catch (TimeoutException e)
{
exception = new NoSuchNamedPipeEndPointException(endPoint, timeout, e);
connectionId = ConnectionId.None;
return(false);
}
catch (IOException e)
{
exception = new NoSuchNamedPipeEndPointException(endPoint, timeout, e);
connectionId = ConnectionId.None;
return(false);
}
catch (Exception e)
{
Log.ErrorFormat("Cauhgt unexpected exception while connecting to '{0}': {1}", endPoint, e);
exception = new NoSuchNamedPipeEndPointException(endPoint, timeout, e);
connectionId = ConnectionId.None;
return(false);
}
var remaining = timeout - (DateTime.Now - started);
ErrorType errorType;
string error;
object errorReason;
if (!TryPerformOutgoingHandshake(pipe, remaining, out errorType, out error, out connectionId, out errorReason))
{
switch (errorType)
{
case ErrorType.Handshake:
exception = new HandshakeException(error);
break;
case ErrorType.AuthenticationRequired:
exception = new AuthenticationRequiredException(error);
break;
case ErrorType.EndPointBlocked:
exception = new RemoteEndpointAlreadyConnectedException(error, errorReason as EndPoint);
break;
default:
exception = new AuthenticationException(error);
break;
}
CurrentConnectionId = connectionId;
return(false);
}
InternalRemoteEndPoint = endPoint;
LocalEndPoint = NamedPipeEndPoint.FromClient(Name);
Log.InfoFormat("EndPoint '{0}' successfully connected to '{1}'", Name, endPoint);
FireOnConnected(endPoint, CurrentConnectionId);
success = true;
exception = null;
return(true);
}
finally
{
if (!success)
{
if (pipe != null)
{
pipe.Close();
pipe.Dispose();
}
InternalRemoteEndPoint = null;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="endPoint"></param>
/// <returns></returns>
public ConnectionId Connect(NamedPipeEndPoint endPoint)
{
return(Connect(endPoint, TimeSpan.FromSeconds(1)));
}
