public ServerContext(int port, int maxclients, ref List<string> TextStack, string OwnIP) { BeginSendUdpServerCallback = new AsyncCallback(OnBeginSendUdpServerCallbackFinished); ServerMessage = System.Text.Encoding.ASCII.GetBytes("OK:" + OwnIP); UdpServer = new UdpClient(new IPEndPoint(IPAddress.Any, 8011)); //da bei xp fehler UdpServer.JoinMulticastGroup(BroadcastServer.Address); UdpServer.BeginSend(ServerMessage, ServerMessage.Length, BroadcastServer, BeginSendUdpServerCallback, null); MaxClients = maxclients; Ip = IPAddress.Any; this.Port = port; listener = new TcpListener(Ip, Port); Clients = new List<ClientContext>(MaxClients); listener.Start(); BeginAcceptSocketCallback = new AsyncCallback(OnClientConnected); this.TextStack = TextStack; }
private void button2_Click(object sender, EventArgs e) { TcpListener serverSocket = new TcpListener(IPAddress.Any, 4955); TcpClient clientSocket = default(TcpClient); serverSocket.Start(); clientSocket = serverSocket.AcceptTcpClient(); try { NetworkStream networkStream = clientSocket.GetStream(); byte[] bytesFrom = new byte[10025]; networkStream.Read(bytesFrom, 0, (int)clientSocket.ReceiveBufferSize); string dataFromClient = System.Text.Encoding.ASCII.GetString(bytesFrom); dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf("$")); MessageBox.Show( dataFromClient); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } }
//Connect to the client public void connect() { if (!clientConnected) { IPAddress ipAddress = IPAddress.Any; TcpListener listener = new TcpListener(ipAddress, portSend); listener.Start(); Console.WriteLine("Server is running"); Console.WriteLine("Listening on port " + portSend); Console.WriteLine("Waiting for connections..."); while (!clientConnected) { s = listener.AcceptSocket(); s.SendBufferSize = 256000; Console.WriteLine("Connection accepted from " + s.RemoteEndPoint); byte[] b = new byte[65535]; int k = s.Receive(b); ASCIIEncoding enc = new ASCIIEncoding(); Console.WriteLine("Received:" + enc.GetString(b, 0, k) + ".."); //Ensure the client is who we want if (enc.GetString(b, 0, k) == "hello" || enc.GetString(b, 0, k) == "hellorcomplete") { clientConnected = true; Console.WriteLine(enc.GetString(b, 0, k)); } } } }
public void StartListening() { R = RowacCore.R; R.Log("[Listener] Starting TCP listener..."); TcpListener listener = new TcpListener(IPAddress.Any, 28165); listener.Start(); while (true) { try { var client = listener.AcceptSocket(); #if DEBUG R.Log("[Listener] Connection accepted."); #endif var childSocketThread = new Thread(() => { byte[] data = new byte[1048576]; // for screenshots and tasklists int size = 0; while (client.Available != 0) size += client.Receive(data, size, 256, SocketFlags.None); // TODO: increase reading rate from 256? client.Close(); string request = Encoding.ASCII.GetString(data, 0, size); #if DEBUG R.Log(string.Format("Received [{0}]: {1}", size, request)); #endif ParseRequest(request); }); childSocketThread.Start(); } catch (Exception ex) { R.LogEx("ListenerLoop", ex); } } }
public TcpServer(IPAddress ip, ushort port) { if (ip == null) throw new NullReferenceException("ip is null"); _listener = new TcpListener(ip, port); }
public async Task Start(IPAddress iP, int port) { tcpListener = new TcpListener(iP, port); connectedTcpClient = null; source = new CancellationTokenSource(); token = source.Token; tcpListener.Start(); EventHandler serverStartedHandler = ServerStarted; if (serverStartedHandler != null) { serverStartedHandler(this, null); } connectedTcpClient = await Task.Run(() => tcpListener.AcceptTcpClientAsync(), token); if (connectedTcpClient != null) { EventHandler clientConnectedHandler = ClientConnected; if (clientConnectedHandler != null) { clientConnectedHandler(this, null); } var c = new Thread(() => ServerReceive()); c.Start(); } }
//to get messages from server public void recieve() { TcpListener listner = new TcpListener(IPAddress.Parse(ip), portOut); while (true) { listner.Start(); TcpClient reciever = listner.AcceptTcpClient(); Stream r_stream = reciever.GetStream(); Byte[] bytes = new Byte[256]; int i; data = null; while ((i = r_stream.Read(bytes, 0, bytes.Length)) != 0) { data = System.Text.Encoding.ASCII.GetString(bytes, 0, i); } string[] lines = Regex.Split(data, ":"); com.Invoke(new Action(() => { eval.evaluate(data, com); com.displayData("\n msg => \n" + data + "\n"); })); r_stream.Close(); listner.Stop(); reciever.Close(); } }
static void Main(string[] args) { //string ipString = "127.0.0.1"; //System.Net.IPAddress ipAdd = System.Net.IPAddress.Parse(ipString); string host = "localhost"; System.Net.IPAddress ipAdd = System.Net.Dns.GetHostEntry(host).AddressList[0]; //Listenするポート番号 int port = 2001; //TcpListenerオブジェクトを作成する System.Net.Sockets.TcpListener listener = new System.Net.Sockets.TcpListener(ipAdd, port); //Listenを開始する listener.Start(); Console.WriteLine($"Debug server started. port:{port}"); TaskContext tc = new TaskContext(); while (true) { Console.WriteLine($"Waiting client"); TcpClient client = listener.AcceptTcpClient(); Console.WriteLine($"Client is connected"); ClientTask ct = new ClientTask(); ct.Start(tc, client); } }
public void CreateTcpListener() { TcpClient client = null; NetworkStream ns = null; System.IO.StreamReader sr = null; try { listener = new System.Net.Sockets.TcpListener(ipEndPoint); listener.Start(); while (true) { client = listener.AcceptTcpClient(); ns = client.GetStream(); sr = new System.IO.StreamReader(ns); while (client.Connected) { string data = sr.ReadLine(); if (data != null) { textBox1.AppendText(data + "\r\n"); } } } } catch (Exception error) { MessageBox.Show(error.ToString()); } }
public async void ListenAsync(string ip, int port) { if (Listening) { throw new Exception("Listening"); } Listening = true; server = new System.Net.Sockets.TcpListener(IPAddress.Parse(ip), port); server.Start(); ListeningStarted(this, server); Env.Print($"listening: {server.LocalEndpoint.ToString()}"); try { while (true) { Env.Print("waiting for a connection"); var client = await server.AcceptTcpClientAsync(); Env.Print("one incoming tcp connection"); var session = new TcpClientSession(client); NewSession.Invoke(this, session); TcpClientAccepted?.Invoke(this, session); session.Receive(); } } catch (Exception ex) { Env.Print(ex.Message); } }
/// <summary> /// Create an new Instance of the TCP-Listener on Port 5000 /// </summary> internal Server() { try { AnrlDB.AnrlDataContext db = new AnrlDB.AnrlDataContext(); if (!db.DatabaseExists()) { db.CreateDatabase(); } CalculateTabels = new System.Timers.Timer(20000); CalculateTabels.Elapsed += new ElapsedEventHandler(CalculateTabels_Elapsed); CalculateTabels.Start(); running = true; this.tcpListener = new TcpListener(IPAddress.Any, 5000); this.listenThread = new Thread(new ThreadStart(ListenForClients)); this.listenThread.Start(); db.Dispose(); } catch (Exception ex) { Logger.Log("Exception in Server.Server" + ex.ToString(), 11); } }
protected override EventResult OnConnectBusy() { var addr_family = (devp_.AddressFamily.Value == AddressFamilyType.IPv6) ? (AddressFamily.InterNetworkV6) : (AddressFamily.InterNetwork); try { /* ソケット生成 + バインド */ switch (devp_.LocalBindMode.Value) { case BindModeType.INADDR_ANY: local_ep_text_ = string.Format("INADDR_ANY:{0}", devp_.LocalPortNo.Value); tcp_listener_ = new TcpListener((addr_family == AddressFamily.InterNetworkV6) ? (IPAddress.IPv6Any) : (IPAddress.Any), (ushort)devp_.LocalPortNo.Value); break; case BindModeType.SelectAddress: /* 選択中のアドレスファミリと異なる設定の場合はエラー */ if (devp_.LocalIpAddress.Value.AddressFamily != addr_family) { return(EventResult.Error); } local_ep_text_ = string.Format("{0}:{1}", devp_.LocalIpAddress.Value, devp_.LocalPortNo.Value); tcp_listener_ = new TcpListener(devp_.LocalIpAddress.Value, (ushort)devp_.LocalPortNo.Value); break; } /* 待ち受け開始 */ tcp_listener_.Start((int)devp_.Capacity.Value); return(EventResult.Success); } catch { return(EventResult.Error); } }
public void Start() { // 01 Listen to the endpoint this.listener = new System.Net.Sockets.TcpListener(this.endpoint); try { this.listener.Stop(); this.listener.Start(); this.isRunning = true; } catch (System.Net.Sockets.SocketException) { Console.WriteLine($"Server says: Can not listen local:'{this.endpoint.Port}'. Quit."); var errorMessage = new Message(99, $"Server can not listen local:'{this.endpoint.Port}'."); return; } Console.WriteLine(); Console.WriteLine("------------------------------------------"); Console.WriteLine($"Server started at '{System.DateTime.Now}'"); Console.WriteLine("------------------------------------------"); Console.WriteLine(); // 02 (Loop)Receive the request and send response. while (this.IsRunning()) { using (var stream = this.listener.AcceptTcpClient().GetStream()) { this.ReadProcessWrite(stream); } } }
public LoopbackTcpStream(params byte[] initialStagedReadBytes) { var tcpListener = new SystemTcpListener(IPAddress.Loopback, 0); try { tcpListener.Start(); var clientSocket = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true }; clientSocket.Connect(tcpListener.LocalEndpoint); this._senderStream = new NetworkStream(clientSocket, true); var receiverSocket = tcpListener.AcceptSocket(); this._receiverStream = new NetworkStream(receiverSocket, true); this.LocalEndPoint = receiverSocket.LocalEndPoint; this.RemoteEndPoint = receiverSocket.RemoteEndPoint; this._writtenBytes = new BufferBlock <byte>(); } finally { tcpListener.Stop(); } if (initialStagedReadBytes != null) { this.StageReadBytes(initialStagedReadBytes); } }
public async Task Start(string remoteServerIp, ushort remoteServerPort, ushort localPort, string localIp) { //var clients = new ConcurrentDictionary<IPEndPoint, TcpClient>(); IPAddress localIpAddress = string.IsNullOrEmpty(localIp) ? IPAddress.IPv6Any : IPAddress.Parse(localIp); var server = new System.Net.Sockets.TcpListener(new IPEndPoint(localIpAddress, localPort)); server.Server.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, false); server.Start(); Console.WriteLine($"TCP proxy started {localPort} -> {remoteServerIp}|{remoteServerPort}"); while (true) { try { var remoteClient = await server.AcceptTcpClientAsync(); remoteClient.NoDelay = true; new TcpClient(remoteClient, new IPEndPoint(IPAddress.Parse(remoteServerIp), remoteServerPort)); } catch (Exception) { } } }
public void clientServerInit() { try { // Start server this.tcpserver = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Parse(this.networkConfig.ipAddress), this.networkConfig.port); this.tcpserver.Start(); // Start thread to listening for new clients this.clientListenerThread = new System.Threading.Thread(new System.Threading.ThreadStart(clientListener)); this.clientListenerThread.Start(); // Start thread to listening on removed clients //this.clientRemoverThread = new System.Threading.Thread(new System.Threading.ThreadStart(clientRemover)); // this.clientRemoverThread.Start(); if (this.statusChangedEvent != null) { this.statusChangedEvent(this.communicationName + ": Server started. Listening for Clients at Port - " + this.networkConfig.port); } } catch (System.Net.Sockets.SocketException ex) { Debug.Write("Error in clientServerInit: " + ex); } }
private ServerCore() { LoadConfig(); RegisterCommanders(); try { sqlConnecter = SqlConnector.Instance; } catch (Exception ex) { Console.WriteLine("Could not connect to Mysql: \"" + ex.Message + "\""); Console.WriteLine("Aborting. Press any key to exit"); Console.Read(); return; } idConnection = new Dictionary <UInt32, TcpClient>(); connectionWorker = new Dictionary <TcpClient, ClientWorker>(); connectionId = new Dictionary <TcpClient, UInt32>(); workers = new List <ClientWorker>(); TcpListener tcpListener = new System.Net.Sockets.TcpListener(IPAddress.Parse(ip), port); tcpListener.Start(); while (true) { TcpClient connection = tcpListener.AcceptTcpClient(); Console.WriteLine("Someone connected"); ClientWorker worker = new ClientWorker(connection); lock (mutex) { connectionWorker.Add(connection, worker); workers.Add(worker); } } }
public Form2(String hostPort, Form1 form1) { // // Required for Windows Form Designer support // InitializeComponent(); // // TODO: Add any constructor code after InitializeComponent call // dataReadyToSend = new AutoResetEvent(false); refToForm1 = form1; // Resolve the local host. IPHostEntry localHost = Dns.Resolve(Dns.GetHostName()); // Create a local end point for listening. IPEndPoint localEndPoint = new IPEndPoint(localHost.AddressList[0], 4001); // Instantiate the TCP Listener. tcpListener = new TcpListener(localEndPoint); tcpListener.Start(); tcp = tcpListener.AcceptTcpClient(); ethernetThreadStart = new ThreadStart(this.ThreadProcPollOnEthernet); pollDevicesEthernetThread = new Thread(ethernetThreadStart); pollDevicesEthernetThread.Name = "Listener's Receive Thread"; pollDevicesEthernetThread.ApartmentState = System.Threading.ApartmentState.MTA; pollDevicesEthernetThread.Start(); }
public void ModbusTcpSlave_ConnectionClosesGracefully() { TcpListener slaveListener = new TcpListener(ModbusMasterFixture.TcpHost, ModbusMasterFixture.Port); slaveListener.Start(); ModbusTcpSlave slave = ModbusTcpSlave.CreateTcp(ModbusMasterFixture.SlaveAddress, slaveListener); Thread slaveThread = new Thread(slave.Listen); slaveThread.IsBackground = true; slaveThread.Start(); using (TcpClient masterClient = new TcpClient(ModbusMasterFixture.TcpHost.ToString(), ModbusMasterFixture.Port)) { ModbusIpMaster master = ModbusIpMaster.CreateIp(masterClient); master.Transport.Retries = 0; bool[] coils = master.ReadCoils(1, 1); Assert.AreEqual(1, coils.Length); Assert.AreEqual(1, slave.Masters.Count); } // give the slave some time to remove the master Thread.Sleep(50); Assert.AreEqual(0, slave.Masters.Count); slaveListener.Stop(); }
public override void Initialize(NetworkPackageGenerator packageGenerator, TcpInitInfo initInfo) { _tcpListener = new System.Net.Sockets.TcpListener(IPAddress.Parse(initInfo.IpAddress), initInfo.Port); _packageGenerator = packageGenerator; IpAddresses = initInfo.IpAddress; Port = initInfo.Port; }
/// <summary> /// Constructor of the TCP service object /// </summary> /// <param name="port">TCP port number</param> public TCPService(int port) { TcpListener tempTCPListener; tempTCPListener = new TcpListener(System.Net.Dns.GetHostAddresses(System.Net.Dns.GetHostName())[0], port); tempTCPListener.Start(); serverSocket = tempTCPListener; // serverSocket.setReuseAddress(true); // serverSocket.setLoopbackMode(false); // true *disables* loopback acceptThread = new Thread(AcceptThreadRun); acceptThread.IsBackground = true; acceptThread.Start(); long inittime = DateTime.Now.Ticks / 10000; long starttime = DateTime.Now.Ticks / 10000; while (true) { try { System.Threading.Thread.Sleep(1000); } catch (System.Threading.ThreadInterruptedException) { } long endtime = System.DateTime.Now.Ticks / 10000; double dt = (endtime - starttime) / 1000.0; starttime = endtime; Console.WriteLine("{0,10:N} : {1,10:N} kB/s, {2:D} clients", (endtime - inittime) / 1000.0, bytesCount / 1024.0 / dt, clients.Count); bytesCount = 0; } }
/// <summary> /// Starts accepting connections. /// </summary> public void Start() { if (disposed) { throw new ObjectDisposedException(this.ToString()); } // This is equivalent to the behavior of TcpListener.Create in .NET 4.5. listener = new Net.TcpListener(IPAddress.Any, port); //listener.Server.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, 0); listener.Start(); listenerSubscription = Observable .FromAsync(() => listener.AcceptTcpClientAsync()) .Repeat() .Select(client => new ReactiveSocket(client)) .Subscribe(socket => { connections.Add(socket); observable.OnNext(socket); IDisposable disposeSubscription = Observable.FromEventPattern <EventHandler, EventArgs>( h => socket.Disposed += h, h => socket.Disposed -= h) .FirstAsync().Subscribe(x => { connections.Remove(socket); }); this.socketDisposable.Add(disposeSubscription); }); }
public Servidor() { Console.WriteLine ("Iniciando servidor"); ipAddress = Dns.GetHostEntry("localhost").AddressList[0]; listener = new TcpListener (ipAddress, porta); listener.Start (); }
/// <summary> /// Starts listening for clients /// </summary> /// <param name="ipAddress">The IP address to use</param> /// <param name="port">The port on which to listen</param> public void Start(IPAddress ipAddress, int port) { _server = new TcpListener(ipAddress, port); _server.Start(); _listenProc = W.Threading.Thread.Create(ListenForClientsProc, ListenForClientsProc_OnComplete); IsListening = true; }
public TCPListener(int _portNumber, IMessageProcessor _messageProcessor) { PortNumber = _portNumber; MessageProcessor = _messageProcessor; tcpListener = new TcpListener(IPAddress.Any, PortNumber); }
private void ListenForClients() { tcplistener = new TcpListener(IPAddress.Loopback, int.Parse(ConfigurationManager.AppSettings["port"])); tcplistener.Start(); try { while (true) { //blocks until a client has connected to the server TcpClient client = tcplistener.AcceptTcpClient(); // here was first an message that send hello client // /////////////////////////////////////////////////// //create a thread to handle communication //with connected client Thread clientThread = new Thread(new ParameterizedThreadStart(HandleClientComm)); clientThread.Start(client); } } catch (SocketException e) { if ((e.SocketErrorCode == SocketError.Interrupted)) { } } }
public const int MAX_PORT = 65535; // highest port allocatable /// <summary>Finds first available port starting at start_port and returns server socket </summary> public static System.Net.Sockets.TcpListener createServerSocket(int start_port) { System.Net.Sockets.TcpListener ret = null; while (true) { try { System.Net.Sockets.TcpListener temp_tcpListener; temp_tcpListener = new System.Net.Sockets.TcpListener(start_port); temp_tcpListener.Start(); ret = temp_tcpListener; } catch (System.Net.Sockets.SocketException bind_ex) { start_port++; continue; } catch (System.IO.IOException io_ex) { } break; } return(ret); }
public void StartServer() { if (m_SourceForm == null) { m_SynchronizingObject = m_SourceForm; } //* Find the IPV4 address of this computer string LocalComputerName = System.Net.Dns.GetHostName(); //* same as My.Computer.Name System.Net.IPAddress localAddr = GetIPv4Address(LocalComputerName); if (localAddr == null) { localAddr = System.Net.IPAddress.Parse("127.0.0.1"); } try { server = new TcpListener(localAddr, m_TCPPort); server.Start(); server.BeginAcceptTcpClient(ConnectionAccepted, server); } catch (SocketException e) { Console.WriteLine("SocketException: {0}", e); } }
// constructeur public FormServeur() { InitializeComponent(); Joueur1 = new Joueur(panelFond, new Point(100, 100),true); Joueur2 = new Joueur(panelFond, new Point(100, 150),false); // Cette fois les joueurs sont clairements labelScoreJ1.Text = "0"; labelScoreJ2.Text = "0"; // L'interface n'est plus la même non plus, on dédouble tout. pBChargeJ1.Maximum = 1000; pBChargeJ1.Minimum = 0; pBChargeJ2.Maximum = 1000; pBChargeJ2.Minimum = 0; try { IPAddress ipAd = IPAddress.Parse("127.0.0.1"); //on utilise l'adresse ip locale myList = new TcpListener(ipAd, 8001); //initialisation du listener myList.Start(); // on écoute sur le port Console.WriteLine("The server is running at port 8001..."); Console.WriteLine("The local End point is :" + myList.LocalEndpoint); // Ces trois lignes ci ne servent qu'a controler via la console ce qui se passe. Console.WriteLine("Waiting for a connection....."); cl = myList.AcceptTcpClient(); // dés qu'il y a une connection on peut passer a la suite Console.WriteLine("Connection accepted from " + cl.Client.RemoteEndPoint); stm = cl.GetStream(); // le flux de données est créé } catch (Exception e) { Console.WriteLine("Error..... " + e.StackTrace); Console.ReadLine(); } th1 = new Thread(Launch); // on lance le thread qui va lire le flux th1.Name = "Serveur"; th1.Start(); }
private void startServer() { try { server = new TcpListener(IPAddress.Any, 8888); server.Start(); stopBtn.Enabled = true; startBtn.Enabled = false; txtReceive.AppendText(">> Waiting For Connection...\n"); if (InvokeRequired) { this.Invoke(new Action(() => AcceptClients())); return; } AcceptClients(); STR = new StreamReader(client.GetStream()); STW = new StreamWriter(client.GetStream()); STW.AutoFlush = true; txtReceive.AppendText("\n**Connection Established**\n"); txtReceive.AppendText("==========\n"); receivingWorker.RunWorkerAsync(); sendingWorker.WorkerSupportsCancellation = true; receivingWorker.WorkerSupportsCancellation = true; } catch (Exception ex) { MessageBox.Show(ex.ToString()); } }
public int FindFreePort(int startingPort) { Exception lastException = null; for (int i = startingPort; i < 65535; i++) { try { var listener = new TcpListener(IPAddress.Loopback, i); listener.Start(); listener.Stop(); logger.Debug("Found free port: {0}", i); return i; } catch (SocketException e) { if (e.SocketErrorCode == SocketError.AddressAlreadyInUse) lastException = e; else throw; } } throw lastException; }
private void ListenForClients(object olistener) { System.Net.Sockets.TcpListener listener = olistener as System.Net.Sockets.TcpListener; listener.Start(); while (!_cancelToken.IsCancellationRequested && !_shutdown) { try { //blocks until a client has connected to the server TcpClient client = listener.AcceptTcpClient(); // Wait for a client, spin up a thread. var clientThread = new Thread(new ParameterizedThreadStart(HandleNewClient)); clientThread.Start(client); } catch (SocketException ex) { if (ex.SocketErrorCode == SocketError.Interrupted) { break; } } } }
public static async Task AcceptClientsAsync(TcpListener listener, CancellationToken cancel) { await Task.Yield(); while (!cancel.IsCancellationRequested) { try { var timeoutTask = Task.Delay(2000); var acceptTask = listener.AcceptTcpClientAsync(); await Task.WhenAny(timeoutTask, acceptTask); if (!acceptTask.IsCompleted) continue; var client = await acceptTask; HandleClientAsync(client, cancel); } catch (Exception aex) { var ex = aex.GetBaseException(); Console.WriteLine("Accepting error: " + ex.Message); } } }
public PcapTcpStream(ushort localTcpPort, bool useSsl, int idleTimeoutMilliSeconds) : this(useSsl, idleTimeoutMilliSeconds) { this.socketState = TcpSocketState.Closed; this.tcpListener = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Any, (int)localTcpPort); tcpListener.Start(); this.socketState = TcpSocketState.Listening; }
static void BackupProcess() { Console.WriteLine("I am backup!"); IPAddress ipAddress = Dns.GetHostEntry("localhost").AddressList[0]; TcpListener listener = new TcpListener(ipAddress, port); listener.Start(); Socket sock = listener.AcceptSocket(); Stream str = new NetworkStream(sock); StreamReader sr = new StreamReader(str); string line = "-1"; try { while (true) line = sr.ReadLine(); } catch(IOException) { sr.Close(); listener.Stop(); PrimaryProcess(Convert.ToInt32(line) + 1); } }
private static readonly String s_newline = Environment.NewLine; //$NON-NLS-1$ public PlayerSessionManager() { m_debuggerCallbacks = new DefaultDebuggerCallbacks(); m_serverSocket = null; m_prefs = new System.Collections.Hashtable(); // manager setPreference(SessionManager.PREF_ACCEPT_TIMEOUT, 120000); // 2 minutes setPreference(SessionManager.PREF_URI_MODIFICATION, 1); // session // response to requests setPreference(SessionManager.PREF_RESPONSE_TIMEOUT, 750); // 0.75s setPreference(SessionManager.PREF_CONTEXT_RESPONSE_TIMEOUT, 1000); // 1s setPreference(SessionManager.PREF_GETVAR_RESPONSE_TIMEOUT, 1500); // 1.5s setPreference(SessionManager.PREF_SETVAR_RESPONSE_TIMEOUT, 5000); // 5s setPreference(SessionManager.PREF_SWFSWD_LOAD_TIMEOUT, 5000); // 5s // wait for a suspend to occur after a halt setPreference(SessionManager.PREF_SUSPEND_WAIT, 7000); // invoke getters by default setPreference(SessionManager.PREF_INVOKE_GETTERS, 1); // hierarchical variables view setPreference(SessionManager.PREF_HIERARCHICAL_VARIABLES, 0); }
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(); } }
public HttpServer(int port) { prefixes.TryAdd( "/favicon.ico", new StaticHandler( new ResourceResponse(HttpCode.Ok, "image/icon", "favicon")) ); prefixes.TryAdd( "/static/browse.css", new StaticHandler( new ResourceResponse(HttpCode.Ok, "text/css", "browse_css")) ); RegisterHandler(new IconHandler()); listener = new TcpListener(new IPEndPoint(IPAddress.Any, port)); listener.Server.Ttl = 32; listener.Server.UseOnlyOverlappedIO = true; listener.Start(); RealPort = (listener.LocalEndpoint as IPEndPoint).Port; NoticeFormat( "Running HTTP Server: {0} on port {1}", Signature, RealPort); ssdpServer = new SsdpHandler(); timeouter.Elapsed += TimeouterCallback; timeouter.Enabled = true; Accept(); }
private bool startListen() { try { if (tcpListener == null) tcpListener = new TcpListener(IPAddress.Any, tcpPort); if (udpClient == null || udpClosed) { udpClient = new UdpClient(udpPort); //udpClient = new UdpClient(udpPort, AddressFamily.InterNetwork); udpClosed = false; } if (udpListenThread == null || !udpListenThread.IsAlive) { udpListenThread = new Thread(new ThreadStart(listenForUdpClients)); udpListenThread.IsBackground = true; udpListenThread.Start(); } if (tcpListenThread == null || !tcpListenThread.IsAlive) { tcpListenThread = new Thread(new ThreadStart(listenForTcpClients)); tcpListenThread.IsBackground = true; tcpListenThread.Start(); } Trace.WriteLine("Server started on TCP-Port: " + tcpPort + " and UDP-Port: " + udpPort); return true; } catch { Trace.WriteLine("Couldn't start server on Tcp-Port: " + tcpPort + " and Udp-Port: " + udpPort); return false; } }
public void Start(int port) { _keepRunning = true; _tcpListener = new TcpListener(IPAddress.Any, port); _listenThread = new Thread(ListenForConnections); _listenThread.Start(); }
// starts up the listener thread and heartbeat public bool Start() { bool worked = false; int attempts = 0; int attemptsMax = 20; int port = world.config.GetInt( "Port" ); do { try { listener = new TcpListener( IPAddress.Any, port ); listener.Start(); worked = true; } catch( Exception ex ) { world.log.Log( "Could not start listening on port {0}, trying next port. ({1})", LogType.Error, port, ex.Message ); port++; attempts++; } } while( !worked && attempts < attemptsMax ); if( !worked ) { world.log.Log( "Could not start listening after {0} tries. Giving up!", LogType.FatalError, attemptsMax ); return false; } sessions = new List<Session>(); world.log.Log( "Server.Run: now accepting connections at port {0}.", LogType.Debug, port ); return true; }
static private void ListenHandler() { var myIP = Communication.GetLocalIP(); var epLocal = new System.Net.IPEndPoint(myIP, TCPPort); var tcpListener = new System.Net.Sockets.TcpListener(epLocal); tcpListener.Start(); while (IsListening) { System.Threading.Thread.Sleep(1000); if (tcpListener.Pending()) { var tcpClient = tcpListener.AcceptTcpClient(); var netStream = tcpClient.GetStream(); var buffer = new byte[1024]; if (!netStream.DataAvailable) { continue; } List <byte> bufferTotal = new List <byte>(); while (netStream.DataAvailable) { netStream.Read(buffer, 0, 1024); bufferTotal.AddRange(buffer); } tcpClient.Close(); netStream.Close(); var receive = System.Text.Encoding.UTF8.GetString(bufferTotal.ToArray()); Owner.Invoke(DgGetMsg, receive); } } tcpListener.Stop(); }
public void Start() { _stop = false; _listener = new TcpListener(IPAddress.Any, _port); _listener.Start(); _listener.BeginAcceptSocket(OnAcceptSocket, null); }
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; } }
public override void Initiate() { base.Initiate(); Console.WriteLine("Web communicator"); Console.Write("Starting socket..."); try { server = new TcpListener(IPAddress.Any, portNumber); server.Start(); } catch { Program.Shutdown("Server Startup Failed"); return; } Console.WriteLine("Done"); while (Program.Update) { TcpClient newClient = server.AcceptTcpClient(); ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessClient), newClient); } }
public void FTP_Receive(string filename) { try { System.Net.IPAddress localAdd = System.Net.IPAddress.Parse(ips.AddressList[0].ToString()); System.Net.Sockets.TcpListener listener = new System.Net.Sockets.TcpListener(localAdd, FTPPORTNO); listener.Start(); TcpClient tcpClient = listener.AcceptTcpClient(); NetworkStream nws = tcpClient.GetStream(); if (File.Exists("c:\\temp\\" + filename)) { File.Delete("c:\\temp\\" + filename); } fs = new System.IO.FileStream("c:\\temp\\" + filename, FileMode.Append, FileAccess.Write); int counter = 0; int totalBytes = 0; do { int bytesRead = nws.Read(data, 0, tcpClient.ReceiveBufferSize); totalBytes += bytesRead; fs.Write(data, 0, bytesRead); ToolStripStatusLabel1.Text = "Receiving " + totalBytes + " bytes...."; Application.DoEvents(); counter += 1; } while (!(!(nws.DataAvailable))); ToolStripStatusLabel1.Text = "Receiving " + totalBytes + " bytes....Done."; fs.Close(); tcpClient.Close(); listener.Stop(); } catch (Exception ex) { MessageBox.Show(ex.ToString()); } }
public ServerBase(string ip, int port) { var bindIP = IPAddress.None; if (!IPAddress.TryParse(ip, out bindIP)) { Log.Normal($"Server can't be started: Invalid IP-Address ({ip})"); Console.ReadKey(true); Environment.Exit(0); } try { listener = new TcpListener(bindIP, port); listener.Start(); if (isRunning = listener.Server.IsBound) new Thread(AcceptConnection).Start(200); } catch (Exception ex) { ExceptionLog.Write(ex); Log.Error(ex.Message); } }
void HandleThreadStart() { try { TCL = new System.Net.Sockets.TcpListener(new System.Net.IPEndPoint(System.Net.IPAddress.Any, 10112)); TCL.Start(); do { try { System.Net.Sockets.Socket S = TCL.AcceptSocket(); FeuerwehrCloud.Helper.Logger.WriteLine("| < [FAX] *** Incoming notification"); S.Blocking = false; S.BeginReceive(buffer, 0, DEFAULT_SIZE - dataRecieved, System.Net.Sockets.SocketFlags.None, new AsyncCallback(HandleAsyncCallback), S); if (IsTerminating) { break; } } catch (Exception e2x) { } } while (true); } catch (Exception ex) { if (ex.Message.Contains("already in use")) { FeuerwehrCloud.Helper.Logger.WriteLine("Kann FeuerwehrCloud-Server FaxModul nicht starten!"); } } }
public const int MAX_PORT = 65535; // highest port allocatable /// <summary>Finds first available port starting at start_port and returns server socket </summary> public static System.Net.Sockets.TcpListener createServerSocket(int start_port) { System.Net.Sockets.TcpListener ret = null; while (true) { try { System.Net.Sockets.TcpListener temp_tcpListener; temp_tcpListener = new System.Net.Sockets.TcpListener(start_port); temp_tcpListener.Start(); ret = temp_tcpListener; } catch (System.Net.Sockets.SocketException bind_ex) { //Trace.error("util.createServerSocket()",bind_ex.Message); start_port++; continue; } catch (System.IO.IOException io_ex) { //Trace.error("Util.createServerSocket():2" + io_ex.Message); } break; } return(ret); }
public HtmlGetServer(int Port, TcpListener listener) { Listener = listener; if (Listener==null) Listener = new TcpListener(IPAddress.Any, Port); Listener.Start(); while (true) { try { ThreadPool.QueueUserWorkItem(new WaitCallback(ClientThread), Listener.AcceptTcpClient()); } catch { } // Принимаем новых клиентов. После того, как клиент был принят, он передается в новый поток (ClientThread) // с использованием пула потоков. /* // Принимаем нового клиента TcpClient Client = Listener.AcceptTcpClient(); // Создаем поток Thread Thread = new Thread(new ParameterizedThreadStart(ClientThread)); // И запускаем этот поток, передавая ему принятого клиента Thread.Start(Client); */ } }
private void StartListen2() { //Create an instance of TcpListener to listen for TCP connection. var tcpListener = new TcpListener(SampleTcpPort); try { while (true) { tcpListener.Start(); //Program blocks on Accept() until a client connects. Socket soTcp = tcpListener.AcceptSocket(); Console.Message = ("SampleClient is connected through TCP."); OnChanged(EventArgs.Empty); var received = new Byte[512]; soTcp.Receive(received, received.Length, 0); String dataReceived = System.Text.Encoding.ASCII.GetString(received); Console.Message=(dataReceived); String returningString = "The Server got your message through TCP: " + dataReceived; OnChanged(EventArgs.Empty); Byte[] returningByte = System.Text.Encoding.ASCII.GetBytes (returningString.ToCharArray()); //Returning a confirmation string back to the client. soTcp.Send(returningByte, returningByte.Length, 0); } } catch (SocketException se) { Console.Message = ("A Socket Exception has occurred!" + se); OnChanged(EventArgs.Empty); } }
public TCPServer(int port) { listener = new TcpListener(IPAddress.Any, port); player = new AI(this); listener.Start(); Start(); }
public static void InitalizeListener(int port) { _listener = new System.Net.Sockets.TcpListener(_ip, port); _listener.Start(); System.Threading.Timer _t = new System.Threading.Timer(Listen, null, 0, 100); }
public async Task Start(string remoteServerIp, ushort remoteServerPort, ushort localPort, string localIp, byte[] byteMapClient2Setver, byte[] byteMapSetver2Client) { //var clients = new ConcurrentDictionary<IPEndPoint, TcpClient>(); IPAddress localIpAddress = string.IsNullOrEmpty(localIp) ? IPAddress.IPv6Any : IPAddress.Parse(localIp); var server = new System.Net.Sockets.TcpListener(new IPEndPoint(localIpAddress, localPort)); server.Server.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, false); server.Start(); Console.WriteLine($"TCP proxy started {localPort} -> {remoteServerIp}|{remoteServerPort}"); while (true) { try { var remoteClient = await server.AcceptTcpClientAsync(); remoteClient.NoDelay = true; var ips = await Dns.GetHostAddressesAsync(remoteServerIp); new TcpClient(remoteClient, new IPEndPoint(ips.First(), remoteServerPort), byteMapClient2Setver, byteMapSetver2Client); } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(ex); Console.ResetColor(); } } }
public Server() { config = new INIReader(System.IO.File.ReadAllLines("config.ini")); chat = new ServerChat(); instance = this; vehicleController = new ServerVehicleController(); api = new ServerApi(this); gamemodeManager = new GamemodeManager(api); gamemodeManager.loadFromFile("gamemodes/" + config.getString("gamemode")); server = new TcpListener(IPAddress.Any, config.getInt("game_port")); server.Start(); server.BeginAcceptTcpClient(onIncomingConnection, null); playerpool = new List<ServerPlayer>(); Timer timer = new Timer(); timer.Elapsed += onBroadcastTimer; timer.Interval = config.getInt("broadcast_interval"); timer.Enabled = true; timer.Start(); UDPStartPort = config.getInt("udp_start_port"); Timer timer_slow = new Timer(); timer_slow.Elapsed += timer_slow_Elapsed; timer_slow.Interval = config.getInt("slow_interval"); timer_slow.Enabled = true; timer_slow.Start(); http_server = new HTTPServer(); Console.WriteLine("Started game server on port " + config.getInt("game_port").ToString()); Console.WriteLine("Started http server on port " + config.getInt("http_port").ToString()); }
public EmbeddedSmtpServer(IPAddress address, int port = 25) { Address = address; Port = port; Listener = new TcpListener(Address, port); }
/// <summary> /// Server's main loop implementation. /// </summary> /// <param name="log"> The Logger instance to be used.</param> public void Run( Logger log ) { TcpListener srv = null; try { srv = new TcpListener( IPAddress.Loopback, portNumber ); srv.Start(); while ( true ) { log.LogMessage( "Listener - Waiting for connection requests." ); 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 _dispatcher.ProcessConnection(socket.GetStream(), log); //Handler protocolHandler = new Handler( socket.GetStream(), log ); // Synchronously process requests made through de current TCP connection //Task.Factory.StartNew((handler) => ((Handler) handler).Run(), protocolHandler); //protocolHandler.Run(); Program.ShowInfo( Store.Instance ); } } finally { log.LogMessage( "Listener - Ending." ); if ( srv != null ) { srv.Stop(); } } }
public void Start() { IPEndPoint ip = new IPEndPoint(IPAddress.Any, _port); _listener = new System.Net.Sockets.TcpListener(ip); _listener.Start(); _listener.BeginAcceptTcpClient(AcceptCallback, _listener); }
public EpoxyListener(EpoxyTransport parentTransport, IPEndPoint listenEndpoint) { this.parentTransport = parentTransport; listener = new System.Net.Sockets.TcpListener(listenEndpoint); serviceHost = new ServiceHost(parentTransport); connections = new HashSet <EpoxyConnection>(); shutdownTokenSource = new CancellationTokenSource(); }
/* * @see Flash.Tools.Debugger.SessionManager#stopListening() */ public override void stopListening() { if (m_serverSocket != null) { m_serverSocket.Stop(); m_serverSocket = null; } }