ConnectAsync() public method

public ConnectAsync ( IPAddress address, int port ) : System.Threading.Tasks.Task
address IPAddress
port int
return System.Threading.Tasks.Task
        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());
            }
        }
Example #2
1
	    public async Task<TcpClient> ConnectAsync(string hostname, int port)
	    {
	        TcpClient client = new TcpClient();
	        await client.ConnectAsync(hostname, port);
	        DoHandshake(client, hostname, port);
	        return client;
	    } 
Example #3
0
        private async Task ConnectAsyncInternal(CancellationTokenSource cts = null)
        {
            if (Connected)
            {
                throw new InvalidOperationException();
            }

            _client = new System.Net.Sockets.TcpClient();
            if (cts == null)
            {
                await _client.ConnectAsync(_info.IpAddress, _info.Port);
            }
            else
            {
                try
                {
                    await _client.ConnectAsync(_info.IpAddress, _info.Port).WithCancellation(cts.Token);
                }
                catch (OperationCanceledException)
                {
                    Logger.LogWarning("Connecting interrupted");
                    return;
                }
            }

            Logger.Log($"Connected with {_info.IpAddress}:{_info.Port}");
        }
Example #4
0
        public async Task ConnectAsync(CancellationToken cancellationToken = default(CancellationToken))
        {
            try
            {
                //Connect async method
                await CloseAsync().ConfigureAwait(false);

                cancellationToken.ThrowIfCancellationRequested();
                _client = new System.Net.Sockets.TcpClient();
                cancellationToken.ThrowIfCancellationRequested();
                await _client.ConnectAsync(_server, _port).ConfigureAwait(false);
                await CloseIfCanceledAsync(cancellationToken).ConfigureAwait(false);

                // get stream and do SSL handshake if applicable

                _stream = _client.GetStream();
                await CloseIfCanceledAsync(cancellationToken).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                await CloseIfCanceledAsync(cancellationToken).ConfigureAwait(false);

                throw;
            }
        }
Example #5
0
        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...";
            }
        }
Example #6
0
        /// <summary>
        /// Attempts to connect to the remote host.
        /// </summary>
        /// <param name="hostAddress">The IP Address of the host.</param>
        /// <param name="port">The port to connect over.</param>
        /// <param name="asyncConnect">A value indicating if the function should hang until a connection is made.</param>
        /// <exception cref="System.ArgumentNullException"></exception>
        /// <exception cref="System.FormatException"></exception>
        /// <exception cref="System.InvalidOperationException"></exception>
        public void Connect(string hostAddress, int port, bool asyncConnect = false)
        {
            _client = new Socket();
            if (asyncConnect)
            {
                _client.ConnectAsync(IPAddress.Parse(hostAddress), port);
            }
            else
            {
                _client.ConnectAsync(IPAddress.Parse(hostAddress), port).Wait();
            }

            HostAddress = hostAddress;
            Port        = port;
            _stream     = _client.GetStream();
        }
Example #7
0
        public static async Task StartTcpClient()
        {
            var client = new System.Net.Sockets.TcpClient();
            await client.ConnectAsync(IPAddress.Parse("127.0.0.1"), 688);

            var stream = client.GetStream();

            var receiveMessage = string.Empty;
            var sendMessage    = string.Empty;

            if (stream.CanWrite)
            {
                Console.WriteLine("input send message");
                var input = Console.ReadLine();
                receiveMessage = input;
                sendMessage    = "SendMessage: " + receiveMessage;
                var sendBytes = Encoding.UTF8.GetBytes(receiveMessage);
                stream.Write(sendBytes, 0, sendBytes.Length);
            }

            if (stream.CanRead)
            {
                var readBytes = new Byte[4096];
                var i         = stream.Read(readBytes, 0, 4096);
                receiveMessage = Encoding.UTF8.GetString(readBytes, 0, i);
                Console.WriteLine("ReceiveMessage: " + receiveMessage);
            }
            _event.Set();
        }
Example #8
0
        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 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);
                     }
                 }
             }
         });
 }
Example #10
0
        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)
                    );
                }
            }
        }
Example #11
0
        public async void Connect_(IPAddress proxyIP, int port)
        {
            int errorCode = 0;

            _msgCounter = 0;
            // message = "";
            _exchangeCommandActive = false;
            GUI_Communicator.sendStatus("Laser", "HardwareMonitor", "Step 1");
            try
            {
                _proxyIp      = proxyIP;
                errorCode     = 0;
                _innolasProxy = new System.Net.Sockets.TcpClient();
                await _innolasProxy.ConnectAsync(_proxyIp, Convert.ToInt32(port));

                if (_innolasProxy.Connected)
                {
                    _innolasStream = _innolasProxy.GetStream();
                    System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(receiveThread));
                }
                else
                {
                    errorCode = -1;
                    //         message = "Unable to connect";
                }
            }
            catch
            {
                errorCode = -2;
                //     message = "Exception : " + ex.Message;
            }
            //  return errorCode;
        }
