private WindowsIdentity Authenticate(ref Stream netStream, TcpServerSocketHandler streamManager)
{
// Use the identity for impersonation etc.
NegotiateStream negoServer = null;
try
{
negoServer = new NegotiateStream(netStream);
// Block for authentication request
TokenImpersonationLevel impLevel = TokenImpersonationLevel.Identification;
if (_impersonate)
{
impLevel = TokenImpersonationLevel.Impersonation;
}
negoServer.AuthenticateAsServer((NetworkCredential)CredentialCache.DefaultCredentials, _protectionLevel, impLevel);
netStream = negoServer;
return((WindowsIdentity)negoServer.RemoteIdentity);
}
catch
{
streamManager.SendErrorResponse(
String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Tcp_ServerAuthenticationFailed")), false);
if (negoServer != null)
{
negoServer.Close();
}
throw;
}
}
private WindowsIdentity Authenticate(ref Stream netStream, TcpServerSocketHandler streamManager)
{
NegotiateStream stream = null;
WindowsIdentity remoteIdentity;
try
{
stream = new NegotiateStream(netStream);
TokenImpersonationLevel identification = TokenImpersonationLevel.Identification;
if (this._impersonate)
{
identification = TokenImpersonationLevel.Impersonation;
}
stream.AuthenticateAsServer((NetworkCredential)CredentialCache.DefaultCredentials, this._protectionLevel, identification);
netStream = stream;
remoteIdentity = (WindowsIdentity)stream.RemoteIdentity;
}
catch
{
streamManager.SendErrorResponse(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Tcp_ServerAuthenticationFailed"), new object[0]), false);
if (stream != null)
{
stream.Close();
}
throw;
}
return(remoteIdentity);
}
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
{
TcpServerSocketHandler handler = null;
handler = (TcpServerSocketHandler)state;
handler.SendResponse(headers, stream);
if (handler.CanServiceAnotherRequest())
{
handler.BeginReadMessage();
}
else
{
handler.Close();
}
}
} // StopListening
//
// end of IChannelReceiver implementation
//
//
// Server helpers
//
// Thread for listening
void Listen()
{
bool bOkToListen = false;
try
{
_tcpListener.Start();
bOkToListen = true;
}
catch (Exception e)
{
_startListeningException = e;
}
_waitForStartListening.Set(); // allow main thread to continue now that we have tried to start the socket
InternalRemotingServices.RemotingTrace( "Waiting to Accept the Socket on Port: " + _port);
//
// Wait for an incoming socket
//
Socket socket;
while (bOkToListen)
{
InternalRemotingServices.RemotingTrace("TCPChannel::Listen - tcpListen.Pending() == true");
try
{
socket = _tcpListener.AcceptSocket();
if (socket == null)
{
throw new RemotingException(
String.Format(
CoreChannel.GetResourceString("Remoting_Socket_Accept"),
Marshal.GetLastWin32Error().ToString()));
}
// disable nagle delay
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);
// set linger option
LingerOption lingerOption = new LingerOption(true, 3);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption);
TcpServerSocketHandler streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue);
streamManager.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest);
streamManager.BeginReadMessage();
}
catch (Exception e)
{
if (!_bListening)
{
// We called Stop() on the tcp listener, so gracefully exit.
bOkToListen = false;
}
else
{
// we want the exception to show up as unhandled since this
// is an unexpected failure.
if (!(e is SocketException))
{
//throw;
}
}
}
}
}
} // TcpServerTransportSink
internal void ServiceRequest(Object state)
{
TcpServerSocketHandler streamManager = (TcpServerSocketHandler)state;
ITransportHeaders headers = streamManager.ReadHeaders();
Stream requestStream = streamManager.GetRequestStream();
headers["__CustomErrorsEnabled"] = streamManager.CustomErrorsEnabled();
// process request
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, streamManager);
IMessage responseMessage;
ITransportHeaders responseHeaders;
Stream responseStream;
#if !FEATURE_PAL
// If Impersonation was requested impersonate the client identity
WindowsIdentity identity = streamManager.ImpersonationIdentity;
WindowsImpersonationContext context = null;
IPrincipal oldPrincipal = null;
bool principalChanged = false;
if (identity != null)
{
oldPrincipal = Thread.CurrentPrincipal;
principalChanged = true;
if (_impersonate)
{
Thread.CurrentPrincipal = new WindowsPrincipal(identity);
context = identity.Impersonate();
}
else
{
Thread.CurrentPrincipal = new GenericPrincipal(identity, null);
}
}
#endif // !FEATURE_PAL
ServerProcessing processing;
// wrap Undo in an outer try block
try{
try{
processing =
_nextSink.ProcessMessage(sinkStack, null, headers, requestStream,
out responseMessage,
out responseHeaders, out responseStream);
}
finally{
#if !FEATURE_PAL
// Revert the principal if we had changed the principal
if (principalChanged)
{
Thread.CurrentPrincipal = oldPrincipal;
}
// Revert the impersonation if we had impersonated
if (_impersonate)
{
context.Undo();
}
#endif // !FEATURE_PAL
}
}
catch { throw; }
// handle response
switch (processing)
{
case ServerProcessing.Complete:
{
// Send the response. Call completed synchronously.
sinkStack.Pop(this);
streamManager.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
// No response needed, but the following method will make sure that
// we send at least a skeleton reply if the incoming request was
// not marked OneWayRequest (client/server metadata could be out of
// [....]).
streamManager.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.OneWay
case ServerProcessing.Async:
{
sinkStack.StoreAndDispatch(this, streamManager);
break;
} // case ServerProcessing.Async
} // switch (processing)
// async processing will take care if handling this later
if (processing != ServerProcessing.Async)
{
if (streamManager.CanServiceAnotherRequest())
{
streamManager.BeginReadMessage();
}
else
{
streamManager.Close();
}
}
} // ServiceRequest
// AcceptSocket method which will invoke the
// authorization callbacks
void AcceptSocketCallback(IAsyncResult ar)
{
Socket socket = null;
InternalRemotingServices.RemotingTrace("TCPChannel::Listen - tcpListen.Pending() == true");
TcpServerSocketHandler streamManager = null;
bool closeImmediately = true;
try
{
//
// Wait for an incoming socket
// if the listener is still active
if (_tcpListener.IsListening)
{
_tcpListener.BeginAcceptSocket(_acceptSocketCallback, null);
}
socket = _tcpListener.EndAcceptSocket(ar);
if (socket == null)
{
throw new RemotingException(
String.Format(
CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Socket_Accept"),
Marshal.GetLastWin32Error().ToString(CultureInfo.CurrentCulture)));
}
if (_authorizeRemotingConnection != null)
{
bool authorized = _authorizeRemotingConnection.IsConnectingEndPointAuthorized(socket.RemoteEndPoint);
if (!authorized)
{
throw new RemotingException(CoreChannel.GetResourceString(
"Remoting_Tcp_ServerAuthorizationEndpointFailed"));
}
}
// disable nagle delay
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);
// Set keepalive flag, so that inactive sockets can be cleaned up
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1);
// set linger option
LingerOption lingerOption = new LingerOption(true, 3);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption);
Stream netStream = new SocketStream(socket);
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, netStream);
#if !FEATURE_PAL
WindowsIdentity identity = null;
#endif // !FEATURE_PAL
// If authentication is requested wait for auth request.
closeImmediately = false;
if (_secure)
{
#if !FEATURE_PAL
identity = Authenticate(ref netStream, streamManager);
// Create a new SocketHandler to wrap the new netStream
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, netStream);
if (_authorizeRemotingConnection != null)
{
bool authorized = _authorizeRemotingConnection.IsConnectingIdentityAuthorized(identity);
if (!authorized)
{
throw new RemotingException(CoreChannel.GetResourceString(
"Remoting_Tcp_ServerAuthorizationIdentityFailed"));
}
}
#else
throw new NotSupportedException();
#endif // !FEATURE_PAL
}
#if !FEATURE_PAL
// Cache the identity for impersonation
streamManager.ImpersonationIdentity = identity;
#endif // !FEATURE_PAL
streamManager.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest);
streamManager.BeginReadMessage();
}
catch (Exception e)
{
// Close the socket pre-emptively. We also close the socket if
// We need to catch all exceptions if we hit ObjectDisposedException
try{
if (streamManager != null)
{
streamManager.SendErrorResponse(e, false);
}
if (socket != null)
{
if (closeImmediately)
{
socket.Close(0);
}
else
{
socket.Close();
}
}
}catch (Exception) {}
if (!_bListening)
{
// We called Stop() on the tcp listener, so gracefully exit.
//bOkToListen = false;
}
else
{
// we want the exception to show up as unhandled since this
// is an unexpected failure.
if (!(e is SocketException))
{
// <
}
}
}
}
internal void ServiceRequest(object state)
{
ITransportHeaders headers2;
Stream stream2;
ServerProcessing processing;
TcpServerSocketHandler handler = (TcpServerSocketHandler)state;
ITransportHeaders requestHeaders = handler.ReadHeaders();
Stream requestStream = handler.GetRequestStream();
requestHeaders["__CustomErrorsEnabled"] = handler.CustomErrorsEnabled();
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, handler);
WindowsIdentity impersonationIdentity = handler.ImpersonationIdentity;
WindowsImpersonationContext context = null;
IPrincipal currentPrincipal = null;
bool flag = false;
if (impersonationIdentity != null)
{
currentPrincipal = Thread.CurrentPrincipal;
flag = true;
if (this._impersonate)
{
Thread.CurrentPrincipal = new WindowsPrincipal(impersonationIdentity);
context = impersonationIdentity.Impersonate();
}
else
{
Thread.CurrentPrincipal = new GenericPrincipal(impersonationIdentity, null);
}
}
try
{
try
{
IMessage message;
processing = this._nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out message, out headers2, out stream2);
}
finally
{
if (flag)
{
Thread.CurrentPrincipal = currentPrincipal;
}
if (this._impersonate)
{
context.Undo();
}
}
}
catch
{
throw;
}
switch (processing)
{
case ServerProcessing.Complete:
sinkStack.Pop(this);
handler.SendResponse(headers2, stream2);
break;
case ServerProcessing.OneWay:
handler.SendResponse(headers2, stream2);
break;
case ServerProcessing.Async:
sinkStack.StoreAndDispatch(this, handler);
break;
}
if (processing != ServerProcessing.Async)
{
if (handler.CanServiceAnotherRequest())
{
handler.BeginReadMessage();
}
else
{
handler.Close();
}
}
}
private WindowsIdentity Authenticate(ref Stream netStream, TcpServerSocketHandler streamManager)
{
// Use the identity for impersonation etc.
NegotiateStream negoServer = null;
try
{
negoServer = new NegotiateStream(netStream);
// Block for authentication request
TokenImpersonationLevel impLevel = TokenImpersonationLevel.Identification;
if (_impersonate)
impLevel = TokenImpersonationLevel.Impersonation;
negoServer.AuthenticateAsServer((NetworkCredential)CredentialCache.DefaultCredentials, _protectionLevel, impLevel);
netStream = negoServer;
return (WindowsIdentity)negoServer.RemoteIdentity;
}
catch
{
streamManager.SendErrorResponse(
String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Tcp_ServerAuthenticationFailed")), false);
if (negoServer != null)
negoServer.Close();
throw;
}
}
// AcceptSocket method which will invoke the
// authorization callbacks
void AcceptSocketCallback(IAsyncResult ar)
{
Socket socket = null;
InternalRemotingServices.RemotingTrace("TCPChannel::Listen - tcpListen.Pending() == true");
TcpServerSocketHandler streamManager = null;
bool closeImmediately = true;
try
{
//
// Wait for an incoming socket
// if the listener is still active
if (_tcpListener.IsListening)
_tcpListener.BeginAcceptSocket(_acceptSocketCallback, null);
socket = _tcpListener.EndAcceptSocket(ar);
if (socket == null)
{
throw new RemotingException(
String.Format(
CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Socket_Accept"),
Marshal.GetLastWin32Error().ToString(CultureInfo.CurrentCulture)));
}
if (_authorizeRemotingConnection != null)
{
bool authorized = _authorizeRemotingConnection.IsConnectingEndPointAuthorized(socket.RemoteEndPoint);
if (!authorized)
throw new RemotingException(CoreChannel.GetResourceString(
"Remoting_Tcp_ServerAuthorizationEndpointFailed"));
}
// disable nagle delay
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);
// Set keepalive flag, so that inactive sockets can be cleaned up
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1);
// set linger option
LingerOption lingerOption = new LingerOption(true, 3);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption);
Stream netStream = new SocketStream(socket);
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, netStream);
#if !FEATURE_PAL
WindowsIdentity identity = null;
#endif // !FEATURE_PAL
// If authentication is requested wait for auth request.
closeImmediately = false;
if (_secure)
{
#if !FEATURE_PAL
identity = Authenticate(ref netStream, streamManager);
// Create a new SocketHandler to wrap the new netStream
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, netStream);
if (_authorizeRemotingConnection != null)
{
bool authorized = _authorizeRemotingConnection.IsConnectingIdentityAuthorized(identity);
if (!authorized)
throw new RemotingException(CoreChannel.GetResourceString(
"Remoting_Tcp_ServerAuthorizationIdentityFailed"));
}
#else
throw new NotSupportedException();
#endif // !FEATURE_PAL
}
#if !FEATURE_PAL
// Cache the identity for impersonation
streamManager.ImpersonationIdentity = identity;
#endif // !FEATURE_PAL
streamManager.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest);
streamManager.BeginReadMessage();
}
catch (Exception e)
{
// Close the socket pre-emptively. We also close the socket if
// We need to catch all exceptions if we hit ObjectDisposedException
try{
if (streamManager != null){
streamManager.SendErrorResponse(e, false);
}
if (socket != null){
if (closeImmediately)
socket.Close(0);
else
socket.Close();
}
}catch(Exception){}
if (!_bListening)
{
// We called Stop() on the tcp listener, so gracefully exit.
//bOkToListen = false;
}
else
{
// we want the exception to show up as unhandled since this
// is an unexpected failure.
if (!(e is SocketException))
{
// <
}
}
}
}
} // TcpServerTransportSink
internal void ServiceRequest(Object state)
{
TcpServerSocketHandler streamManager = (TcpServerSocketHandler)state;
ITransportHeaders headers = streamManager.ReadHeaders();
Stream requestStream = streamManager.GetRequestStream();
headers["__CustomErrorsEnabled"] = streamManager.CustomErrorsEnabled();
// process request
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, streamManager);
IMessage responseMessage;
ITransportHeaders responseHeaders;
Stream responseStream;
ServerProcessing processing;
// wrap Undo in an outer try block
try{
try{
processing =
_nextSink.ProcessMessage(sinkStack, null, headers, requestStream,
out responseMessage,
out responseHeaders, out responseStream);
}
finally{
}
}
catch { throw; }
// handle response
switch (processing)
{
case ServerProcessing.Complete:
{
// Send the response. Call completed synchronously.
sinkStack.Pop(this);
streamManager.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
// No response needed, but the following method will make sure that
// we send at least a skeleton reply if the incoming request was
// not marked OneWayRequest (client/server metadata could be out of
// sync).
streamManager.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.OneWay
case ServerProcessing.Async:
{
sinkStack.StoreAndDispatch(this, streamManager);
break;
} // case ServerProcessing.Async
} // switch (processing)
// async processing will take care if handling this later
if (processing != ServerProcessing.Async)
{
if (streamManager.CanServiceAnotherRequest())
{
streamManager.BeginReadMessage();
}
else
{
streamManager.Close();
}
}
} // ServiceRequest
private void AcceptSocketCallback(IAsyncResult ar)
{
Socket socket = null;
TcpServerSocketHandler streamManager = null;
bool flag = true;
try
{
if (this._tcpListener.IsListening)
{
this._tcpListener.BeginAcceptSocket(this._acceptSocketCallback, null);
}
socket = this._tcpListener.EndAcceptSocket(ar);
if (socket == null)
{
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Socket_Accept"), new object[] { Marshal.GetLastWin32Error().ToString(CultureInfo.CurrentCulture) }));
}
if ((this._authorizeRemotingConnection != null) && !this._authorizeRemotingConnection.IsConnectingEndPointAuthorized(socket.RemoteEndPoint))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Tcp_ServerAuthorizationEndpointFailed"));
}
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.Debug, 1);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1);
LingerOption optionValue = new LingerOption(true, 3);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, optionValue);
Stream stream = new SocketStream(socket);
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, stream);
WindowsIdentity identity = null;
flag = false;
if (this._secure)
{
identity = this.Authenticate(ref stream, streamManager);
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, stream);
if ((this._authorizeRemotingConnection != null) && !this._authorizeRemotingConnection.IsConnectingIdentityAuthorized(identity))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Tcp_ServerAuthorizationIdentityFailed"));
}
}
streamManager.ImpersonationIdentity = identity;
streamManager.DataArrivedCallback = new WaitCallback(this._transportSink.ServiceRequest);
streamManager.BeginReadMessage();
}
catch (Exception exception)
{
try
{
if (streamManager != null)
{
streamManager.SendErrorResponse(exception, false);
}
if (socket != null)
{
if (flag)
{
socket.Close(0);
}
else
{
socket.Close();
}
}
}
catch (Exception)
{
}
if (this._bListening)
{
SocketException exception3 = exception as SocketException;
}
}
}
} // StopListening
//
// end of IChannelReceiver implementation
//
//
// Server helpers
//
// Thread for listening
void Listen()
{
bool bOkToListen = false;
try
{
_tcpListener.Start();
bOkToListen = true;
}
catch (Exception e)
{
_startListeningException = e;
}
_waitForStartListening.Set(); // allow main thread to continue now that we have tried to start the socket
InternalRemotingServices.RemotingTrace("Waiting to Accept the Socket on Port: " + _port);
//
// Wait for an incoming socket
//
Socket socket;
while (bOkToListen)
{
InternalRemotingServices.RemotingTrace("TCPChannel::Listen - tcpListen.Pending() == true");
try
{
socket = _tcpListener.AcceptSocket();
if (socket == null)
{
throw new RemotingException(
String.Format(
CoreChannel.GetResourceString("Remoting_Socket_Accept"),
Marshal.GetLastWin32Error().ToString()));
}
// disable nagle delay
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);
// set linger option
LingerOption lingerOption = new LingerOption(true, 3);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption);
TcpServerSocketHandler streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue);
streamManager.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest);
streamManager.BeginReadMessage();
}
catch (Exception e)
{
if (!_bListening)
{
// We called Stop() on the tcp listener, so gracefully exit.
bOkToListen = false;
}
else
{
// we want the exception to show up as unhandled since this
// is an unexpected failure.
if (!(e is SocketException))
{
//throw;
}
}
}
}
}
private WindowsIdentity Authenticate(ref Stream netStream, TcpServerSocketHandler streamManager)
{
NegotiateStream stream = null;
WindowsIdentity remoteIdentity;
try
{
stream = new NegotiateStream(netStream);
TokenImpersonationLevel identification = TokenImpersonationLevel.Identification;
if (this._impersonate)
{
identification = TokenImpersonationLevel.Impersonation;
}
stream.AuthenticateAsServer((NetworkCredential) CredentialCache.DefaultCredentials, this._protectionLevel, identification);
netStream = stream;
remoteIdentity = (WindowsIdentity) stream.RemoteIdentity;
}
catch
{
streamManager.SendErrorResponse(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Tcp_ServerAuthenticationFailed"), new object[0]), false);
if (stream != null)
{
stream.Close();
}
throw;
}
return remoteIdentity;
}
private void AcceptSocketCallback(IAsyncResult ar)
{
Socket socket = null;
TcpServerSocketHandler streamManager = null;
bool flag = true;
try
{
if (this._tcpListener.IsListening)
{
this._tcpListener.BeginAcceptSocket(this._acceptSocketCallback, null);
}
socket = this._tcpListener.EndAcceptSocket(ar);
if (socket == null)
{
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Socket_Accept"), new object[] { Marshal.GetLastWin32Error().ToString(CultureInfo.CurrentCulture) }));
}
if ((this._authorizeRemotingConnection != null) && !this._authorizeRemotingConnection.IsConnectingEndPointAuthorized(socket.RemoteEndPoint))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Tcp_ServerAuthorizationEndpointFailed"));
}
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.Debug, 1);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1);
LingerOption optionValue = new LingerOption(true, 3);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, optionValue);
Stream stream = new SocketStream(socket);
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, stream);
WindowsIdentity identity = null;
flag = false;
if (this._secure)
{
identity = this.Authenticate(ref stream, streamManager);
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, stream);
if ((this._authorizeRemotingConnection != null) && !this._authorizeRemotingConnection.IsConnectingIdentityAuthorized(identity))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Tcp_ServerAuthorizationIdentityFailed"));
}
}
streamManager.ImpersonationIdentity = identity;
streamManager.DataArrivedCallback = new WaitCallback(this._transportSink.ServiceRequest);
streamManager.BeginReadMessage();
}
catch (Exception exception)
{
try
{
if (streamManager != null)
{
streamManager.SendErrorResponse(exception, false);
}
if (socket != null)
{
if (flag)
{
socket.Close(0);
}
else
{
socket.Close();
}
}
}
catch (Exception)
{
}
if (this._bListening)
{
SocketException exception3 = exception as SocketException;
}
}
}