| public ConnectAsync ( IPAddress address, int port ) : System.Threading.Tasks.Task | ||
| address | IPAddress | |
| port | int | |
| return | System.Threading.Tasks.Task | |
public static void Main(string[] args)
{
Console.WriteLine("Starting...");
X509Certificate2 serverCertificate = new X509Certificate2("certificate.pfx"); // Any valid certificate with private key will work fine.
TcpListener listener = new TcpListener(IPAddress.Any, 4567);
TcpClient client = new TcpClient();
listener.Start();
Task clientConnectTask = client.ConnectAsync(IPAddress.Loopback, 4567);
Task<TcpClient> listenerAcceptTask = listener.AcceptTcpClientAsync();
Task.WaitAll(clientConnectTask, listenerAcceptTask);
TcpClient server = listenerAcceptTask.Result;
SslStream clientStream = new SslStream(client.GetStream(), false, new RemoteCertificateValidationCallback(ValidateServerCertificate), null, EncryptionPolicy.RequireEncryption);
SslStream serverStream = new SslStream(server.GetStream(), false, null, null, EncryptionPolicy.RequireEncryption);
Task clientAuthenticationTask = clientStream.AuthenticateAsClientAsync(serverCertificate.GetNameInfo(X509NameType.SimpleName, false), null, SslProtocols.Tls12, false);
Task serverAuthenticationTask = serverStream.AuthenticateAsServerAsync(serverCertificate, false, SslProtocols.Tls12, false);
Task.WaitAll(clientAuthenticationTask, serverAuthenticationTask);
byte[] readBuffer = new byte[256];
Task<int> readTask = clientStream.ReadAsync(readBuffer, 0, readBuffer.Length); // Create a pending ReadAsync, which will wait for data that will never come (for testing purposes).
byte[] writeBuffer = new byte[256];
Task writeTask = clientStream.WriteAsync(writeBuffer, 0, writeBuffer.Length); // The main thread actually blocks here (not asychronously waits) on .NET Core making this call.
bool result = Task.WaitAll(new Task[1] { writeTask }, 5000); // This code won't even be reached on .NET Core. Works fine on .NET Framework.
if (result)
{
Console.WriteLine("WriteAsync completed successfully while ReadAsync was pending... nothing locked up.");
}
else
{
Console.WriteLine("WriteAsync failed to complete after 5 seconds.");
}
}
public static async Task<Socket> ConnectToServerAsync(IPEndPoint endpoint, IEnumerable<AddressFamily> addressFamilies)
{
ValidateEndpoint(endpoint, addressFamilies);
var tcpClient = new TcpClient();
await tcpClient.ConnectAsync(endpoint.Address, endpoint.Port);
return tcpClient.Client;
}
public async Task ServerNoEncryption_ClientNoEncryption_ConnectWithNoEncryption()
{
using (var serverNoEncryption = new DummyTcpServer(
new IPEndPoint(IPAddress.Loopback, 0), EncryptionPolicy.NoEncryption))
using (var client = new TcpClient())
{
await client.ConnectAsync(serverNoEncryption.RemoteEndPoint.Address, serverNoEncryption.RemoteEndPoint.Port);
using (var sslStream = new SslStream(client.GetStream(), false, AllowAnyServerCertificate, null, EncryptionPolicy.NoEncryption))
{
if (SupportsNullEncryption)
{
await sslStream.AuthenticateAsClientAsync("localhost", null, SslProtocolSupport.DefaultSslProtocols, false);
_log.WriteLine("Client authenticated to server({0}) with encryption cipher: {1} {2}-bit strength",
serverNoEncryption.RemoteEndPoint, sslStream.CipherAlgorithm, sslStream.CipherStrength);
CipherAlgorithmType expected = CipherAlgorithmType.Null;
Assert.Equal(expected, sslStream.CipherAlgorithm);
Assert.Equal(0, sslStream.CipherStrength);
}
else
{
var ae = await Assert.ThrowsAsync<AuthenticationException>(() => sslStream.AuthenticateAsClientAsync("localhost", null, SslProtocolSupport.DefaultSslProtocols, false));
Assert.IsType<PlatformNotSupportedException>(ae.InnerException);
}
}
}
}
private async Task StartClientToServerComms()
{
string host = "10.1.1.84";
int port = 58846;
Console.WriteLine("[Relay] Connecting to {0}:{1}", host, port);
using (var nextTcpClient = new TcpClient())
{
await nextTcpClient.ConnectAsync(host, port);
Console.WriteLine("[Relay] Connected to server");
byte[] clientBuffer = new byte[4096];
using (var clientToServerNetworkStream = new SslStream(nextTcpClient.GetStream(), true,
(sender, certificate, chain, errors) => { return true; }))
{
clientToServerNetworkStream.AuthenticateAsClient(host);
while (true)
{
var clientBytes = await clientToServerNetworkStream.ReadAsync(clientBuffer, 0, clientBuffer.Length);
if (clientBytes > 0)
{
Console.WriteLine("Client sent {0}", DelugeRPC.DelugeProtocol.DecompressAndDecode(clientBuffer).Dump());
await clientToServerNetworkStream.WriteAsync(clientBuffer, 0, clientBuffer.Length);
}
}
}
}
}
private static async Task<int> Run(int port) {
using (var client = new TcpClient()) {
await client.ConnectAsync(IPAddress.Loopback, port);
var utf8 = new UTF8Encoding(false);
using (var reader = new StreamReader(client.GetStream(), utf8, false, 4096, true))
using (var writer = new StreamWriter(client.GetStream(), utf8, 4096, true)) {
var filename = await reader.ReadLineAsync();
var args = (await reader.ReadLineAsync()).Split('|')
.Select(s => utf8.GetString(Convert.FromBase64String(s)))
.ToList();
var workingDir = await reader.ReadLineAsync();
var env = (await reader.ReadLineAsync()).Split('|')
.Select(s => s.Split(new[] { '=' }, 2))
.Select(s => new KeyValuePair<string, string>(s[0], utf8.GetString(Convert.FromBase64String(s[1]))))
.ToList();
var outputEncoding = await reader.ReadLineAsync();
var errorEncoding = await reader.ReadLineAsync();
return await ProcessOutput.Run(
filename,
args,
workingDir,
env,
false,
new StreamRedirector(writer, outputPrefix: "OUT:", errorPrefix: "ERR:"),
quoteArgs: false,
elevate: false,
outputEncoding: string.IsNullOrEmpty(outputEncoding) ? null : Encoding.GetEncoding(outputEncoding),
errorEncoding: string.IsNullOrEmpty(errorEncoding) ? null : Encoding.GetEncoding(errorEncoding)
);
}
}
}
public async Task<TcpClient> ConnectAsync(string hostname, int port)
{
TcpClient client = new TcpClient();
await client.ConnectAsync(hostname, port);
DoHandshake(client, hostname, port);
return client;
}
private void timer1_Tick(object sender, EventArgs e)
{
if (System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
{
TcpClient tcpclnt = new TcpClient();
label4.Text = "Attempting to connect to RPi...";
if (tcpclnt.ConnectAsync("192.168.55.3", 5069).Wait(1000))
{
label4.Text = "Couldn't connect to RPi";
}
else
{
label4.Text = "Connected to RPi";
this.Hide();
Form MainForm = new MainForm();
MainForm.Show();
timer1.Dispose();
}
}
else
{
label4.Text = "Waiting for network...";
}
}
public static void Main(string[] args)
{
if(args.Length != 1)
{
Console.WriteLine("need ipadress ");
return;
}
IPAddress ipAddress = IPAddress.Parse(args[0]);
int port = 7681;
TcpClient client = new TcpClient();
client.ConnectAsync(ipAddress, port).Wait();
Console.WriteLine("connected");
using (NegotiateStream stream = new NegotiateStream(client.GetStream()))
{
Console.WriteLine("authenticating");
stream.AuthenticateAsClientAsync(CredentialCache.DefaultNetworkCredentials, null, "HOST/skapilac10.fareast.corp.microsoft.com").Wait();
Console.WriteLine("authenticated");
var sendBuffer = Encoding.UTF8.GetBytes("Request from client");
stream.Write(sendBuffer, 0, sendBuffer.Length);
var recvBuffer = new byte[1024];
var byteCount = stream.Read(recvBuffer, 0, recvBuffer.Length);
Console.WriteLine("Recieved: {0}", Encoding.UTF8.GetString(recvBuffer, 0, byteCount));
}
}
public override bool Initialize()
{
Logger.Log($"Connecting to Twitch IRC -> {Account.Username}");
_Client = new TcpClient();
_Client.ConnectAsync("irc.twitch.tv", 6667).Wait();
_Writer = new StreamWriter(_Client.GetStream());
_Reader = new StreamReader(_Client.GetStream());
Logger.Log("Sending login credentials");
_SendStringRaw($"PASS {Account.OAuth}");
_SendStringRaw($"NICK {Account.Username}");
var response = IRCMessage.Parse(_Reader.ReadLine());
if (response.Type != "001")
{
Logger.Log("Server did not return expected login message");
return false;
}
// runners
new Thread(_SendRunner).Start();
new Thread(_ReceiveRunner).Start();
Logger.Log("Connecting to channels");
foreach (var c in Channels)
_SendString($"JOIN #{c}", MessagePriority.Medium);
return true;
}
/// <summary>
/// Method to determine if the user's clock is syncrhonised to NIST time.
/// </summary>
private static async Task BeginCheckAsync()
{
if (!NetworkMonitor.IsNetworkAvailable)
{
// Reschedule later otherwise
ScheduleCheck(TimeSpan.FromMinutes(1));
return;
}
EveMonClient.Trace();
Uri url = new Uri(NetworkConstants.NISTTimeServer);
DateTime serverTimeToLocalTime;
bool isSynchronised;
await Dns.GetHostAddressesAsync(url.Host)
.ContinueWith(async task =>
{
IPAddress[] ipAddresses = task.Result;
if (!ipAddresses.Any())
return;
try
{
DateTime dateTimeNowUtc;
DateTime localTime = DateTime.Now;
using (TcpClient tcpClient = new TcpClient())
{
await tcpClient.ConnectAsync(ipAddresses.First(), url.Port);
using (NetworkStream netStream = tcpClient.GetStream())
{
// Set a three seconds timeout
netStream.ReadTimeout = (int)TimeSpan.FromSeconds(3).TotalMilliseconds;
byte[] data = new byte[24];
await netStream.ReadAsync(data, 0, data.Length);
data = data.Skip(7).Take(17).ToArray();
string dateTimeText = Encoding.ASCII.GetString(data);
dateTimeNowUtc = DateTime.ParseExact(dateTimeText,
"yy-MM-dd HH:mm:ss",
CultureInfo.CurrentCulture.DateTimeFormat,
DateTimeStyles.AssumeUniversal);
}
}
serverTimeToLocalTime = dateTimeNowUtc.ToLocalTime();
TimeSpan timediff =
TimeSpan.FromSeconds(Math.Abs(serverTimeToLocalTime.Subtract(localTime).TotalSeconds));
isSynchronised = timediff < TimeSpan.FromSeconds(60);
OnCheckCompleted(isSynchronised, serverTimeToLocalTime, localTime);
}
catch (Exception exc)
{
CheckFailure(exc);
}
}, EveMonClient.CurrentSynchronizationContext).ConfigureAwait(false);
}
/// <summary>
/// Connects the client to a remote host using the specified
/// IP address and port number as an asynchronous operation.
/// </summary>
/// <param name="host">host.</param>
/// <param name="port">port.</param>
/// <param name="certificate">certificate.</param>
/// <exception cref="ConnectionInterruptedException"></exception>
public async Task ConnectAsync(string host, int port, X509Certificate2 certificate)
{
try
{
// connect via tcp
tcpClient = new TcpClient();
await tcpClient.ConnectAsync(host, port);
await Task.Run(() =>
{
// create ssl stream
sslStream = new SslStream(tcpClient.GetStream(), true,
Ssl.ServerValidationCallback,
Ssl.ClientCertificateSelectionCallback,
EncryptionPolicy.RequireEncryption);
// handshake
Ssl.ClientSideHandshake(certificate, sslStream, host);
});
}
catch (CertificateException e)
{
throw new ConnectionInterruptedException("Connection failed. Reason: " + e.Message);
}
catch
{
throw new ConnectionInterruptedException("Connection failed.");
}
}
public async Task<bool> Connect(string hostname, int port)
{
if(ServerConnectionStarting != null)
ServerConnectionStarting(this, new ServerConnectionEventArgs{Message = "Connecting to " + hostname + ":" + port.ToString() + "...", Status = ServerConnectionStatus.Connecting, Timestamp = DateTime.Now});
try
{
TcpClient = new TcpClient();
TcpClient.NoDelay = true;
await TcpClient.ConnectAsync(hostname, port);
}
catch
{
if(ServerConnectionFailed != null)
ServerConnectionFailed(this, new ServerConnectionEventArgs{Message = "Failed to connect! Make sure the server is running and that your hostname and port are correct.", Status = ServerConnectionStatus.Disconnected, Timestamp = DateTime.Now});
}
if(IsConnected)
{
TcpClientStream = TcpClient.GetStream();
if(ServerConnectionSucceeded != null)
ServerConnectionSucceeded(this, new ServerConnectionEventArgs{Message = "Successfully connected.", Status = ServerConnectionStatus.Connected, Timestamp = DateTime.Now});
Keepalive.Reset();
return true;
}
else return false;
}
public void Download()
{
using (TcpClient tcpClient = new TcpClient())
{
if (!tcpClient.ConnectAsync(IpAdress, 80).Wait(TIMEOUT))
{
Console.WriteLine("La connection vers " + Uri + " a timeout");
return;
}
stream = tcpClient.GetStream();
var byteRequest = Encoding.ASCII.GetBytes(string.Format(GetRequest, Uri.LocalPath, Uri.Host));
stream.Write(byteRequest, 0, byteRequest.Length);
bufferSize = tcpClient.ReceiveBufferSize;
List<byte> srcByte = new List<byte>();
while (!stream.DataAvailable) ;
while (stream.DataAvailable)
{
byte[] data = new byte[bufferSize];
int read = stream.Read(data, 0, bufferSize);
srcByte.AddRange(data.Take(read));
}
ParseRequest(srcByte.ToArray());
}
}
private async Task SendServiceMessage(Message packet)
{
var command = packet.Json;
try
{
using (var tcpClient = new TcpClient())
{
await tcpClient.ConnectAsync(IPAddress.Loopback, 22005);
using (var stream = tcpClient.GetStream())
using (var sw = new StreamWriter(stream, Encoding.UTF8))
{
if (tcpClient.Connected)
{
await sw.WriteLineAsync(command);
await sw.FlushAsync();
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
protected override async Task Send(SyslogMessage syslogMessage)
{
var client = new TcpClient();
client.ConnectAsync(Hostname, LogglyConfig.Instance.Transport.EndpointPort).Wait();
try
{
byte[] messageBytes = syslogMessage.GetBytes();
var networkStream = await GetNetworkStream(client).ConfigureAwait(false);
await networkStream.WriteAsync(messageBytes, 0, messageBytes.Length).ConfigureAwait(false);
await networkStream.FlushAsync().ConfigureAwait(false);
}
catch (AuthenticationException e)
{
LogglyException.Throw(e, e.Message);
}
finally
{
#if NET_STANDARD
client.Dispose();
#else
client.Close();
#endif
}
}
public override Task PostEmailAsync(string name, string[] to, string[] cc, string[] bcc, string subject, string message, params Attachment[] Attachments)
{
if (!ssl)
return Task.Factory.StartNew(async () =>
{
using (var client = new TcpClient())
{
await client.ConnectAsync(server, port);
using (var stream = client.GetStream())
using (var reader = new StreamReader(stream))
using (var writer = new StreamWriter(stream) { AutoFlush = true, NewLine = "\r\n" })
{
TcpWrite(writer, reader, name, to, cc, bcc, subject, message, Attachments);
}
}
});
else
return Task.Factory.StartNew(async () =>
{
using (var client = new TcpClient())
{
await client.ConnectAsync(server, port);
using (var stream = new SslStream(client.GetStream(), false))
{
await stream.AuthenticateAsClientAsync(server);
using (var reader = new StreamReader(stream))
using (var writer = new StreamWriter(stream) { AutoFlush = true, NewLine = "\r\n" })
{
TcpWrite(writer, reader, name, to, cc, bcc, subject, message, Attachments);
}
}
}
});
}
public static async Task SendAndReceive()
{
using (var client = new TcpClient())
{
await client.ConnectAsync(host, port);
using (NetworkStream stream = client.GetStream())
using (var writer = new StreamWriter(stream, Encoding.ASCII, 1024, leaveOpen: true))
using (var reader = new StreamReader(stream, Encoding.ASCII, true, 1024, leaveOpen: true))
{
writer.AutoFlush = true;
string line = string.Empty;
do
{
WriteLine("enter a string, bye to exit");
line = ReadLine();
await writer.WriteLineAsync(line);
string result = await reader.ReadLineAsync();
WriteLine($"received {result} from server");
} while (line != "bye");
WriteLine("so long, and thanks for all the fish");
}
}
}
public async Task ReadLineAsync_ThrowsOnConnectionClose()
{
TcpListener listener = new TcpListener(IPAddress.Loopback, 0);
try
{
listener.Start();
Task<TcpClient> acceptTask = listener.AcceptTcpClientAsync();
TcpClient client = new TcpClient();
await client.ConnectAsync(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndpoint).Port);
using (TcpClient serverTcpClient = await acceptTask)
{
TcpClientConnectionChannel channel = new TcpClientConnectionChannel(serverTcpClient);
client.Dispose();
await Assert.ThrowsAsync<ConnectionUnexpectedlyClosedException>(async () =>
{
await channel.ReadLineAsync();
});
}
}
finally
{
listener.Stop();
}
}
public async Task ConnectAsync(string hostname, int port)
{
_tcpClient = new TcpClient();
await _tcpClient.ConnectAsync(hostname, port);
var networkStream = _tcpClient.GetStream();
_reader = new StreamReader(networkStream, Encoding.ASCII, false, BufferSize, true);
_writer = new StreamWriter(networkStream, Encoding.ASCII, BufferSize, true);
}
public async Task<DebugSession> ConnectToServerAsync(string ipAddress)
{
CurrentServer = IPAddress.Parse(ipAddress);
var tcp = new TcpClient();
await tcp.ConnectAsync(CurrentServer, MonoDebugServer.TcpPort);
return new DebugSession(this, _type, tcp.Client);
}
private static async Task ConsumeOneAsync(TcpClient client, IPAddress ip, int port)
{
await client.ConnectAsync(ip, port);
using (var stream = client.GetStream())
{
await TcpMessenger.ReadAndWriteAsync(stream, Constants.ServerToClient, Constants.ClientToServer);
}
}
protected override async Task<Stream> ConnectForShutdownAsync(string pipeName, int timeout)
{
var port = int.Parse(pipeName);
var ipAddress = IPAddress.Parse(DefaultAddress);
var client = new TcpClient();
await client.ConnectAsync(ipAddress, port).ConfigureAwait(false);
return client.GetStream();
}
public async Task<PingPayload> Ping(){
NetworkStream = null;
WriteBuffer.Clear();
ReadOffset = 0;
var client = new TcpClient();
await client.ConnectAsync(Host, Port);
if (!client.Connected)
return null;
NetworkStream = client.GetStream();
/*
* Send a "Handshake" packet
* http://wiki.vg/Server_List_Ping#Ping_Process
*/
WriteVarInt(47);
WriteString(Host);
WriteShort(Port);
WriteVarInt(1);
await Flush(0);
/*
* Send a "Status Request" packet
* http://wiki.vg/Server_List_Ping#Ping_Process
*/
await Flush(0);
var message = new List<byte>();
var buf = new byte[1024];
var bytes = await NetworkStream.ReadAsync(buf, 0, buf.Length, CancellationToken);
message.AddRange(new ArraySegment<byte>(buf, 0, bytes));
var length = ReadVarInt(buf);
var left = length - (message.Count - ReadOffset);
while (left > 0) {
buf = new byte[1024];
bytes = await NetworkStream.ReadAsync(buf, 0, buf.Length, CancellationToken);
message.AddRange(new ArraySegment<byte>(buf, 0, bytes));
left -= bytes;
}
client.Close();
ReadOffset = 0;
var buffer = message.ToArray();
length = ReadVarInt(buffer);
ReadVarInt(buffer); // packetID
var jsonLength = ReadVarInt(buffer);
var json = ReadString(buffer, jsonLength);
var ping = JsonConvert.DeserializeObject<PingPayload>(json);
ping.Motd = ping.Motd != null ? CleanMotd(ping.Motd) : null;
return ping;
}
public async Task Connect ()
{
if (IsConnected ())
return;
tcp = new TcpClient ();
// Disable Nagle for HTTP/2
tcp.NoDelay = true;
await tcp.ConnectAsync (Host, (int)Port);
if (UseTls) {
sslStream = new SslStream (tcp.GetStream (), false,
(sender, certificate, chain, sslPolicyErrors) => true);
await sslStream.AuthenticateAsClientAsync (
Host,
Certificates ?? new X509CertificateCollection (),
System.Security.Authentication.SslProtocols.Tls12,
false);
clientStream = sslStream;
} else {
clientStream = tcp.GetStream ();
}
// Send out preface data
var prefaceData = System.Text.Encoding.ASCII.GetBytes (ConnectionPreface);
await clientStream.WriteAsync (prefaceData, 0, prefaceData.Length);
await clientStream.FlushAsync ();
// Start reading the stream on another thread
var readTask = Task.Factory.StartNew (() => {
try { read (); }
catch (Exception ex) {
Console.WriteLine ("Read error: " + ex);
Disconnect ();
}
}, TaskCreationOptions.LongRunning);
readTask.ContinueWith (t => {
// TODO: Handle the error
Console.WriteLine ("Error: " + t.Exception);
Disconnect ();
}, TaskContinuationOptions.OnlyOnFaulted);
// Send an un-ACK'd settings frame
await SendFrame(new SettingsFrame ());
// We need to wait for settings server preface to come back now
resetEventConnectionSettingsFrame = new ManualResetEventSlim ();
resetEventConnectionSettingsFrame.Reset ();
if (!resetEventConnectionSettingsFrame.Wait (ConnectionTimeout)) {
Disconnect ();
throw new Exception ("Connection timed out");
}
}
private static async void ConnectAsTcpClient()
{
using (var tcpClient = new TcpClient())
{
//todo: https://github.com/fuzeman/rencode-sharp/issues/6
string host = "10.1.1.104";
int port = 58846;
Console.WriteLine("[Client] Connecting to server");
await tcpClient.ConnectAsync(host, port);
Console.WriteLine("[Client] Connected to server");
using (var networkStream = new SslStream(tcpClient.GetStream(), true,
(sender, certificate, chain, errors) => { return true; }))
{
networkStream.AuthenticateAsClient(host);
Commands command = new Commands(networkStream);
command.OnLogin += (o, e) => { Console.WriteLine("logged in"); };
command.OnError += (o, e) =>
{
HandleError(((RPCErrorEventArgs)e).Message);
};
command.Login("localclient", "test");
//while (!command.IsLoggedIn)
//{
// Thread.Sleep(1000);
//}
//command.Info();
//command.GetFilterTree();
//command.GetSessionStatus();
//command.GetFilterTree();
//command.GetFreeSpace();
//command.GetNumConnections();
//command.GetConfigValuesDefault();
command.AddTorrent("magnet:?xt=urn:btih:3f19b149f53a50e14fc0b79926a391896eabab6f&dn=ubuntu-15.10-desktop-amd64.iso");
while (true)
{
var buffer = new byte[4096];
var byteCount = await networkStream.ReadAsync(buffer, 0, buffer.Length);
var response = DelugeProtocol.DecompressAndDecode(buffer) as object[];
if (response != null)
{
command.HandleResponse(response);
}
}
}
}
}
protected override async Task<BuildResponse> RunServerCompilation(List<string> arguments, BuildPaths buildPaths, string keepAlive, string libDirectory, CancellationToken cancellationToken)
{
var client = new TcpClient();
await client.ConnectAsync("127.0.0.1", port: 12000).ConfigureAwait(true);
var request = BuildRequest.Create(_language, buildPaths.WorkingDirectory, arguments, keepAlive, libDirectory);
await request.WriteAsync(client.GetStream(), cancellationToken).ConfigureAwait(true);
return await BuildResponse.ReadAsync(client.GetStream(), cancellationToken).ConfigureAwait(true);
}
public async Task<byte[]> ConnectAsync() {
client = new TcpClient ();
await client.ConnectAsync (IPAddress.Loopback, 1984);
var stream = client.GetStream ();
await stream.WriteAsync (new byte[] { 1, 9, 8, 4 }, 0, 4);
var buffer = new byte[8];
await stream.ReadAsync (buffer, 0, 8);
return buffer;
}
public async void SslStream_SendReceiveOverNetworkStream_Ok()
{
TcpListener listener = new TcpListener(IPAddress.Any, 0);
using (X509Certificate2 serverCertificate = Configuration.Certificates.GetServerCertificate())
using (TcpClient client = new TcpClient())
{
listener.Start();
Task clientConnectTask = client.ConnectAsync(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndpoint).Port);
Task<TcpClient> listenerAcceptTask = listener.AcceptTcpClientAsync();
await Task.WhenAll(clientConnectTask, listenerAcceptTask);
TcpClient server = listenerAcceptTask.Result;
using (SslStream clientStream = new SslStream(
client.GetStream(),
false,
new RemoteCertificateValidationCallback(ValidateServerCertificate),
null,
EncryptionPolicy.RequireEncryption))
using (SslStream serverStream = new SslStream(
server.GetStream(),
false,
null,
null,
EncryptionPolicy.RequireEncryption))
{
Task clientAuthenticationTask = clientStream.AuthenticateAsClientAsync(
serverCertificate.GetNameInfo(X509NameType.SimpleName, false),
null,
SslProtocols.Tls12,
false);
Task serverAuthenticationTask = serverStream.AuthenticateAsServerAsync(
serverCertificate,
false,
SslProtocols.Tls12,
false);
await Task.WhenAll(clientAuthenticationTask, serverAuthenticationTask);
byte[] readBuffer = new byte[256];
Task<int> readTask = clientStream.ReadAsync(readBuffer, 0, readBuffer.Length);
byte[] writeBuffer = new byte[256];
Task writeTask = clientStream.WriteAsync(writeBuffer, 0, writeBuffer.Length);
bool result = Task.WaitAll(
new Task[1] { writeTask },
TestConfiguration.PassingTestTimeoutMilliseconds);
Assert.True(result, "WriteAsync timed-out.");
}
}
}
public async Task ConnectAsync()
{
IsConnected = false;
_triedConnect = true;
_tcpClient = new TcpClient();
await _tcpClient.ConnectAsync(GlobalConfig.IpAddress, GlobalConfig.Port).ConfigureAwait(false);
StartListening();
IsConnected = true;
}
public async Task ConnectAsync()
{
IsConnecting = true;
_tcpClient = new TcpClient();
await _tcpClient.ConnectAsync(GlobalConfig.IpAddress, GlobalConfig.Port);
_networkStream = _tcpClient.GetStream();
IsConnecting = false;
Task.Run(() => StartListening());
}