Example #12
0
        private void Run()
        {
            Task.Run(async() =>
            {
                try
                {
                    CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
                    CancellationToken cancellationToken             = cancellationTokenSource.Token;
                    using (_remoteClient)
                        using (client)
                        {
                            await client.ConnectAsync(_remoteServer.Address, _remoteServer.Port);
                            var serverStream = client.GetStream();
                            var remoteStream = _remoteClient.GetStream();
                            CancellationTokenSource cancellationTokenSource2 = new CancellationTokenSource();
                            CancellationToken cancellationToken2             = cancellationTokenSource.Token;

                            // await Task.WhenAny(remoteStream.CopyToAsync(serverStream), serverStream.CopyToAsync(remoteStream));
                            // await Task.WhenAll(StreamCopy.CopyToAsync3(remoteStream, serverStream, 1536, byteMapClient2Setver, cancellationToken),
                            //  StreamCopy.CopyToAsync3(serverStream, remoteStream, 1536, byteMapSetver2Client, cancellationToken2));
                            await Task.WhenAny(StreamCopy.CopyToAsync3(remoteStream, serverStream, 1536, byteMapClient2Setver, cancellationToken), StreamCopy.CopyToAsync4(serverStream, remoteStream, 1536, byteMapSetver2Client, cancellationToken2));
                        }
                }
                catch (Exception) { }
                finally
                {
                    Console.WriteLine($"Closed {_clientEndpoint} => {_remoteServer}");
                    _remoteClient = null;
                }
            });
        }
Example #13
0
        /// <summary>
        /// Establish the TCP connection asynchonously
        /// </summary>
        /// <param name="keepalive">Wether the connection should be kept alive after a first message</param>
        /// <returns>True for success, False otherwise</returns>
        public async Task <bool> ConnectAsync(bool keepalive = true)
        {
            try
            {
                // connect socket
                connection                = new System.Net.Sockets.TcpClient();
                connection.NoDelay        = true;
                connection.ReceiveTimeout = 2000;
                await connection.ConnectAsync(EndPoint.Address, EndPoint.Port).ConfigureAwait(false);

                System.IO.Stream connectionStream = connection.GetStream();

                Stream = new IpcStream(connectionStream, KnownTypes, Encryptor);
            }
            catch (SocketException e)
            {
                System.Diagnostics.Debug.WriteLine(e);
                return(false);
            }

            if (keepalive)
            {
                StartPing();
            }

            return(true);
        }
Example #14
0
        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;
        }
Example #15
0
        private string getCommand(string _cmd)
        {
            string minerData    = "";
            var    clientSocket = new System.Net.Sockets.TcpClient();

            if (clientSocket.ConnectAsync(this.host, this.port).Wait(5000))
            {
                //string get_menu_request = "threads|";
                NetworkStream serverStream = clientSocket.GetStream();
                byte[]        outStream    = System.Text.Encoding.ASCII.GetBytes(_cmd);
                serverStream.Write(outStream, 0, outStream.Length);
                serverStream.Flush();

                byte[] inStream = new byte[clientSocket.ReceiveBufferSize];
                serverStream.Read(inStream, 0, (int)clientSocket.ReceiveBufferSize);
                string _returndata = System.Text.Encoding.ASCII.GetString(inStream);
                minerData = _returndata.Substring(0, _returndata.LastIndexOf("|") + 1);
            }
            else
            {
                Console.WriteLine("SGMiner socket failed");
            }

            // Close socket
            clientSocket.Close();
            clientSocket = null;

            return(minerData);
        }
        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();
            }
        }
Example #17
0
        public async Task ConnectAsync(string url)
        {
            Uri    uri   = new Uri(url);
            string query = uri.PathAndQuery;
            bool   ssl   = uri.Scheme.ToLower().StartsWith("wss");
            int    port  = uri.Port > 0 ? uri.Port : (ssl ? 443 : 80);

            await client.ConnectAsync(uri.Host, port);

            ConnectionStream stream = new ConnectionStream(ref client, ssl);

            if (ssl)
            {
                await stream.Authenticate(ConnectionStream.AuthMode.Client, uri.Host);
            }

            if (!(await Handshake(stream, uri, port)))
            {
                state = WebsockState.Closed;
                throw new Exception("Failed connection at handshake");
            }

            protocol = new WebsockProtocol(ref stream);
            state    = WebsockState.Open;
            try {
                while (true)
                {
                    await OnMessage(await protocol.GetMessage());
                }
            } catch (WebsockCloseException ex) {
                await OnClose(ex.Code, ex.Reason);
            } finally {
                protocol.Dispose();
            }
        }
