public Task TcpSocketClient_ShouldThrowPCLException_InPlaceOfNativeSocketException()
        {
            var sut = new TcpSocketClient();
            var unreachableHostName = ":/totallynotvalid@#$";

            return Assert.ThrowsAsync<Exception>(() => sut.ConnectAsync(unreachableHostName, 8000));
        }
        /// <summary>
        ///     Binds the <code>TcpSocketListener</code> to the specified port on all endpoints and listens for TCP connections.
        /// </summary>
        /// <param name="port">The port to listen on. If '0', selection is delegated to the operating system.</param>
        /// <param name="listenOn">The <code>CommsInterface</code> to listen on. If unspecified, all interfaces will be bound.</param>
        /// <returns></returns>
        public Task StartListeningAsync(int port, ICommsInterface listenOn = null)
        {
            if (listenOn != null && !listenOn.IsUsable)
                throw new InvalidOperationException("Cannot listen on an unusable interface. Check the IsUsable property before attemping to bind.");
            
            _listenCanceller = new CancellationTokenSource();
            _backingStreamSocketListener = new StreamSocketListener();

            _backingStreamSocketListener.ConnectionReceived += (sender, args) =>
            {
                var nativeSocket = args.Socket;
                var wrappedSocket = new TcpSocketClient(nativeSocket, _bufferSize);

                var eventArgs = new TcpSocketListenerConnectEventArgs(wrappedSocket);
                if (ConnectionReceived != null)
                    ConnectionReceived(this, eventArgs);
            };

            var sn = port == 0 ? "" : port.ToString();
#if !WP80    
            if (listenOn != null)
            {
                var adapter = ((CommsInterface)listenOn).NativeNetworkAdapter;

                return _backingStreamSocketListener
                            .BindServiceNameAsync(sn, SocketProtectionLevel.PlainSocket, adapter)
                            .AsTask();
            }
            else
#endif
                return _backingStreamSocketListener
                            .BindServiceNameAsync(sn)
                            .AsTask();
        }
        public async Task Initialize(string host, string port, ConnectionChannel connectionChannel, HeartbeatChannel heartbeatChannel, Action<Stream, bool> packetReader)
        {
            if (_client == null) _client = new TcpSocketClient();
            await _client.ConnectAsync(host, int.Parse(port), true, default(CancellationToken), true);


            connectionChannel.OpenConnection();
            heartbeatChannel.StartHeartbeat();

            await Task.Run(() =>
            {
                while (true)
                {
                    var sizeBuffer = new byte[4];
                    byte[] messageBuffer = { };
                    // First message should contain the size of message
                    _client.ReadStream.Read(sizeBuffer, 0, sizeBuffer.Length);
                    // The message is little-endian (that is, little end first),
                    // reverse the byte array.
                    Array.Reverse(sizeBuffer);
                    //Retrieve the size of message
                    var messageSize = BitConverter.ToInt32(sizeBuffer, 0);
                    messageBuffer = new byte[messageSize];
                    _client.ReadStream.Read(messageBuffer, 0, messageBuffer.Length);
                    var answer = new MemoryStream(messageBuffer.Length);
                    answer.Write(messageBuffer, 0, messageBuffer.Length);
                    answer.Position = 0;
                    packetReader(answer, true);
                }
            });
        }
        public async Task TcpSocketClient_ShouldSendReceiveData()
        {
            var bytesToSend = new byte[] {0x1, 0x2, 0x3, 0x4, 0x5};
            var len = bytesToSend.Length;
            var port = PortGranter.GrantPort();

            var listener = new TcpSocketListener();
            await listener.StartListeningAsync(port);

            var tcs = new TaskCompletionSource<bool>();
            listener.ConnectionReceived += async (sender, args) =>
            {
                var bytesReceived = new byte[len];
                await args.SocketClient.ReadStream.ReadAsync(bytesReceived, 0, len);

                var allSame =
                    Enumerable
                        .Zip(bytesToSend,
                            bytesReceived,
                            (s, r) => s == r)
                        .All(b => b);

                tcs.SetResult(allSame);
            };

            var client = new TcpSocketClient();
            await client.ConnectAsync("127.0.0.1", port);
            await client.WriteStream.WriteAsync(bytesToSend, 0, len);

            var ok = await tcs.Task;

            await listener.StopListeningAsync();

            Assert.True(ok);
        }
        public Task TcpSocketClient_ShouldThrowNormalException_WhenNotPlatformSpecific()
        {
            var sut = new TcpSocketClient();
            var tooHighForAPort = Int32.MaxValue;

            return Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => sut.ConnectAsync("127.0.0.1", tooHighForAPort));
        }
        private Task OnlyThrowsSocketExceptionOnNet()
        {
            var sut = new TcpSocketClient();
            var unreachableHostName = ":/totallynotvalid@#$";

            return sut.ConnectAsync(unreachableHostName, 8000);
        }
        private Task OnlyThrowsSocketExceptionOnWinRT()
        {
            var sut = new TcpSocketClient();
            var tooHighForAPort = Int32.MaxValue;

            return sut.ConnectAsync("127.0.0.1", tooHighForAPort);
        }
        public TcpSocketClientPage()
        {
            _client = new TcpSocketClient();
            _messagesSub = new Subject<Message>();
            _messagesObs = _messagesSub.AsObservable();
            

            InitView();
        }
