public MobileTcpListener(MobileNetworkSettings settings, UsersService userService) { _settings = settings; _listener = new TcpSocketListener (); _userService = userService; _listener.ConnectionReceived = OnConnectionReceived; }
public TcpSocketListenerPage() { _listener = new TcpSocketListener(); _messagesSub = new Subject<Message>(); _messagesObs = _messagesSub.AsObservable(); _listener.ConnectionReceived += (sender, args) => { var client = args.SocketClient; Device.BeginInvokeOnMainThread(() => _clients.Add(client)); Task.Factory.StartNew(() => { foreach (var msg in client.ReadStrings(_canceller.Token)) { _messagesSub.OnNext(msg); } Device.BeginInvokeOnMainThread(()=> _clients.Remove(client)); }, TaskCreationOptions.LongRunning); }; InitView(); }
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 async Task StartServer(int port, bool singleConnection) { // Create TCP listener var listener = new TcpSocketListener(2048); listener.ConnectionReceived = async (sender, args) => { var clientSocketContext = new SimpleSocket(); try { // Stop listening if we accept only a single connection if (singleConnection) await listener.StopListeningAsync(); clientSocketContext.SetSocket((TcpSocketClient)args.SocketClient); // 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) await SendAndReceiveAck(clientSocketContext.socket, MagicAck, MagicAck); if (Connected != null) Connected(clientSocketContext); clientSocketContext.isConnected = true; } catch (Exception) { clientSocketContext.DisposeSocket(); } }; // Start listening await listener.StartListeningAsync(port); }
/// <inheritdoc/> public override async Task<FtpResponse> Process(FtpCommand command, CancellationToken cancellationToken) { if (Data.PassiveSocketClient != null) { await Data.PassiveSocketClient.DisconnectAsync(); Data.PassiveSocketClient.Dispose(); Data.PassiveSocketClient = null; } if (Data.TransferTypeCommandUsed != null && !string.Equals(command.Name, Data.TransferTypeCommandUsed, StringComparison.OrdinalIgnoreCase)) return new FtpResponse(500, $"Cannot use {command.Name} when {Data.TransferTypeCommandUsed} was used before."); int port; var isEpsv = string.Equals(command.Name, "EPSV", StringComparison.OrdinalIgnoreCase); if (isEpsv) { if (string.IsNullOrEmpty(command.Argument) || string.Equals(command.Argument, "ALL", StringComparison.OrdinalIgnoreCase)) { port = 0; } else { port = Convert.ToInt32(command.Argument, 10); } } else { port = 0; } Data.TransferTypeCommandUsed = command.Name; var sem = new SemaphoreSlim(0, 1); var listener = new TcpSocketListener(); listener.ConnectionReceived += (sender, args) => { Data.PassiveSocketClient = args.SocketClient; sem.Release(); }; await listener.StartListeningAsync(port); var localPort = listener.LocalPort; if (isEpsv || Server.ServerAddress.Contains(":")) { var listenerAddress = new Address(localPort); await Connection.WriteAsync(new FtpResponse(229, $"Entering Extended Passive Mode ({listenerAddress})."), cancellationToken); } else { var listenerAddress = new Address(Server.ServerAddress, localPort); await Connection.WriteAsync(new FtpResponse(227, $"Entering Passive Mode ({listenerAddress})."), cancellationToken); } await sem.WaitAsync(TimeSpan.FromSeconds(5), cancellationToken); await listener.StopListeningAsync(); listener.Dispose(); return null; }
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); }
public GWServerHttp(int serverPort = DefaultPort, IGWClient[] clients = null) { _listener = new TcpSocketListener(); _port = serverPort; if (clients != null) { foreach (IGWClient client in clients) _clients.Add(client.Name.ToLower(), client); } _listener.ConnectionReceived += (s, e) => ProcessRequestAsync(e.SocketClient); }
public Server() { this.IsMulticastConnected = false; this._receiver = new UdpSocketMulticastClient(); this._receiver.MessageReceived += MessageReceived; this._listener = new TcpSocketListener(); this._listener.ConnectionReceived += ListenerConnectionReceived; IsMulticastConnected = JoinMultiUdp(); if (!IsMulticastConnected) { var msg = new Message(MessageTypes.NetworkWarning, "Cannot connect to multicast UDP."); MessageManager.SendMessage(msg); } }
public async Task StartServer(int port, bool singleConnection, int retryCount = 1) { // Create TCP listener var listener = new TcpSocketListener(2048); listener.ConnectionReceived = async (sender, args) => { var clientSocketContext = new SimpleSocket(); try { // Stop listening if we accept only a single connection if (singleConnection) await listener.StopListeningAsync(); clientSocketContext.SetSocket((TcpSocketClient)args.SocketClient); // 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) await SendAndReceiveAck(clientSocketContext.socket, MagicAck, MagicAck); Connected?.Invoke(clientSocketContext); clientSocketContext.isConnected = true; } catch (Exception) { clientSocketContext.DisposeSocket(); } }; for (int i = 0; i < retryCount; ++i) { try { // Start listening await listener.StartListeningAsync(port); break; // Break if no exception, otherwise retry } catch (Exception) { // If there was an exception last try, propragate exception if (i == retryCount - 1) throw; } } }
public string revc_text(int length) { string result = ""; var listener = new TcpSocketListener(); listener.ConnectionReceived += async (sender, args) => { var _client = args.SocketClient; List<byte> all_byte = new List<byte>(); for (int i = 0; i < length; i++) { var nextByte = await Task.Run(() => client.ReadStream.ReadByte()); all_byte.Add((byte)nextByte); } result = (new System.Text.UTF8Encoding()).GetString(all_byte.ToArray(), 0, all_byte.Count); }; listener.StartListeningAsync(port[0]); return result; }
private async Task ExecuteServerListener(CancellationToken cancellationToken) { using (var listener = new TcpSocketListener(0)) { listener.ConnectionReceived = ConnectionReceived; await listener.StartListeningAsync(Port); try { for (; ;) { cancellationToken.ThrowIfCancellationRequested(); await Task.Delay(100, cancellationToken); } } finally { await listener.StopListeningAsync(); foreach (var connection in _connections.ToArray()) connection.Close(); } } }
async void loginButton_Clicked(object sender, EventArgs e) { StringBuilder sb = new StringBuilder("https://accounts.google.com/o/oauth2/auth"); // append query strings sb.Append("?"); sb.Append("scope=email%20profile&"); sb.Append("redirect_uri=http://localhost:" + LISTEN_PORT + "&"); sb.Append("response_type=code&"); sb.Append("client_id=" + APP_ID); Debug.WriteLine("url: " + sb.ToString()); webView.Source = sb.ToString(); webView.IsVisible = true; TcpSocketListener listener = new TcpSocketListener(); listener.ConnectionReceived += DidConnect; await listener.StartListeningAsync(LISTEN_PORT); //HttpClient mClient = new HttpClient //{ // BaseAddress = new Uri("https://accounts.google.com/o/oauth2/auth") //}; //http://stackoverflow.com/questions/17096201/build-query-string-for-system-net-httpclient-get }
[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(); }
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(); } }); var recv = Task.Run(async () => { var buf = new byte[1000]; while (!token.IsCancellationRequested) { await socket.ReadStream.ReadAsync(buf, 0, buf.Length, token); recvd.AddRange(buf); } }); return Task.WhenAll(send, recv); }; // let the sockets run for 2.5 seconds var cts = new CancellationTokenSource(); var timer = Task.Run(() => Task.Delay(TimeSpan.FromSeconds(2.5)).ContinueWith(t => cts.Cancel())); var socketRunners = Task.WhenAll( Task.Run(() => sendAndReceive(socket1, sentToSocket2, recvdBySocket1, cts.Token)), Task.Run(() => sendAndReceive(socket2, sentToSocket1, recvdBySocket2, cts.Token)) ); await timer; 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 socket1OK = Enumerable.Zip(sentToSocket1, recvdBySocket1, (s, r) => s == r) .All(b => b); var socket2OK = Enumerable.Zip(sentToSocket1, recvdBySocket1, (s, r) => s == r) .All(b => b); Assert.True(socket1OK, "Socket1 received data did not match what was sent to it"); Assert.True(socket2OK, "Socket2 received data did not match what was sent to it"); // 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 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 TcpListener(NetworkSettings settings) { _settings = settings; _listener = new TcpSocketListener(); }
private Task ExecuteServerListener(AutoResetEvent e) { return Task.Run(() => { _log = LogManager?.CreateLog(typeof(FtpServer)); using (var listener = new TcpSocketListener(0)) { listener.ConnectionReceived = ConnectionReceived; try { e.Reset(); listener.StartListeningAsync(Port).Wait(); _log?.Debug("Server listening on port {0}", Port); try { e.WaitOne(); } finally { listener.StopListeningAsync().Wait(); foreach (var connection in _connections.ToArray()) connection.Close(); } } catch (Exception ex) { _log?.Fatal(ex, "{0}", ex.Message); } } } ); }