Example #18
0
        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);
            }
        }
Example #19
0
 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;
 }
Example #20
0
        public static void SocketPrint(string printerName, byte[] docToPrint)
        {
            try
            {
                string[] printParameters = printerName.Split(':');
                string   address         = printParameters[0];
                int      port            = Convert.ToInt16(printParameters[1]);
                System.Net.Sockets.TcpClient clientSocket = new System.Net.Sockets.TcpClient();

                if (clientSocket.ConnectAsync(address, port).Wait(timeOut))
                {
                    //clientSocket.Connect(address, port);
                    NetworkStream serverStream = clientSocket.GetStream();
                    byte[]        outStream    = docToPrint;
                    serverStream.Write(outStream, 0, outStream.Length);
                    serverStream.Flush();
                    serverStream.Close();
                }
                else
                {
                    throw new Exception(string.Format("SOCKET_PRINT_TIMEOUT on {0}:{1}", address, port));
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        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);
                    }
                }
            }
        }
Example #22
0
		/// <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.");
			}
		}
Example #23
0
        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);
                        }
                    }
                }
            }
        }
Example #24
0
        public async Task <bool> SendData()
        {
            bool ret = false;

            try
            {
                await clientSocket.ConnectAsync("127.0.0.1", 38300);

                ret = clientSocket.Connected;
            }
            catch (SocketException se)
            {
            }
            catch (ObjectDisposedException odse)
            {
                clientSocket.Close();
                clientSocket = new TcpClient();
                await clientSocket.ConnectAsync("127.0.0.1", 38300);

                ret = clientSocket.Connected;
            }

            if (ret)
            {
                NetworkStream serverStream = clientSocket.GetStream();
                byte[]        inStream     = new byte[clientSocket.ReceiveBufferSize];
                serverStream.Read(inStream, 0, (int)clientSocket.ReceiveBufferSize);
                string returndata = System.Text.Encoding.ASCII.GetString(inStream);

                List <string> songs = new List <string>();
                songs = Directory.EnumerateFiles(m_filePath, "*.bkN", SearchOption.AllDirectories).ToList();

                for (int i = 0; i < songs.Count; i++)
                {
                    using (var fileStream = new FileStream(songs[i], FileMode.Open, FileAccess.Read))
                    {
                        try
                        {
                            byte[] outStream = StreamToByteArray(fileStream);
                            serverStream.Write(outStream, 0, outStream.Length);
                            serverStream.Flush();
                        }
                        catch (IOException ioe)
                        {
                            serverStream.Dispose();
                            clientSocket.Close();
                            break; //no active android server host running
                        }
                    }
                }

                serverStream.Dispose();
                serverStream.Close();
                clientSocket.Close();
                StartADBCommannds("forward --remove tcp:38300", null, null);
            }


            return(ret);
        }
Example #25
0
        private void Send_Click(object sender, RoutedEventArgs e)
        {
            // Ma partie (byron)
            readData = "Conected to Chat Server ...";
            msg();
            clientSocket.ConnectAsync("10.29.18.145", 8888);
            serverStream = clientSocket.GetStream();

            byte[] outStream = System.Text.Encoding.ASCII.GetBytes(textbox1.Text + "$");
            serverStream.Write(outStream, 0, outStream.Length);
            serverStream.Flush();
            //


            // Mise en mémoire dans BDD
            var message = textbox1.Text;
            var pubdate = DateTime.Now.ToString();

            var task = Task.Run <int>(() =>
            {
                return(saveMessage(message, pubdate, ConnectedUser.IdUser.ToString(), currentGroup));
            });

            int      idMessage   = task.Result;
            string   _pubdate    = pubdate;
            Messages sendMessage = new Messages(idMessage, _pubdate, message, ConnectedUser.Pseudo, currentGroup);

            Messages.Add(sendMessage);
            textbox1.Text = "";
            double count = messageListView.Items.Count();

            messageScrollView.ChangeView(0, count * 50, 1);
        }
        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");

                }
            }
            
        }
Example #27
0
        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.");
            }
        }
Example #28
0
        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;
        }
        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
            }

        }
Example #30
0
        /// <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);
        }
 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();
 }
Example #32
0
 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);
 }
 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);
     }
 }
        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);
        }
Example #35
0
        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");
            }
        }
Example #36
0
        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 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.");
                }
            }
        }
Example #38
0
 public async Task ConnectAsync()
 {
     IsConnecting = true;
     _tcpClient = new TcpClient();
     await _tcpClient.ConnectAsync(GlobalConfig.IpAddress, GlobalConfig.Port);
     _networkStream = _tcpClient.GetStream();
     IsConnecting = false;
     Task.Run(() => StartListening());
 }
