private MultiplexedConnection OnCreateConnection(int connectionId, object streamConnectionObject)
{
StreamConnection streamConnection = (StreamConnection)streamConnectionObject;
if (streamConnection.ConnectionInfo.StartsWith("tcp:", StringComparison.OrdinalIgnoreCase))
{
int port = int.Parse(streamConnection.ConnectionInfo.Substring(4));
TcpClient tcpClient = new TcpClient(AddressFamily.InterNetwork);
tcpClient.LingerState.Enabled = true;
tcpClient.NoDelay = true;
tcpClient.Connect(targetHost, port);
return(new MultiplexedServiceTcpConnection(streamConnection, tcpClient, connectionId));
}
else if (streamConnection.ConnectionInfo.StartsWith("np:", StringComparison.OrdinalIgnoreCase))
{
string pipe = streamConnection.ConnectionInfo.Substring(3);
NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", pipe, PipeDirection.InOut, PipeOptions.Asynchronous, System.Security.Principal.TokenImpersonationLevel.Impersonation);
pipeClient.Connect();
return(new MultiplexedServiceNamedPipeConnection(streamConnection, pipeClient, connectionId));
}
else
{
throw new InvalidOperationException();
}
}
public MultiplexedServiceTcpConnection(StreamConnection streamConnection, TcpClient tcpClient, int connectionId)
: base(tcpClient.GetStream().Write, connectionId)
{
this.streamConnection = streamConnection;
this.tcpClient = tcpClient;
this.outputPump = new MultiplexConnectionOutputPump(tcpClient.GetStream().Read, streamConnection.Stream.Write, connectionId);
this.outputPump.BeginRunPump(PumpCompleted, null);
}
public MultiplexedServiceNamedPipeConnection(StreamConnection streamConnection, NamedPipeClientStream pipeClient, int connectionId)
: base(pipeClient.Write, connectionId)
{
this.streamConnection = streamConnection;
this.pipeClient = pipeClient;
this.outputPump = new MultiplexConnectionOutputPump(pipeClient.Read, streamConnection.Stream.Write, connectionId);
this.outputPump.BeginRunPump(PumpCompleted, null);
}
public MultiplexedServiceNamedPipeConnection(StreamConnection streamConnection, NamedPipeClientStream pipeClient, int connectionId)
: base(pipeClient.Write, connectionId)
{
this.streamConnection = streamConnection;
this.pipeClient = pipeClient;
this.outputPump = new MultiplexConnectionOutputPump(pipeClient.Read, streamConnection.Stream.Write, connectionId);
this.outputPump.BeginRunPump(PumpCompleted, null);
}
public MultiplexedServiceTcpConnection(StreamConnection streamConnection, TcpClient tcpClient, int connectionId)
: base(tcpClient.GetStream().Write, connectionId)
{
this.streamConnection = streamConnection;
this.tcpClient = tcpClient;
this.outputPump = new MultiplexConnectionOutputPump(tcpClient.GetStream().Read, streamConnection.Stream.Write, connectionId);
this.outputPump.BeginRunPump(PumpCompleted, null);
}
void StreamAccepted(IAsyncResult asyncResult)
{
try
{
StreamConnection streamConnection = streamServerHost.EndAccept(asyncResult);
if (streamConnection != null)
{
streamServerHost.BeginAccept(StreamAccepted, null);
if (streamConnection.ConnectionInfo.StartsWith("tcp:", StringComparison.OrdinalIgnoreCase))
{
int port;
if (!int.TryParse(streamConnection.ConnectionInfo.Substring(4), out port))
{
try
{
streamConnection.Stream.Close();
}
catch (Exception ex)
{
Trace.TraceError("Error closing stream: {0}", ex.Message);
}
return;
}
else
{
bool portAllowed = noPortConstraints;
Trace.TraceInformation("Incoming connection for port {0}", port);
if (!portAllowed)
{
for (int i = 0; i < allowedPorts.Count; i++)
{
if (port == allowedPorts[i])
{
portAllowed = true;
break;
}
}
}
if (!portAllowed)
{
Trace.TraceWarning("Incoming connection for port {0} not permitted", port);
try
{
streamConnection.Stream.Close();
}
catch (Exception ex)
{
Trace.TraceError("Error closing stream: {0}", ex.Message);
}
return;
}
}
}
else if (streamConnection.ConnectionInfo.StartsWith("np:", StringComparison.OrdinalIgnoreCase))
{
string pipeName = streamConnection.ConnectionInfo.Substring(3);
Trace.TraceInformation("Incoming connection for pipe {0}", pipeName);
bool pipeAllowed = noPipeConstraints;
if (!pipeAllowed)
{
for (int i = 0; i < allowedPipes.Count; i++)
{
if (pipeName.Equals(allowedPipes[i], StringComparison.OrdinalIgnoreCase))
{
pipeAllowed = true;
break;
}
}
}
if (!pipeAllowed)
{
Trace.TraceWarning("Incoming connection for pipe {0} not permitted", pipeName);
try
{
streamConnection.Stream.Close();
}
catch (Exception ex)
{
Trace.TraceError("Error closing stream: {0}", ex.Message);
}
return;
}
}
else
{
Trace.TraceError("Unable to handle connection for {0}", streamConnection.ConnectionInfo);
streamConnection.Stream.Close();
return;
}
MultiplexConnectionInputPump connectionPump =
new MultiplexConnectionInputPump(streamConnection.Stream.Read,
OnCreateConnection,
streamConnection);
connectionPump.Run(false);
}
}
catch (Exception ex)
{
Trace.TraceError("Error accepting connection: {0}", ex.Message);
}
}
