private static Client CreatedConnectedClient()
{
var client = new TcpSocket();
client.Connect(ServerAddress, serverPort);
return(client);
}
public void TestEvent()
{
bool isOnConnecting = false;
bool isOnConnected = false;
bool isOnDisconnected = false;
bool isOnSend = false;
bool isOnReceive = false;
TcpSocket tcp = new TcpSocket();
tcp.OnConnecting += () => { isOnConnecting = true; };
tcp.OnConnected += () => { isOnConnected = true; };
tcp.OnDisconnected += () => { isOnDisconnected = true; };
tcp.OnSendBytes += (x) => { isOnSend = true; };
tcp.OnReceiveBytes += (x) => { isOnReceive = true; };
tcp.Connect(Common.GetIpEndPoint());
Assert.IsTrue(isOnConnecting);
Common.WaitTrue(ref isOnConnected);
Assert.IsTrue(isOnConnected);
tcp.Send(new byte[10]);
Common.WaitTrue(ref isOnSend);
Assert.IsTrue(isOnSend);
Common.WaitTrue(ref isOnReceive);
Assert.IsTrue(isOnReceive);
tcp.Disconnect();
Assert.IsTrue(isOnDisconnected);
}
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 void TcpStart()
{
//enabled = true;
tcpClient = new TcpSocket();
tcpClient.Connect(curHost.host, curHost.portTcp);
tcpRuning = true;
}
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 void StartReceive(IPAddress Address, int Port, string FilePath)
{
// store destination path
_filePath = FilePath;
// initialize the file socket
_clientSocket = new TcpSocket();
// use the FileDataReceived callback
_clientSocket.DataReceived += new TcpSocket.DataReceivedDelegate(OnDataReceived);
_clientSocket.Connected += new TcpSocket.ConnectedDelegate(OnConnected);
_clientSocket.DisConnected += new TcpSocket.DisConnectedDelegate(OnDisConnected);
_clientSocket.Connect(Address, Port);
if (!_clientSocket.IsConnected)
{
// connect attempt failed
throw new CryptoSocketException("DtmFileTransfer:StartReceive", "Could not connect to the remote host!", new SocketException((int)SocketError.ConnectionAborted));
}
else
{
// create the temp file note: is WriteThrough more secure here?
_tempPath = Path.Combine(Path.GetDirectoryName(_filePath), Path.GetFileNameWithoutExtension(Path.GetRandomFileName()) + ".tmp");
using (new FileStream(_tempPath, FileMode.Create, FileAccess.Write, FileShare.Read)) { }
// set to hidden to avoid cross process errors
File.SetAttributes(_tempPath, File.GetAttributes(_tempPath) | FileAttributes.Hidden);
_clientSocket.ReceiveBufferSize = m_bufferSize;
_clientSocket.SendBufferSize = m_bufferSize;
// start receiving
_clientSocket.ReceiveAsync();
_clientSocket.ReceiveTimeout = -1;
// connection established
_isConnected = true;
}
}
public void PauseShouldPreventNewConnections()
{
ServerHelper.EchoServer((server, port, sync) =>
{
server.Pause(5000); // prevent connections for 5 seconds
Assert.IsTrue(server.IsPaused, "Server should be paused");
var socket = new TcpSocket(TcpSocketType.IPv4);
socket.Data += (data, count) => Assert.Fail("We should never receive data");
socket.Connect(port, connectedCallback: self =>
{
Assert.IsTrue(server.IsPaused, "Server should be paused");
self.Write("test");
Thread.Sleep(2000);
Assert.IsFalse(self.IsConnected);
sync.SignalAndWait();
});
Thread.Sleep(10000);
Assert.IsFalse(server.IsPaused, "Server should be unpaused");
//accepting connections
socket = new TcpSocket(TcpSocketType.IPv4);
socket.Connect(port, connectedCallback: self =>
{
Assert.IsTrue(self.IsConnected);
sync.SignalAndWait();
});
}, 3);
}
public void CanSendDataUsingCallbackToExampleSite()
{
TimeSpan timeout = TimeSpan.FromSeconds(2);
ManualResetEvent check = new ManualResetEvent(false);
IPAddress[] addresses = Dns.GetHostAddresses("www.example.com");
IPEndPoint endpoint = new IPEndPoint(addresses[0], 80);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
socket.Bind();
worker.Start();
TcpSocketSendCallback onSent = result =>
{
check.Set();
};
TcpSocketConnectCallback onConnected = result =>
{
string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
byte[] data = Encoding.ASCII.GetBytes(request);
socket.Send(data, onSent);
};
socket.Connect(endpoint, onConnected);
bool completed = check.WaitOne(timeout);
Assert.That(completed, Is.True);
}
}
public async Task <string> Send(IPEndPoint endpoint, string message)
{
int progress = 0;
byte[] output = new byte[message.Length];
byte[] bytes = Encoding.ASCII.GetBytes(message);
using (TcpSocket socket = factory.Tcp())
{
socket.Bind();
TcpSocketConnect connected = await socket.Connect(endpoint);
TcpSocketSend sent = await socket.Send(bytes);
while (progress < output.Length)
{
SocketBuffer buffer = new SocketBuffer(output, progress);
TcpSocketReceive received = await socket.Receive(buffer);
if (received.Count == 0)
{
break;
}
progress += received.Count;
}
}
return(Encoding.ASCII.GetString(output));
}
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 CanReceiveDataUsingTasksToHostedEchoServer()
{
string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
byte[] input = Encoding.ASCII.GetBytes(request);
byte[] output = new byte[input.Length];
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
using (EchoServer server = new EchoServer(factory))
{
socket.Bind();
worker.Start();
server.Start();
await socket.Connect(server.Endpoint);
await socket.Send(input);
await socket.Receive(output);
Assert.That(input, Is.EqualTo(output));
}
}
}
IEnumerator ConnectInternal(bool useDelay)
{
if (useDelay)
{
yield return(new WaitForSeconds(5f)); // немного ждём, полезно для реконнекта
}
if (startConnect)
{
yield break;
}
startConnect = true;
if (socket == null)
{
socket = new TcpSocket();
socket.OnMessageReceived += OnMessageReceived;
socket.OnError += OnErrorReceived;
}
var connectInfo = ChatSettings.Me;
socket.Connect(connectInfo.Host, connectInfo.Port);
textEntering.gameObject.SetActive(true);
buttonConnect.gameObject.SetActive(false);
//chatTitle.gameObject.SetActive(false);
startConnect = false;
++connectCounter;
yield break;
}
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);
}
}
}
public void Connect(Connection connection, Address address, bool noVerification)
{
TcpSocket socket = new TcpSocket();
if (connection.Handler != null && connection.Handler.CanHandle(EventId.SocketConnect))
{
connection.Handler.Handle(Event.Create(EventId.SocketConnect, connection, null, null, socket));
}
socket.Connect(address.Host, address.Port);
if (address.UseSsl)
{
SslSocket sslSocket = new SslSocket(socket, noVerification);
if (connection.Handler != null && connection.Handler.CanHandle(Handler.EventId.SocketConnect))
{
connection.Handler.Handle(Event.Create(EventId.SslAuthenticate, connection, null, null, sslSocket));
}
else
{
sslSocket.AuthenticateAsClient(address.Host);
}
this.socketTransport = sslSocket;
}
else
{
this.socketTransport = socket;
}
}
public void ConnectToUnknownHostShouldTimeOut()
{
using (var client = new TcpSocket())
{
bool isTimedOut = false;
client.Connect(ServerAddress, 12345, () => isTimedOut = true);
Assert.IsFalse(isTimedOut);
Thread.Sleep((int)((client.Timeout + 0.5f) * 1000));
Assert.IsTrue(isTimedOut);
}
}
public void Connect(string strIpAddress, int port)
{
m_IpAddress = strIpAddress;
m_Port = port;
mClientSocket = new TcpSocket <XPacket>();
mClientSocket.Connect(m_IpAddress, m_Port, OnConnectedCallback, HandleReceiveData);
Debug.Log("Net# Connect to " + strIpAddress + ": " + port);
}
static public int Connect(IntPtr l)
{
try {
TcpSocket self = (TcpSocket)checkSelf(l);
self.Connect();
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
public void Execute(PeerConnectorContext context)
{
TcpSocket socket = context.Dependencies.Network.New();
IPAddress[] addresses = Dns.GetHostAddresses(remote.Host);
IPAddress address = addresses[0].MapToIPv4();
IPEndPoint endpoint = new IPEndPoint(address, remote.Port);
socket.Bind();
socket.Connect(endpoint, data => OnConnected(context, data));
}
public void ClientThread(object context)
{
Main.gameMenu = true;
Main.menuMode = 888;
Main.MenuUI.SetState(new UINetworkConnection());
object[] parameter = (object[])context;
bool exitThread = false;
DimPlayer player = (DimPlayer)parameter[0];
int numberOfAttempt = 0;
RemoteAddress adress = new TcpAddress(Netplay.ServerIP, 7776);
ClientLoopSetup(adress);
ISocket secondarySocket = new TcpSocket();
secondarySocket.Connect(new TcpAddress(Netplay.ServerIP, 7776));
while (!exitThread)
{
try
{
Thread.Sleep(2500);
if (secondarySocket.IsDataAvailable())
{
byte[] data = new byte[ushort.MaxValue];
secondarySocket.AsyncReceive(data, 0, ushort.MaxValue, new SocketReceiveCallback(Netplay.Connection.ClientReadCallBack), null);
using (MemoryStream stream = new MemoryStream(data))
{
BinaryReader reader = new BinaryReader(new MemoryStream(data));
}
numberOfAttempt++;
}
else
{
byte[] data = new byte[ushort.MaxValue];
using (MemoryStream stream = new MemoryStream(data))
{
BinaryWriter writer = new BinaryWriter(stream);
writer.Write("hey");
secondarySocket.AsyncSend(writer.BaseStream.ReadAllBytes(), 0, ushort.MaxValue, new SocketSendCallback(Netplay.Connection.ClientWriteCallBack), null);
}
}
}
catch (Exception e)
{
LogManager.GetLogger("Second thread").Error(e.Message, e);
}
}
Netplay.Connection.Socket.Close();
Netplay.StartTcpClient();
player.inTransit = false;
}
public void Connect(Connection connection, Address address, bool noVerification)
{
var ipHostEntry = Dns.GetHostEntry(address.Host);
Exception exception = null;
TcpSocket socket = null;
foreach (var ipAddress in ipHostEntry.AddressList)
{
if (ipAddress == null)
{
continue;
}
try
{
socket = new TcpSocket();
socket.Connect(new IPEndPoint(ipAddress, address.Port));
exception = null;
break;
}
catch (SocketException socketException)
{
if (socket != null)
{
socket.Close();
socket = null;
}
exception = socketException;
}
}
if (exception != null)
{
throw exception;
}
if (address.UseSsl)
{
SslSocket sslSocket = new SslSocket(socket);
sslSocket.AuthenticateAsClient(
address.Host,
null,
noVerification ? SslVerification.NoVerification : SslVerification.VerifyPeer,
SslProtocols.Default);
this.socketTransport = sslSocket;
}
else
{
this.socketTransport = socket;
}
}
public void Connect(Connection connection, Address address, bool noVerification)
{
var ipHostEntry = Dns.GetHostEntry(address.Host);
Exception exception = null;
TcpSocket socket = null;
foreach (var ipAddress in ipHostEntry.AddressList)
{
if (ipAddress == null)
{
continue;
}
try
{
socket = new TcpSocket();
socket.Connect(new IPEndPoint(ipAddress, address.Port));
exception = null;
break;
}
catch (SocketException socketException)
{
if (socket != null)
{
socket.Close();
socket = null;
}
exception = socketException;
}
}
if (exception != null)
{
throw exception;
}
if (address.UseSsl)
{
SslSocket sslSocket = new SslSocket(socket);
sslSocket.AuthenticateAsClient(
address.Host,
null,
noVerification ? SslVerification.NoVerification : SslVerification.VerifyPeer,
SslProtocols.Default);
this.socketTransport = sslSocket;
}
else
{
this.socketTransport = socket;
}
}
static void Main(string[] args)
{
Console.WriteLine("[Client]");
try
{
dora.Connect("127.0.0.1", 9999);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.ReadLine();
}
public void TestConnect()
{
TcpSocket tcp = new TcpSocket();
tcp.Connect(Common.GetIpEndPoint());
//Test connected
Common.WaitConnected(tcp);
Assert.IsTrue(tcp.IsConnected);
//Test disconnect
tcp.Disconnect();
Assert.IsFalse(tcp.IsConnected);
}
private void OnSent(TcpSocketSend data)
{
if (data.Status == SocketStatus.OK)
{
outgoing = new SocketBuffer(data.Buffer.Data, data.Buffer.Offset + data.Count, data.Buffer.Count - data.Count);
if (incoming.Count > 0)
{
socket.Receive(incoming, OnReceived);
}
else if (outgoing.Count > 0)
{
socket.Send(outgoing, OnSent);
}
else
{
incoming = new SocketBuffer(incoming.Data);
outgoing = new SocketBuffer(outgoing.Data);
if (session.Elapsed > TimeSpan.FromMinutes(1))
{
socket = factory.Tcp();
session = Stopwatch.StartNew();
socket.Bind();
socket.Connect(endpoint, OnConnected);
data.Socket.Dispose();
}
else
{
socket.Send(outgoing, OnSent);
}
}
}
else
{
Console.WriteLine("OnSent");
socket.Dispose();
}
counter += data.Count;
if (counter - previous > 1024 * 1024 * 1024)
{
previous = counter;
Console.WriteLine($"{counter}: {counter / watch.ElapsedMilliseconds}");
}
}
public void ReconnectTest()
{
TcpSocket socket = new TcpSocket();
Assert.IsFalse(socket.Connected);
socket.Connect(new DnsEndPoint("www.google.com", 80));
Assert.IsTrue(socket.Connected);
socket.Dispose();
Assert.IsFalse(socket.Connected);
socket.Reconnect();
Assert.IsTrue(socket.Connected);
}
public async Task CanHandleNotBoundSocket()
{
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
using (TcpSocket socket = factory.Tcp())
{
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, 80);
TcpSocketConnect connected = await socket.Connect(endpoint);
Assert.That(connected.Status, Is.Not.EqualTo(SocketStatus.OK));
}
}
}
public void ExceptionTest()
{
AutoResetEvent evt = new AutoResetEvent(false);
Exception testException = null;
var tcp = new TcpSocket();
tcp.OnException += (e) =>
{
testException = e;
evt.Set();
};
tcp.Connect("123", 999);
evt.WaitOne();
Assert.IsNotNull(testException);
}
public void Start()
{
if (this.isConnecting)
{
return;
}
TcpSocket tcpSocket = new TcpSocket(settings.MasterServerIP, settings.MasterServerPort);
tcpSocket.Connect();
this.MasterServer = new MasterServer(tcpSocket, this.masterServerPacketProcessor);
this.MasterServer.TcpSocketWorker.Run();
this.isConnecting = true;
}
public void Connect(Connection connection, Address address, bool noVerification)
{
TcpSocket socket = new TcpSocket();
socket.Connect(address.Host, address.Port);
if (address.UseSsl)
{
SslSocket sslSocket = new SslSocket(socket, noVerification);
sslSocket.AuthenticateAsClient(address.Host);
this.socketTransport = sslSocket;
}
else
{
this.socketTransport = socket;
}
}
public void TestSendReceive()
{
TcpSocket tcp = new TcpSocket();
tcp.Connect(Common.GetIpEndPoint());
Common.WaitConnect(tcp);
int length = 0;
tcp.OnSocketReceive += (x) =>
{
length = x.Length;
};
tcp.Send(new byte[10]);
Common.WaitValue(ref length, 10);
Assert.AreEqual(length, 10);
}
public void Connect(Connection connection, Address address, bool noVerification)
{
TcpSocket socket = new TcpSocket();
socket.Connect(address.Host, address.Port);
if (address.UseSsl)
{
SslSocket sslSocket = new SslSocket(socket, noVerification);
sslSocket.AuthenticateAsClient(address.Host);
this.socketTransport = sslSocket;
}
else
{
this.socketTransport = socket;
}
}
public void ServerRemovesStaleConnections()
{
ServerHelper.Server((server, port, sync) =>
{
var socket = new TcpSocket(TcpSocketType.IPv4);
socket.Connect(port, connectedCallback: self =>
{
Thread.Sleep(500);
Assert.AreEqual(1, server.ConnectionCount, "we are connected");
self.Dispose();
Thread.Sleep(500);
Assert.AreEqual(0, server.ConnectionCount, "no connections now");
sync.SignalAndWait();
});
}, timeout: 30);
}
public void TestLargeMessage()
{
var tcp = new TcpSocket();
tcp.Connect(Common.GetIpEndPoint());
Common.WaitConnected(tcp);
int length = 0;
tcp.OnSocketReceive += (x) =>
{
length += x.Length;
};
tcp.Send(new byte[1 << 10]);
Common.WaitValue(ref length, 1 << 10, 10000);
tcp.DisConnect();
Console.WriteLine(length);
Assert.AreEqual(length, 1 << 10);
}
public void TestEvent()
{
var tcp = new TcpSocket();
bool isConnecting = false;
tcp.OnConnecting += () => { isConnecting = true; };
bool isConnected = false;
tcp.OnConnected += () => { isConnected = true; };
bool isDisconnected = false;
tcp.OnDisconnected += () => { isDisconnected = true; };
tcp.Connect(Common.GetIpEndPoint());
Common.WaitConnect(tcp);
tcp.DisConnect();
Assert.IsTrue(isConnecting);
Assert.IsTrue(isConnected);
Assert.IsTrue(isDisconnected);
}
public void Connect(Connection connection, Address address, bool noVerification)
{
var ipHostEntry = Dns.GetHostEntry(address.Host);
Exception exception = null;
TcpSocket socket = null;
// reference to SSL socket, wrapper for above TCP socket
SslSocket sslSocket = null;
foreach (var ipAddress in ipHostEntry.AddressList)
{
if (ipAddress == null)
{
continue;
}
try
{
socket = new TcpSocket();
// SSL connection requested with an SSL host
if (address.UseSsl)
{
// wrap TCP socket to SSL socket
sslSocket = new SslSocket(socket, address.Host, ValidateCertificate);
}
socket.Connect(new IPEndPoint(ipAddress, address.Port));
exception = null;
break;
}
catch (SocketException socketException)
{
if (address.UseSsl)
{
if (sslSocket != null)
{
sslSocket.Close();
sslSocket = null;
}
}
if (socket != null)
{
socket.Close();
socket = null;
}
exception = socketException;
}
}
if (exception != null)
{
throw exception;
}
if (address.UseSsl)
{
this.socketTransport = sslSocket;
}
else
{
this.socketTransport = socket;
}
}