private void ProcessAccept(Socket clientSocket) { Interlocked.Increment(ref _pendingRequests); try { #if FEATURE_SOCKET_SETSOCKETOPTION clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true); clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, true); #endif //FEATURE_SOCKET_SETSOCKETOPTION var originatorEndPoint = (IPEndPoint)clientSocket.RemoteEndPoint; RaiseRequestReceived(originatorEndPoint.Address.ToString(), (uint)originatorEndPoint.Port); using (var channel = Session.CreateChannelDirectTcpip()) { channel.Exception += Channel_Exception; channel.Open(Host, Port, this, clientSocket); channel.Bind(); channel.Close(); } } catch (Exception exp) { RaiseExceptionEvent(exp); CloseSocket(clientSocket); } finally { Interlocked.Decrement(ref _pendingRequests); } }
private void ProcessAccept(Socket clientSocket) { // close the client socket if we're no longer accepting new connections if (!IsStarted) { CloseClientSocket(clientSocket); return; } // capture the countdown event that we're adding a count to, as we need to make sure that we'll be signaling // that same instance; the instance field for the countdown event is re-initialized when the port is restarted // and at that time there may still be pending requests var pendingChannelCountdown = _pendingChannelCountdown; pendingChannelCountdown.AddCount(); try { using (var channel = Session.CreateChannelDirectTcpip()) { channel.Exception += Channel_Exception; try { if (!HandleSocks(channel, clientSocket, Session.ConnectionInfo.Timeout)) { CloseClientSocket(clientSocket); return; } // start receiving from client socket (and sending to server) channel.Bind(); } finally { channel.Close(); } } } catch (Exception exp) { RaiseExceptionEvent(exp); CloseClientSocket(clientSocket); } finally { // take into account that CountdownEvent has since been disposed; when stopping the port we // wait for a given time for the channels to close, but once that timeout period has elapsed // the CountdownEvent will be disposed try { pendingChannelCountdown.Signal(); } catch (ObjectDisposedException) { } } }
private void ProcessAccept(Socket clientSocket) { // close the client socket if we're no longer accepting new connections if (!IsStarted) { CloseClientSocket(clientSocket); return; } // capture the countdown event that we're adding a count to, as we need to make sure that we'll be signaling // that same instance; the instance field for the countdown event is re-initialized when the port is restarted // and at that time there may still be pending requests var pendingChannelCountdown = _pendingChannelCountdown; pendingChannelCountdown.AddCount(); try { var originatorEndPoint = (IPEndPoint)clientSocket.RemoteEndPoint; RaiseRequestReceived(originatorEndPoint.Address.ToString(), (uint)originatorEndPoint.Port); using (var channel = Session.CreateChannelDirectTcpip()) { channel.Exception += Channel_Exception; channel.Open(Host, Port, this, clientSocket); channel.Bind(); channel.Close(); } } catch (Exception exp) { RaiseExceptionEvent(exp); CloseClientSocket(clientSocket); } finally { // take into account that CountdownEvent has since been disposed; when stopping the port we // wait for a given time for the channels to close, but once that timeout period has elapsed // the CountdownEvent will be disposed try { pendingChannelCountdown.Signal(); } catch (ObjectDisposedException) { } } }
private void AcceptCallback(IAsyncResult ar) { // Get the socket that handles the client request var serverSocket = (Socket)ar.AsyncState; Socket clientSocket; try { clientSocket = serverSocket.EndAccept(ar); } catch (ObjectDisposedException) { // when the socket is closed, an ObjectDisposedException is thrown // by Socket.EndAccept(IAsyncResult) return; } Interlocked.Increment(ref _pendingRequests); try { clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true); clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, true); var originatorEndPoint = (IPEndPoint)clientSocket.RemoteEndPoint; RaiseRequestReceived(originatorEndPoint.Address.ToString(), (uint)originatorEndPoint.Port); using (var channel = Session.CreateChannelDirectTcpip()) { channel.Exception += Channel_Exception; channel.Open(Host, Port, this, clientSocket); channel.Bind(); channel.Close(); } } catch (Exception exp) { RaiseExceptionEvent(exp); CloseSocket(clientSocket); } finally { Interlocked.Decrement(ref _pendingRequests); } }
private void ProcessAccept(Socket remoteSocket) { Interlocked.Increment(ref _pendingRequests); #if DEBUG_GERT Console.WriteLine("ID: " + Thread.CurrentThread.ManagedThreadId + " | " + remoteSocket.RemoteEndPoint + " | ForwardedPortDynamic.ProcessAccept | " + DateTime.Now.ToString("hh:mm:ss.fff")); #endif // DEBUG_GERT try { #if FEATURE_SOCKET_SETSOCKETOPTION remoteSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true); remoteSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, true); #endif //FEATURE_SOCKET_SETSOCKETOPTION using (var channel = Session.CreateChannelDirectTcpip()) { channel.Exception += Channel_Exception; try { if (!HandleSocks(channel, remoteSocket, Session.ConnectionInfo.Timeout)) { CloseSocket(remoteSocket); return; } // start receiving from client socket (and sending to server) channel.Bind(); } #if DEBUG_GERT catch (SocketException ex) { Console.WriteLine("ID: " + Thread.CurrentThread.ManagedThreadId + " | " + ex.SocketErrorCode + " | " + DateTime.Now.ToString("hh:mm:ss.fff") + " | " + ex); } #endif // DEBUG_GERT finally { channel.Close(); } } } catch (SocketException ex) { // ignore exception thrown by interrupting the blocking receive as part of closing // the forwarded port if (ex.SocketErrorCode != SocketError.Interrupted) { #if DEBUG_GERT RaiseExceptionEvent(new Exception("ID: " + Thread.CurrentThread.ManagedThreadId, ex)); #else RaiseExceptionEvent(ex); #endif // DEBUG_GERT } CloseSocket(remoteSocket); } catch (Exception exp) { #if DEBUG_GERT Console.WriteLine("ID: " + Thread.CurrentThread.ManagedThreadId + " | " + exp + " | " + DateTime.Now.ToString("hh:mm:ss.fff")); #endif // DEBUG_GERT RaiseExceptionEvent(exp); CloseSocket(remoteSocket); } finally { Interlocked.Decrement(ref _pendingRequests); } }
private void AcceptCallback(IAsyncResult ar) { // Get the socket that handles the client request var serverSocket = (Socket)ar.AsyncState; Socket clientSocket; try { clientSocket = serverSocket.EndAccept(ar); } catch (ObjectDisposedException) { // when the socket is closed, an ObjectDisposedException is thrown // by Socket.EndAccept(IAsyncResult) return; } Interlocked.Increment(ref _pendingRequests); try { clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true); clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, true); using (var channel = Session.CreateChannelDirectTcpip()) { channel.Exception += Channel_Exception; var version = new byte[1]; // create eventhandler which is to be invoked to interrupt a blocking receive // when we're closing the forwarded port EventHandler closeClientSocket = (sender, args) => CloseSocket(clientSocket); try { Closing += closeClientSocket; var bytesRead = clientSocket.Receive(version); if (bytesRead == 0) { CloseSocket(clientSocket); return; } if (version[0] == 4) { HandleSocks4(clientSocket, channel); } else if (version[0] == 5) { HandleSocks5(clientSocket, channel); } else { throw new NotSupportedException(string.Format("SOCKS version {0} is not supported.", version[0])); } // interrupt of blocking receive is now handled by channel (SOCKS4 and SOCKS5) // or no longer necessary Closing -= closeClientSocket; // start receiving from client socket (and sending to server) channel.Bind(); } finally { channel.Close(); } } } catch (SocketException ex) { // ignore exception thrown by interrupting the blocking receive as part of closing // the forwarded port if (ex.SocketErrorCode != SocketError.Interrupted) { RaiseExceptionEvent(ex); } CloseSocket(clientSocket); } catch (Exception exp) { RaiseExceptionEvent(exp); CloseSocket(clientSocket); } finally { Interlocked.Decrement(ref _pendingRequests); } }