public async Task <LoopSession> Start()
{
int?port;
ReceiverService loop =
new ReceiverBuilder()
.WithDefinition(new LoopMessages())
.Build(hooks);
TcpSocket client = pool.New();
TcpSocket server = pool.New();
client.Bind();
server.Bind(out port);
server.Listen(1);
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, port.Value);
Task <TcpSocketAccept> accept = server.Accept();
client.Connect(endpoint, null);
PeerHash peer = PeerHash.Random();
TcpSocketAccept accepted = await accept;
NetworkConnection receiver = pool.Create(accepted.Connection, NetworkDirection.Incoming, accepted.GetRemote());
loop.StartProcessing(peer, receiver);
return(new LoopSession(client, loop));
}
public async Task CanHandleTerminatedStream()
{
IPAddress localhost = IPAddress.Loopback;
IPEndPoint endpoint = new IPEndPoint(localhost, 1234);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
using (TcpSocket server = factory.Tcp())
using (TcpSocket socket = factory.Tcp())
{
socket.Bind();
worker.Start();
server.Bind(endpoint.Port);
server.Listen(1);
Task <TcpSocketAccept> acceptable = server.Accept();
await socket.Connect(endpoint);
TcpSocketAccept accepted = await acceptable;
accepted.Connection.Dispose();
byte[] buffer = new byte[10];
TcpSocketSend sent = await socket.Send(buffer);
Assert.That(sent.Status, Is.EqualTo(SocketStatus.OK));
}
}
}
public async Task ShouldTriggerConnectionSentWhenSentSomeBytes()
{
NetworkDirection direction = NetworkDirection.Outgoing;
NetworkOutgoingMessage message = new RandomMessage(113);
using (NetworkFixture fixture = new NetworkFixture())
using (TcpSocket host = fixture.Pool.New())
using (TcpSocket socket = fixture.Pool.New())
{
TcpSocketInfo info = host.BindAndInfo();
int port = info.Endpoint.Port;
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, port);
socket.Bind();
host.Listen(10);
host.Accept(null);
await socket.Connect(endpoint);
NetworkConnection connection = fixture.Pool.Create(socket, direction, endpoint);
Trigger handler = Trigger.Bind(ref fixture.Hooks.OnConnectionSent, data =>
{
data.Remote.Should().Be(NetworkAddress.Parse(endpoint));
data.Connection.Should().Be(connection);
data.Bytes.Should().Be(message.Length);
});
connection.Send(message);
handler.Wait().Should().BeTrue();
}
}
public async Task CanObtainAcceptedRemoteEndpointUsingTasks()
{
using (CompletionThread worker = new CompletionThread())
{
IPEndPoint endpoint;
SocketFactory factory = new SocketFactory(worker);
using (TcpSocket server = factory.Tcp())
using (TcpSocket client = factory.Tcp())
{
worker.Start();
client.Bind();
server.Bind(IPAddress.Loopback);
server.Listen(1);
endpoint = server.Info().Endpoint;
Task <TcpSocketAccept> accepting = server.Accept();
await client.Connect(endpoint);
TcpSocketAccept accepted = await accepting;
IPEndPoint remote = accepted.GetRemote();
Assert.That(remote.Address, Is.EqualTo(endpoint.Address));
Assert.That(remote.Port, Is.Not.EqualTo(endpoint.Port));
Assert.That(remote.Port, Is.Not.Zero);
}
}
}
///<summary>Processes a SOCKS request from a client.</summary>
///<param name="Request">The request to process.</param>
protected override async Task ProcessRequest(byte[] Request)
{
int Ret;
try
{
if (Request[0] == 1)
{ // CONNECT
IPAddress RemoteIP;
int RemotePort = Request[1] * 256 + Request[2];
Ret = Array.IndexOf(Request, (byte)0, 7);
Username = Encoding.ASCII.GetString(Request, 7, Ret - 7);
if (Request[3] == 0 && Request[4] == 0 && Request[5] == 0 && Request[6] != 0)
{// Use remote DNS
Ret = Array.IndexOf(Request, (byte)0, Ret + 1);
RemoteIP = Dns.GetHostAddressesAsync(Encoding.ASCII.GetString(Request, Username.Length + 8, Ret - Username.Length - 8)).Result[0];
}
else
{ //Do not use remote DNS
RemoteIP = IPAddress.Parse(Request[3].ToString() + "." + Request[4].ToString() + "." + Request[5].ToString() + "." + Request[6].ToString());
}
RemoteConnection = new TcpSocket(RemoteIP.AddressFamily, false);
try
{
await RemoteConnection.ConnectAsync(new IPEndPoint(RemoteIP, RemotePort));
await OnConnected(null);
}
catch (Exception ex)
{
Console.WriteLine("[WARN] " + ex.Message + "\r\n" + ex.StackTrace);
await OnConnected(ex);
}
}
else if (Request[0] == 2)
{ // BIND
byte[] Reply = new byte[8];
long LocalIP = BitConverter.ToInt64(Listener.GetLocalExternalIP().Result.GetAddressBytes(), 0);
AcceptSocket = new TcpSocket(IPAddress.Any.AddressFamily, false);
AcceptSocket.Bind(new IPEndPoint(IPAddress.Any, 0));
AcceptSocket.Listen(50);
RemoteBindIP = IPAddress.Parse(Request[3].ToString() + "." + Request[4].ToString() + "." + Request[5].ToString() + "." + Request[6].ToString());
Reply[0] = 0; //Reply version 0
Reply[1] = 90; //Everything is ok :)
Reply[2] = (byte)(Math.Floor(((IPEndPoint)AcceptSocket.LocalEndPoint).Port / 256.0)); //Port/1
Reply[3] = (byte)(((IPEndPoint)AcceptSocket.LocalEndPoint).Port % 256); //Port/2
Reply[4] = (byte)((LocalIP % 256)); //IP Address/1
Reply[5] = (byte)(Math.Floor((LocalIP % 65536) / 256.0)); //IP Address/2
Reply[6] = (byte)(Math.Floor((LocalIP % 16777216) / 65536.0)); //IP Address/3
Reply[7] = (byte)(Math.Floor(LocalIP / 16777216.0)); //IP Address/4
await Connection.SendAsync(Reply, async (int x) => { await OnStartAccept(); });
}
}
catch (Exception ex)
{
Console.WriteLine("[WARN] " + ex.Message + "\r\n" + ex.StackTrace);
await Dispose(ReplyCode.RequestRejected1);
}
}
public ConnectorSession(NetworkPool pool, PeerConnector connector)
{
int?port;
this.connector = connector;
this.server = pool.New();
server.Bind(out port);
server.Listen(1);
endpoint = new IPEndPoint(IPAddress.Loopback, port.Value);
}
public void Start()
{
assignedPort = configuration.Port.Bind(socket);
if (assignedPort == null)
{
hooks.CallListenerFailed(configuration, assignedPort.Value, $"Binding to the requested port failed.");
}
else
{
socket.Listen(8);
socket.Accept(OnAccept);
hooks.CallListenerStarted(configuration, assignedPort.Value);
}
}
///<summary>Starts listening on the selected IP address and port.</summary>
///<exception cref="SocketException">There was an error while creating the listening socket.</exception>
public async void Start()
{
try
{
ListenSocket = new TcpSocket(Address.AddressFamily, this.Secure);
ListenSocket.Bind(new IPEndPoint(Address, Port));
ListenSocket.Listen(50);
SocketConnection socket = await ListenSocket.AcceptAsync();
await this.OnAccept(socket);
}
catch (Exception ex)
{
Console.WriteLine("[WARN] " + ex.Message + "\r\n" + ex.StackTrace);
this.Dispose();
throw new SocketException();
}
}
public async Task ShouldTriggerConnectionReceivedWhenReceivedSomeBytes()
{
NetworkDirection direction = NetworkDirection.Outgoing;
NetworkOutgoingMessage message = new RandomMessage(113);
using (NetworkFixture fixture = new NetworkFixture())
using (TcpSocket host = fixture.Pool.New())
using (TcpSocket socket = fixture.Pool.New())
{
TcpSocketInfo info = host.BindAndInfo();
int port = info.Endpoint.Port;
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, port);
socket.Bind();
host.Listen(10);
Task <TcpSocketAccept> task = host.Accept();
await socket.Connect(endpoint);
TcpSocketAccept accept = await task;
NetworkConnection connection = fixture.Pool.Create(socket, direction, endpoint);
NetworkBlock block = new NetworkBlock(new byte[1024], 0, message.Length);
Trigger handler = Trigger.Bind(ref fixture.Hooks.OnConnectionReceived, data =>
{
data.Remote.Should().Be(NetworkAddress.Parse(endpoint));
data.Connection.Should().NotBeNull();
data.Bytes.Should().Be(message.Length);
});
connection.Receive(new NullReceiver());
message.ToBytes(block);
block.With((buffer, offset, count) =>
{
accept.Connection.Send(new SocketBuffer(buffer, offset, count), null);
});
handler.Wait().Should().BeTrue();
}
}
public async Task ShouldTriggerConnectionTerminatedWhenSending()
{
NetworkDirection direction = NetworkDirection.Outgoing;
using (NetworkFixture fixture = new NetworkFixture())
using (TcpSocket host = fixture.Pool.New())
using (TcpSocket socket = fixture.Pool.New())
{
TcpSocketInfo info = host.BindAndInfo();
int port = info.Endpoint.Port;
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, port);
socket.Bind();
host.Listen(10);
Task <TcpSocketAccept> task = host.Accept();
TcpSocketConnect connect = await socket.Connect(endpoint);
TcpSocketAccept accept = await task;
connect.Status.Should().Be(SocketStatus.OK);
accept.Status.Should().Be(SocketStatus.OK);
accept.Connection.Dispose();
NetworkConnection connection = fixture.Pool.Create(socket, direction, endpoint);
Trigger handler = Trigger.Bind(ref fixture.Hooks.OnConnectionTerminated, data =>
{
data.Remote.Should().Be(NetworkAddress.Parse(endpoint));
data.Connection.Should().NotBeNull();
});
for (int i = 0; i < 10; i++)
{
connection.Send(new OneByteMessage());
}
handler.Wait().Should().BeTrue();
}
}
public async Task <NegotiatorFixturePair> Create()
{
int?port;
TcpSocket host = pool.New();
TcpSocket client = pool.New();
client.Bind();
host.Bind(out port);
host.Listen(1);
Task <TcpSocketAccept> accept = host.Accept();
Task <TcpSocketConnect> connect = client.Connect(port.Value);
TcpSocketAccept accepted = await accept;
TcpSocketConnect connected = await connect;
NetworkConnection local = pool.Create(connected.Socket, NetworkDirection.Outgoing, connected.Endpoint);
NetworkConnection remote = pool.Create(accepted.Connection, NetworkDirection.Incoming, accepted.GetRemote());
return(new NegotiatorFixturePair(local, remote));
}
public void Start()
{
socket.Listen(10);
socket.Accept(OnAccepted);
}
///<summary>Processes a received query.</summary>
///<param name="Query">The query to process.</param>
private async Task ProcessQuery(byte[] Query)
{
try
{
Request request = null;
Request.ParseRequest(Query, out request);
switch (request.Command)
{
case Command.Connect: //CONNECT
IPAddress RemoteIP = request.DstAddr;
int RemotePort = 0;
if (Query[3] == 1)
{
RemoteIP = IPAddress.Parse(Query[4].ToString() + "." + Query[5].ToString() + "." + Query[6].ToString() + "." + Query[7].ToString());
RemotePort = Query[8] * 256 + Query[9];
}
else if (Query[3] == 3)
{
if (RemoteIP == null)
{
RemoteIP = Dns.GetHostAddressesAsync(Encoding.ASCII.GetString(Query, 5, Query[4])).Result[0];
}
RemotePort = Query[4] + 5;
RemotePort = Query[RemotePort] * 256 + Query[RemotePort + 1];
}
RemoteConnection = new TcpSocket(RemoteIP.AddressFamily, false);
try
{
await RemoteConnection.ConnectAsync(new IPEndPoint(RemoteIP, RemotePort));
await OnConnected(null);
}
catch (SocketException ex)
{
Console.WriteLine("[WARN] SocketError=" + ex.SocketErrorCode + "\r\n");
await OnConnected(ex);
}
catch (Exception ex)
{
Console.WriteLine("[WARN] " + ex.Message + "\r\n" + ex.StackTrace);
await OnConnected(ex);
}
break;
case Command.Bind: //BIND
byte[] Reply = new byte[10];
long LocalIP = BitConverter.ToInt64(Listener.GetLocalExternalIP().Result.GetAddressBytes(), 0);
AcceptSocket = new TcpSocket(IPAddress.Any.AddressFamily, false);
AcceptSocket.Bind(new IPEndPoint(IPAddress.Any, 0));
AcceptSocket.Listen(50);
Reply[0] = 5; //Version 5
Reply[1] = 0; //Everything is ok :)
Reply[2] = 0; //Reserved
Reply[3] = 1; //We're going to send a IPv4 address
Reply[4] = (byte)((LocalIP % 256)); //IP Address/1
Reply[5] = (byte)((LocalIP % 65536) / 256); //IP Address/2
Reply[6] = (byte)((LocalIP % 16777216) / 65536); //IP Address/3
Reply[7] = (byte)(Math.Floor(LocalIP / 16777216.0)); //IP Address/4
Reply[8] = (byte)(Math.Floor(((IPEndPoint)AcceptSocket.LocalEndPoint).Port / 256.0)); //Port/1
Reply[9] = (byte)(((IPEndPoint)AcceptSocket.LocalEndPoint).Port % 256); //Port/2
await Connection.SendAsync(Reply, async (int x) => { await this.OnStartAccept(); });
break;
case Command.UdpAssociate: //UDP ASSOCIATE
if (request.DstAddr.Equals(IPAddress.Any) && request.DstPort == 0)
{
request.DstPort = FreePort.FindNextAvailableUDPPort(4200);
if (request.DstPort == 0)
{
await Dispose(ReplyCode.SocksFailure);
return;
}
}
if (request.DstAddr.Equals(IPAddress.Any))
{
request.DstAddr = ((IPEndPoint)Connection.LocalEndPoint).Address;
}
UdpClientEndPoint = new IPEndPoint(request.DstAddr, request.DstPort);
LocalBindEndPoint = new IPEndPoint(((IPEndPoint)(Connection.LocalEndPoint)).Address, request.DstPort);
var reply = request.CreateReply(LocalBindEndPoint.Address, LocalBindEndPoint.Port);
await Connection.SendAsync(reply.ToBytes(), async (int x) => { await this.StartUdpReceive(); });
break;
default:
await Dispose(ReplyCode.UnsupportedCommand);
break;
}
}
catch (Exception ex)
{
Console.WriteLine("[WARN] " + ex.Message + "\r\n" + ex.StackTrace);
await Dispose(ReplyCode.SocksFailure);
}
}