Beispiel #9
0
        private async Task SendTcpAsync(ClientInfo clientInfo, byte[] message)
        {
            var client = new TcpSocketClient();
            await client.ConnectAsync(clientInfo.IpAddress, SharedSettings.TcpPort);

            client.WriteStream.Write(message, 0, message.Length);
            await client.WriteStream.FlushAsync();

            await client.DisconnectAsync();
        }
        public async Task TcpSocketClient_ShouldBeAbleToConnect()
        {
            var port = PortGranter.GrantPort();
            var listener = new TcpSocketListener();
            await listener.StartListeningAsync(port);

            var sut = new TcpSocketClient();
            await sut.ConnectAsync("127.0.0.1", port);

            await listener.StopListeningAsync();

            // getting here means nothing went boom
            Assert.True(true);
        }
 private static bool OpenConnection()
 {
     try
     {
         // Send initial parameters
         var networkStream = ImageComparisonServer.WriteStream;
         var binaryWriter = new BinaryWriter(networkStream);
         ImageTestResultConnection.Write(binaryWriter);
         return true;
     }
     catch
     {
         ImageComparisonServer = null;
         return false;
     }
 }
        public static bool Connect()
        {
            if (ImageComparisonServer != null)
                return true;

            try
            {
                ImageComparisonServer = new TcpSocketClient();
                var t = Task.Run(async () => await ImageComparisonServer.ConnectAsync(XenkoImageServerHost, XenkoImageServerPort));
                t.Wait();
            }
            catch (Exception)
            {
                ImageComparisonServer = null;

                return false;
            }

            return OpenConnection();
        }
        public static void Disconnect()
        {
            if (ImageComparisonServer != null)
            {
                try
                {
                    // Properly sends a message notifying we want to close the connection
                    var networkStream = ImageComparisonServer.WriteStream;
                    var binaryWriter = new BinaryWriter(networkStream);
                    binaryWriter.Write((int)ImageServerMessageType.ConnectionFinished);
                    binaryWriter.Flush();

                    ImageComparisonServer.Dispose();
                }
                catch (Exception)
                {
                    // Ignore failures on disconnect
                }
                ImageComparisonServer = null;
            }
        }
 public static bool Connect(SimpleSocket simpleSocket)
 {
     ImageComparisonServer = simpleSocket.Socket;
     return OpenConnection();
 }
#pragma warning disable 4014
        private void WaitForConnections(CancellationToken cancelToken)
        {
            Task.Factory.StartNew(async () =>
            {
                while (!cancelToken.IsCancellationRequested)
                {
                    var nativeClient = await Task.Run(() => _backingTcpListener.AcceptTcpClient(), cancelToken);
                    var wrappedClient = new TcpSocketClient(nativeClient, _bufferSize);

                    var eventArgs = new TcpSocketListenerConnectEventArgs(wrappedClient);
                    if (ConnectionReceived != null)
                        ConnectionReceived(this, eventArgs);
                }
            },
                cancelToken,
                TaskCreationOptions.LongRunning,
                TaskScheduler.Default);
        }
        public async Task StartClient(string address, int port, bool needAck = true)
        {
            // Create TCP client
            var socket = new TcpSocketClient(2048);

            try
            {
                await socket.ConnectAsync(address, port);

                SetSocket(socket);
                //socket.NoDelay = true;

                // Do an ack with magic packet (necessary so that we know it's not a dead connection,
                // it sometimes happen when doing port forwarding because service don't refuse connection right away but only fails when sending data)
                if (needAck)
                    await SendAndReceiveAck(socket, MagicAck, MagicAck);

                Connected?.Invoke(this);

                isConnected = true;
            }
            catch (Exception)
            {
                DisposeSocket();
                throw;
            }
        }
Beispiel #17
0
 public MobileTcpClient(UsersService usersService, TcpSocketClient client)
 {
     _usersService = usersService;
     _client = client;
 }
        public void Connect()
        {
            this.socket = new TcpSocketClient();

            // connection is executed synchronously
            this.socket.ConnectAsync(this.remoteHostName,
                this.remotePort,
                this.sslProtocol != MqttSslProtocols.None).Wait();
        }
 private void SetSocket(TcpSocketClient socket)
 {
     this.socket = socket;
 }
        private void DisposeSocket()
        {
            if (this.socket != null)
            {
                if (isConnected)
                {
                    isConnected = false;
                    Disconnected?.Invoke(this);
                }

                this.socket.Dispose();
                this.socket = null;
            }
        }
