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
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(); } } }
} // 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
// 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 authentication is requested wait for auth request. closeImmediately = false; if (_secure) { throw new NotSupportedException(); } 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)) { //throw; } } } }
} // 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; } } } } }
// 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 authentication is requested wait for auth request. closeImmediately = false; if (_secure) { throw new NotSupportedException(); } 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)) { //throw; } } } }