private static async Task AcceptMany(TcpListener tcpListener, int howMany) { List<WeakReference<Task>> waitingFor = new List<WeakReference<Task>>(); for (int i = 1; howMany == 0 || i <= howMany; i++) { Console.WriteLine("Waiting for {0}", i); Stopwatch sw = new Stopwatch(); sw.Start(); var listener = await tcpListener.AcceptSocketAsync(); sw.Stop(); Console.WriteLine("Accepted {0} in {1} milliseconds", i, sw.ElapsedMilliseconds); //var workTask = WorkWith(i, listener); //if (!workTask.IsCompleted) waitingFor.Add(new WeakReference<Task>(workTask)); } Console.WriteLine("Maximum requests processed. Waiting for them to finish"); var toWaitFor = waitingFor.Select(x => { Task tsk; if (!x.TryGetTarget(out tsk)) { Console.WriteLine("Failed to get task"); } return tsk; }).Where(x => x != null && !x.IsCompleted); await Task.WhenAll(toWaitFor); }
protected async Task <Stream> AcceptStreamAsync(System.Net.Sockets.TcpListener listener) { try { LoggerHelper.Debug($"Accept stream on {listener.LocalEndpoint.ToString()}"); Socket = await listener.AcceptSocketAsync(); BaseStream = new NetworkStream(Socket); LastActivity = DateTime.Now; if (IsDataConnection) { if (Configuration.ShouldEncrypt && Configuration.EncryptionType == FtpEncryption.Explicit) { await ActivateEncryptionServerAsync(); } } else { if (Configuration.ShouldEncrypt && Configuration.EncryptionType == FtpEncryption.Implicit) { await ActivateEncryptionServerAsync(); } } return(this); } catch (Exception exception) { LoggerHelper.Error($"Could accept connect {listener.LocalEndpoint.ToString()} :{exception.ToString()}"); throw; } }
private async Task AcceptAsync(CancellationToken t) { Log.Information("{0}.{1}: Accepting connections...", this, nameof(AcceptAsync)); while (!t.IsCancellationRequested) { Socket socket = null; try { socket = await listener.AcceptSocketAsync(); var connection = EpoxyConnection.MakeServerConnection( parentTransport, this, serviceHost, socket); socket = null; // connection now owns the socket and will close it lock (connectionsLock) { connections.Add(connection); } await connection.StartAsync(); Log.Debug("{0}.{1}: Accepted connection from {2}.", this, nameof(AcceptAsync), connection.RemoteEndPoint); } catch (SocketException ex) { Log.Fatal(ex, "{0}.{1}: Accept failed with error {2}.", this, nameof(AcceptAsync), ex.SocketErrorCode); ShutdownSocketSafe(socket); } catch (ObjectDisposedException) { ShutdownSocketSafe(socket); // TODO: ignoring this exception is needed during shutdown, // but there should be a cleaner way. We should // switch to having a proper life-cycle for a // connection. } } Log.Information("{0}.{1}: Shutting down.", this, nameof(AcceptAsync)); }
private async Task AcceptAsync(CancellationToken t) { logger.Site().Information("Accepting connections on {0}", ListenEndpoint); while (!t.IsCancellationRequested) { Socket socket = null; try { socket = await listener.AcceptSocketAsync(); var connection = EpoxyConnection.MakeServerConnection( parentTransport, this, serviceHost, socket, logger, metrics); socket = null; // connection now owns the socket and will close it lock (connectionsLock) { connections.Add(connection); } await connection.StartAsync(); logger.Site().Debug("Accepted connection from {0}.", connection.RemoteEndPoint); } catch (SocketException ex) { logger.Site().Error(ex, "Accept failed with error {0}.", ex.SocketErrorCode); ShutdownSocketSafe(socket, logger); } catch (ObjectDisposedException) { ShutdownSocketSafe(socket, logger); // TODO: ignoring this exception is needed during shutdown, // but there should be a cleaner way. We should // switch to having a proper life-cycle for a // connection. } } logger.Site().Information("Shutting down connection on {0}", ListenEndpoint); }
private static async Task RespondToOneMsg(TcpListener listener) { var socket = await listener.AcceptSocketAsync(); var client = await listener.AcceptTcpClientAsync(); Console.WriteLine("Connected"); using (var stream = new NegotiateStream(client.GetStream())) { await stream.AuthenticateAsServerAsync(CredentialCache.DefaultNetworkCredentials, ProtectionLevel.EncryptAndSign, TokenImpersonationLevel.Identification); Console.WriteLine($"remote {stream.RemoteIdentity.AuthenticationType}"); Console.WriteLine($"remote name = {stream.RemoteIdentity.Name}"); var recvBuffer = new byte[1024]; var byteCount = stream.Read(recvBuffer, 0, recvBuffer.Length); Console.WriteLine(Encoding.UTF8.GetString(recvBuffer, 0, byteCount)); var sendBuffer = Encoding.UTF8.GetBytes("Reply from server"); stream.Write(sendBuffer, 0, sendBuffer.Length); } }
public void TcpSocket_maps_to_MessageFrameQueueWriter() { var port = TestHelpers.GetFreePort(); var server = new TcpListener(IPAddress.Loopback, port); server.Start(); server.AcceptSocketAsync(); using (var client = new TcpClient()) { client.Connect(IPAddress.Loopback, port); var socket = new TcpSocket(new RedFoxEndpoint(), client); var factory = new MessageFrameWriterFactory(); var writer = factory.CreateWriterFromSocket(socket); Assert.IsInstanceOf<MessageFrameStreamWriter>(writer); } }
/// <summary> /// TCP thread that listens for incoming connections. /// </summary> public static async void TcpListenerProcess() { Trace.WriteLine("TCP: Starting TcpListener..."); //IPAddress addr = IPAddress.Loopback; try { #if DEBUG const int port = 4032; var addr = new IPAddress(new byte[] { 192, 168, 1, 2 }); var listener = new TcpListener(addr, port); Trace.WriteLine(string.Format("TCP: Listening on {0}:{1}...", addr, port)); #else var listener = new TcpListener( RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["Endpoint1"].IPEndpoint); listener.ExclusiveAddressUse = false; #endif listener.Start(); while (true) { var socket = await listener.AcceptSocketAsync(); var newClient = new Client(socket); newClient.OnDisconnected += OnClientDisconnected; //WorkerRole.ClientManager.GlobalClientList.Add(newClient); newClient.ReceiveAsync(); } } catch (Exception e) { Trace.WriteLine(string.Format("TCP: Caught exception!! '{0}'\n{1}", e.Message, e.StackTrace)); Trace.WriteLine("TcpListener shutting down."); } }
void IProxyService.Start() { ProxyClients = new ConcurrentDictionary<IntPtr, Socket>(); new Thread(async t => { ProxyConnection = new TcpListener(IPAddress.Any, 3939); ProxyConnection.Start(); while (true) { var socket = await ProxyConnection.AcceptSocketAsync(); ProxyClients.Clear(); ProxyClients.TryAdd(socket.Handle, socket); var socketAsyncEventArgs = new SocketAsyncEventArgs(); byte[] buffer = new byte[8192]; socketAsyncEventArgs.SetBuffer(buffer, 0, buffer.Length); socketAsyncEventArgs.Completed += SocketAsyncEventArgs_Completed; socket.ReceiveAsync(socketAsyncEventArgs); } }).Start(); }
public void Start () { if (IsListening) return; if (!(Environment.GetEnvironmentVariable ("MONO_DEBUG")?.Contains ("disable_omit_fp") ?? false)) { MessageService.ShowWarning ("Set environment variable", $@"It is highly recommended to set environment variable ""MONO_DEBUG"" to ""disable_omit_fp"" and restart {BrandingService.ApplicationName} to have better results."); } IsListening = true; //start listening on random port listener = new TcpListener (IPAddress.Loopback, 0); listener.Start (); listener.AcceptSocketAsync ().ContinueWith (t => { if (!t.IsFaulted && !t.IsCanceled) { socket = t.Result; tcpLoopThread = new Thread (new ThreadStart (TcpLoop)); tcpLoopThread.IsBackground = true; tcpLoopThread.Start (); listener.Stop (); } }); //get random port provided by OS var port = ((IPEndPoint)listener.LocalEndpoint).Port; process = new Process (); process.StartInfo.FileName = "mono"; process.StartInfo.Arguments = $"{typeof (UIThreadMonitorDaemon.MainClass).Assembly.Location} {port} {Process.GetCurrentProcess ().Id}"; process.StartInfo.UseShellExecute = false; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.RedirectStandardError = true;//Ignore it, otherwise it goes to IDE logging process.Start (); process.StandardError.ReadLine (); dumpsReaderThread = new Thread (new ThreadStart (DumpsReader)); dumpsReaderThread.IsBackground = true; dumpsReaderThread.Start (); pumpErrorThread = new Thread (new ThreadStart (PumpErrorStream));//We need to read this... pumpErrorThread.IsBackground = true; pumpErrorThread.Start (); }
protected async Task ListenerAsync() { try { IPAddress ipAddress = IPAddress.Any; _listener = new TcpListener(ipAddress, _port); _listener.Start(); while (true) { using (Socket clientSocket = await _listener.AcceptSocketAsync()) { string message = GetRandomQuoteOfTheDay(); var encoder = new UnicodeEncoding(); byte[] buffer = encoder.GetBytes(message); clientSocket.Send(buffer, buffer.Length, 0); } } } catch (SocketException ex) { Trace.TraceError($"QuoteServer {ex.Message}"); throw new QuoteException("socket error", ex); } }
private static async Task<ProxyResult> StartAsync(TcpListener listener, bool requireAuth, bool expectCreds) { ProxyResult result = new ProxyResult(); var headers = new Dictionary<string, string>(); Socket clientSocket = null; Stream clientStream = null; StreamReader clientReader = null; string url = null; try { // Get and parse the incoming request. Func<Task> getAndReadRequest = async () => { clientSocket = await listener.AcceptSocketAsync().ConfigureAwait(false); clientStream = new NetworkStream(clientSocket, ownsSocket: false); clientReader = new StreamReader(clientStream, Encoding.ASCII); headers.Clear(); url = clientReader.ReadLine().Split(' ')[1]; string line; while (!string.IsNullOrEmpty(line = clientReader.ReadLine())) { string[] headerParts = line.Split(':'); headers.Add(headerParts[0].Trim(), headerParts[1].Trim()); } }; await getAndReadRequest().ConfigureAwait(false); // If we're expecting credentials, look for them, and if we didn't get them, send back // a 407 response. Optionally, process a new request that would expect credentials. if (requireAuth && !headers.ContainsKey("Proxy-Authorization")) { // Send back a 407 await clientSocket.SendAsync( new ArraySegment<byte>(Encoding.ASCII.GetBytes("HTTP/1.1 407 Proxy Auth Required\r\nProxy-Authenticate: Basic\r\n\r\n")), SocketFlags.None).ConfigureAwait(false); clientSocket.Shutdown(SocketShutdown.Send); clientSocket.Dispose(); if (expectCreds) { // Wait for a new connection that should have an auth header this time and parse it. await getAndReadRequest().ConfigureAwait(false); } else { // No credentials will be coming in a subsequent request. return default(ProxyResult); } } // Store any auth header we may have for later comparison. string authValue; if (headers.TryGetValue("Proxy-Authorization", out authValue)) { result.AuthenticationHeaderValue = Encoding.UTF8.GetString(Convert.FromBase64String(authValue.Substring("Basic ".Length))); } // Forward the request to the server. var request = new HttpRequestMessage(HttpMethod.Get, url); foreach (var header in headers) request.Headers.Add(header.Key, header.Value); using (HttpClient outboundClient = new HttpClient()) using (HttpResponseMessage response = await outboundClient.SendAsync(request).ConfigureAwait(false)) { // Transfer the response headers from the server to the client. var sb = new StringBuilder($"HTTP/{response.Version.ToString(2)} {(int)response.StatusCode} {response.ReasonPhrase}\r\n"); foreach (var header in response.Headers.Concat(response.Content.Headers)) { sb.Append($"{header.Key}: {string.Join(", ", header.Value)}\r\n"); } sb.Append("\r\n"); byte[] headerBytes = Encoding.ASCII.GetBytes(sb.ToString()); await clientStream.WriteAsync(headerBytes, 0, headerBytes.Length).ConfigureAwait(false); // Forward the content from the server, both to the client and to a memory stream which we'll use // to return the data from the proxy. var resultBody = new MemoryStream(); using (Stream responseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false)) { byte[] buffer = new byte[0x1000]; int bytesRead = 0; while ((bytesRead = responseStream.Read(buffer, 0, buffer.Length)) > 0) { await clientStream.WriteAsync(buffer, 0, bytesRead).ConfigureAwait(false); resultBody.Write(buffer, 0, bytesRead); } } // Return the result result.ResponseContent = resultBody.ToArray(); return result; } } finally { clientSocket.Dispose(); listener.Stop(); } }
public async Task <ITransport> AcceptConnection() { var socket = await _listener.AcceptSocketAsync(); return(new SocketTransport(socket, _socketSettings, _loggerFactory)); }
/// <summary> /// Returns a <see cref="HNode"/> that was intercepted on the specified port in an asynchronous operation. /// </summary> /// <param name="port">The port to listen to for local connection attempts.</param> /// <returns></returns> public static async Task<HNode> InterceptAsync(int port) { var listener = new TcpListener(IPAddress.Loopback, port); listener.Start(); var node = new HNode(await listener.AcceptSocketAsync()); listener.Stop(); return node; }
private async Task ListenAsync() { var listener = new TcpListener(IPAddress.Any, _configuration.ServerPort); listener.Start(); _log.InfoFormat("TCP listener started on port {0}", _configuration.ServerPort); try { while (true) { var acceptTask = listener.AcceptSocketAsync(); if (await Task.WhenAny(acceptTask, _cancelTaskCompletionSource.Task) != acceptTask) return; var socket = acceptTask.Result; _log.InfoFormat("Accepted connection from: {0}", socket.RemoteEndPoint); var task = Task.Run(async () => await ReceiveAsync(socket)); } } catch (Exception ex) { _log.Error("Error while listening for TCP clients", ex); } finally { listener.Stop(); _log.Info("TCP listener stopped"); } }
public static async Task<HNode> ListenAsync(int port) { var listener = new TcpListener(IPAddress.Any, port); try { listener.Start(); Socket client = await listener.AcceptSocketAsync() .ConfigureAwait(false); return new HNode(client); } finally { listener.Stop(); } }
// // Summary: // Begins an asynchronous operation to accept an incoming connection attempt. // // Parameters: // callback: // An System.AsyncCallback delegate that references the method to invoke when the // operation is complete. // // state: // A user-defined object containing information about the accept operation. This // object is passed to the callback delegate when the operation is complete. // // Returns: // An System.IAsyncResult that references the asynchronous creation of the System.Net.Sockets.Socket. // // Exceptions: // T:System.Net.Sockets.SocketException: // An error occurred while attempting to access the socket. See the Remarks section // for more information. // // T:System.ObjectDisposedException: // The System.Net.Sockets.Socket has been closed. public static IAsyncResult BeginAcceptSocket(this TcpListener listener, AsyncCallback callback, object state) { return(TaskToApm.Begin(listener.AcceptSocketAsync(), callback, state)); }
public static Task StartServer( TransferType transferType, TransferError transferError, out IPEndPoint serverEndPoint) { var server = new TcpListener(IPAddress.Loopback, 0); Task serverTask = ((Func<Task>)async delegate { server.Start(); using (var client = await server.AcceptSocketAsync()) using (var stream = new NetworkStream(client)) using (var reader = new StreamReader(stream, Encoding.ASCII)) { // Read past request headers. string line; while (!string.IsNullOrEmpty(line = reader.ReadLine())) ; // Determine response transfer headers. string transferHeader = null; string content = "This is some response content."; if (transferType == TransferType.ContentLength) { if (transferError == TransferError.ContentLengthTooLarge) { transferHeader = $"Content-Length: {content.Length + 42}\r\n"; } else { transferHeader = $"Content-Length: {content.Length}\r\n"; } } else if (transferType == TransferType.Chunked) { transferHeader = "Transfer-Encoding: chunked\r\n"; } // Write response. using (var writer = new StreamWriter(stream, Encoding.ASCII)) { writer.Write("HTTP/1.1 200 OK\r\n"); writer.Write($"Date: {DateTimeOffset.UtcNow:R}\r\n"); writer.Write("Content-Type: text/plain\r\n"); if (!string.IsNullOrEmpty(transferHeader)) { writer.Write(transferHeader); } writer.Write("\r\n"); if (transferType == TransferType.Chunked) { string chunkSizeInHex = string.Format( "{0:x}\r\n", content.Length + (transferError == TransferError.ChunkSizeTooLarge ? 42 : 0)); writer.Write(chunkSizeInHex); writer.Write($"{content}\r\n"); if (transferError != TransferError.MissingChunkTerminator) { writer.Write("0\r\n\r\n"); } } else { writer.Write($"{content}\r\n"); } writer.Flush(); } client.Shutdown(SocketShutdown.Both); } })(); serverEndPoint = (IPEndPoint)server.LocalEndpoint; return serverTask; }
public async Task <ISocket> AcceptSocket() { var socket = await _listener.AcceptSocketAsync(); return(new TcpSocket(socket, _socketSettings, _loggerFactory)); }
private void ListenThread(TcpListener serverSocket) { try { while (!m_StopEvent.WaitOne(0)) { #if DOTNET_CORE var task = serverSocket.AcceptSocketAsync(); task.Wait(); var clientSocket = task.Result; #else var clientSocket = serverSocket.AcceptSocket(); #endif if (clientSocket != null) { string sessionId = Guid.NewGuid().ToString("N"); Log("[{0}] : Accepted connection from client {1}", sessionId, clientSocket.RemoteEndPoint); SpawnThread("VsCodeDebugSession_" + sessionId, () => { using (var networkStream = new NetworkStream(clientSocket)) { try { RunSession(sessionId, networkStream); } catch (Exception ex) { Log("[{0}] : Error : {1}", ex.Message); } } #if DOTNET_CORE clientSocket.Dispose(); #else clientSocket.Close(); #endif Log("[{0}] : Client connection closed", sessionId); }); } } } catch (Exception e) { Log("Fatal error in listening thread : {0}", e.Message); } finally { if (serverSocket != null) serverSocket.Stop(); } }
private async void AcceptSocketAsync(TcpListener listener) { bool bRepeat = true; do { try { // End the operation and display the received data on // the console. Socket client = await listener.AcceptSocketAsync(); // Process the connection here. (Add the client to a // server table, read data, etc.) //Console.WriteLine("Client connected completed"); new CAHttpClient(this, client, listener); //new HttpClient(this, client, listener); bRepeat = false; } catch (SocketException excep) { Console.WriteLine("Accept tcp connection failed, error:"); Console.WriteLine(excep.Message); //listener.BeginAcceptSocket(OnAcceptNewClient, listener); } catch (Exception excep) { Console.WriteLine("Exception listener.AcceptSocketAsync()"); Console.WriteLine(excep.Message); bRepeat = false; } } while (bRepeat); }