Example #39
0
    public Task <bool> Connect()
    {
        try
        {
            var addresses = Dns.GetHostAddresses(ip);
            for (int i = 0; i < addresses.Length; i++)
            {
                if (addresses[i].AddressFamily == AddressFamily.InterNetwork ||
                    addresses[i].AddressFamily == AddressFamily.InterNetworkV6)
                {
                    var client  = new System.Net.Sockets.TcpClient(addresses[i].AddressFamily);
                    var address = addresses[i];
                    NetwrokState = NetworkState.CONNECTING;
                    return(Task.Run(async() =>
                    {
                        try
                        {
                            CloseSocket();
                            stopThread = false;
                            tcpClient = client;
                            await tcpClient.ConnectAsync(address, port);
                            if (tcpClient.Connected == true)
                            {
                                Debug.Log("[jyk] Connected:" + stopThread);
                                stream = tcpClient.GetStream();
                                NetwrokState = NetworkState.CONNECTED;
                                this.receiveThread = new Thread(new ThreadStart(ReceiveMessage));
                                this.receiveThread.IsBackground = true;
                                this.receiveThread.Start();
                            }
                            else
                            {
                                Debug.Log("[jyk] DisConnected:" + stopThread);
                                NetwrokState = NetworkState.DISCONNECTED;
                            }

                            return tcpClient.Connected;
                        }
                        catch (Exception e)
                        {
                            if (OnConnectFailed != null)
                            {
                                OnConnectFailed(e);
                            }

                            return false;
                        }
                    }));
                }
            }
            return(Task.FromResult(false));
        }
        catch (Exception e)
        {
            return(Task.FromResult(false));
        }
    }
Example #40
0
		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;
		}
Example #41
0
        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);
        }
Example #42
0
        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);
                        }

                    }
                    

                }
            }
        }
 public async Task ConnectAsync()
 {
     IsConnected = false;
     _triedConnect = true;
     _tcpClient = new TcpClient();
     await _tcpClient.ConnectAsync(GlobalConfig.IpAddress, GlobalConfig.Port).ConfigureAwait(false);
     StartListening();
     IsConnected = true;
 }
Example #44
0
        public static async void AttemptConnectionToListner(int port)
        {
            if (_reporter == null)
            {
                _reporter = new TcpClient();
            }
            try
            {
                await _reporter.ConnectAsync(_ip, port);

                _connected = true;
            }
            catch
            {
                Broadcast(_reporter, new MessageEventArgs(new Message("Connection attempt failed.")));
            }
        }
Example #45
0
 public async System.Threading.Tasks.Task <string> Connect(string ip_addr, string port)
 {
     connectSocket = new System.Net.Sockets.TcpClient();
     try
     {
         await connectSocket.ConnectAsync(ip_addr, Int32.Parse(port));
     }
     catch (Exception ex)
     {
         _canConnect = false;
         Debug.Log(ex);
         throw new Exception("Server not found at: " + ip_addr);
     }
     streamOut  = connectSocket.GetStream();
     writer     = new StreamWriter(streamOut);
     reader     = new StreamReader(streamOut);
     _connected = true;
     return(null);
 }
Example #46
0
 public async System.Threading.Tasks.Task <string> Connect(string ip_addr, string port)
 {
     connectSocket = new Windows.Networking.Sockets.StreamSocket();
     Windows.Networking.HostName serverHost = new Windows.Networking.HostName(ip_addr);
     try {
         await connectSocket.ConnectAsync(serverHost, port);
     }
     catch {
         _canConnect = false;
         _connected  = false;
         throw new Exception("Server not found.");
     }
     streamOut  = connectSocket.OutputStream.AsStreamForWrite();
     streamIn   = connectSocket.InputStream.AsStreamForRead();
     writer     = new StreamWriter(streamOut);
     reader     = new StreamReader(streamIn);
     _connected = true;
     return(null);
 }
Example #47
0
        /// <summary>
        /// Attempts to connect to a local or remote Tungsten RPC Server
        /// </summary>
        /// <param name="remoteAddress">The IP address of the Tungsten RPC Server</param>
        /// <param name="remotePort">The port on which the Tungsten RPC Server is listening</param>
        /// <returns>A bool specifying success/failure</returns>
        /// <remarks>If an exception occurs, the Disconnected delegate will be called with the specific exception</remarks>
        public async Task <bool> ConnectAsync(IPAddress remoteAddress, int remotePort)
        {
            Exception ex = null;

            try
            {
                RemoteEndPoint = new IPEndPoint(remoteAddress, remotePort);
                _client        = new TcpClient();

                await _client.ConnectAsync(remoteAddress, remotePort);
            }
            catch (ArgumentNullException e) //the address parameter is null
            {
                ex = e;
                System.Diagnostics.Debug.WriteLine(string.Format("Argument Null Exception: {0}", e.Message));
            }
            catch (ArgumentOutOfRangeException e) //the port is not between MinPort and MaxPort
            {
                ex = e;
                System.Diagnostics.Debug.WriteLine(string.Format("Argument Out of Range Exception: {0}", e.Message));
            }
            catch (SocketException e) //an error occured while accessing the socket.
            {
                ex = e;
                var errorCode = Enum.GetName(typeof(System.Net.Sockets.SocketError), e.SocketErrorCode);
                System.Diagnostics.Debug.WriteLine(string.Format("Socket Exception({0}): {1}", errorCode, e.Message));
            }
            catch (ObjectDisposedException e) //TcpClient is closed
            {
                ex = e;
                System.Diagnostics.Debug.WriteLine(string.Format("Object Disposed Exception: {0}", e.Message));
            }
            if (ex != null)
            {
                Disconnect(ex);
                return(false);
            }
            FinalizeConnection(RemoteEndPoint);
            OnConnected(RemoteEndPoint);
            return(true);
        }
