public EndAcceptTcpClient ( IAsyncResult asyncResult ) : |
||
asyncResult | IAsyncResult | |
Результат |
public static void Main(string[] args) { Action<object> cw = Console.WriteLine; cw("* any"); cw(IPAddress.Any); cw(IPAddress.IPv6Any); cw("* loopback"); cw(IPAddress.Loopback); cw(IPAddress.IPv6Loopback); cw("* none"); cw(IPAddress.None); cw(IPAddress.IPv6None); cw("* bc4"); //trivia: there is no bc6, only multicast cw(IPAddress.Broadcast); TcpListener l = new TcpListener(IPAddress.Any, 7896); l.Start(); l.BeginAcceptTcpClient(ar => { var c = l.EndAcceptTcpClient(ar); l.Stop(); //var s = new StreamWriter(c.GetStream()); //s.WriteLine("test writer : needed"); //s.Flush(); var bs = System.Text.Encoding.UTF8.GetBytes("test direct : not needed"); c.GetStream().Write(bs, 0, bs.Length); c.Close(); }, l); //start client var q = new TcpClient("localhost", 7896); var qs = new StreamReader(q.GetStream()); Console.WriteLine(qs.ReadLine()); // l.Stop(); }
private void OnConnect(IAsyncResult ar) { SOCK.TcpClient newClient = null; try { newClient = m_tcpListener.EndAcceptTcpClient(ar); } catch (Exception) { } if (null != newClient) { System.Net.IPEndPoint newEp = (System.Net.IPEndPoint)newClient.Client.RemoteEndPoint; m_Settings.WriteMessageToLog( LogMessageType.Information + 1, string.Format(CultureInfo.CurrentUICulture, "Client {0}:{1} connected.", newEp.Address, newEp.Port) ); SipProxyServer sps = new SipProxyServer(newClient, m_Settings); sps.PipeDead += Proxy_PipeDead; m_ClientConnections.Add(newEp, sps); } m_tcpListener.BeginAcceptTcpClient(OnConnect, null); }
private void ThreadProc() { TcpListener listner = null; try { listner = new TcpListener(IPAddress.Any, _connectionString.Port); listner.Start(1); Thread clientThread = null; do { try { //_tcpClientConnected.Reset(); IAsyncResult aResult = listner.BeginAcceptTcpClient(null, null); int eventIndex = WaitHandle.WaitAny(new[] { _exit, aResult.AsyncWaitHandle }); if (eventIndex == 0) break; //using (TcpClient client = listner.EndAcceptTcpClient(aResult)) //{ // aResult.AsyncWaitHandle.Close(); // ReadInLoop(client); //} TcpClient client = listner.EndAcceptTcpClient(aResult); aResult.AsyncWaitHandle.Close(); if (_tcpClientConnected != null) _tcpClientConnected.Set(); else _tcpClientConnected = new AutoResetEvent(false); if (clientThread != null && clientThread.ThreadState == ThreadState.Running) clientThread.Join(); clientThread = new Thread(ReadInLoop) { IsBackground = true }; clientThread.Start(client); //_client = listner.EndAcceptTcpClient(aResult); //aResult.AsyncWaitHandle.Close(); //listner.Stop(); //_client.Client.ReceiveTimeout = ReceiveTimeout; //ReadInLoop(); } catch (Exception ex) { _log.WriteError(string.Format("TcpExternalSystemServer: {0}", ex)); Thread.Sleep(5000); } } while (!_exit.WaitOne(0)); listner.Stop(); } catch (Exception ex) { _log.WriteError(string.Format("TcpExternalSystemServer.ThreadProc:\n{0}",ex)); } finally { listner = null; } }
private void ConnectionAccepted(IAsyncResult ar) { if (!StopThread) { // Dim listener As TcpListener = CType(ar.AsyncState, TcpListener) TcpClient client = server.EndAcceptTcpClient(ar); byte[] bytes = new byte[1025]; // Get a stream object for reading and writing NetworkStream stream = client.GetStream(); int i = stream.Read(bytes, 0, bytes.Length); string header = "<html xmlns : msxsl = \"urn:schemas-Microsoft - com: xslt\" meta content=\"en-us\" http-equiv=\"Content-Language\" /> " + "<meta content=\"text/html; charset=utf-16\" http-equiv=\"Content-Type\" /> " + "<meta http-equiv=\"refresh\" content=\"" + m_RefreshTime.ToString() + "\"> "; header += "<img src=\"data:image/png;base64,"; byte[] b = System.Text.ASCIIEncoding.Default.GetBytes(header); stream.Write(b, 0, b.Length); byte[] Imgbytes = null; bmpScreenCapture = new Bitmap(m_SourceForm.Width, m_SourceForm.Height); m_SourceForm.Invoke(dcc); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { bmpScreenCapture.Save(ms, System.Drawing.Imaging.ImageFormat.Png); Imgbytes = ms.ToArray(); } string s = Convert.ToBase64String(Imgbytes); Imgbytes = System.Text.ASCIIEncoding.Default.GetBytes(s); try { stream.Write(Imgbytes, 0, Imgbytes.Length); string trailer = " \"/>"; b = System.Text.ASCIIEncoding.Default.GetBytes(trailer); stream.Write(b, 0, b.Length); // Shutdown and end connection client.Close(); } catch (Exception ex) { } } if (!StopThread) { server.BeginAcceptTcpClient(ConnectionAccepted, server); } }
/// <summary> /// Server's main loop implementation. /// </summary> /// <param name="log"> The Logger instance to be used.</param> public void Run(Logger log) { try { _srv = new TcpListener(IPAddress.Loopback, _portNumber); _srv.Start(); log.Start(); AsyncCallback callback = null; callback = delegate(IAsyncResult iar) { TcpClient socket = _srv.EndAcceptTcpClient(iar); log.LogMessage("Listener - Waiting for connection requests."); _srv.BeginAcceptTcpClient(callback, _srv); // Process the previous request try { socket.LingerState = new LingerOption(true, LingerTime); log.LogMessage(String.Format("Listener - Connection established with {0}.", socket.Client.RemoteEndPoint)); log.LogMessage(String.Format("Listener - Connection is going to last {0} seconds", LingerTime)); // Instantiating protocol handler and associate it to the current TCP connection Handler protocolHandler = new Handler(socket.GetStream(), log); // Synchronously process requests made through de current TCP connection protocolHandler.Run(); } catch (Exception e) { MessageBox.Show(e.Message); } ShowInfo(Store.Instance); }; log.LogMessage("Listener - Waiting for connection requests."); _srv.BeginAcceptTcpClient(callback, _srv); } catch (Exception) { log.LogMessage("Listener - Ending."); log.Stop(); _srv.Stop(); } }
internal ClientConnection(ServerView father, TcpClient textTcp, String password, ArrayList name) { this._father = father; this._textTcp = textTcp; ChallengeMessage auth = new ChallengeMessage(); auth.salt = new Random().Next().ToString(); auth.sendMe(textTcp.GetStream()); //mando il sale ResponseChallengeMessage respo = ResponseChallengeMessage.recvMe(textTcp.GetStream()); if (name.Contains(respo.username)) { //connessione fallita ConfigurationMessage fail = new ConfigurationMessage("Nome utente già utilizzato"); fail.sendMe(textTcp.GetStream()); throw new ClientConnectionFail("Un client ha fornito un nome utente già utilizzato"); } this._username = respo.username; if (Pds2Util.createPswMD5(password, auth.salt).Equals(respo.pswMd5)) { //creo le connessioni per i socket clipboard e video IPAddress localadd = ((IPEndPoint)textTcp.Client.LocalEndPoint).Address; TcpListener lvideo = new TcpListener(localadd, 0); lvideo.Start(); IAsyncResult videores = lvideo.BeginAcceptTcpClient(null, null); TcpListener lclip = new TcpListener(localadd, 0); lclip.Start(); IAsyncResult clipres = lclip.BeginAcceptTcpClient(null, null); int porta_video = ((IPEndPoint)lvideo.LocalEndpoint).Port; int clip_video = ((IPEndPoint)lclip.LocalEndpoint).Port; new ConfigurationMessage(porta_video, clip_video, "Benvenuto") .sendMe(textTcp.GetStream()); _clipTcp = lclip.EndAcceptTcpClient(clipres); _videoTcp = lvideo.EndAcceptTcpClient(videores); //now the client is connected _textReceiver = new Thread(_receiveText); _textReceiver.IsBackground = true; _textReceiver.Start(); _clipReceiver = new Thread(_receiveClipboard); _clipReceiver.IsBackground = true; _clipReceiver.Start(); } else { //connessione fallita ConfigurationMessage fail = new ConfigurationMessage("password sbagliata"); fail.sendMe(textTcp.GetStream()); throw new ClientConnectionFail("Un client ha fornito una password sbagliata"); } }
private void AcceptTcpClientTaskComplete(IAsyncResult ar) { try { if (ar.AsyncState is TcpListener tcp_listener) { var tcp_client = tcp_listener_.EndAcceptTcpClient(ar); /* 新しいクライアントの受け入れ */ if (tcp_client != null) { /* Buffer Size */ tcp_client.SendBufferSize = (int)devp_.SendBufferSize.Value; tcp_client.ReceiveBufferSize = (int)devp_.RecvBufferSize.Value; /* Reuse Address */ if (devp_.ReuseAddress.Value) { tcp_client.Client.SetSocketOption( (devp_.AddressFamily.Value == AddressFamilyType.IPv6) ? (SocketOptionLevel.IPv6) : (SocketOptionLevel.IP), SocketOptionName.ReuseAddress, true); } /* Keep Alive設定 */ if (devp_.KeepAliveOnOff.Value) { SocketIOControl( tcp_client.Client, IOControlCode.KeepAliveValues, (uint)((devp_.KeepAliveOnOff.Value) ? (1u) : (0u)), (uint)devp_.KeepAliveTime_Value.Value, (uint)devp_.KeepAliveInterval_Value.Value); } /* TTL設定 */ if (devp_.TTL_Unicast.Value) { tcp_client.Client.Ttl = (byte)devp_.TTL_Unicast_Value.Value; } /* クライアントリストへ追加 */ lock (tcp_clients_sync_) { tcp_clients_.Add(new TcpClientObject(this, tcp_client)); } } } } catch { } }
private void AcceptCallback(IAsyncResult iar) { try { System.Net.Sockets.TcpListener listener = (System.Net.Sockets.TcpListener)iar.AsyncState; _connector = listener.EndAcceptTcpClient(iar); _dataStream = _connector.GetStream(); StateObject receveieData = new StateObject(); receveieData.client = _connector; _dataStream.BeginRead(receveieData.buffer, 0, receveieData.buffer.Length, AcceptData, receveieData); _listener.BeginAcceptTcpClient(AcceptCallback, _listener); } catch (Exception ex) { SFLib.Logger.Exception(ex.Message); } }
private void Accept(IAsyncResult ar) { try { System.Net.Sockets.TcpListener server = (TcpListener)ar.AsyncState; TcpClient client = server.EndAcceptTcpClient(ar); Receive(client.Client); /* * BackgroundWorker backWorker = new BackgroundWorker(); * backWorker.WorkerReportsProgress = true; * backWorker.WorkerSupportsCancellation = true; * * backWorker.DoWork += this.backWorker_DoWork; * backWorker.ProgressChanged += this.backWorker_ProgressChanged; * backWorker.RunWorkerCompleted += this.backWorker_RunWorkerCompleted; * * backWorker.RunWorkerAsync(client); * _socketBackworkers.Add(backWorker);*/ } catch (Exception ex) { Console.WriteLine(ex.ToString()); error_text = ex.ToString(); } }
/// <summary> /// Comprueba si hay nuevos clientes para conectar /// </summary> private void ComprobarClienteConectado(IAsyncResult ar) { if (clientes == null) { clientes = new List <ClienteTCP>(); } if (AceptarNuevasConexiones) { try { ClienteTCP nuevoCliente = new ClienteTCP(listener.EndAcceptTcpClient(ar), "Servidor"); clientes.Add(nuevoCliente); nuevoCliente.DatosRecibidos += new DelegadoComandoRecibido(DatosClienteRecibidos); //Esperar más clientes listener.BeginAcceptTcpClient(new AsyncCallback(ComprobarClienteConectado), null); //Invocar el evento InvocarEvento(ClienteConectado, ControlInvoke, nuevoCliente, null); } catch { } } }
/// <summary> /// Server's main loop implementation. /// </summary> /// <param name="log"> The Logger instance to be used.</param> public Task<Boolean> Run(Logger log) { TcpListener srv = null; try { srv = new TcpListener(IPAddress.Loopback, portNumber); srv.Start(); ///////////////////////////////////////////////////////////////// /////////////////////////////APM///////////////////////////////// ///////////////////////////////////////////////////////////////// AsyncCallback onAccepted = null; onAccepted = delegate(IAsyncResult ar) { TcpClient socket = null; try { int timeout = (int)ar.AsyncState; if (timeout == 0) return; int time = Environment.TickCount; using (socket = srv.EndAcceptTcpClient(ar)) { if(Environment.TickCount - time > timeout) return; socket.LingerState = new LingerOption(true, 10); log.LogMessage(String.Format("Listener - Connection established with {0}.", socket.Client.RemoteEndPoint)); log.IncrementRequests(); // Instantiating protocol handler and associate it to the current TCP connection Handler protocolHandler = new Handler(socket.GetStream(), log); // Synchronously process requests made through de current TCP connection protocolHandler.Run(); srv.BeginAcceptTcpClient(onAccepted, null); } Program.ShowInfo(Store.Instance); } catch (SocketException) { Console.WriteLine("Socket error"); } catch (ObjectDisposedException) { } }; srv.BeginAcceptTcpClient(onAccepted, 20); Console.ReadLine(); return null; ////////////////////////////////////////////////////// ////////////////////////////////////////////////////// //while (true) //{ // log.LogMessage("Listener - Waiting for connection requests."); // using (TcpClient socket = srv.AcceptTcpClient()) // { // socket.LingerState = new LingerOption(true, 10); // log.LogMessage(String.Format("Listener - Connection established with {0}.", // socket.Client.RemoteEndPoint)); // // Instantiating protocol handler and associate it to the current TCP connection // Handler protocolHandler = new Handler(socket.GetStream(), log); // // Synchronously process requests made through de current TCP connection // protocolHandler.Run(); // } // Program.ShowInfo(Store.Instance); //} } finally { log.LogMessage("Listener - Ending."); srv.Stop(); } }
private void StartListening(TcpListener server) { if (_shouldStop) { return; } server.BeginAcceptTcpClient(new AsyncCallback(delegate(IAsyncResult result) { TcpClient client = null; try { client = server.EndAcceptTcpClient(result); } catch (Exception e) { LogManger.Error(e, this.GetType()); } if (client != null) { ThreadPool.QueueUserWorkItem(ClientReceiveMessage, client); } StartListening(server); }), server); }
public void TestAsyncBasic() { var listener = new TcpListener(IPAddress.Loopback, 0); listener.Start(5); var ep = (IPEndPoint)listener.LocalEndpoint; Console.WriteLine("Server> waiting for accept"); listener.BeginAcceptTcpClient((IAsyncResult ar) => { var client = listener.EndAcceptTcpClient(ar); var sslStream = new SslStream(client.GetStream(), false); Console.WriteLine("Server> authenticate"); sslStream.BeginAuthenticateAsServer(_ctx.ServerCertificate, async (ar2) => { sslStream.EndAuthenticateAsServer(ar2); Console.WriteLine("Server> CurrentCipher: {0}", sslStream.Ssl.CurrentCipher.Name); Assert.AreEqual("AES256-GCM-SHA384", sslStream.Ssl.CurrentCipher.Name); var buf = new byte[256]; await sslStream.ReadAsync(buf, 0, buf.Length); Assert.AreEqual(clientMessage.ToString(), buf.ToString()); await sslStream.WriteAsync(serverMessage, 0, serverMessage.Length); sslStream.Close(); client.Close(); Console.WriteLine("Server> done"); }, null); }, null); var evtDone = new AutoResetEvent(false); var tcp = new TcpClient(AddressFamily.InterNetwork); tcp.BeginConnect(ep.Address.ToString(), ep.Port, (IAsyncResult ar) => { tcp.EndConnect(ar); var sslStream = new SslStream(tcp.GetStream()); Console.WriteLine("Client> authenticate"); sslStream.BeginAuthenticateAsClient("localhost", async (ar2) => { sslStream.EndAuthenticateAsClient(ar2); Console.WriteLine("Client> CurrentCipher: {0}", sslStream.Ssl.CurrentCipher.Name); Assert.AreEqual("AES256-GCM-SHA384", sslStream.Ssl.CurrentCipher.Name); await sslStream.WriteAsync(clientMessage, 0, clientMessage.Length); var buf = new byte[256]; await sslStream.ReadAsync(buf, 0, buf.Length); Assert.AreEqual(serverMessage.ToString(), buf.ToString()); sslStream.Close(); tcp.Close(); Console.WriteLine("Client> done"); evtDone.Set(); }, null); }, null); evtDone.WaitOne(); }
static IEnumerator<Int32> Server(AsyncEnumerator ae, ServerState server) { var sleeper = new CountdownTimer(); var settings = server.settings; var ipe = new IPEndPoint(IPAddress.Parse(settings.addressforward), settings.portforward); var serverSock = new TcpListener(IPAddress.Parse(settings.addresslisten), settings.portlisten); serverSock.Start(20); Console.WriteLine("Server started"); Console.WriteLine("Listening on {0}:{1}", settings.addresslisten, settings.portlisten); Console.WriteLine("Forwarding to {0}:{1}", settings.addressforward, settings.portforward); while (true) { serverSock.BeginAcceptTcpClient(ae.End(), null); yield return 1; TcpClient local = null; try { local = serverSock.EndAcceptTcpClient(ae.DequeueAsyncResult()); local.NoDelay = true; local.LingerState.Enabled = false; } catch (SocketException) { Console.WriteLine("A client failed to connect"); } if(local != null) { // handle client var localAe = new AsyncEnumerator(); localAe.BeginExecute(ServerConnectRemote(localAe, server, ipe, local), localAe.EndExecute, localAe); } } }
private void EstablishConnection(int listenPort, CancellationToken token) { // listen and accept listener = new TcpListener(IPAddress.Any, listenPort); token.ThrowIfCancellationRequested(); TcpClient client; try { IsListening = true; listener.Start(); // can be refactored. extract a static method. var ar = listener.BeginAcceptTcpClient(null, null); WaitUntilCompleted(ar, NetworkPollingInterval, token); token.ThrowIfCancellationRequested(); client = listener.EndAcceptTcpClient(ar); } finally { listener.Stop(); IsListening = false; token.ThrowIfCancellationRequested(); } // get network stream. var ns = client.GetStream(); ns.ReadTimeout = NetworkTimeOut; ns.WriteTimeout = NetworkTimeOut; networkStream = ns; IsNetworkConnected = true; token.ThrowIfCancellationRequested(); }
private static WindowsIdentity LogonUserTCPListen(string userName, string domain, string password) { // need a full duplex stream - loopback is easiest way to get that TcpListener tcpListener = new TcpListener(IPAddress.Loopback, 0); tcpListener.Start(); ManualResetEvent done = new ManualResetEvent(false); WindowsIdentity id = null; tcpListener.BeginAcceptTcpClient(delegate(IAsyncResult asyncResult) { try { using (NegotiateStream serverSide = new NegotiateStream( tcpListener.EndAcceptTcpClient(asyncResult).GetStream())) { serverSide.AuthenticateAsServer(CredentialCache.DefaultNetworkCredentials, ProtectionLevel.None, TokenImpersonationLevel.Impersonation); id = (WindowsIdentity)serverSide.RemoteIdentity; } } catch { id = null; } finally { done.Set(); } }, null); using (NegotiateStream clientSide = new NegotiateStream(new TcpClient("localhost", ((IPEndPoint)tcpListener.LocalEndpoint).Port).GetStream())) { try { clientSide.AuthenticateAsClient(new NetworkCredential(userName, password, domain), "", ProtectionLevel.None, TokenImpersonationLevel.Impersonation); } catch { id = null; }//When the authentication fails it throws an exception } tcpListener.Stop(); done.WaitOne();//Wait until we really have the id populated to continue return id; }
public static void DoBeginAcceptTcpClient(TcpListener listener) { listener.BeginAcceptTcpClient(x => { var newClient = listener.EndAcceptTcpClient(x); string ipaddress = newClient.Client.RemoteEndPoint.ToString(); Console.WriteLine(ipaddress + " has connected."); DoBeginAcceptTcpClient(listener); new Thread(() => { string clientName = ipaddress; string _username = null; CommandContext _commandContext = null; TerminalApi _terminalApi; bool _appRunning = true; bool _passwordField = false; var stream = newClient.GetStream(); var streamReader = new StreamReader(stream); var streamWriter = new StreamWriter(stream); streamWriter.AutoFlush = true; streamWriter.WriteLine("Welcome to the U413 telnet server."); Action<string> invokeCommand = commandString => { var kernel = new StandardKernel(new U413Bindings(false)); _terminalApi = kernel.Get<TerminalApi>(); _terminalApi.Username = _username; _terminalApi.CommandContext = _commandContext; streamWriter.WriteLine("Loading..."); var commandResult = _terminalApi.ExecuteCommand(commandString); // Set the terminal API command context to the one returned in the result. _commandContext = commandResult.CommandContext; // If the result calls for the screen to be cleared, clear it. if (commandResult.ClearScreen) for (int count = 0; count <= 25; count++) streamWriter.WriteLine(); // Set the terminal API current user to the one returned in the result and display the username in the console title bar. _username = commandResult.CurrentUser != null ? commandResult.CurrentUser.Username : null; //Console.Title = commandResult.TerminalTitle; // Add a blank line to the console before displaying results. if (commandResult.Display.Count > 0) streamWriter.WriteLine(); // Iterate over the display collection and perform relevant display actions based on the type of the object. foreach (var displayItem in commandResult.Display) { if ((displayItem.DisplayMode & DisplayMode.Parse) != 0) displayItem.Text = U413.Domain.Utilities.BBCodeUtility.ConvertTagsForConsole(displayItem.Text); streamWriter.WriteLine(displayItem.Text); } streamWriter.WriteLine(); //if (!commandResult.EditText.IsNullOrEmpty()) // SendKeys.SendWait(commandResult.EditText.Replace("\n", "--")); // If the terminal is prompting for a password then set the global PasswordField bool to true. _passwordField = commandResult.PasswordField; // If the terminal is asking to be closed then kill the runtime loop for the console. _appRunning = !commandResult.Exit; }; invokeCommand("INITIALIZE"); streamWriter.Write("> "); while (!streamReader.EndOfStream) { var commandString = streamReader.ReadLine(); Console.WriteLine("{0}: {1}", (_username ?? clientName), commandString); invokeCommand(commandString); streamWriter.Write("> "); } }).Start(); }, null); }
private void AcceptClients() { try { this.listener = new TcpListener(IPAddress.Any, TcpClientReceivePort); this.listener.Start(); this.listener.BeginAcceptTcpClient((IAsyncResult ar)=> { try { var tcpClient = listener.EndAcceptTcpClient(ar); var client = new Client(this, tcpClient); this.AddClient(client); } catch (Exception ex) { MessageBox.Show(ex.Message); } }, null); } catch (Exception ex) { MessageBox.Show(ex.Message); } }
/// <summary> /// Handle an incoming connection /// </summary> private void HandleRecieve(IAsyncResult result, TcpListener listener) { // Print debug message waiting for data AppendDebugListMessage("Waiting for data."); // Interrupt this process once stop listenening is true if (StopListening) return; // Accept connection using (TcpClient client = listener.EndAcceptTcpClient(result)) { client.NoDelay = true; // Get the data stream ftom the tcp client using (NetworkStream stream = client.GetStream()) { using (StreamReader reader = new StreamReader(stream)) { using (StreamWriter writer = new StreamWriter(stream)) { writer.AutoFlush = true; // read data from sender string data = reader.ReadLine(); // write the line to the console Console.WriteLine(data); // Send the received data back to the sender // in Order to make sure we recieved the // right amount and correct data. writer.WriteLine(data); // Send our Categories, Families and Types to Grasshopper writer.WriteLine(FamiliesToRespond); // if there is some useful data if (data != null && data.Length > 5) { // Set the debugger message AppendDebugListMessage("Received " + data.Length + " Bytes."); // Deserialize the received data string Grevit.Types.ComponentCollection cc = StringToComponents(data); // If anything useful has been deserialized if (cc != null && cc.Items.Count > 0) { // Add Component collection to the client static component collection AddComponents(cc); // print another debug message about the component received AppendDebugListMessage("Translated " + cc.Items.Count.ToString() + " components."); // set stop listening switch StopListening = true; } } } } } } // If stop listening is set stop all listening processes if (StopListening) { // Stop the listener listener.Server.Close(); listener.Stop(); // Wait until processes are stopped Thread.Sleep(2000); // close the dialog automatically this.DialogResult = System.Windows.Forms.DialogResult.OK; this.Close(); } }
protected override StreamConnection DoConnect(Uri source) { TcpClient client = null; var bind_addr = GetBindAddress(source); if (bind_addr==null) { throw new BindErrorException(String.Format("Cannot resolve bind address: {0}", source.DnsSafeHost)); } var listener = new TcpListener(IPAddress.Any, 1935); try { listener.Start(1); Logger.Debug("Listening on {0}", bind_addr); var ar = listener.BeginAcceptTcpClient(null, null); WaitAndProcessEvents(ar.AsyncWaitHandle, stopped => { if (ar.IsCompleted) { client = listener.EndAcceptTcpClient(ar); } return null; }); Logger.Debug("Client accepted"); } catch (SocketException) { throw new BindErrorException(String.Format("Cannot bind address: {0}", bind_addr)); } finally { listener.Stop(); } if (client!=null) { this.client = client; return new StreamConnection(client.GetStream(), client.GetStream()); } else { return null; } }