Beispiel #21
0
 private TcpClient(IUsersService usersService, TcpSocketClient client)
 {
     _usersService = usersService;
     _client = client;
 }
        public async Task TcpSocketClient_ShouldSendReceiveDataSimultaneously(int bufferSize)
        {
            var port = PortGranter.GrantPort();

            TcpSocketListener listener = null;
            TcpSocketClient socket1 = null;

            // get both ends of a connected socket, with or without buffer
            if (bufferSize != -1)
            {
                listener = new TcpSocketListener(bufferSize);
                socket1 = new TcpSocketClient(bufferSize);
            }
            else
            {
                listener = new TcpSocketListener();
                socket1 = new TcpSocketClient();
            }

            var tcs = new TaskCompletionSource<ITcpSocketClient>();
            
            await listener.StartListeningAsync(port);
            listener.ConnectionReceived += (sender, args) => tcs.SetResult(args.SocketClient);

            await socket1.ConnectAsync("127.0.0.1", port);

            var socket2 = await tcs.Task;
            await listener.StopListeningAsync();

            // socket1 is the socket from the client end
            // socket2 is the socket from the server end

            // for five seconds, send and receive the data 
            var sentToSocket1 = new List<byte>();
            var sentToSocket2 = new List<byte>();
            var recvdBySocket1 = new List<byte>();
            var recvdBySocket2 = new List<byte>();

            // send random data and keep track of it
            // also keep track of what is received
            Func<ITcpSocketClient, List<byte>, List<byte>, CancellationToken, Task> sendAndReceive =
                (socket, sent, recvd, token) =>
                {
                    var r = new Random(socket.GetHashCode());
                    var send = Task.Run(async () =>
                    {
                        var buf = new byte[1000];
                        while (!token.IsCancellationRequested)
                        {
                            r.NextBytes(buf);
                            sent.AddRange(buf);
                            await socket.WriteStream.WriteAsync(buf, 0, buf.Length, token);
                            await socket.WriteStream.FlushAsync(token);
                        }
                    });

                    var recv = Task.Run(async () =>
                    {
                        var buf = new byte[1000];
                        while (!token.IsCancellationRequested)
                        {
                            var len = await socket.ReadStream.ReadAsync(buf, 0, buf.Length, token);
                            recvd.AddRange(buf.Take(len));
                        }
                    });

                    var innerTcs = new TaskCompletionSource<bool>();
                    token.Register(() => innerTcs.SetResult(true));

                    return innerTcs.Task;
                };

            // let the sockets run for 2.5 seconds
            var socketRunners =
                Task.WhenAll(
                    Task.Run(() => sendAndReceive(socket1, sentToSocket2, recvdBySocket1, new CancellationTokenSource(TimeSpan.FromSeconds(2.5)).Token).ContinueWith(t=> Debug.WriteLine($"Socket 1 task completed: {t}"))),
                    Task.Run(() => sendAndReceive(socket2, sentToSocket1, recvdBySocket2, new CancellationTokenSource(TimeSpan.FromSeconds(2.5)).Token).ContinueWith(t => Debug.WriteLine($"Socket 2 task completed: {t}")))
                    );

            await socketRunners;

            Debug.WriteLine("Sent to S1:{0}, Recvd by S1:{1}", sentToSocket1.Count, recvdBySocket1.Count);
            Debug.WriteLine("Sent to S2:{0}, Recvd by S2:{1}", sentToSocket2.Count, recvdBySocket2.Count);

            // zip will join up to the lowest index of both lists (must be recvd)
            // it's ok if recvd is shorter than sent because we cancel abruptly,
            // but we want to be sure that everything that was received matches 
            // everything that sent, and that we did both send and receive.

            var socket1Errors =
                Enumerable.Zip(recvdBySocket1, sentToSocket1,
                            (r, s) => s == r)
                        .Count(b => !b);

            var socket2Errors =
                Enumerable.Zip(recvdBySocket2, 
                                sentToSocket2,
                            (r, s) => s == r)
                        .Count(b => !b);
            
            var max = new[] {recvdBySocket1.Count, recvdBySocket2.Count, sentToSocket1.Count, sentToSocket2.Count}.Max();
            Func<List<byte>, int, string> getValueOrStars =
                (bytes, i) => bytes.Count > i ? ((int) bytes[i]).ToString().PadLeft(3, '0') : "***";

            var rows =
                Enumerable.Range(0, max - 1)
                    .Select(i =>
                    {
                        var sTo1 = getValueOrStars(sentToSocket1, i);
                        var rBy1 = getValueOrStars(recvdBySocket1, i);
                        var sTo2 = getValueOrStars(sentToSocket2, i);
                        var rBy2 = getValueOrStars(recvdBySocket2, i);

                        return new { Index = i, SentTo1 = sTo1, ReceivedBy1 = rBy1, SentTo2 = sTo2, ReceivedBy2 = rBy2};
                    })
                    .Where(r => (r.SentTo1 != r.ReceivedBy1 && r.ReceivedBy1 != "***") || (r.SentTo2 != r.ReceivedBy2 && r.ReceivedBy2 != "***"))
                    .Select(r=> $"{r.Index}: \t{r.SentTo1}\t{r.ReceivedBy1}\t{r.SentTo2}\t{r.ReceivedBy2}\t")
                    .Take(1000);
            
            Func<IEnumerable<byte>, string> show = bs => $"[ {String.Join(", ", bs.Take(5).Select(b => (int) b))} ]";

            if (socket1Errors > 0 || socket2Errors > 0)
            {
                Assert.True(socket1Errors == 0,
                    $"Socket1 received {socket1Errors} byte/s that did not match what was sent to it{Environment.NewLine}{String.Join(Environment.NewLine, rows)}");
                Assert.True(socket2Errors == 0,
                    $"Socket2 received {socket2Errors} byte/s that did not match what was sent to it{Environment.NewLine}{String.Join(Environment.NewLine, rows)}");
            }
            // eww, but does the job we need
            Assert.True(recvdBySocket1.Count > 5000, String.Format("Socket 1 received data count was less than 5000 : {0}", recvdBySocket1.Count));
            Assert.True(recvdBySocket2.Count > 5000, String.Format("Socket 2 received data count was less than 5000 : {0}", recvdBySocket2.Count));

            await socket1.DisconnectAsync();
            await socket2.DisconnectAsync();
        }
        public Task TcpSocketClient_Connect_ShouldCancelByCancellationToken()
        {
            var sut = new TcpSocketClient();
            
            var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
            var ct = cts.Token;

            // let's just hope no one's home :)
            return Assert.ThrowsAsync<OperationCanceledException>(()=> sut.ConnectAsync("99.99.99.99", 51234, cancellationToken: cts.Token));
        }
        [InlineData(1000)] // yes buffered stream
        public async Task TcpSocketClient_ShouldBeAbleToDisconnectThenReconnect(int bufferSize)
        {
            TcpSocketClient sut = null;

            var port = PortGranter.GrantPort();
            var listener = new TcpSocketListener();
            await listener.StartListeningAsync(port);

            if (bufferSize != -1)
                sut = new TcpSocketClient(bufferSize);
            else
                sut = new TcpSocketClient();

            await sut.ConnectAsync("127.0.0.1", port);
            await sut.DisconnectAsync();

            await sut.ConnectAsync("127.0.0.1", port); 
            await sut.DisconnectAsync();

            await listener.StopListeningAsync();
        }
 private static async Task SendAndReceiveAck(TcpSocketClient socket, uint sentAck, uint expectedAck)
 {
     await socket.WriteStream.WriteInt32Async((int)sentAck);
     await socket.WriteStream.FlushAsync();
     var ack = (uint)await socket.ReadStream.ReadInt32Async();
     if (ack != expectedAck)
         throw new SimpleSocketException("Invalid ack");
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="TcpConnection" /> class.
 /// </summary>
 /// <param name="useSsl">if set to <c>true</c> the connection is secured using SSL.</param>
 public TcpConnection(bool useSsl)
 {
     _isSecure = useSsl;
     _client = new TcpSocketClient();
 }
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="socket">Socket opened with the client</param>
 public MqttNetworkChannel(TcpSocketClient socket)
 {
     this.socket = socket;
     this.sslProtocol = MqttSslProtocols.None;
 }
 public void TcpSocketClient_Constructor_ShouldSucceed()
 {
     // just checking bait and switch is set up
     var socket = new TcpSocketClient();
     Assert.True(true);
 }
Beispiel #29
0
 private int ReadByte(TcpSocketClient client)
 {
     return Task.Run(() => client.ReadStream.ReadByte()).Result;
 }
        /// <summary>
        /// Connects to the Logentries API Server.
        /// </summary>
        public void Connect()
        {
            if (_useHttpPut)
            {
                _httpClient = new HttpClient();
            }
            else
            {
                _socketClient = new TcpSocketClient();

                var task = _socketClient.ConnectAsync(_url, _tcpPort, _useSsl);

                task.Wait(new TimeSpan(0, 0, 30));
            }
        }