public async Task DoubleConnectTest()
{
TcpSocket sock = new TcpSocket();
await sock.ConnectAsync("localhost", 1002);
var result = await sock.ConnectAsync("localhost", 1002);
Assert.AreEqual(result, SocketStatus.Error);
}
private async void TryConnectToController(string ipAddress, int port)
{
if (controllerClientSocket != null)
{
TextToaster.Toast("Cannot connect to multiple controllers at once.");
return;
}
++connectingCount;
var random = new System.Random();
int userId = random.Next();
IPAddress controllerIpAddress;
if (!IPAddress.TryParse(ipAddress, out controllerIpAddress))
{
TextToaster.Toast($"Failed to parse {ipAddress} as an IP address.");
--connectingCount;
return;
}
var controllerEndPoint = new IPEndPoint(controllerIpAddress, port);
var tcpSocket = new TcpSocket(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp));
if (await tcpSocket.ConnectAsync(controllerEndPoint))
{
controllerClientSocket = new ControllerClientSocket(userId, tcpSocket);
}
--connectingCount;
}
public void RejectHugePacket()
{
using (TcpListener listener = new TcpListener(1024))
{
listener.Blocking = true;
listener.Listen(PORT);
TcpSocket clientSock = new TcpSocket();
var connectionResult = clientSock.ConnectAsync("localhost", PORT).Result;
var status = listener.Accept(out TcpSocket serverSock);
Assert.AreEqual(SocketStatus.Done, status);
var largePacket = new NetPacket();
largePacket.WriteBytes(new byte[8192], true);
while (clientSock.Send(largePacket) != SocketStatus.Done)
{
;
}
Assert.AreEqual(SocketStatus.Disconnected, serverSock.Receive(largePacket));
Assert.IsFalse(serverSock.Connected);
clientSock.Dispose();
serverSock.Dispose();
largePacket.Dispose();
}
}
public void NoConnectTest()
{
TcpSocket sock = new TcpSocket();
var result = sock.ConnectAsync("localhost", 1002).Result;
Assert.AreEqual(result, SocketStatus.Error);
}
private async void TryConnectToController()
{
if (controllerClient != null)
{
textToaster.Toast("A controller is already connected.");
return;
}
if (!ConnectWindowVisibility)
{
textToaster.Toast("Cannot try connecting to more than one remote machine.");
return;
}
ConnectWindowVisibility = false;
var random = new System.Random();
int userId = random.Next();
var tcpSocket = new TcpSocket(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp));
if (await tcpSocket.ConnectAsync(IPAddress.Loopback, ControllerMessages.PORT))
{
textToaster.Toast("connected");
controllerClient = new ControllerClient(userId, tcpSocket);
}
else
{
textToaster.Toast("not connected");
}
ConnectWindowVisibility = true;
}
private async void TryConnectToController(string ipAddress, int port)
{
if (controllerClientSocket != null)
{
TextToaster.Toast("Cannot connect to multiple controllers at once.");
return;
}
if (!IPAddress.TryParse(ipAddress, out IPAddress controllerIpAddress))
{
TextToaster.Toast($"Failed to parse {ipAddress} as an IP address.");
return;
}
Interlocked.Increment(ref connectingCount);
var controllerEndPoint = new IPEndPoint(controllerIpAddress, port);
var tcpSocket = new TcpSocket(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp));
try
{
if (await tcpSocket.ConnectAsync(controllerEndPoint))
{
controllerClientSocket = new ControllerClientSocket(viewerId, tcpSocket);
}
}
catch (TcpSocketException e)
{
TextToaster.Toast($"Failed not connect to the controller: {e.Message}");
}
Interlocked.Decrement(ref connectingCount);
}
public void SocketDisposeTest()
{
TcpSocket sock = new TcpSocket();
sock.Dispose();
Assert.CatchAsync <ObjectDisposedException>(() => { return(sock.ConnectAsync("localhost", 1002).AsTask()); });
}
public void SocketCloseTest()
{
TcpSocket sock = new TcpSocket();
sock.Close();
Assert.DoesNotThrowAsync(() => { return(sock.ConnectAsync("localhost", 1002).AsTask()); });
}
///<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);
}
}
// [Test]
public void StressTest()
{
TcpListener listener = new TcpListener();
listener.Listen(PORT);
TcpSocket clientSock = new TcpSocket();
var connectionResult = clientSock.ConnectAsync("localhost", PORT).Result;
var status = listener.Accept(out TcpSocket serverSock);
for (int i = 0; i < 1000000; i++)
{
NetPacket packet = new NetPacket();
var messageTo = Guid.NewGuid().ToString();
packet.WriteString(messageTo);
while (serverSock.Send(packet) != SocketStatus.Done)
{
;
}
packet.Clear();
while (clientSock.Receive(packet) != SocketStatus.Done)
{
;
}
Assert.AreEqual(messageTo, packet.ReadString());
packet.ResetWrite();
packet.WriteString($"Message with code {messageTo} received.");
while (clientSock.Send(packet) != SocketStatus.Done)
{
;
}
packet.Clear();
while (serverSock.Receive(packet) != SocketStatus.Done)
{
;
}
packet.Dispose();
}
listener.Dispose();
clientSock.Dispose();
serverSock.Dispose();
}
public async Task ConnectTest()
{
TcpListener listener = new TcpListener();
listener.Listen(666);
TcpSocket clientSock = new TcpSocket();
await clientSock.ConnectAsync("localhost", PORT);
var status = listener.Accept(out TcpSocket serverSock);
Assert.AreEqual(status, SocketStatus.Done);
Assert.NotNull(serverSock);
listener.Stop();
clientSock.Close();
serverSock.Close();
}
///<summary>Starts connecting to the remote host.</summary>
public override async Task StartHandshake()
{
try
{
DestinationSocket = new TcpSocket(MapTo.AddressFamily, this.Secure);
await DestinationSocket.ConnectAsync(MapTo);
await OnConnected();
}
catch (SocketException ex)
{
Console.WriteLine("connect error: " + ex.SocketErrorCode);
Dispose();
}
catch (Exception ex)
{
Dispose();
}
}
static void client()
{
Console.Title = "Client";
TcpSocket socket = new TcpSocket();
socket.AsyncConnectionResult += (s, e) =>
{
if (e.Connected)
{
Console.WriteLine("Client Connected!");
beginChat(false, socket);
while (true)
{
string msg = Console.ReadLine();
if (socket.Connected)
{
if (msg.ToLower() != "disconnect")
{
byte[] msgPayload = Encoding.ASCII.GetBytes(msg);
socket.SendAsync(msgPayload);
}
else
{
socket.Disconnect();
break;
}
}
else
{
break;
}
}
}
else
{
Console.WriteLine("Connection could not be made... Retrying in 2 seconds...");
client();
}
};
socket.ConnectAsync(IPAddress.Loopback, 1000);
}
public void SendReceiveTest()
{
const string serverMessage = "HelloFromServer";
const string clientMessage = "ResponseFromClient";
using (TcpListener listener = new TcpListener())
{
listener.Blocking = true;
listener.Listen(PORT);
TcpSocket clientSock = new TcpSocket();
var connectionResult = clientSock.ConnectAsync("localhost", PORT).Result;
var status = listener.Accept(out TcpSocket serverSock);
NetPacket packet = new NetPacket();
NetPacket clientPacket = new NetPacket();
packet.WriteString(serverMessage);
// Send message to client.
Assert.AreEqual(SocketStatus.Done, serverSock.Send(packet));
// Read message from server.
Assert.AreEqual(SocketStatus.Done, clientSock.Receive(clientPacket));
Assert.AreEqual(serverMessage, clientPacket.ReadString());
// Send message back to server.
clientPacket.Clear(SerializationMode.Writing);
clientPacket.WriteString(clientMessage);
Assert.AreEqual(SocketStatus.Done, clientSock.Send(clientPacket));
// Read message from client.
Assert.AreEqual(SocketStatus.Done, serverSock.Receive(packet));
Assert.AreEqual(clientMessage, packet.ReadString());
clientSock.Dispose();
serverSock.Dispose();
packet.Dispose();
clientPacket.Dispose();
}
}
public Task <bool> ConnectAsync(IPEndPoint ipEndPoint)
{
return(socket.ConnectAsync(ipEndPoint));
}
///<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);
}
}
public async Task ConnectAsync()
{
if (IsConnected || isConnecting)
{
return;
}
lock (connectAsyncLock)
{
if (IsConnected || isConnecting)
{
return;
}
isConnecting = true;
}
try
{
IPAddress[] ipAddresses;
IPAddress ip;
if (IPAddress.TryParse(host, out ip))
{
ipAddresses = new IPAddress[] { ip };
}
else
{
trace.Debug("Resolving DNS for Host '{0}'", host);
ipAddresses = await GetHostAddressesAsync(host);
}
Exception exception = null;
for (int i = 0; i < ipAddresses.Length; i++)
{
if (ipAddresses[i] == null ||
(ipAddresses[i].AddressFamily == AddressFamily.InterNetwork && !Socket.OSSupportsIPv4) ||
(ipAddresses[i].AddressFamily == AddressFamily.InterNetworkV6 && !Socket.OSSupportsIPv6))
{
continue;
}
socket = new Socket(ipAddresses[i].AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
trace.Debug("Attempting to connect to {0}:{1}", ipAddresses[i].ToString(), port.ToString());
await TcpSocket.ConnectAsync(socket, ipAddresses[i], port);
trace.Debug("Successfully connected to {0}:{1}", ipAddresses[i].ToString(), port.ToString());
exception = null;
break;
}
catch (Exception e)
{
exception = e;
socket.Dispose();
socket = null;
}
}
if (socket == null)
{
trace.Error(exception, "Error connecting to {0}", host);
throw exception ?? new SocketException((int)SocketError.AddressNotAvailable);
}
if (useTLS)
{
trace.Debug("Starting TLS Authentication.");
sslStream = new SslStream(new NetworkStream(socket));
await sslStream.AuthenticateAsClientAsync(host, null, SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls, true); // TODO super-safe defaults, but need to parameterize
trace.Debug("Finished TLS Authentication.");
}
IsConnected = true;
}
finally
{
isConnecting = false;
}
}