Example #48
0
        /// <summary>
        /// Attempts to connect to a local or remote Tungsten RPC Server
        /// </summary>
        /// <param name="remoteAddress">The IP address of the Tungsten RPC Server</param>
        /// <param name="remotePort">The port on which the Tungsten RPC Server is listening</param>
        /// <returns>A bool specifying success/failure</returns>
        /// <remarks>If an exception occurs, the Disconnected delegate will be called with the specific exception</remarks>
        public async Task Connect(IPAddress remoteAddress, int remotePort)
        {
            Exception ex = null;

            try
            {
                _client = new TcpClient();
                await _client.ConnectAsync(remoteAddress, remotePort);
            }
            catch (ArgumentNullException e) //the address parameter is null
            {
                ex = e;
                Log.e(e);
            }
            catch (ArgumentOutOfRangeException e) //the port is not between MinPort and MaxPort
            {
                ex = e;
                Log.e(e);
            }
            catch (SocketException e) //an error occured while accessing the socket.
            {
                ex = e;
                var errorCode = Enum.GetName(typeof(System.Net.Sockets.SocketError), e.SocketErrorCode);
                Log.e("Socket Exception({0}): {1}", errorCode, e.Message);
            }
            catch (ObjectDisposedException e) //TcpClient is closed
            {
                ex = e;
                Log.e(e);
            }
            if (ex != null)
            {
                Disconnect(ex);
                return;
            }
            FinalizeConnection(remoteAddress);
            OnConnected(remoteAddress);
        }
Example #49
0
        private void Run()
        {
            Task.Run(async() =>
            {
                try
                {
                    using (_remoteClient)
                        using (client)
                        {
                            await client.ConnectAsync(_remoteServer.Address, _remoteServer.Port);
                            var serverStream = client.GetStream();
                            var remoteStream = _remoteClient.GetStream();

                            await Task.WhenAny(remoteStream.CopyToAsync(serverStream), serverStream.CopyToAsync(remoteStream));
                        }
                }
                catch (Exception) { }
                finally
                {
                    Console.WriteLine($"Closed {_clientEndpoint} => {_remoteServer}");
                    _remoteClient = null;
                }
            });
        }
Example #50
0
        public async Task <byte[]> SendMessage(byte[] message,
                                               CancellationToken cancellationToken = default(CancellationToken))
        {
            await Task.Yield();

            var result = default(byte[]);

            try
            {
                //query the server
                using (var client = new System.Net.Sockets.TcpClient(AddressFamily.InterNetwork))
                {
                    client.Client.NoDelay = true;

                    if (!cancellationToken.IsCancellationRequested)
                    {
                        await client.ConnectAsync(ServerConnection.Host, ServerConnection.Port);

                        if (!cancellationToken.IsCancellationRequested)
                        {
                            using (var stream = client.GetStream())
                            {
                                if (PacketFormatter != null)
                                {
                                    message = PacketFormatter.AddFooter(message);
                                }

                                if (!cancellationToken.IsCancellationRequested)
                                {
                                    await stream.WriteAsync(message, 0, message.Length);

                                    await stream.FlushAsync();

                                    if (!cancellationToken.IsCancellationRequested)
                                    {
                                        using (var memoryStream = new MemoryStream())
                                        {
                                            var readBuffer = new byte[32768];
                                            while (true)
                                            {
                                                var read = await stream.ReadAsync(readBuffer, 0, readBuffer.Length);

                                                if (read > 0)
                                                {
                                                    await memoryStream.WriteAsync(readBuffer, 0, read);
                                                }
                                                if (read <= 0 || readBuffer[read - 1] == 4)
                                                {
                                                    var data = memoryStream.ToArray();
                                                    if (PacketFormatter != null)
                                                    {
                                                        result = PacketFormatter.RemoveFooter(data);
                                                    }
                                                    else
                                                    {
                                                        result = data;
                                                    }
                                                    break;
                                                }
                                            }

                                            memoryStream.Close();
                                            memoryStream.Dispose();
                                        }
                                    }

                                    stream.Close();
                                    stream.Dispose();
                                }
                            }
                        }

                        client.Close();
                        client.Dispose();
                    }
                }
            }
            catch (Exception)
            {
            }

            return(result);
        }
