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);
}
}