public static ValueTask <SocketReceiveResult> ReceiveBlockAsync(this ManagedTcpSocket managedTcp, Memory <byte> buffer, CancellationToken cancellationToken = default)
{
int count = buffer.Length;
while (buffer.Length > 0)
{
ValueTask <SocketReceiveResult> t = managedTcp.ReceiveAsync(buffer, cancellationToken);
if (t.IsCompletedSuccessfully)
{
SocketReceiveResult result = t.Result;
if (result.BytesReceived > 0 && result.ErrorCode == SocketError.Success)
{
// Уменьшить буфер на столько, сколько приняли.
buffer = buffer.Slice(result.BytesReceived);
}
else
{
return(new ValueTask <SocketReceiveResult>(result));
}
}
else
{
return(WaitForReceiveBlockAsync(t, count, managedTcp, buffer, cancellationToken));
}
}
// Всё выполнено синхронно.
return(new ValueTask <SocketReceiveResult>(new SocketReceiveResult(count, SocketError.Success)));
static async ValueTask <SocketReceiveResult> WaitForReceiveBlockAsync(ValueTask <SocketReceiveResult> t, int count,
ManagedTcpSocket managedTcp, Memory <byte> buffer, CancellationToken cancellationToken)
{
SocketReceiveResult result = await t.ConfigureAwait(false);
if (result.BytesReceived > 0 && result.ErrorCode == SocketError.Success)
{
// Уменьшить буфер на сколько приняли.
buffer = buffer.Slice(result.BytesReceived);
if (buffer.Length == 0)
{
return(new SocketReceiveResult(count, SocketError.Success));
}
else
// Прочитали всё что необходимо.
{
return(await ReceiveBlockAsync(managedTcp, buffer, cancellationToken).ConfigureAwait(false));
}
}
else
{
return(result);
}
}
public static async Task <Socks5LoginPassword> ReceiveAsync(ManagedTcpSocket managedTcp, Memory <byte> buffer)
{
Debug.Assert(buffer.Length >= MaximumSize);
SocketReceiveResult rcvResult = await managedTcp.ReceiveAsync(buffer).ConfigureAwait(false);
if (!rcvResult.ReceiveSuccess)
{
return(default);
internal static async ValueTask <Socks5Request> ReceiveRequestAsync(ManagedTcpSocket managedTcp, Memory <byte> buffer)
{
Debug.Assert(buffer.Length >= MaximumSize);
// Как минимум должно быть 4 байта.
SocketReceiveResult rcvResult = await managedTcp.ReceiveBlockAsync(buffer.Slice(0, 4)).ConfigureAwait(false);
if (!rcvResult.ReceiveSuccess)
{
return(default);
/// <remarks>Не бросает исключения.</remarks>
public static Task RunAsync(int connectionId, ManagedTcpSocket socketA, ManagedTcpSocket socketB)
{
var proxy1 = new Proxy(socketA, connectionId);
var proxy2 = new Proxy(socketB, connectionId);
proxy1._other = proxy2;
proxy2._other = proxy1;
Task task1 = Task.Factory.StartNew(proxy1.ReceiveAsync, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap();
Task task2 = Task.Factory.StartNew(proxy2.ReceiveAsync, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap();
return(Task.WhenAll(task1, task2));
}
public static async ValueTask <Socks5AuthRequest> ReceiveAsync(ManagedTcpSocket managedTcp, Memory <byte> buffer)
{
Debug.Assert(buffer.Length >= MaximumSize);
// Как минимум должно быть 2 байта.
SocketReceiveResult rcvResult = await managedTcp.ReceiveBlockAsync(buffer.Slice(0, 2)).ConfigureAwait(false);
if (!rcvResult.ReceiveSuccess)
{
return(new Socks5AuthRequest(authMethods: null));
}
byte version = buffer.Span[0];
if (version != 5)
{
throw new InvalidOperationException($"Не верный номер версии Socks. Получено {version}, ожидалось 5");
}
// Количество поддерживаемых методов аутентификации.
byte authCount = buffer.Span[1];
// Номера методов аутентификации, переменная длина, 1 байт для каждого поддерживаемого метода.
Memory <byte> authSpan = buffer.Slice(2, authCount);
rcvResult = await managedTcp.ReceiveBlockAsync(authSpan).ConfigureAwait(false);
if (!rcvResult.ReceiveSuccess)
{
return(new Socks5AuthRequest(authMethods: null));
}
var authMethods = new Socks5AuthMethod[authSpan.Length];
for (int i = 0; i < authSpan.Length; i++)
{
Socks5AuthMethod a = (Socks5AuthMethod)authSpan.Span[i];
if (Enum.IsDefined(typeof(Socks5AuthMethod), a))
{
authMethods[i] = a;
}
else
{
ThrowHelper.ThrowException(new InvalidOperationException("Ошибка протокола SOCKS 5"));
}
}
return(new Socks5AuthRequest(authMethods));
}
private static void TestShutdown()
{
Socket tcp = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var mTcp = new ManagedTcpSocket(tcp);
mTcp.Client.Connect("google.com", 80);
DelayShutdown(tcp);
SocketReceiveResult n;
try
{
n = mTcp.ReceiveAsync(new byte[1024]).AsTask().Result;
}
catch (Exception)
{
}
}
static async Task Main(string[] args)
{
TcpListener listener = new TcpListener(IPAddress.Any, 1234);
listener.Start();
TcpClient cli1 = new TcpClient("127.0.0.1", 1234);
var mCli1 = new ManagedTcpSocket(cli1.Client);
TcpClient cli2 = listener.AcceptTcpClient();
var mCli2 = new ManagedTcpSocket(cli2.Client);
ThreadPool.QueueUserWorkItem(async delegate
{
var buf = new byte[] { 1, 2, 3 };
Thread.Sleep(2000);
mCli2.Client.Shutdown(SocketShutdown.Send);
//while (true)
//{
// var rcv = await mCli2.ReceiveAsync(buf);
//}
});
Thread.Sleep(500);
var rcv = await mCli2.ReceiveAsync(new byte[10]);
while (true)
{
var snd = await mCli1.SendAsync(new byte[] { 1, 2, 3 });
Thread.Sleep(500);
}
Thread.Sleep(-1);
}
public Proxy(ManagedTcpSocket socket, int connectionId)
{
Socket = socket;
ConnectionId = connectionId;
}
public Socks5Connection(TcpClient tcp, Socks5Listener listener)
{
_managedTcp = new ManagedTcpSocket(tcp.Client);
_listener = listener;
}