Example #51
0
        public async Task ConnectAsync(IPEndPoint ep)
        {
            await _client.ConnectAsync(ep.Address, ep.Port);

            _stream = _client.GetStream();
        }
Example #52
0
        public async Task ConnectAsync()
        {
            await _tcpClient.ConnectAsync(_ipAddress, _port);

            _stream = _tcpClient.GetStream();
        }
Example #53
0
        public Stats getStats(string _host, int _port)
        {
            Stats stats = new Stats()
            {
                online              = false,
                ex                  = null,
                uptime              = "",
                version             = "",
                hashrates           = new List <string>(),
                dcr_hashrates       = new List <string>(),
                temps               = new List <string>(),
                fan_speeds          = new List <string>(),
                power_usage         = new List <string>(),
                type                = 2,
                dual_accepted       = 0,
                dual_rejected       = 0,
                total_dual_hashrate = ""
            };

            try
            {
                var clientSocket = new System.Net.Sockets.TcpClient();

                if (clientSocket.ConnectAsync(_host, _port).Wait(5000))
                {
                    string        get_menu_request = "{\"id\":1, \"method\":\"getstat\"}\n";
                    NetworkStream serverStream     = clientSocket.GetStream();
                    byte[]        outStream        = System.Text.Encoding.ASCII.GetBytes(get_menu_request);
                    serverStream.Write(outStream, 0, outStream.Length);
                    serverStream.Flush();

                    byte[] inStream = new byte[clientSocket.ReceiveBufferSize];
                    serverStream.Read(inStream, 0, (int)clientSocket.ReceiveBufferSize);
                    string _returndata = System.Text.Encoding.ASCII.GetString(inStream);
                    string jsonData    = _returndata.Substring(0, _returndata.LastIndexOf("}") + 1);

                    EWBFTemplate result = JsonConvert.DeserializeObject <EWBFTemplate>(jsonData);

                    stats.version = "EWBF";

                    int total_hashrate = 0;

                    if (result.result.Count > 0)
                    {
                        foreach (EWBFOBjectTemplate gpu in result.result)
                        {
                            // Speed
                            stats.hashrates.Add(gpu.speed_sps.ToString());
                            stats.power_usage.Add(gpu.gpu_power_usage.ToString());
                            stats.fan_speeds.Add("0");
                            stats.temps.Add(gpu.temperature.ToString());
                            total_hashrate += gpu.speed_sps;

                            // Shares
                            stats.accepted += gpu.accepted_shares;
                            stats.rejected += gpu.rejected_shares;
                        }
                    }

                    stats.total_hashrate = total_hashrate.ToString();

                    // Close socket
                    clientSocket.Close();
                    clientSocket = null;

                    stats.online = true; // Online
                }
                else
                {
                    Console.WriteLine("EWBF socket failed");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("EWBF Exception: " + ex.Message);
            }

            return(stats);
        }
        public Stats getStats(string _host, int _port, string _password)
        {
            Stats stats = new Stats()
            {
                online              = false,
                ex                  = null,
                uptime              = "",
                version             = "",
                hashrates           = new List <string>(),
                dcr_hashrates       = new List <string>(),
                temps               = new List <string>(),
                fan_speeds          = new List <string>(),
                power_usage         = new List <string>(),
                type                = 0,
                dual_accepted       = 0,
                dual_rejected       = 0,
                total_dual_hashrate = ""
            };

            try
            {
                var clientSocket = new System.Net.Sockets.TcpClient();

                if (clientSocket.ConnectAsync(_host, _port).Wait(5000))
                {
                    string        get_menu_request = "{\"id\":0,\"jsonrpc\":\"2.0\",\"method\":\"miner_getstat1\",\"psw\":\"" + _password + "\"}";
                    NetworkStream serverStream     = clientSocket.GetStream();
                    byte[]        outStream        = System.Text.Encoding.ASCII.GetBytes(get_menu_request);
                    serverStream.Write(outStream, 0, outStream.Length);
                    serverStream.Flush();

                    byte[] inStream = new byte[clientSocket.ReceiveBufferSize];
                    serverStream.Read(inStream, 0, (int)clientSocket.ReceiveBufferSize);
                    string _returndata = System.Text.Encoding.ASCII.GetString(inStream);

                    if (_returndata.Length == 0)
                    {
                        throw new Exception("Invalid data");
                    }

                    Console.WriteLine(_returndata);

                    EthMonJsonTemplate result = JsonConvert.DeserializeObject <EthMonJsonTemplate>(_returndata);

                    stats.version = result.result[0]; // Version
                    stats.uptime  = result.result[1]; // Uptime

                    string[] miner_stats = result.result[2].Split(';');
                    stats.total_hashrate = miner_stats[0];
                    stats.accepted       = Int32.Parse(miner_stats[1]);
                    stats.rejected       = Int32.Parse(miner_stats[2]);

                    // Dual Stats
                    string[] dual_stats = result.result[4].Split(';');
                    stats.total_dual_hashrate = dual_stats[0];
                    stats.dual_accepted       = Int32.Parse(dual_stats[1]);
                    stats.dual_rejected       = Int32.Parse(dual_stats[2]);

                    string[] hashrates = result.result[3].Split(';'); // ETH Hashrates

                    for (int i = 0; i < hashrates.Length; i++)
                    {
                        stats.hashrates.Add(hashrates[i]);
                    }

                    string[] dcr_hashrates = result.result[5].Split(';'); // DCR Hashrates

                    for (int i = 0; i < dcr_hashrates.Length; i++)
                    {
                        stats.dcr_hashrates.Add(dcr_hashrates[i]);
                    }

                    // Temps and fan speeds
                    string[] temp = result.result[6].Split(';');
                    try
                    {
                        int temp_row = 0;
                        for (int i = 0; i < temp.Length; i++)
                        {
                            stats.temps.Add(temp[i]);
                            stats.fan_speeds.Add(temp[i + 1]);
                            i++;
                            temp_row++;
                        }
                    } catch (Exception ex)
                    {
                    }

                    // Close socket
                    clientSocket.Close();
                    clientSocket = null;

                    stats.online = true; // Online
                }
                else
                {
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.WriteLine(ex.StackTrace);
                stats.ex = ex;
                logger.LogWrite("Host socket exception: " + ex.ToString());
            }

            return(stats);
        }
Example #55
0
 public virtual async Task ConnectAsync(IPAddress parse, int port)
 {
     await Client.ConnectAsync(parse, port);
 }
Example #56
0
        public async Task RunAsync()
        {
            bool isConnected = false;

            //do
            //{
            tcpClient = new System.Net.Sockets.TcpClient(AddressFamily.InterNetworkV6);
            tcpClient.Client.DualMode = true;

            log.LogInformation("Connecting to server");

            Task connectTask;

            connectTask = tcpClient.ConnectAsync(Server.ServerAddress, Server.Port);

            var timeoutTask = Task.Delay(ConnectTimeout);

            if (await Task.WhenAny(connectTask, timeoutTask) == timeoutTask)
            {
                log.LogWarning("Connection timeout");

                closedTcs.TrySetResult(true);
                OnClosed(true);
                return;
            }

            try
            {
                await connectTask;
            }
            catch (Exception e)
            {
                log.LogError("Exception: {exception}", e.Message);
                closedTcs.TrySetResult(true);
                OnClosed(true);
                return;
            }

            stream = tcpClient.GetStream();

            // Read until the connection is closed.
            // A closed connection can only be detected while reading, so we need to read
            // permanently, not only when we might use received data.
            var networkReadTask = Task.Run(async() =>
            {
                byte[] buffer = new byte[10240];
                while (true)
                {
                    int readLength;
                    try
                    {
                        readLength = await stream.ReadAsync(buffer, 0, buffer.Length);
                    }
                    catch (IOException ex) when((ex.InnerException as SocketException)?.ErrorCode == (int)SocketError.OperationAborted ||
                                                (ex.InnerException as SocketException)?.ErrorCode == 125 /* Operation canceled (Linux) */)
                    {
                        // Warning: This error code number (995) may change.
                        // See https://docs.microsoft.com/en-us/windows/desktop/winsock/windows-sockets-error-codes-2
                        // Note: NativeErrorCode and ErrorCode 125 observed on Linux.
                        log.LogInformation("Connection closed locally: {exception}", ex.Message);
                        readLength = -1;
                    }
                    catch (IOException ex) when((ex.InnerException as SocketException)?.ErrorCode == (int)SocketError.ConnectionAborted)
                    {
                        log.LogWarning("Connection aborted: {exception}", ex.Message);
                        readLength = -1;
                    }
                    catch (IOException ex) when((ex.InnerException as SocketException)?.ErrorCode == (int)SocketError.ConnectionReset)
                    {
                        log.LogWarning("Connection reset remotely {exception}", ex.Message);
                        readLength = -2;
                    }
                    if (readLength <= 0)
                    {
                        if (readLength == 0)
                        {
                            log.LogWarning("Connection closed remotely");
                        }
                        closedTcs.TrySetResult(true);
                        OnClosed(readLength != -1);
                        return;
                    }
                    var message       = Encoding.ASCII.GetString(buffer, 0, readLength);            // Convert from bytes to ASCII
                    var splitMessages = message.Split('\n', StringSplitOptions.RemoveEmptyEntries); // The sever may have given us more than a single line, split on newline
                    int messages      = 0;
                    foreach (var currentMessage in splitMessages)
                    {
                        messages++;
                        MessageQueue.Enqueue(currentMessage);
                    }
                    await OnReceivedAsync(messages);
                }
            });

            closedTcs = new TaskCompletionSource <bool>();
            await OnConnectedAsync();

            //} while (//reconnect logic);
        }
        /// <summary>
        /// Establish the connection to the server with retries up to either the timeout specified or the value in Settings.ConnectTimeoutMs.
        /// </summary>
        /// <param name="timeoutMs">The amount of time in milliseconds to continue attempting connections.</param>
        public void ConnectWithRetries(int?timeoutMs = null)
        {
            if (timeoutMs != null && timeoutMs < 1)
            {
                throw new ArgumentException("Timeout milliseconds must be greater than zero.");
            }
            if (timeoutMs != null)
            {
                _Settings.ConnectTimeoutMs = timeoutMs.Value;
            }

            if (IsConnected)
            {
                Logger?.Invoke(_Header + "already connected");
                return;
            }
            else
            {
                Logger?.Invoke(_Header + "initializing client");

                InitializeClient(_Ssl, _PfxCertFilename, _PfxPassword);

                Logger?.Invoke(_Header + "connecting to " + ServerIpPort);
            }

            _TokenSource = new CancellationTokenSource();
            _Token       = _TokenSource.Token;

            CancellationTokenSource connectTokenSource = new CancellationTokenSource();
            CancellationToken       connectToken       = connectTokenSource.Token;

            Task cancelTask  = Task.Delay(_Settings.ConnectTimeoutMs, _Token);
            Task connectTask = Task.Run(() =>
            {
                int retryCount = 0;

                while (true)
                {
                    try
                    {
                        string msg = _Header + "attempting connection to " + _ServerIp + ":" + _ServerPort;
                        if (retryCount > 0)
                        {
                            msg += " (" + retryCount + " retries)";
                        }
                        Logger?.Invoke(msg);

                        _Client.Dispose();
                        _Client = new TcpClient();
                        _Client.ConnectAsync(_ServerIp, _ServerPort).Wait(1000, connectToken);

                        if (_Client.Connected)
                        {
                            Logger?.Invoke(_Header + "connected to " + _ServerIp + ":" + _ServerPort);
                            break;
                        }
                    }
                    catch (TaskCanceledException)
                    {
                        break;
                    }
                    catch (OperationCanceledException)
                    {
                        break;
                    }
                    catch (Exception e)
                    {
                        Logger?.Invoke(_Header + "failed connecting to " + _ServerIp + ":" + _ServerPort + ": " + e.Message);
                    }
                    finally
                    {
                        retryCount++;
                    }
                }
            }, connectToken);

            Task.WhenAny(cancelTask, connectTask).Wait();

            if (cancelTask.IsCompleted)
            {
                connectTokenSource.Cancel();
                _Client.Close();
                throw new TimeoutException("Timeout connecting to " + ServerIpPort);
            }

            try
            {
                _NetworkStream = _Client.GetStream();

                if (_Ssl)
                {
                    if (_Settings.AcceptInvalidCertificates)
                    {
                        _SslStream = new SslStream(_NetworkStream, false, new RemoteCertificateValidationCallback(AcceptCertificate));
                    }
                    else
                    {
                        _SslStream = new SslStream(_NetworkStream, false);
                    }

                    _SslStream.AuthenticateAsClient(_ServerIp, _SslCertCollection, SslProtocols.Tls12, !_Settings.AcceptInvalidCertificates);

                    if (!_SslStream.IsEncrypted)
                    {
                        throw new AuthenticationException("Stream is not encrypted");
                    }
                    if (!_SslStream.IsAuthenticated)
                    {
                        throw new AuthenticationException("Stream is not authenticated");
                    }
                    if (_Settings.MutuallyAuthenticate && !_SslStream.IsMutuallyAuthenticated)
                    {
                        throw new AuthenticationException("Mutual authentication failed");
                    }
                }

                if (_Keepalive.EnableTcpKeepAlives)
                {
                    EnableKeepalives();
                }
            }
            catch (Exception)
            {
                throw;
            }

            _IsConnected  = true;
            _LastActivity = DateTime.Now;
            _IsTimeout    = false;
            _Events.HandleConnected(this, new ClientConnectedEventArgs(ServerIpPort));
            _DataReceiver      = Task.Run(() => DataReceiver(_Token), _Token);
            _IdleServerMonitor = Task.Run(() => IdleServerMonitor(), _Token);
        }